MCP Servers

Qué es Model Context Protocol (MCP)

El Model Context Protocol (MCP) es un protocolo abierto introducido por Anthropic en noviembre de 2024 que estandariza la forma en que las aplicaciones proporcionan herramientas y contexto a los modelos de lenguaje. 

En lugar de que cada empresa desarrolle su propia implementación para conectar herramientas externas, MCP establece un estándar común que permite la interoperabilidad entre diferentes sistemas.

Arquitectura del protocolo

MCP funciona mediante una arquitectura cliente-servidor donde los servidores MCP exponen herramientas específicas que los clientes pueden utilizar. 

Esta separación permite que las herramientas se ejecuten de forma independiente y segura, mientras que el modelo de lenguaje actúa como cliente que consume estas capacidades.

# Conceptualmente, MCP funciona así:
# Cliente (OpenAI API) ←→ Servidor MCP (herramientas específicas)
# 
# El modelo solicita herramientas → El servidor las proporciona
# El modelo ejecuta herramientas → El servidor devuelve resultados

Los servidores MCP pueden ser mantenidos por diferentes organizaciones y exponer herramientas relacionadas con sus servicios. Por ejemplo, Stripe mantiene un servidor MCP que expone herramientas para crear enlaces de pago, mientras que GitHub podría mantener otro para interactuar con repositorios.

Protocolos de transporte soportados

MCP soporta múltiples protocolos de transporte para la comunicación entre cliente y servidor:

• Streamable HTTP: Permite comunicación en tiempo real con respuestas streaming
• HTTP/SSE: Utiliza Server-Sent Events para mantener conexiones persistentes
• stdio: Para servidores locales que se ejecutan como procesos independientes

# Ejemplo de configuración de servidor MCP
mcp_server_config = {
    "server_label": "stripe_payments",
    "server_url": "https://mcp.stripe.com",
    "transport": "streamable_http",  # Protocolo de transporte
    "authentication": {
        "type": "bearer_token",
        "token": "sk_live_..."
    }
}

Ecosistema actual de servidores

El ecosistema MCP ha crecido rápidamente desde su introducción. Actualmente incluye servidores oficiales mantenidos por empresas como Cloudflare, HubSpot, Intercom, PayPal, Shopify, Stripe, Twilio y Zapier, entre otros.

Cada servidor MCP expone un conjunto específico de herramientas relacionadas con su dominio:

• Stripe MCP: Herramientas para pagos, suscripciones y facturación
• GitHub MCP: Herramientas para gestión de repositorios y código
• Shopify MCP: Herramientas para comercio electrónico y gestión de productos
• Twilio MCP: Herramientas para comunicaciones y mensajería

Ventajas del estándar MCP

La adopción de MCP como estándar ofrece varios beneficios significativos:

Interoperabilidad: Los desarrolladores pueden utilizar herramientas de diferentes proveedores sin necesidad de implementar integraciones específicas para cada uno.

Seguridad: Las herramientas se ejecutan en servidores remotos controlados por sus respectivos proveedores, lo que reduce los riesgos de seguridad en el lado del cliente.

Escalabilidad: Nuevos servidores MCP pueden añadirse al ecosistema sin modificar el código cliente, permitiendo que el sistema crezca orgánicamente.

# Un mismo cliente puede usar múltiples servidores MCP
tools_config = [
    {
        "type": "mcp",
        "server_label": "payments",
        "server_url": "https://mcp.stripe.com"
    },
    {
        "type": "mcp", 
        "server_label": "communications",
        "server_url": "https://mcp.twilio.com"
    },
    {
        "type": "mcp",
        "server_label": "analytics", 
        "server_url": "https://mcp.analytics-provider.com"
    }
]

Integración con OpenAI

OpenAI ha integrado soporte nativo para MCP en su API Responses en marzo de 2025, permitiendo que los modelos accedan directamente a servidores MCP remotos. Esta integración elimina la necesidad de implementar proxies o adaptadores personalizados, simplificando significativamente el proceso de conexión con herramientas externas.

La implementación de OpenAI incluye características avanzadas como filtrado de herramientas, sistema de aprobaciones para control de seguridad, y autenticación flexible mediante headers personalizados.

El protocolo MCP representa un paso importante hacia la estandarización del ecosistema de herramientas para modelos de lenguaje, facilitando la creación de aplicaciones más robustas y extensibles que pueden aprovechar capacidades distribuidas across múltiples servicios especializados.

Cómo invocar MCP servers con OpenAI SDK

La integración de servidores MCP con el OpenAI SDK se realiza a través de la API Responses, que proporciona soporte nativo para conectar con servidores remotos. Esta implementación permite que los modelos accedan directamente a herramientas externas sin necesidad de configuraciones complejas.

Configuración básica de un servidor MCP

Para conectar con un servidor MCP, necesitas especificar la configuración del servidor en el parámetro tools de la API Responses. La estructura básica incluye el tipo de herramienta, etiqueta del servidor y URL del endpoint:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "deepwiki",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "require_approval": "never"
        }
    ],
    input="¿Qué protocolos de transporte soporta la especificación MCP versión 2025-03-26?"
)

print(response.output_text)

