Cómo Exponer tu API Existente a los LLMs a través de MCP: Una Guía Completa

Integrar modelos de lenguaje grande (LLMs) con tu API existente puede ser un desafío. Tradicionalmente, necesitarías conectores personalizados o plugins específicos de plataforma para permitir el acceso de la IA a tu servicio. El Protocolo de Contexto de Modelo (MCP) ofrece una mejor manera.

¿Qué es el protocolo de contexto de modelo (MCP)?

MCP es un estándar abierto de Anthropic (ahora un proyecto de código abierto) que estandariza cómo los asistentes de IA se conectan a datos y herramientas externas. Piensa en MCP como un adaptador universal—un “puerto USB-C” para aplicaciones de IA. En lugar de crear integraciones individuales para cada modelo o plataforma, expones tu API una vez a través de MCP, y cualquier LLM compatible con MCP puede utilizarla.

Beneficios Clave de MCP

• Estandarización: Reemplaza integraciones fragmentadas con un protocolo único y consistente
• Reutilización: Construye tu conector de API una vez como servidor MCP, y múltiples clientes de IA pueden aprovecharlo
• Control: El servidor MCP se ejecuta en tu entorno, por lo que puedes aplicar seguridad y gestionar exactamente a qué puede acceder el modelo

MCP actúa como un sistema de plugins universal para LLMs, proporcionando una forma estructurada para que una IA llame a funciones o recupere datos de fuentes externas.

Entendiendo los primitivos de MCP

MCP utiliza tres conceptos principales para exponer funcionalidades:

1. Recursos: Son como puntos finales de datos de solo lectura. Un recurso se identifica por un URI (por ejemplo, todo://list) y proporciona datos al modelo. Los recursos están destinados a cargar contexto en el modelo (como recuperar un documento, registro de base de datos o lista de tareas). Son similares a solicitudes GET y normalmente no cambian el estado.
2. Herramientas: Son acciones u operaciones que el modelo puede invocar—esencialmente funciones con parámetros y valores de retorno que el LLM puede llamar. Las herramientas pueden tener efectos secundarios o realizar cálculos. Piensa en las herramientas como “funciones que la IA puede llamar”.
3. Prompts: MCP permite definir plantillas de conversación o flujos de trabajo reutilizables. Los prompts son como fragmentos de conversación predefinidos que el servidor puede proporcionar al cliente.

En resumen: los recursos cargan datos para el modelo, las herramientas realizan acciones, y los prompts guían las interacciones.

Implementación: Guía paso a paso

Veamos cómo exponer una API REST simple a un asistente de IA usando MCP.

Paso 1: Configurar un ejemplo de API REST simple

Usaremos una API básica de lista de tareas como nuestro ejemplo. Aquí hay una implementación mínima usando Flask:

from flask import Flask, request, jsonify

app = Flask(__name__)
tasks = [ {"id": 1, "title": "Sample Task", "done": False} ]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    # Return the full list of tasks
    return jsonify(tasks)

@app.route('/tasks', methods=['POST'])
def create_task():
    # Add a new task from the JSON request body
    data = request.get_json()
    new_task = {
        "id": len(tasks) + 1,
        "title": data.get("title"),
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

# Run with: flask run

Esta API tiene dos endpoints:

• GET /tasks - Recuperar todas las tareas
• POST /tasks - Añadir una nueva tarea

En un escenario real, esto podría ser cualquier API existente con un backend de base de datos.

Paso 2: Crear un servidor MCP para envolver la API

Ahora crearemos un servidor MCP en Python que exponga nuestra API de tareas a un LLM:

Primero, instala el paquete MCP:

pip install "mcp[cli]"

Luego crea un archivo llamado todo_mcp_server.py:

from mcp.server.fastmcp import FastMCP
import requests  # we'll use requests to call our REST API

# Initialize an MCP server with a descriptive name
mcp = FastMCP("To-Do API MCP Server")

# Define a Resource for reading tasks (like a GET endpoint)
@mcp.resource("todo://list")
def list_tasks() -> list:
    """Fetch all to-do tasks from the API."""
    response = requests.get("http://localhost:5000/tasks")
    response.raise_for_status()
    return response.json()  # return the list of tasks

# Define a Tool for adding a new task (like a POST operation)
@mcp.tool()
def add_task(title: str) -> dict:
    """Add a new task via the API and return the created task."""
    payload = {"title": title}
    response = requests.post("http://localhost:5000/tasks", json=payload)
    response.raise_for_status()
    return response.json()  # return the new task data

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

Analicemos lo que está sucediendo:

• Creamos una instancia FastMCP llamada "To-Do API MCP Server", que configura el servidor y registra nuestras herramientas/recursos.
• Usamos @mcp.resource("todo://list") para exponer un recurso que devuelve la lista de tareas. Esto se mapea a nuestro endpoint GET de la API.
• Usamos @mcp.tool() para exponer una herramienta que añade una nueva tarea. Esto se mapea a nuestro endpoint POST de la API.
• Las docstrings para cada función son importantes - el LLM verá estas descripciones cuando decida cómo usar las herramientas.
• Ejecutamos el servidor con mcp.run(transport="stdio"), que se comunica usando entrada/salida estándar (bueno para desarrollo local).

En este punto, tenemos un servidor MCP con dos capacidades: un recurso todo://list (para obtener tareas) y una herramienta add_task (para crear una tarea). Estas corresponden a las funcionalidades de nuestra API. En efecto, hemos envuelto la API REST con MCP.

Paso 3: Ejecutar y probar el servidor MCP localmente

Antes de ejecutar el servidor MCP, asegúrate de que tu API Flask esté funcionando (por ejemplo, con flask run).

Ahora inicia el servidor MCP en modo de desarrollo:

mcp dev ./todo_mcp_server.py

El comando mcp dev lanza un panel de control de desarrollo interactivo en tu navegador. Este panel te permite:

1. Ver el nombre de tu servidor MCP y las herramientas/recursos disponibles
2. Probar el recurso todo://list - debería devolver la lista actual de tareas
3. Probar la herramienta add_task - introduce un título de tarea y ejecútalo
4. Verificar resultados y ver registros en el panel de historial

Este panel es invaluable para desarrollo y depuración. Está utilizando el mismo protocolo MCP que usaría un cliente LLM real, pero con una interfaz gráfica para pruebas.

Paso 4: Conectar el servidor MCP a un cliente LLM

Ahora vamos a conectar un LLM en vivo a nuestro servidor MCP. Varios asistentes de IA y herramientas son compatibles con MCP, incluyendo:

Conexión con Claude desktop

La aplicación Claude Desktop de Anthropic tiene soporte integrado para servidores MCP locales. Para integrar:

mcp install ./todo_mcp_server.py

Esto registra tu servidor con Claude. En la interfaz de Claude, deberías ver disponible tu “To-Do API MCP Server”. Ahora cuando tengas una conversación con Claude, puedes:

• Preguntar: “Lista mis tareas pendientes” - Claude usará el recurso todo://list
• Solicitar: “Añade una tarea para comprar leche” - Claude usará la herramienta add_task

Claude se encargará de ejecutar el servidor MCP y enrutar las solicitudes cuando la IA decida usarlo.

Conexión con el IDE Cursor

Cursor es un editor de código con un asistente de IA que soporta MCP. Para conectar:

1. Ve a la configuración de Cursor en “Model Context Protocol”
2. Añade tu servidor MCP proporcionando la ruta a todo_mcp_server.py
3. Especifica el transporte (stdIo)

Una vez conectado, Cursor detectará las herramientas y recursos de tu servidor. Entonces podrás hacer preguntas al asistente de Cursor como “¿Qué tareas hay en mi lista de tareas?” o “Añade ‘escribir entrada de blog’ a mis tareas.”

Notas generales sobre clientes LLM

Los pasos exactos de conexión varían según el cliente:

• Para Claude Desktop, usa mcp install o la interfaz de la aplicación
• Para Cursor, configura el servidor en la configuración
• Otros entornos pueden tener enfoques diferentes

Después de conectar, prueba solicitando a la IA de una manera que fomente el uso de herramientas. Muchos clientes MCP indicarán visualmente cuando la IA usa una herramienta.

Nota de Seguridad: Al conectar un servidor MCP, el LLM tendrá acceso a todo lo que ese servidor expone. Los servidores MCP típicamente se ejecutan localmente o dentro de tu infraestructura, lo cual es bueno para la seguridad. Si tu API requiere autenticación, puedes incluir esas credenciales en el código de tu servidor MCP.

Comparando MCP con enfoques tradicionales

Veamos cómo usar MCP para exponer una API difiere de otros métodos de integración:

Llamadas directas a la API de LLM (Sin MCP)

Sin MCP, podrías:

• Usar llamadas a funciones o plugins que son específicos de plataforma (vinculados a OpenAI o un entorno específico)
• Incrustar detalles de API en prompts, lo cual es propenso a errores - el modelo podría alucinar endpoints o enviar formatos incorrectos

GraphQL u otros lenguajes de consulta

Con GraphQL, podrías hacer que el LLM construya consultas, pero:

• El modelo aún necesita conocer el esquema y la sintaxis de consulta
• Probablemente necesitarías una capa de integración personalizada para verificar las consultas del modelo

La ventaja de MCP

Usar MCP abstrae estos detalles en una interfaz estandarizada:

• El LLM no necesita conocer métodos HTTP o sintaxis de consulta
• Consulta al servidor MCP para conocer herramientas y recursos disponibles, que tienen nombres y descripciones legibles por humanos
• El proceso se centra en capacidades en lugar de llamadas de bajo nivel
• El mismo servidor MCP funciona para cualquier cliente que soporte el protocolo

Aquí hay una comparación detallada:

Aspecto Integración API Tradicional Usando Integración MCP Estandarización Sin estándar unificado - cada plataforma tiene su propio método de integración o formato de plugin Un estándar abierto entre plataformas - construye una vez, usa en cualquier lugar Descubrimiento de Acciones El LLM debe ser informado sobre qué endpoints/consultas están disponibles, o están codificados Los clientes LLM pueden listar programáticamente herramientas/recursos disponibles de un servidor MCP Acceso a Datos Las respuestas de API a menudo se envían a través de prompts, alcanzando límites de contexto Los recursos MCP cargan datos directamente en el contexto del LLM de manera gestionada Esfuerzo de Codificación Alto - llamadas HTTP personalizadas, análisis y manejo de errores para cada modelo Simplificado - el SDK de MCP maneja detalles del protocolo; tú escribes funciones Python Seguridad y Control El modelo podría generar llamadas HTTP arbitrarias si no está restringido El servidor MCP actúa como guardián - tú decides exactamente qué se expone Flexibilidad Difícil de adaptar a nuevos LLMs o casos de uso Muy flexible - los modelos pueden orquestar múltiples llamadas MCP; fácil de añadir nuevas herramientas

En resumen, MCP ofrece una capa más amigable para IA sobre tu API. En lugar de lidiar con llamadas HTTP crudas, el modelo interactúa con acciones y datos nombrados que tienen sentido en una conversación.

Conclusión

Exponer tu API REST existente a LLMs a través de MCP puede simplificar enormemente la integración. En lugar de crear conexiones individuales para cada plataforma de IA, implementas el Protocolo de Contexto de Modelo una vez y obtienes compatibilidad con cualquier cliente compatible.

MCP proporciona una forma estandarizada, segura y flexible de conectar IA y tus datos. Convierte tu API en un componente modular que cualquier IA avanzada puede usar de manera responsable e inteligente. Esto abre nuevas posibilidades: tu asistente impulsado por LLM podría combinar tu API con otros conectores MCP, todo dentro del mismo marco unificado.

Preguntas Frecuentes