Model Context Protocol (MCP) de Anthropic: Arquitectura y Tutorial de Creación de Servidores

1. El Problema de la Fragmentación M x N en Aplicaciones de IA

Históricamente, si tenías $M$ aplicaciones de IA (Claude, ChatGPT, Cursor, agentes propietarios) y $N$ fuentes de datos o herramientas (PostgreSQL, Slack, GitHub, Jira), tenías que construir y mantener $M imes N$ integraciones diferentes. MCP transforma este escenario en un ecosistema $M + N$: cada herramienta expone un servidor MCP, y cada cliente se conecta a través de la misma especificación universal.

2. Los Tres Primitivos Fundamentales de MCP

• Resources (Recursos): Datos pasivos que el LLM puede leer como contexto adicional (archivos locales, esquemas de bases de datos, logs de servidores).
• Tools (Herramientas): Funciones ejecutables que el LLM puede invocar para interactuar con el entorno exterior (enviar un email, ejecutar una query SQL, crear una rama en Git).
• Prompts (Plantillas): Flujos preconfigurados de instrucciones estructuradas para guiar al modelo en tareas específicas.

3. Tutorial Práctico: Crear un Servidor MCP en Python con FastMCP

pip install mcp

from mcp.server.fastmcp import FastMCP
import sqlite3

# Inicializar servidor FastMCP
mcp = FastMCP("Servidor-Base-Datos-Corporativa")

@mcp.tool()
def consultar_stock_producto(id_producto: str) -> str:
    """Consulta el stock disponible y almacén de un producto en la base de datos."""
    # Lógica de conexión y consulta segura
    return f"Producto {id_producto}: 142 unidades disponibles en el Almacén Central de Madrid."

@mcp.resource("config://servidor")
def obtener_configuracion_sistema() -> str:
    """Devuelve los parámetros de entorno y estado del cluster."""
    return "Estado: ACTIVO | Región: eu-west-1 | Versión API: 3.4.1"

if __name__ == "__main__":
    mcp.run(transport="stdio")

4. Checklist para Desarrollar Servidores MCP Seguros

• Implementa validación estricta de parámetros en todas las herramientas mediante Pydantic para evitar ataques de inyección SQL o de comandos bash.
• Prefiere el transporte stdio para herramientas locales con privilegios de sistema, reservando sse para APIs en la nube.

5. Especificación de Mensajes JSON-RPC 2.0 en MCP

A nivel de red, toda la comunicación en Model Context Protocol sigue la especificación estándar JSON-RPC. A continuación se muestra la estructura real de un intercambio cuando el cliente solicita listar herramientas y ejecutarlas:

// 1. El Cliente solicita listar herramientas disponibles
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list"
}

// 2. El Servidor responde con las firmas de herramientas
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "consultar_stock_producto",
        "description": "Consulta el stock disponible de un producto.",
        "inputSchema": {
          "type": "object",
          "properties": {
            "id_producto": {"type": "string"}
          },
          "required": ["id_producto"]
        }
      }
    ]
  }
}

6. Conectar tu Servidor MCP con Claude Desktop

Para utilizar tu servidor local en la aplicación oficial de Claude Desktop, añade el conector en ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "base-datos-corporativa": {
      "command": "python",
      "args": ["C:/proyectos/servidor_mcp.py"]
    }
  }
}

7. Seguridad y Permisos: El Principio de Mínimo Privilegio en MCP

Dar acceso a un LLM a herramientas del sistema conlleva riesgos severos si el modelo es víctima de una inyección indirecta de prompts (por ejemplo, leyendo un email malicioso que contiene instrucciones para borrar archivos).

Buenas Prácticas de Blindaje:

• Aislamiento de Recursos (Read-Only por defecto): El servidor MCP debe exponer por defecto recursos de solo lectura, exigiendo confirmación humana explícita antes de ejecutar herramientas mutadoras (UPDATE, DELETE, git push).
• Sanitización de Argumentos: Valida todos los parámetros de entrada contra expresiones regulares estrictas; nunca pases cadenas del LLM directamente a os.system() o subprocess.Popen(shell=True).

8. Creación de un Cliente MCP en Node.js / TypeScript

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "python",
  args: ["servidor_mcp.py"]
});

