Model Context Procotol (MCP) con InterSystems IRIS: De cero a héroe

Introducción

Hoy en día, asistentes de programación como Claude, GitHub Copilot y Cursor han transformado la forma en que los desarrolladores escriben código. Sin embargo, estas herramientas presentan limitaciones, ya que están aisladas de los sistemas y las fuentes de datos con los que trabajan a diario. Esta limitación puede superarse mediante el Model Context Protocol (MCP), un estándar abierto diseñado para conectar asistentes de IA con fuentes de datos y herramientas externas de forma segura y estandarizada.

En este artículo de revisión, exploraremos el estado actual de la técnica en lo que respecta al MCP dentro del ecosistema de InterSystems. Además, analizaremos cómo este estándar abierto conecta los asistentes de IA con fuentes de datos externas y presentaremos un primer ejemplo de un server MCP personalizado desarrollado en Python e integrado con el paquete intersystems-irispython.

Tabla de contenido

Parte 1: ¿Qué es el Model Context Protocol?

1.1 Orígenes

El MCP fue presentado por Anthropic el 25 de noviembre de 2024 [1] como un proyecto de código abierto con el objetivo de conectar sistemas de IA con fuentes de datos, reemplazando las integraciones fragmentadas. Antes de MCP, cada aplicación de IA requería integraciones personalizadas para acceder a distintas fuentes de datos, como bases de datos o API. MCP resuelve este problema al proporcionar un protocolo único y estandarizado que cualquier aplicación de IA puede utilizar para conectarse a server compatibles.

1.2 Importancia del MCP

El protocolo aborda tres desafíos clave:

1. Estandarización: ya no es necesario desarrollar integraciones personalizadas para cada nueva herramienta. Cualquier asistente de IA puede utilizar server MCP que exponen capacidades específicas para interactuar con diversos recursos mediante un formato estandarizado que los modelos de lenguaje (LLM) pueden comprender fácilmente.
2. Seguridad: MCP aísla cada server, lo que significa que la IA solo puede acceder al contexto específico requerido para la tarea inmediata y no puede acceder a otros server ni al historial completo de la conversación.
3. Integración: al tratarse de un protocolo abierto, permite combinar fácilmente varios server de manera simultánea, facilitando la creación de flujos de trabajo de IA modulares y personalizados sin complicar excesivamente la arquitectura.

Recursos oficiales:

• Anuncio de Anthropic: Introducción al Model Context Protocol [1]
• Model Context Protocol - Especificación [2]
• Repositorio de GitHub - Model Context Protocol [3]
• ¿Qué es el Model Context Protocol (MCP)? [4]

Part 2: Comprensión de la arquitectura de MCP

2.1 The Client-Host-Server Model

MCP sigue una arquitectura cliente-host-server [5]:

• MCP Host: aplicación de IA (Claude Desktop, Cursor, VS Code, etc.) que coordina y administra uno o varios clientes MCP.
• MCP Client: componente dentro del host que mantiene una conexión dedicada con un server MCP.
• MCP Server: programa que proporciona funcionalidades a los clientes MCP. Los server MCP pueden ejecutarse localmente en la máquina del usuario o de forma remota.

Cada host puede crear múltiples clientes, y cada cliente mantiene una conexión dedicada 1:1 con su server correspondiente. 

Por ejemplo, Cursor actúa como un MCP Host. Cuando Cursor establece una conexión con un server MCP, instancia un objeto cliente MCP que mantiene la conexión con ese server específico. Posteriormente, si Cursor se conecta a otro server MCP, instancia un cliente MCP adicional para mantener la nueva conexión.

Puede encontrar la fuente original de la imagen aquí [6].

2.2 Modelo de transporte

MCP admite dos mecanismos de transporte:

• Server locales: utilizan Standard Input/Output (STDIO) para la comunicación directa entre procesos locales que se ejecutan en la misma máquina. Dado que este mecanismo evita la sobrecarga de red, representa una mejor opción para integraciones locales o utilidades de línea de comandos. Actualmente, MCP utiliza STDIO como capa de transporte predeterminada.
• Server remotos: utilizan Streamable HTTP para gestionar interacciones a través de una red. El cliente envía mensajes mediante HTTP POST, mientras que el server puede utilizar opcionalmente Server-Sent Events (SSE) para transmitir datos en tiempo real. Este mecanismo de transporte permite que los server MCP se ejecuten de forma remota (en otra máquina, en la nube, etc.) y sean accesibles mediante una URL.

2.3 Modelo de datos

