Introducción

Imagina que tienes los mejores agentes de inteligencia artificial disponibles, capaces de razonar, planificar y ejecutar tareas complejas. Pero están aislados, sin acceso a tus datos, sin conexión con tus herramientas de trabajo, sin capacidad de interactuar con tu entorno real.

El Model Context Protocol (MCP) cambia ese panorama. Es el estándar abierto que permite conectar agentes IA con tu infraestructura de forma unificada, segura y transparente.

En este artículo explicare qué es MCP, qué es un MCP server, y por qué debería importarte como desarrollador o profesional que trabaja con IA.

Nota rápida: MCP no es una tecnología propietaria. Es un protocolo abierto, similar a HTTP o JSON-RPC, que define cómo los agentes solicitan contextos y cómo los servidores de recursos responden.

¿Qué es MCP?

MCP (Model Context Protocol) es un estándar de protocolo abierto desarrollado por Anthropic que define cómo los agentes de inteligencia artificial pueden conectarse con datos, herramientas y conectores de una manera unificada.

El protocolo resuelve un problema fundamental: la fragmentación. Antes de MCP, cada herramienta, cada plataforma, cada proveedor tenía su propia API, sus propios formatos, sus propias autenticaciones. Los agentes IA necesitaban adaptadores personalizados para cada servicio, multiplicando la complejidad y las vulnerabilidades.

Con MCP:

  • Un único formato de comunicación: MCP usa JSON-RPC 2.0 como base, un estándar bien conocido en el mundo del desarrollo.
  • Separación de preocupaciones: El agente solo sabe qué hacer, el server MCP sabe qué datos o herramientas ofrecen.
  • Seguridad por diseño: Los servers MCP deciden qué puede acceder cada agente, sin exponer credenciales directamente.
  • Interoperabilidad: Un agente puede conectarse a múltiples servers MCP sin reescribirse.

La arquitectura de MCP es simple:

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│    Agente AI    │────▶│     MCP Client   │◀───│   MCP Server     │
│    (Llama,      │  RPC│   (ponte como     │  ───────┐   (Tu data, │
│     Claude, etc)│     │    puente)        │         │   herramientas)  
└─────────────────┘     └──────────────────┘         └──────────────┘

El agente define qué quiere hacer (ej. "buscar en Google", "leer un archivo", "buscar en repositorio de código").
El MCP server define qué puede ofrecer (ej. "puedo buscar", "puedo leer archivos", "puedo consultar una base de datos").

¿Qué es un MCP Server?

Un MCP server es un componente o servicio que expone recursos, herramientas o prompts al protocolo MCP. Es el "punto de conexión" entre tus datos/herramientas y los agentes.

Tipos de servidores MCP

1. Servers de recursos (Resources)

Expone datos estáticos o dinámicos que los agentes pueden leer.

Ejemplos:

  • Un servidor que sirve el contenido de tu wiki interno
  • Un servidor que expone las notas de tus sesiones anteriores
  • Un servidor que consulta una base de datos de métricas
{"method": "resources/list"}

Respuesta del server:

[
  {"uri": "mcp://tu-servidor/datos/proyecto-alpha", "name": "Datos Proyecto Alpha"},
  {"uri": "mcp://tu-servidor/notas/", "name": "Mis notas"}
]

2. Servers de herramientas (Tools)

Expone acciones que los agentes pueden invocar.

Ejemplos:

  • Buscar en Google
  • Ejecutar comandos en tu terminal
  • Consultar una API REST
  • Generar un resumen de un documento
{"method": "tools/list"}

Respuesta del server:

[
  {
    "name": "buscar_en_google",
    "description": "Realiza una búsqueda en Google y devuelve resultados relevantes",
    "inputSchema": {
      "type": "object",
      "properties": {
        "query": {"type": "string"}
      }
    }
  }
]

3. Servers de prompts (Prompts)

Expone plantillas de prompts predefinidos que los agentes pueden usar como punto de partida para la conversación.

Ejemplos:

  • "Genera un plan de desarrollo para este problema"
  • "Actúa como revisor de código para este pull request"
  • "Crea una especificación técnica para esta API"

Ejemplo práctico: un servidor MCP en Python

Este es un ejemplo mínimo de un MCP server que expone una herramienta de búsqueda:

from mcp.server import Server
from mcp.server.stdio import stdio

server = Server("mi-server-busqueda")

@server.list_tools()
async def list_tools() -> list:
    return [
        {
            "name": "buscar_en_google",
            "description": "Realiza una búsqueda en Google",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "El texto a buscar"}
                },
                "required": ["query"]
            }
        }
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "buscar_en_google":
        query = arguments.get("query")
        # Aquí harías la búsqueda real
        return {"content": [{"type": "text", "text": f"Resultados para: {query}"}]}
    return {"error": "Herramienta no encontrada"}

if __name__ == "__main__":
    await server.run()

¿Dónde se ejecutan los servers MCP?

Los MCP servers son tan flexibles que pueden estar en cualquier lugar:

  • Contenedores Docker: Tu servidor de búsqueda puede estar en Docker con acceso al internet.
  • Lambda functions: Un server MCP puede estar en AWS Lambda, consultando una API de tu empresa.
  • Script local: Un script Python que lee tus archivos del sistema.
  • Servicios web: Un API Express.js o FastAPI que expone endpoints MCP.
  • Procesos locales: Un proceso que tiene acceso a tu terminal o base de datos local.

Lo importante es que el protocolo es el mismo, sin importar dónde residan los datos o dónde se ejecuten las herramientas.

¿Por qué importa MCP?

1. Resuelve la fragmentación

Imagina tener que:

  • Configurar credenciales separadas para Slack, GitHub, Google Drive, Notion, Jira
  • Escribir scripts diferentes para conectar con cada servicio
  • Manuamente pasar información entre herramientas

