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

MCP y conectores: conexión de servicios externos

Lección 9 de 25 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. MCP y conectores: conexión de servicios externos
  2. ¿Qué es MCP?
  3. Conexión de un servidor MCP
  4. Servidores MCP remotos mediante SSE
  5. Conectores de OpenAI
  6. Combinación de MCP y herramientas de función
  7. Filtrado de herramientas MCP
  8. Gestión de errores en MCP
  9. Puntos clave

Actualizado el 2 de noviembre de 2026 — Agent Builder. El 3 de junio de 2026, OpenAI anunció el cierre de Agent Builder, programado para el 30 de noviembre de 2026; ChatKit sigue disponible. De aquí en adelante, OpenAI dirige a los usuarios al SDK de Agents o a los agentes del espacio de trabajo de ChatGPT. Desde el 10 de septiembre de 2026, OpenAI ofrece una API de Agents en beta pública que aloja la orquestación de agentes (véase ChatGPT en 2026, lección 10).

MCP y conectores: conexión de servicios externos

El Model Context Protocol (MCP) es un estándar abierto que permite a tu agente conectarse a servicios externos de forma estandarizada. En lugar de reescribir integraciones para cada servicio, conectas un servidor MCP y tu agente gana nuevas herramientas al instante. Donde antes habrías escrito trescientas líneas de código cliente para GitHub, ahora solo necesitas una única declaración de servidor.

¿Qué es MCP?

MCP es un estándar abierto que define cómo se comunica un cliente (tu agente) con un servidor, es decir, un servicio externo. Cada servidor MCP expone herramientas que tu agente puede utilizar. El protocolo se encarga del transporte, la serialización y el descubrimiento de herramientas. Esta última característica es la más valiosa para el trabajo diario: el agente consulta al servidor para ver qué puede hacer, así que no tienes que mantener una lista manualmente. El SDK de Agents incluye soporte nativo para MCP y se conecta a cualquier servidor compatible.

Conexión de un servidor MCP

El SDK proporciona la clase MCPServerStdio para servidores locales que se comunican mediante stdin/stdout, normalmente un proceso de Node lanzado con npx.

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

# Servidor MCP local (se comunica vía stdin/stdout)
file_server = MCPServerStdio(
    name="File Manager",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/path/to/folder"],
)

async def main():
    async with file_server:
        agent = Agent(
            name="File Agent",
            instructions="Gestionas archivos para el usuario.",
            mcp_servers=[file_server],
        )
        result = await Runner.run(agent, "Lista los archivos en la carpeta raíz.")
        print(result.final_output)

El bloque async with no es solo decorativo: inicia el proceso del servidor, descubre sus herramientas y lo apaga limpiamente cuando el bloque finaliza. Un agente creado fuera de este contexto no tendrá ninguna herramienta.

Servidores MCP remotos mediante SSE

Para servidores alojados, utiliza MCPServerSse y el transporte SSE (Server-Sent Events). La lógica es la misma; solo cambian la URL y las cabeceras de autenticación.

from agents.mcp import MCPServerSse

github_server = MCPServerSse(
    name="GitHub",
    url="https://mcp.github.com/sse",
    headers={"Authorization": "Bearer ghp_your_token"},
)

async def main():
    async with github_server:
        agent = Agent(
            name="DevOps Agent",
            instructions="Gestionas repositorios de GitHub.",
            mcp_servers=[github_server],
        )
        result = await Runner.run(
            agent,
            "Crea una incidencia en el repositorio my-project con el título 'Critical Bug'"
        )
        print(result.final_output)

Conectores de OpenAI

Además de MCP, OpenAI ofrece conectores gestionados directamente en la plataforma. Se integran en Agent Builder y siguen siendo utilizables mediante el SDK sin necesidad de que alojes un servidor.

from agents import Agent, Runner

# Los conectores configurados en Agent Builder están disponibles automáticamente
agent = Agent(
    name="CRM Agent",
    instructions="""Eres un asistente de CRM. Usa los conectores
    para acceder a Salesforce, HubSpot y Google Workspace.""",
    model="gpt-5.6-terra",
    # Los conectores están vinculados a la configuración del agente en la plataforma
)