En MCP, la estructura y la semántica de los mensajes se basan en el protocolo JSON-RPC 2.0 [7]. Toda la comunicación sigue una estructura similar a la siguiente

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "query_database",
    "arguments": {
      "sql": "SELECT * FROM Patient LIMIT 10"
    }
  }
}

2.4 Implementación de las primitivas fundamentales

MCP define tres primitivas fundamentales que los server pueden exponer [5]:

• Tools: funciones que el agente de IA puede invocar para realizar acciones según las solicitudes del usuario. Por ejemplo, las herramientas pueden escribir en una base de datos, consumir API o modificar archivos.
• Resources: fuentes de datos pasivas que proporcionan información contextual a las aplicaciones de IA, ofreciendo acceso de solo lectura al contenido de archivos, esquemas de bases de datos o documentación de API.
• Prompts: instrucciones predefinidas que indican al modelo cómo trabajar con herramientas y recursos específicos, ayudando al usuario a estructurar las interacciones con el agente de IA.

Part 3: Creación de server MCP desde cero con Python

Antes de profundizar en los ejemplos de código, es importante comprender cómo construir server MCP en Python.

MCP proporciona SDK oficiales para múltiples lenguajes de programación, incluidos TypeScript, Java y Python [8]. En este artículo, nos centraremos en Python, ya que es ampliamente utilizado en la comunidad de InterSystems y se integra fácilmente con IRIS mediante el Native SDK [9].

3.1 Uso de uv para crear un nuevo paquete de Python

Antes de hablar sobre el código, debemos comprender cómo crear un entorno adecuado para nuestra aplicación, que no solo contendrá el código Python, sino también:

• dependencias
• versión de Python
• entry points

Para configurar el entorno utilizaremos el gestor de paquetes uv, una herramienta moderna para Python que simplifica la creación de entornos, la resolución de dependencias y la ejecución reproducible de server MCP [10].

Puede inicializar correctamente la estructura de carpetas de su proyecto MCP utilizando la instrucción uv init.

uv init --package my-mcp-server

my-mcp-server/
├── pyproject.toml      
├── README.md
├── .python-version     
└── src/
    └── my_mcp_server/
        └── __init__.py

[build-system] 
requires = ["hatchling"] 
build-backend = "hatchling.build" 

[project] 
name = "my-mcp-server" 
version = "0.1.0" 
description = "" 
readme = "README.md" 
requires-python = ">=3.12" 
dependencies = []

Después de crear la estructura del proyecto, puede agregar dependencias utilizando la instrucción uv add.

uv add fastmcp intersystems-irispython requests

[project]
...
dependencies = [
    "fastmcp>=3.2",
    "intersystems-irispython>=5.3",
    "requests>=2.32",
]

[[package]]
name = "fastmcp"
version = "3.2.1"
dependencies = [
    "pydantic",
    "typing-extensions",
]

Finalmente, es momento de añadir un punto de entrada para iniciar el server.

[project.scripts]
my-mcp-server = "my_mcp_server.entrypoint:main"

3.2 Estructura básica de un server MCP

Veamos ahora los paquetes disponibles que podemos utilizar para implementar un server MCP. Mientras que el paquete oficial mcp proporciona la implementación central del protocolo [12], el paquete FastMCP se ha consolidado como uno de los frameworks más sencillos y rápidos para construir server MCP en Python [13]. En este artículo, se mostrará la estructura mínima de un server MCP utilizando FastMCP.

Un server se define en tres pasos principales:

• inicializar el server
• definir tools, resources y prompts mediante decoradores de funciones
• ejecutar el proceso

from fastmcp import FastMCP

# 1. Create the MCP server instance
mcp = FastMCP(name="My MCP Server")

# 2. Define tools, resources and prompts using decorators
@mcp.tool
def my_tool(param: str) -> str:
    """Description of what this tool does. This text is sent to the LLM."""
    return f"Result: {param}"

# 3. Run the server (defaults to STDIO transport)
if __name__ == "__main__":
    mcp.run()

3.4 Implementing Core Primitives

Veamos cómo implementar cada tipo de primitiva:

1. Tools: las tools permiten que la IA realice acciones. En este ejemplo definimos una tool que el agente de IA puede utilizar para consultar la base de datos mediante el decorador @mcp.tool. Cabe destacar que el docstring se convierte en la descripción de la tool mostrada a la IA. De hecho, al utilizar este decorador, FastMCP genera automáticamente un esquema JSON a partir de los type hints de Python y de los docstrings, indicando a la IA exactamente cómo debe utilizar la función.

@mcp.tool
def query_database(sql: str) -> str:
    """
    Execute an SQL query against the database.
    
    Args:
        sql: The SQL query to execute
    
    Returns:
        Query results as a string
    """
    # Logic to connect to IRIS and execute SQL goes here
    return execute_query(sql)