El parámetro server_label actúa como identificador único para el servidor dentro de tu aplicación, mientras que server_url especifica el endpoint donde se encuentra alojado el servidor MCP.

Ejemplo de uso:

Proceso de descubrimiento de herramientas

Cuando conectas con un servidor MCP, la API Responses ejecuta automáticamente un proceso de descubrimiento de herramientas. Este proceso consulta al servidor para obtener la lista de herramientas disponibles y sus esquemas de entrada:

# El SDK automáticamente genera un objeto mcp_list_tools
# que contiene información sobre las herramientas disponibles
response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "github_tools",
            "server_url": "https://mcp.github.com/api",
            "require_approval": "never"
        }
    ],
    input="Lista los archivos del repositorio facebook/react"
)

# La respuesta incluirá automáticamente las herramientas descubiertas
# como read_repository, list_files, get_file_content, etc.

Filtrado de herramientas específicas

Los servidores MCP pueden exponer docenas de herramientas, lo que puede resultar en mayor latencia y costos. Para optimizar el rendimiento, puedes utilizar el parámetro allowed_tools para importar únicamente las herramientas que necesitas:

response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "stripe_payments",
            "server_url": "https://mcp.stripe.com",
            "require_approval": "never",
            "allowed_tools": ["create_payment_link", "get_payment_status"]
        }
    ],
    input="Crea un enlace de pago por 50 euros para una consultoría"
)

Esta configuración limita las herramientas disponibles solo a aquellas especificadas en la lista, reduciendo la complejidad del contexto y mejorando la eficiencia.

Autenticación con servidores MCP

La mayoría de servidores MCP requieren autenticación para acceder a sus herramientas. El SDK permite especificar headers personalizados que se incluirán en todas las peticiones al servidor:

response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "shopify_store",
            "server_url": "https://mcp.shopify.com",
            "headers": {
                "Authorization": "Bearer shop_access_token_here",
                "X-Shopify-Shop-Domain": "mi-tienda.myshopify.com"
            },
            "require_approval": "never"
        }
    ],
    input="Muestra los 5 productos más vendidos de esta semana"
)

Los valores de los headers no se almacenan ni son visibles en las respuestas por motivos de seguridad, por lo que debes incluirlos en cada petición.

Sistema de aprobaciones

Por defecto, OpenAI requiere aprobación manual antes de compartir datos con servidores MCP remotos. Este mecanismo de seguridad te permite revisar qué información se enviará:

# Primera petición - genera una solicitud de aprobación
response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "analytics_service",
            "server_url": "https://mcp.analytics.com"
            # require_approval por defecto es True
        }
    ],
    input="Analiza las métricas de ventas del último trimestre"
)

# La respuesta contendrá un mcp_approval_request
# que debes aprobar en una segunda petición
approval_response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "analytics_service", 
            "server_url": "https://mcp.analytics.com"
        }
    ],
    previous_response_id=response.id,
    input=[
        {
            "type": "mcp_approval_response",
            "approve": True,
            "approval_request_id": "mcpr_ejemplo_id_aprobacion"
        }
    ]
)

Configuración de aprobaciones granulares

Puedes configurar el sistema de aprobaciones de forma granular, especificando qué herramientas no requieren aprobación:

response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "crm_system",
            "server_url": "https://mcp.crm-provider.com",
            "require_approval": {
                "never": {
                    "tool_names": ["get_contact_info", "search_contacts"]
                }
            }
        }
    ],
    input="Busca el contacto de María García en el CRM"
)

Esta configuración permite que las herramientas de consulta se ejecuten automáticamente, mientras que las operaciones de escritura seguirán requiriendo aprobación.

Manejo de múltiples servidores MCP

Una aplicación puede conectar simultáneamente con múltiples servidores MCP, cada uno proporcionando herramientas especializadas:

response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "payments",
            "server_url": "https://mcp.stripe.com",
            "headers": {"Authorization": "Bearer sk_live_..."},
            "require_approval": "never"
        },
        {
            "type": "mcp", 
            "server_label": "inventory",
            "server_url": "https://mcp.inventory-system.com",
            "headers": {"API-Key": "inv_key_..."},
            "require_approval": "never"
        },
        {
            "type": "mcp",
            "server_label": "notifications",
            "server_url": "https://mcp.twilio.com", 
            "headers": {"Authorization": "Bearer twilio_token_..."},
            "require_approval": "never"
        }
    ],
    input="Procesa el pedido #12345: verifica stock, cobra 299€ y envía SMS de confirmación"
)

El modelo puede coordinar automáticamente el uso de herramientas de diferentes servidores para completar tareas complejas que requieren múltiples servicios.

Gestión de errores y fallos

Cuando una herramienta MCP falla, la información del error se incluye en el objeto mcp_call de la respuesta:

response = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "external_api",
            "server_url": "https://mcp.external-service.com",
            "require_approval": "never"
        }
    ],
    input="Consulta datos que podrían no estar disponibles"
)

# Verificar si hubo errores en las llamadas MCP
for output_item in response.output:
    if output_item.type == "mcp_call" and output_item.error:
        print(f"Error en herramienta {output_item.name}: {output_item.error}")

Esta información permite implementar lógica de recuperación o proporcionar feedback específico sobre fallos en herramientas externas.