Con MCP, un único agente puede conectarse a todos esos servicios usando los mismos conectores MCP. No necesitas un script especial para cada plataforma.

2. Mejora la seguridad

Antes, los agentes a veces necesitaban acceso directo a tus API keys, exponiendo credenciales.
Con MCP:

  • Cada server MCP decide qué puede ver cada agente
  • Los tokens de acceso son manejados por el server, no por el agente
  • Puedes auditar quién accede a qué recurso
  • El agente no necesita saber la estructura interna de tus datos
Malo: Agente ────────(API key expuesta)────────► Base de datos

Mejor: Agente ──(MCP server con permisos restrictivos)─► Base de datos

3. Es estandarización abierta

MCP no está atado a un único proveedor:

  • Anthropic (Claude) lo desarrolló inicialmente
  • Es compatible con Llama, Gemini, otros modelos
  • Hay implementaciones en Node.js, Python, Go, Rust
  • La comunidad está creando conectores para cada servicio

Es el HTTPS de los agentes IA.

4. Reduce la complejidad operativa

Sin MCP: tu ingeniero de IA necesita entender 10 APIs diferentes, cada una con su autenticación propia.

Con MCP: tu ingeniero de IA necesita entender un único protocolo y conectar los servers. Los servers pueden estar mantenidos por el equipo de infraestructura, no por el equipo de IA.

5. Habilita agentes multi-fuente

Antes de MCP, un agente se conectaba a una única fuente de datos. Con múltiples servers MCP, un agente puede:

  • Leer notas de tu wiki, buscar en GitHub, consultar tu CRM, y verificar con Slack — en una sola operación coordinada
  • Comparar información de múltiples fuentes antes de tomar una decisión

Ejemplos prácticos

Escenario 1: Investigación de mercado

Tienes un agente de investigación que necesita:

  1. Buscar tendencias en internet (Google)
  2. Leer el análisis interno de la empresa (Wiki)
  3. Consultar el CRM para datos de clientes
  4. Verificar si se anunciaron cambios recientes en la plataforma (Slack)

Sin MCP: necesitas 4 adaptadores separados, 4 sistemas de autenticación, 4 procesos de coordinación.

Con MCP server:

Agente ────────────────────────
  │
  ├─ MCP: google-search ───────► Google
  ├─ MCP: wiki-content ────────► Wiki local
  ├─ MCP: crm-lookups ─────────► CRM (seguido de patrones)
  └─ MCP: slack-channels ───────► Slack

Escenario 2: Desarrollo con contexto

Desarrollador trabajando en un proyecto de código:

# Agente con acceso a:
# - Repositorio de código (MCP: github-files)
# - Issues de GitHub (MCP: github-issues)
# - Base de datos de API (MCP: api-docs)
# - Documentación técnica (MCP: technical-docs)

# El agente puede:
# "Analiza el issue #42 y escribe un pull request que soluciona el problema
#  consultando el código existente y la documentación de la API"

Escenario 3: Análisis de datos unificado

Un server MCP que une múltiples fuentes de datos:

// Recursos disponibles para el agente
[
  {"name": "Ventas 2025", "uri": "mcp://ventas/db/ventas"},
  {"name": "Precios proveedores", "uri": "mcp://precios/db/supply-chain"},
  {"name": "Inventario actual", "uri": "mcp://inventory/db/allocation"}
]

El agente puede responder preguntas como:

"Recomiéndame un proveedor para el componente X basándote en los últimos 3 años de rendimiento, precio y plazos de entrega."

Ejemplo de CLI para MCP

Puedes crear una CLI que expone herramientas MCP:

# Ejecutar tu MCP server en modo CLI
npx @modelcontextprotocol/server-git

# O con Python (usando mcp-server[cli])
mcp-server-git

Los MCP servers también soportan autenticación: OAuth2, tokens, claves compartidas, etc.

Cómo empezar con MCP

Como desarrollador (creador de servers)

  1. Elige tus datos: ¿Qué expones? (api, files, database, prompts, tools)
  2. Define el protocolo: ¿Qué endpoints MCP expones? (list_resources, list_tools, call_tool, read_resource)
  3. Implementa seguridad: ¿Cómo autenticas? ¿Qué límites pones?
  4. Publica: Docker o como servicio web

Como usuario (creador de agentes)

  1. Instala una extensión MCP en tu cliente de IA (Claude Desktop, VS Code, etc.)
  2. Configura connections: Añade los servers MCP de tu elección
  3. Prueba: Ejecuta una tarea compleja y observa cómo el agente orquesta múltiples servers MCP

Libraries:

  • Python: mcp (de Anthropic)
  • Node.js: @modelcontextprotocol/sdk
  • Go: Pruebas de implementación
  • Rust: mcp-rs (en desarrollo)

Conclusión

MCP es el estándar que los agents han necesitado.

Antes del protocolo, cada agente vivía en una isla, sin acceso estructurado a datos externos ni herramientas externas. Ahora, el agente es un orquestador que puede conectar con múltiples servidores MCP, consultando datos, invocando herramientas, invirtiendo prompts, y coordinando múltiples fuentes de información.

El ecosistema está creciendo rápidamente:

  • Anthropic, Microsoft, Google están aportando implementaciones
  • Conectores para Slack, GitHub, Notion, Google Drive se están multiplicando
  • Documentación y tutoriales están proliferando

Si trabajas con agentes IA, familiarizarte con MCP es tan importante como aprender a usar Docker en los años 2010 o REST API en los 2015.

Es el protocolo que permitirá escalar el uso de agentes desde experimentos aislados a flujos de trabajo productivos y seguros.

MCP: Contexto, conexión y estandarización para la era de los agentes.