2. Resources: los resources son fuentes de datos pasivas que la IA puede leer para obtener contexto antes de realizar una acción. Actúan como información de fondo. En este ejemplo definimos un resource utilizando el decorador @mcp.resource("uri") y asignándole un URI único.

@mcp.resource("resource://database/schema")
def get_schema() -> dict:
    """Provides the database schema information to help the AI write better SQL."""
    return {
        "tables": {
            "Patient": ["id", "first_name", "last_name", "dob"],
            "Encounter": ["id", "patient_id", "date", "reason"],
            "Observation": ["id", "encounter_id", "type", "value"]
        },
        "version": "1.0",
        "storage_type": "relational"
    }

3. Prompts: los prompts son plantillas reutilizables que ayudan al usuario a interactuar con la IA. En este ejemplo definimos un prompt mediante el decorador @mcp.prompt, que puede guiar al asistente de IA para realizar tareas repetitivas específicas, como escribir consultas o importar datos en la base de datos.

@mcp.prompt()
def sql_assistant() -> str:
    """A prompt template for IRIS SQL query assistance."""
    return """You are an expert SQL developer specializing in InterSystems IRIS.
    When writing queries:
    - Use proper IRIS SQL syntax (e.g., handle schema names correctly).
    - Favor performance-optimized indices.
    - Explain your reasoning if the query is complex."""

Part 4: Uso de MCP con herramientas de desarrollo de IA

Las herramientas de desarrollo de IA están evolucionando rápidamente desde simples interfaces de chat hacia orquestadores más sofisticados, capaces de interactuar con entornos locales y server remotos mediante el protocolo MCP. Actualmente, aunque varias plataformas ya soportan el protocolo, el proceso de configuración suele estar estandarizado entre ellas.

Las plataformas más populares en la actualidad son:

• Cursor: un IDE potenciado por IA basado en Visual Studio Code que incorpora capacidades de agente de IA e integración con MCP dentro del editor de código [14].

• Claude Desktop: el cliente oficial de Anthropic, que utiliza MCP para dotar a Claude de “habilidades”, como la búsqueda en archivos locales o bases de datos [15].

• Claude Code: un agente basado en CLI que puede integrar server MCP directamente desde la terminal [16].

4.1 Configuración de server MCP

El siguiente JSON muestra cómo conectar Cursor o Claude a un server MCP de IRIS:

{
  "mcpServers": {
    "my-server-name": {
      "command": "executable-or-runtime",
      "args": ["path/to/script-or-package", "--option", "value"],
      "env": {
        "KEY_1": "value-1",
        "KEY_2": "value-2"
      }
    }
  }
}

Cada configuración de un server MCP se basa en unos pocos campos clave que indican a la IA cómo iniciar y comunicarse con el server.

Veamos los campos del JSON para entender cómo funciona esta configuración:

• mcpServers: objeto raíz que lista todos los server conectados. Es posible tener varios server ejecutándose simultáneamente (por ejemplo: uno para IRIS, otro para Google Drive, otro para Atlassian, etc.).
• command: comando utilizado para iniciar el server. Ejemplos comunes incluyen python, node, uvx o npx. En particular, se puede utilizar uvx (para Python) o npx (para Node.js) para ejecutar paquetes directamente desde la web sin necesidad de instalarlos manualmente (véase el siguiente capítulo para más información).
• args: array de argumentos que se pasan al comando. Normalmente incluye la ruta del archivo del server MCP o el nombre del paquete que se va a ejecutar.
• env: conjunto de variables de entorno. Es la forma estándar de pasar información sensible o dependiente del entorno, como nombres de host, números de puerto o credenciales, sin incrustarlos directamente en la lógica del server.

Una vez configurado esto, el asistente de IA puede interactuar directamente con la base de datos de IRIS, ejecutar consultas y acceder a información del esquema sin necesidad de copiar y pegar contexto manualmente.

{
  "command": "uv",
  "args": ["run", "<mcp-server-name>"],
  "env": { "...": "..." }
}

{
  "command": "uvx",
  "args": [
    "--from", "git+https://github.com/<repository>.git",
    "<mcp-server-name>"
  ],
  "env": { "...": "..." }
}

{
  "command": "uvx",
  "args": ["<mcp-server-name>"],
  "env": { "...": "..." }
}

# Use --bump patch / minor / major depending on the change
uv version --bump patch

uv build