La ausencia del parámetro mcp_servers tiene sentido: los conectores están ligados a la configuración del agente en la plataforma. Gestionan por ti la autenticación OAuth, la paginación y el límite de tasa, tres áreas que consumen mucho tiempo cuando se hacen manualmente.

Combinación de MCP y herramientas de función

No tienes que elegir. Un único agente puede usar un servidor MCP para el acceso a datos y tus propias funciones para la lógica de negocio que no quieras delegar.

from agents import Agent, Runner, function_tool
from agents.mcp import MCPServerStdio

@function_tool
def calculate_invoice(amount_excl_tax: float, vat_rate: float = 20.0) -> str:
    """Calcula el importe total con impuestos de una factura."""
    amount_incl_tax = amount_excl_tax * (1 + vat_rate / 100)
    return f"Sin impuestos: {amount_excl_tax} €, IVA {vat_rate}%: {amount_excl_tax * vat_rate / 100:.2f} €, Con impuestos: {amount_incl_tax:.2f} €"

db_server = MCPServerStdio(
    name="Database",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/mydb"],
)

async def main():
    async with db_server:
        agent = Agent(
            name="Accounting Agent",
            instructions="""Te encargas de la contabilidad.
            Usa la base de datos para los datos de clientes
            y la función de cálculo para las facturas.""",
            tools=[calculate_invoice],
            mcp_servers=[db_server],
        )
        result = await Runner.run(
            agent,
            "Recupera los pedidos del cliente Alice y calcula la factura total"
        )
        print(result.final_output)

El cálculo del IVA permanece en tu código, donde es comprobable y auditable; la recuperación de pedidos pasa por el servidor MCP de PostgreSQL. Esa es la división que debes buscar.

Filtrado de herramientas MCP

Un servidor MCP puede exponer decenas de herramientas, la mayoría de las cuales no serán relevantes para tu caso de uso, y cada una consume contexto y aumenta el riesgo de una llamada inadecuada. Empieza inspeccionando qué hay disponible realmente.

server = MCPServerStdio(
    name="GitHub",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-github"],
)

# Puedes filtrar durante la conexión
async with server:
    tools = await server.list_tools()
    # Inspecciona las herramientas disponibles
    for tool in tools:
        print(f"- {tool.name}: {tool.description}")

Gestión de errores en MCP

Un servidor MCP es un proceso o un servicio remoto: puede fallar al iniciarse, perder la conexión o tener un token caducado. Planifica un modo degradado en lugar de dejar que la excepción llegue hasta el usuario.

from agents.mcp import MCPServerStdio

async def create_agent_with_mcp():
    server = MCPServerStdio(
        name="External Service",
        command="npx",
        args=["-y", "my-mcp-server"],
    )

    try:
        async with server:
            agent = Agent(
                name="My Agent",
                instructions="Usa el servicio externo.",
                mcp_servers=[server],
            )
            result = await Runner.run(agent, "Ejecuta la tarea.")
            return result.final_output
    except Exception as e:
        # Modo de respaldo sin MCP
        fallback_agent = Agent(
            name="My Agent (degraded mode)",
            instructions="El servicio externo no está disponible. Informa al usuario.",
        )
        result = await Runner.run(fallback_agent, "El servicio no está disponible.")
        return result.final_output

El agente de respaldo no finge funcionar: anuncia la indisponibilidad. Un agente que inventa una respuesta cuando su fuente de datos está caída cuesta mucho más que uno que admite que no puede continuar.

Puntos clave

  • MCP es un protocolo abierto para conectar servicios externos a tu agente
  • Usa MCPServerStdio para servidores locales y MCPServerSse para servidores remotos
  • Los conectores de OpenAI son integraciones gestionadas en la plataforma
  • Puedes combinar herramientas de función y servidores MCP en el mismo agente
  • Gestiona los errores de conexión de MCP con un modo degradado