¿Qué es MCP (Model Context Protocol)?
Guía completa en español

Publicado el 3 de junio de 2026 · 12 min de lectura · Blog MasterEnClaude

Si has oído hablar de MCP pero no tienes claro qué es exactamente, este artículo te lo explica de principio a fin. Model Context Protocol es probablemente la pieza de infraestructura más importante que ha publicado Anthropic en los últimos meses, y entenderlo te abre las puertas a construir agentes de IA verdaderamente útiles.

¿Qué es MCP exactamente?

MCP (Model Context Protocol) es un protocolo abierto, publicado por Anthropic en noviembre de 2024, que define cómo los modelos de lenguaje como Claude pueden conectarse de forma estandarizada a fuentes de datos externas, herramientas y sistemas. En la práctica, es como un "conector universal" que permite a Claude leer ficheros, consultar bases de datos, llamar a APIs, ejecutar código y mucho más, sin que Anthropic tenga que implementar cada integración por su cuenta.

Antes de MCP, cada equipo que quería conectar un LLM a sus datos lo hacía de forma ad hoc: prompt engineering manual, llamadas a función personalizadas, middleware propietario. MCP estandariza ese proceso con una arquitectura cliente-servidor clara y un protocolo de comunicación basado en JSON-RPC 2.0.

Lo importante: MCP es agnóstico al modelo. Aunque nació en el ecosistema de Anthropic y está integrado en Claude nativo, cualquier LLM puede implementar el protocolo. Ya lo están adoptando otros proyectos de código abierto.

Arquitectura de MCP: cliente, servidor y host

Para entender MCP hay que distinguir tres roles:

• Host: La aplicación que el usuario usa directamente. Por ejemplo, Claude.ai, Claude Code o tu propio chatbot. El host alberga el cliente MCP.
• Cliente MCP: El componente dentro del host que habla el protocolo MCP. Gestiona la conexión con los servidores y expone sus capacidades al modelo.
• Servidor MCP: Un proceso independiente (puede ser local o remoto) que expone capacidades concretas: leer ficheros, consultar una base de datos, llamar a una API de terceros, etc.

El flujo básico es: el host arranca uno o varios servidores MCP, el cliente se conecta a ellos, y Claude puede invocar sus capacidades durante una conversación. El usuario pregunta algo, Claude decide que necesita consultar un servidor MCP para responder, el cliente hace la petición, el servidor devuelve el resultado y Claude integra esa información en su respuesta.

Los tres primitivos: Tools, Resources y Prompts

Los servidores MCP pueden exponer tres tipos de capacidades:

1. Tools (Herramientas)

Son funciones que Claude puede ejecutar. Tienen un nombre, una descripción en lenguaje natural y un schema JSON que define sus parámetros. Cuando Claude decide llamar a una tool, el cliente MCP invoca la función correspondiente en el servidor y devuelve el resultado. Ejemplos: buscar en internet, ejecutar una consulta SQL, enviar un correo, leer un fichero del sistema.

2. Resources (Recursos)

Son fuentes de datos que el servidor expone como contenido que Claude puede leer. Un resource tiene una URI única (por ejemplo, file:///proyecto/src/main.py o db://customers/tabla_ventas), un tipo MIME y su contenido. A diferencia de las tools, los resources no ejecutan acciones, simplemente proporcionan información al contexto.

3. Prompts (Plantillas)

Son plantillas de prompt reutilizables que el servidor puede ofrecer al host. Permiten que los equipos de backend definan instrucciones complejas una sola vez y las reutilicen en múltiples flujos. El usuario puede seleccionar un prompt por nombre y el host lo inyecta en la conversación.

Transportes: cómo se comunican cliente y servidor

MCP soporta dos mecanismos de transporte principales:

• stdio: El servidor se lanza como un subproceso y la comunicación ocurre por stdin/stdout. Es el transporte más común para servidores locales (como en Claude Code o Claude Desktop).
• HTTP con SSE (Server-Sent Events): Permite servidores MCP remotos accesibles vía red. El cliente hace peticiones HTTP y el servidor puede enviar eventos en streaming. Ideal para integraciones cloud o equipos distribuidos.

Ejemplo: servidor MCP mínimo en Python

El SDK oficial de Python (mcp) hace muy sencillo crear un servidor. Aquí un ejemplo de servidor que expone una tool para convertir temperatura:

# pip install mcp
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types

app = Server("conversor-temperatura")

@app.list_tools()
async def listar_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="celsius_a_fahrenheit",
            description="Convierte grados Celsius a Fahrenheit",
            inputSchema={
                "type": "object",
                "properties": {
                    "celsius": {
                        "type": "number",
                        "description": "Temperatura en grados Celsius"
                    }
                },
                "required": ["celsius"]
            }
        )
    ]

