Entender la diferencia entre API, MCP y A2A es la base para construir cualquier sistema de IA real — y confundirlos lleva a arquitecturas que no escalan. Este análisis explica los tres protocolos, cuándo usar cada uno, cómo se integran en un stack completo, y da ejemplos de código y configuración para empezar de inmediato. Especialmente útil para founders técnicos o desarrolladores que están integrando IA en productos o flujos de trabajo propios.
Toda aplicación de IA moderna usa alguna combinación de estos tres protocolos. No son competencia entre sí — son capas que se apilan. Confundirlos lleva a diseños donde la IA no puede acceder a los datos que necesita, o donde un único agente intenta hacer todo en lugar de delegar.
La pregunta central para orientarse es siempre la misma: ¿quién habla con quién?
Una API (Application Programming Interface) es el mecanismo por el que tu aplicación envía texto a un modelo de lenguaje y recibe una respuesta. Es la capa más fundamental: sin API, no existe ningún producto de IA.
El flujo es siempre el mismo: tu app construye un request con el mensaje del usuario, lo manda al endpoint del proveedor con tu API key, el modelo procesa el input, y devuelve una respuesta estructurada.
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const message = await client.messages.create({
model: "claude-sonnet-4-20250514",
max_tokens: 1024,
messages: [{ role: "user", content: "¿Qué es machine learning?" }],
});
console.log(message.content[0].text);
Los principales proveedores con API pública hoy:
| Proveedor | Modelos principales |
|---|---|
| Anthropic | Claude Sonnet, Opus, Haiku |
| OpenAI | GPT-4o, o1, DALL-E |
| Gemini 1.5, Gemini 2.0 | |
| Mistral AI | Mistral Large, Mixtral |
La API requiere intervención humana en cada ciclo: alguien (o algún código tuyo) construye y envía el request. La IA responde, pero no inicia nada por sí sola ni accede a datos externos a menos que tú se los pases explícitamente en el mensaje.
Señal de que necesitas solo API: tu caso de uso es responder preguntas, generar texto, clasificar inputs o traducir contenido. El modelo no necesita acceder a sistemas externos — solo procesar lo que le mandas.
MCP (Model Context Protocol) es un protocolo abierto desarrollado por Anthropic en 2024. Resuelve un problema concreto: la IA necesita acceder a tus datos y herramientas, pero hacerlo manualmente (copiar y pegar desde el calendario, exportar CSV de la base de datos, descargar archivos) es lento e inescalable.
Con MCP, la IA tiene acceso directo. Un MCP Client (Claude, en la mayoría de los casos) se conecta a MCP Servers que exponen capacidades específicas: leer archivos, consultar bases de datos, navegar el web, leer el calendario.
Claude (client) ↔ Google Calendar Server → lee eventos
Claude (client) ↔ PostgreSQL Server → consulta base de datos
Claude (client) ↔ Browser Server → navega el web
El protocolo usa JSON-RPC 2.0 como formato de mensajería. Cada herramienta se describe con un JSON schema que el cliente descubre automáticamente:
{
"name": "read_file",
"description": "Lee el contenido de un archivo",
"inputSchema": {
"type": "object",
"properties": {
"path": { "type": "string" }
},
"required": ["path"]
}
}
El transporte puede ser local (stdio, para servidores que corren en tu máquina) o remoto (SSE/HTTP, para servicios en la nube).
# Agregar acceso al filesystem local
claude mcp add filesystem -s user -- npx -y @anthropic-ai/mcp-filesystem
# Agregar acceso a PostgreSQL
claude mcp add postgres -s project -- npx -y @anthropic-ai/mcp-postgres postgresql://usuario:password@host/db
# Ver todos los MCP configurados
claude mcp list
Con estos dos comandos, Claude puede leer y escribir archivos en tu máquina y consultar tu base de datos directamente desde la conversación, sin que copies nada manualmente.
claude mcp addSeñal de que necesitas MCP: la IA necesita leer tu base de datos, acceder a archivos del proyecto, interactuar con APIs de terceros (calendar, CRM, correo) o navegar sitios web — todo sin que tú copies esos datos al chat manualmente.
A2A (Agent-to-Agent) es un protocolo lanzado por Google en 2025. Su propósito es permitir que agentes de IA se comuniquen y deleguen trabajo entre ellos sin intervención humana en cada paso.
La diferencia con MCP es conceptual: MCP conecta a la IA con herramientas pasivas (una base de datos no toma decisiones). A2A conecta a una IA con otra IA — cada participante puede razonar, decidir y actuar de forma autónoma.
Ejemplo real: generar un reporte de mercado. El agente orquestador asigna investigación a un Research Agent, redacción a un Writer Agent, y distribución a un Delivery Agent. Cada uno publica su capacidad en un Agent Card:
{
"name": "Research Agent",
"description": "Investiga temas y entrega resúmenes",
"skills": ["web_search", "summarize", "cite_sources"],
"endpoint": "https://agent.example.com/a2a"
}
El Agent Card se publica en /.well-known/agent.json del servidor del agente, similar a cómo un sitio publica su robots.txt. Cualquier orquestador puede descubrirlo y comenzar a delegarle trabajo.
Cada tarea tiene un objeto con ID único y un ciclo de vida: submitted → working → completed.
Señal de que necesitas A2A: tienes flujos donde múltiples IAs especializadas necesitan pasar trabajo entre sí de forma autónoma — no como llamadas a herramientas, sino como agentes que toman decisiones independientes en su dominio.
En un sistema de IA maduro, los tres protocolos coexisten en capas:
| Capa | Protocolo | Función | Requiere humano |
|---|---|---|---|
| Base | API | Tu app se comunica con el modelo | Sí |
| Media | MCP | El modelo accede a datos y herramientas | No |
| Alta | A2A | Agentes se coordinan entre sí | No |
Sin API, no hay IA. Sin MCP, la IA opera ciega — solo sabe lo que tú le copias manualmente. Sin A2A, la IA no puede delegar ni escalar a flujos complejos.
La complejidad también escala en ese orden: API es la integración más simple y directa, MCP requiere configurar servidores pero sigue siendo manejable para un solo desarrollador, y A2A implica diseñar arquitecturas multi-agente con estados, handoffs y manejo de errores distribuido.
| Si tu pregunta es... | El protocolo es |
|---|---|
| ¿Mi app manda un mensaje y recibe una respuesta? | API |
| ¿La IA accede a mis herramientas o datos directamente? | MCP |
| ¿Múltiples IAs se pasan trabajo entre ellas? | A2A |
El orden natural de adopción sigue las capas:
Primera llamada a API — elige un proveedor (Anthropic, OpenAI, Google) y haz tu primer request con el SDK oficial. Es la base de todo lo demás.
Primer servidor MCP — instala @anthropic-ai/mcp-filesystem o el MCP de GitHub en Claude Code. En menos de 10 minutos Claude puede leer tu repositorio o tus archivos locales sin que copies nada.
Primer experimento multi-agente — CrewAI o LangGraph tienen ejemplos de dos agentes coordinándose que se pueden correr localmente. El objetivo no es producción, sino entender el modelo mental de A2A.
Leer las especificaciones cuando ya tengas contexto práctico: modelcontextprotocol.io para MCP y google.github.io/A2A para el protocolo A2A.
La trampa común es saltarse capas: intentar implementar A2A sin tener bien claro cómo funciona MCP, o añadir MCP antes de tener una API call básica funcionando. El stack se construye de abajo hacia arriba.