Ir al contenido principal
Español— Elegir un idioma
Menú

MCP y conectores: el estándar universal

Lección 16 de 20 Desarrollador
En esta página
  1. MCP y conectores: el estándar universal
  2. El problema que resuelve MCP
  3. Arquitectura de MCP
  4. Uso de los conectores de OpenAI
  5. Creación de un servidor MCP en Python
  6. Exposición de recursos MCP
  7. Conexión de un servidor MCP a la API de Responses
  8. Patrón: concentrador de múltiples conectores
  9. Seguridad y autenticación
  10. Puntos clave

MCP y conectores: el estándar universal

El Model Context Protocol (MCP) es un estándar abierto que permite a los modelos interactuar con servicios externos mediante un protocolo unificado. Los conectores de OpenAI implementan este estándar para vincular modelos directamente con herramientas de terceros dentro de la API de Responses.

El problema que resuelve MCP

El núcleo del problema es la multiplicación de integraciones: conectar N modelos a M servicios requiere N×M integraciones personalizadas, cada una escrita y mantenida por separado. Cada nuevo servicio te obliga a repetir el trabajo para cada aplicación, y cada cambio en la API corre el riesgo de romper múltiples integraciones.

MCP convierte este producto en una suma: el servicio expone sus capacidades una sola vez usando el protocolo, y cualquier cliente compatible las consume. Esta es la misma lógica que hay detrás de los controladores de impresora o del Language Server Protocol (LSP) en los editores de código: la estandarización no hace que las integraciones sean más potentes; hace que sean económicamente sostenibles.

# Antes de MCP: integración manual para cada servicio
tools = [
    # Función para Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Función para Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Función para Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... docenas de funciones que mantener
]

Con MCP, cada servicio expone sus capacidades mediante un protocolo estándar y el modelo las consume directamente.

Arquitectura de MCP

El protocolo define tres conceptos:

  • Servidor MCP: Un servicio que expone herramientas, recursos y sugerencias (prompts)
  • Cliente MCP: El sistema que consume las capacidades del servidor
  • Transporte: El canal de comunicación entre cliente y servidor
# Un servidor MCP expone:
# - Herramientas: Acciones que el modelo puede ejecutar
# - Recursos: Datos que el modelo puede leer
# - Sugerencias: Plantillas de prompts predefinidas

Uso de los conectores de OpenAI

Los conectores son servidores MCP que ya están alojados y mantenidos: los declaras, te autenticas y los consumes. Este es el punto de entrada natural; no hace falta escribir un servidor MCP para hablar con un servicio común que alguien ya ha conectado.

from openai import OpenAI

client = OpenAI()

# Ejemplo conceptual: conector a un servicio externo
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Crea un ticket de Jira para el error de la página de inicio",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

El parámetro require_approval controla la validación humana:

  • "always": Cada acción requiere aprobación
  • "never": Ejecución automática

Creación de un servidor MCP en Python

Escribir tu propio servidor merece la pena en cuanto un servicio interno necesita ser accesible para varias aplicaciones. La lógica es la misma que para una API interna: lo escribes una vez, de forma limpia, con sus propias reglas de acceso, y todas las aplicaciones se benefician sin tener que reinventar la capa de integración.

from mcp.server import Server
from mcp.types import Tool, TextContent
import json

server = Server("my-crm")

@server.tool()
async def search_client(term: str, field: str = "name") -> str:
    """Busca un cliente en el CRM interno.

    Args:
        term: El término de búsqueda (nombre, correo o ID)
        field: El campo donde buscar (name, email, id)
    """
    # Tu lógica de negocio
    results = await crm_database.search(term, field=field)
    return json.dumps([{
        "id": r.id,
        "name": r.name,
        "email": r.email,
        "company": r.company
    } for r in results])

@server.tool()
async def create_opportunity(
    client_id: str,
    title: str,
    amount: float,
    probability: int
) -> str:
    """Crea una oportunidad de venta en el CRM.

    Args:
        client_id: Identificador del cliente
        title: Título de la oportunidad
        amount: Importe estimado en euros
        probability: Probabilidad de cierre (0-100)
    """
    opp = await crm_database.create_opportunity(
        client_id=client_id,
        title=title,
        amount=amount,
        probability=probability
    )
    return json.dumps({"id": opp.id, "status": "created"})

Exposición de recursos MCP

MCP distingue entre herramientas, que hacen algo, y recursos, que proporcionan algo que leer. Esta distinción es importante porque define el riesgo: un recurso se consulta sin efectos secundarios, mientras que una herramienta puede modificar el estado del mundo. Los controles de aprobación se centran naturalmente en estos últimos.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Estado actual del embudo de ventas."""
    pipeline = await crm_database.get_pipeline()
    return json.dumps({
        "total_opportunities": pipeline.count,
        "total_value": pipeline.total_value,
        "by_stage": {
            "prospecting": pipeline.prospecting,
            "qualification": pipeline.qualification,
            "proposal": pipeline.proposal,
            "negotiation": pipeline.negotiation,
            "closing": pipeline.closing
        }
    })

@server.resource("crm://client/{client_id}")
async def client_profile(client_id: str) -> str:
    """Perfil completo de un cliente."""
    client = await crm_database.get_client(client_id)
    return json.dumps({
        "name": client.name,
        "email": client.email,
        "purchase_history": client.purchases,
        "satisfaction_score": client.nps
    })

Conexión de un servidor MCP a la API de Responses

# Configuración del conector MCP en la llamada a la API
response = client.responses.create(
    model="gpt-5.6-terra",
    input="¿Cuál es el estado de nuestro embudo de ventas? "
          "Crea una oportunidad para el cliente CLI-789: "
          "migración a la nube, 50000 euros, 70% de probabilidad.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Patrón: concentrador de múltiples conectores

Aquí es donde el estándar brilla de verdad: varios servidores declarados uno al lado del otro, con el modelo componiendo acciones entre ellos: leer un ticket aquí, buscar un cliente allí, escribir una respuesta en otro sitio. Sin un protocolo común, este mismo flujo requeriría tres integraciones específicas y su mantenimiento continuo.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Comprueba los tickets abiertos de Jira, envía un resumen a Slack "
          "y actualiza el panel de Notion",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.example.com/jira",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "slack",
            "server_url": "https://mcp.example.com/slack",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "notion",
            "server_url": "https://mcp.example.com/notion",
            "require_approval": "always"
        }
    ]
)

Seguridad y autenticación

# Los servidores MCP gestionan la autenticación mediante cabeceras
# o tokens en la URL de configuración

# Buena práctica: usa siempre require_approval para acciones de escritura
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Validación humana
        "allowed_tools": ["search_client", "client_profile"],  # Restringe herramientas
    }
]

Puntos clave

  • MCP es un estándar abierto para conectar modelos con servicios externos
  • Los conectores de OpenAI integran MCP directamente en la API de Responses
  • Construye tus propios servidores MCP para exponer servicios internos
  • Usa require_approval para controlar la validación humana
  • Conecta varios servidores MCP en una sola llamada para flujos de trabajo transversales