@app.call_tool()
async def llamar_tool(name: str, arguments: dict):
    if name == "celsius_a_fahrenheit":
        celsius = arguments["celsius"]
        fahrenheit = (celsius * 9 / 5) + 32
        return [types.TextContent(type="text", text=f"{celsius}°C = {fahrenheit}°F")]
    raise ValueError(f"Tool desconocida: {name}")

async def main():
    async with stdio_server() as (read_stream, write_stream):
        await app.run(read_stream, write_stream, app.create_initialization_options())

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

Una vez creado, puedes registrar este servidor en Claude Code añadiéndolo a tu configuración de MCP:

# En tu proyecto, ejecuta:
claude mcp add conversor-temperatura python conversor_temp.py

# Claude Code arrancará el servidor automáticamente y Claude
# podrá usar la tool celsius_a_fahrenheit en tus conversaciones.

¿Por qué MCP importa tanto?

La razón de fondo es la siguiente: los modelos de lenguaje son increíblemente capaces razonando y generando texto, pero su conocimiento está congelado en el tiempo de entrenamiento y no tienen acceso nativo a tus datos. MCP resuelve ese problema de forma elegante y estandarizada.

Además, al ser un protocolo abierto con SDKs en Python, TypeScript y otros lenguajes, cualquier desarrollador puede crear un servidor MCP para sus propios sistemas y publicarlo. La comunidad ya ha creado servidores para GitHub, Slack, PostgreSQL, Google Drive, Notion, y docenas de herramientas más.

En el contexto de Claude Code (el agente de programación en terminal), MCP es fundamental: permite a Claude acceder a tu base de código, ejecutar tests, consultar documentación interna o incluso gestionar tus issues en GitHub, todo dentro del mismo flujo de trabajo. Si quieres saber más sobre Claude Code, lee también nuestro artículo Qué es Claude Code y cómo usarlo para programar con IA.

MCP vs. function calling: ¿cuál es la diferencia?

El tool use (o function calling) de la API de Claude permite definir funciones en el cuerpo de la petición a la API y que el modelo decida cuándo invocarlas. MCP es una capa de más alto nivel que:

• Separa la definición de tools del código de la aplicación principal (viven en servidores independientes).
• Añade los primitivos de Resources y Prompts que el tool use puro no tiene.
• Permite que las tools sean descubiertas dinámicamente en tiempo de ejecución.
• Proporciona un protocolo de comunicación estándar reutilizable entre diferentes hosts y servidores.

En la práctica, bajo el capó, cuando Claude usa una tool MCP, la interacción con la API de Anthropic sigue usando el mecanismo de tool use. MCP es la capa de orquestación por encima.

Cómo empezar con MCP hoy mismo

El camino más rápido para experimentar con MCP sin escribir código propio es usar uno de los servidores MCP de referencia que Anthropic mantiene en su repositorio oficial:

• @modelcontextprotocol/server-filesystem: acceso a ficheros locales.
• @modelcontextprotocol/server-github: leer repos, issues y PRs de GitHub.
• @modelcontextprotocol/server-postgres: consultas a bases de datos PostgreSQL.
• @modelcontextprotocol/server-brave-search: búsqueda web en tiempo real.

Para el siguiente paso, lo más eficiente es aprender directamente en el contexto de un proyecto real. En el curso MasterEnClaude dedicamos un módulo completo a MCP: configuración, creación de servidores personalizados, integración con Claude Code y casos de uso avanzados. También puedes empezar descargando nuestra guía gratuita de Claude si aún no lo has hecho.