const client = new Client({ name: "ClienteEmpresarial", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log("Herramientas MCP conectadas:", tools.tools.map(t => t.name));

9. Monitorización y Depuración con el Inspector MCP

Anthropic proporciona una herramienta oficial de depuración interactiva basada en web: MCP Inspector:

npx @modelcontextprotocol/inspector python servidor_mcp.py

El inspector levanta una interfaz visual en el navegador que permite invocar herramientas manualmente, examinar esquemas JSON y auditar los payloads enviados por el modelo en tiempo real.

10. Conclusión y el Futuro de la Estandarización en IA

Model Context Protocol representa el paso definitivo hacia la interoperabilidad abierta de la Inteligencia Artificial, democratizando la conexión entre modelos, herramientas y datos empresariales.

11. Auditoría de Seguridad: Prevención de Inyecciones Indirectas en Servidores MCP

Cuando un servidor MCP ejecuta comandos en el sistema host, debe aplicar validación de límites estricta para que ningún texto procesado desde Internet pueda desbordar la herramienta:

# Validación estricta con Pydantic y lista blanca de caracteres
from pydantic import BaseModel, validator
import re

class ConsultaSegura(BaseModel):
    nombre_archivo: str

    @validator('nombre_archivo')
    def validar_nombre_archivo(cls, v):
        if not re.match(r"^[a-zA-Z0-9_-]+.log$", v):
            raise ValueError("Nombre de archivo inválido. Solo se admiten archivos .log alfanuméricos.")
        return v

12. Conclusión

Model Context Protocol es el pegamento universal que une a los Grandes Modelos de Lenguaje con los datos y herramientas reales del ecosistema corporativo.

13. Arquitectura de Despliegue Remoto con Transporte SSE (Server-Sent Events)

Cuando el servidor MCP debe alojarse en la nube para servir a múltiples empleados de una organización, se utiliza el transporte SSE sobre HTTPS:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Servidor-Cloud-Corporativo")

# Arrancar en modo servidor HTTP con streaming SSE
if __name__ == "__main__":
    mcp.run(transport="sse", host="0.0.0.0", port=8080)

Los clientes remotos se conectan apuntando a la URL https://mcp.empresa.com/sse protegida por autenticación Bearer token corporativa.

14. Resumen de Ventajas para la Infraestructura Corporativa

• Desacoplamiento total entre los modelos de lenguaje y las bases de datos de la empresa.
• Eliminación del código redundante de wrappers y SDKs propietarios.
• Seguridad centralizada mediante auditoría y registro de todas las llamadas a herramientas externas.

15. Integración con Bases de Datos Vectoriales y Sistemas RAG vía MCP

Un servidor MCP puede actuar como pasarela universal entre el modelo de lenguaje y tu base de datos vectorial corporativa (como Qdrant o PostgreSQL pgvector):

from mcp.server.fastmcp import FastMCP
from qdrant_client import QdrantClient

mcp = FastMCP("Servidor-RAG-Vectorial")
qdrant = QdrantClient("http://localhost:6333")

@mcp.tool()
def buscar_documentacion_interna(consulta: str, departamento: str = "general") -> str:
    """Busca en el corpus de ingeniería de la empresa y devuelve los fragmentos técnicos más relevantes."""
    # Lógica de búsqueda vectorial semántica
    resultados = qdrant.search(collection_name="docs_ingenieria", query_text=consulta, limit=3)
    textos = [hit.payload["texto"] for hit in resultados]
    return "
---
".join(textos)

Al empaquetar tu RAG como un servidor MCP, cualquier agente o aplicación compatible puede consultar tu repositorio documental sin necesidad de escribir adaptadores propietarios.

16. Implementación de Rate Limiting y Circuit Breakers en Servidores MCP

Cuando un agente autónomo ejecuta cientos de llamadas por minuto a un servidor MCP conectado a una base de datos de producción (como PostgreSQL), es imprescindible proteger el motor contra saturación de conexiones:

from pyrate_limiter import Limiter, Rate, Duration

# Limitar a máximo 30 llamadas a herramientas por minuto por cliente
tasa_limite = Rate(30, Duration.MINUTE)
limiter = Limiter(tasa_limite)

@mcp.tool()
def ejecutar_query_segura(query_sql: str) -> str:
    limiter.try_acquire("mcp_sql_pool") # Lanza excepción si se supera la tasa
    # Ejecución de la consulta en modo lectura restringida
    return resultado_db

Esta protección de ingeniería garantiza que el servidor MCP permanezca estable incluso si el modelo de lenguaje entra en un bucle repetitivo de razonamiento.

17. Tabla de Especificaciones de Métodos JSON-RPC en el Estándar MCP

18. Ecosistema de Servidores MCP Comunitarios y Futuro Abierto

La adopción de MCP se ha expandido velozmente en el ecosistema de código abierto: ya existen servidores oficiales para conectar con Slack, Google Drive, Notion, Puppeteer (para navegación web) y bases de datos SQLite. Al implementar tus propias herramientas bajo este estándar, tu plataforma se vuelve inmediatamente interoperable con cualquier nuevo cliente o agente que surja en la industria.