#    Export the token as an env var so it does not end up in shell history
#    uv publish reads it automatically from UV_PUBLISH_TOKEN. 
export UV_PUBLISH_TOKEN=pypi-<your-token>     # Linux / macOS / Git Bash 
$env:UV_PUBLISH_TOKEN = "pypi-<your-token>"   # PowerShell 
uv publish 

Part 6: MCP e InterSystems IRIS

En la actualidad ya existen varios ejemplos de server MCP que funcionan con InterSystems IRIS. Dado que IRIS es una base de datos multimodelo, es un candidato ideal para este protocolo. En lugar de limitarse a proporcionar código a una IA, se le ofrece una conexión en tiempo real a los datos, los globals y las métricas del sistema.

6.1 Server MCP existentes para IRIS

Varios desarrolladores han compartido implementaciones MCP o herramientas relacionadas con MCP en la InterSystems Developer Community. Entre ellas destacan las siguientes:

• mcp-server-iris [17] por @Dmitry Maslennikov: server MCP para monitorizar y gestionar producciones de Interoperability mediante lenguaje natural.
• intersystems-objectscript-mcp [18] por Chen Jinyao: server MCP que obtiene rutinas compiladas (.int, .mac, .inc) directamente desde el server IRIS.
• iris-mcp-atelier [19] por @Ernest Salas: server MCP especializado que utiliza la API REST de Atelier para proporcionar a los asistentes de IA acceso de lectura/escritura al código ObjectScript en una instancia IRIS en ejecución.
• servAI [20] por @John Murray: extensión de VS Code que actúa como un envoltorio seguro de credenciales para server MCP, obteniendo automáticamente los datos de conexión y contraseñas desde InterSystems Server Manager y evitando la necesidad de hardcodear credenciales sensibles en archivos JSON de configuración.
• IRIS MCP Server Suite [21] por @Joshua Brandt: conjunto integral de servicios para InterSystems IRIS que incluye cinco server MCP distintos orientados a diferentes dominios.

• InterSystems IRIS AI Hub [22]: actualmente en Early Access y presentado recientemente en READY 2026, proporciona un SDK unificado e integración con server MCP para conectar de forma segura modelos de IA y agentes externos con la lógica de negocio de InterSystems IRIS.

Puedes mencionar en los comentarios todas las aplicaciones y desarrolladores que consideres relevantes para incluir.

Part 7: Creación de tu propio server MCP para IRIS

Aunque las herramientas de la comunidad son excelentes, es posible que con el tiempo necesites un server adaptado a la lógica específica de tu aplicación o simplemente quieras entender cómo funcionan las herramientas mencionadas anteriormente. En esta sección se presenta un ejemplo de cómo implementar un server MCP para trabajar con InterSystems IRIS.

Para construir un server MCP para InterSystems IRIS, se recomienda seguir dos enfoques principales:

1. Uso del InterSystems Python Native SDK [9][23]: intersystems-irispython es el paquete oficial de Python para conectarse con InterSystems IRIS. Proporciona una interfaz ligera para acceder, desde Python, a todos los recursos que antes solo estaban disponibles a través de ObjectScript, como globals o métodos de clase. Es la opción más adecuada para operaciones intensivas sobre datos, manipulación de globals, invocación de lógica de negocio existente y ejecución de SQL de alto rendimiento.
2. Uso de la API REST de Source Code (también conocida como Atelier API) [24]: la Atelier API proporciona una interfaz RESTful (/api/atelier/) diseñada específicamente para la gestión de código fuente. Fue creada originalmente para el IDE Atelier (y actualmente es utilizada por la extensión InterSystems Server Manager de VS Code) y resulta especialmente útil para trabajar con archivos de código, compilar clases o gestionar flujos de trabajo de desarrollo. 

7.1 Implementación base de un server MCP para IRIS

7.2 Aspectos del código

Más allá de las tools, los prompts están diseñados como flujos de trabajo estructurados que incluyen instrucciones sobre cómo utilizar las herramientas disponibles (por ejemplo, los pasos lógicos para crear una tabla importando un archivo .csv desde una carpeta local específica). Los resources, por su parte, proporcionan contexto de solo lectura al modelo, como la versión de IRIS o información del namespace, sin necesidad de realizar llamadas a herramientas.

Esta implementación contiene un número limitado de casos de uso diseñados para ilustrar cómo utilizar tanto el Native Python SDK como la API de Atelier. De nuevo, no se trata de una implementación completa de servicios, sino de un blueprint que sirve como guía para desarrollar su propio server MCP adaptado a las necesidades específicas de su proyecto.

Si desea más información sobre cómo funciona este blueprint, consulte el vídeo relacionado en YouTube:

Part 8: Conclusión

Part 9: Fuentes