comunidad bóvedaAPIs, MCPs y A2A

APIs, MCPs y A2A

Los tres protocolos que mueven la inteligencia artificial hoy. API conecta tu app con la IA, MCP conecta la IA con tus herramientas, y A2A conecta a la IA con otra IA. Tres protocolos, tres capas, un solo stack.

Qué vas a aprender

Qué es cada protocolo — explicado con analogías simples y sin jerga innecesaria.
Cómo identificar cuál estás usando — la pregunta clave siempre es: ¿quién habla con quién?
Ejemplos reales de cada uno — para que lo veas funcionando, no solo en teoría.
El stack completo — cómo se conectan los tres y hacia dónde va todo esto.

01 resumen

El resumen de 30 segundos

Tres protocolos. Tres cosas completamente distintas. La mayoría de la gente que usa IA ahorita solo entiende uno.

API

Tú ↔ La IA

Tu app le habla a un modelo de IA. Tú mandas un mensaje, él te responde. Es la base de todo.

MCP

La IA ↔ Herramientas

La IA habla con tus herramientas: archivos, calendario, base de datos. Ya no copias y pegas — ella va y lo busca sola.

A2A

La IA ↔ Otra IA

IA hablando con otra IA. Sin humano en medio. Agentes que se coordinan, se pasan tareas y entregan resultados.

02 protocolo

API — Tu app hablando con la IA

API significa Application Programming Interface. Es la forma en que tu aplicación le habla a un modelo de IA o a cualquier otro software. Tú mandas un mensaje, el modelo te responde. Todo producto de IA que hayas usado en tu vida está construido encima de esto. Es literalmente el piso.

La analogía del restaurante

Imagínate un restaurante. Tú (el cliente) le dices al mesero qué quieres. El mesero lleva tu pedido a la cocina. El chef lo prepara. El mesero te trae la comida. Tú nunca entras a la cocina, y la cocina nunca sale a tu mesa.

Tú = tu app, tu script, tu producto
El mesero = el API
La cocina = el modelo de IA (Claude, GPT, Gemini...)
La comida = la respuesta que te regresa

Cómo funciona paso a paso

Tu app manda una petición (request) al endpoint del API.
La petición incluye tu mensaje, tu API key y parámetros opcionales (modelo, temperatura, etc.).
El servidor procesa la petición con el modelo de IA.
El servidor te regresa una respuesta (response) con el resultado.

TU APP → "¿Qué es machine learning?" → API → Claude piensa → "Machine learning es..." → TU APP

Ejemplo de código real — Anthropic API

Así se ve una llamada al API de Claude en TypeScript:

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);
// → "Machine learning es una rama de la IA que..."

Eso es todo. Tu app manda un mensaje, el API lo procesa con Claude, y te regresa la respuesta. Así de simple.

Dónde encontrar APIs de IA

Anthropic API

Claude — el modelo de Anthropic. Ideal para texto, código y razonamiento.

OpenAI API

GPT, o1, DALL-E — modelos de OpenAI para texto e imágenes.

Google AI

Gemini — el modelo multimodal de Google.

Mistral AI

Mistral, Mixtral — modelos open-weight europeos.

¿Cómo sé si algo usa API? Pregúntate: ¿mi app está mandando un mensaje y recibiendo una respuesta de otro servicio? Si la respuesta es sí, hay un API de por medio. Cada vez que usas ChatGPT, Claude, o cualquier producto de IA — por debajo hay un API.

03 protocolo

MCP — La IA hablando con tus herramientas

MCP significa Model Context Protocol. Lo construyó Anthropic. Es un protocolo abierto que le permite a la IA conectarse directamente con tus herramientas: tus archivos, tu calendario, tu navegador, tu base de datos — en vez de que tú estés copiando y pegando información en un chat a mano. La IA va y lo busca sola.

La analogía de las llaves

Imagínate que tienes un asistente personal muy inteligente, pero que está encerrado en un cuarto sin ventanas. Cada vez que necesita algo — un archivo, un dato, una fecha — tú tienes que ir, buscarlo, y traérselo. Eso es la IA sin MCP.

Ahora imagínate que le das las llaves de tu oficina. Tu asistente puede abrir cajones, revisar tu calendario, leer tus documentos y buscar lo que necesita — todo solo. Tú solo le dices qué hacer y él se encarga. Eso es MCP.

Cómo funciona — arquitectura cliente-servidor

El cliente MCP es la IA (Claude, por ejemplo).
El servidor MCP es una herramienta que expone capacidades específicas.
El cliente descubre qué puede hacer el servidor y lo usa cuando lo necesita.

Claude (cliente) ↔ Servidor MCP de Google Calendar → lee tus eventosClaude (cliente) ↔ Servidor MCP de PostgreSQL → consulta tu base de datosClaude (cliente) ↔ Servidor MCP del navegador → navega páginas web

En vez de que tú copies la información al chat, la IA va y la obtiene directamente.

Detalle técnico — JSON-RPC y transporte

MCP usa JSON-RPC 2.0 como formato de mensajes. Cada herramienta que un servidor expone se describe con un schema JSON que le dice al cliente qué parámetros acepta y qué devuelve.

// Ejemplo: cómo un servidor MCP expone una herramienta
{
  "name": "read_file",
  "description": "Lee el contenido de un archivo",
  "inputSchema": {
    "type": "object",
    "properties": {
      "path": { "type": "string", "description": "Ruta del archivo" }
    },
    "required": ["path"]
  }
}

El transporte puede ser stdio (procesos locales) o SSE/HTTP (servidores remotos). La mayoría de MCPs en Claude Code usan stdio — el servidor corre como un proceso hijo en tu máquina.

Cómo se configura un MCP en Claude Code

# Agregar un servidor MCP de filesystem
claude mcp add filesystem -s user -- npx -y @anthropic-ai/mcp-filesystem

# Agregar un servidor MCP de PostgreSQL
claude mcp add postgres -s project -- npx -y @anthropic-ai/mcp-postgres \
  postgresql://user:pass@localhost:5432/mydb

# Ver los MCPs instalados
claude mcp list

Una vez instalado, Claude Code descubre automáticamente las herramientas del servidor y las usa cuando las necesita.

Ejemplos reales

Archivos locales

Claude Code lee y edita tus archivos directamente sin que los copies al chat.

Base de datos

Claude consulta tu PostgreSQL, MySQL o SQLite vía un servidor MCP.

Calendario

Claude revisa tu Google Calendar y te agenda reuniones sin salir del chat.

Navegador web

Claude navega páginas, extrae datos y llena formularios con un browser MCP.

Dónde encontrar MCPs

MCP Hub — directorio oficial de servidores MCP.
GitHub — busca "mcp server" para servidores de la comunidad.
Claude Code — muchos MCPs se instalan con claude mcp add.
Smithery — marketplace de servidores MCP.

¿Cómo sé si algo usa MCP? Pregúntate: ¿la IA está accediendo a mis herramientas o datos directamente, sin que yo los copie al chat? Si la respuesta es sí, probablemente hay un MCP de por medio.

04 protocolo

A2A — La IA hablando con otra IA

A2A significa Agent-to-Agent. Google lo lanzó en 2025. Es un protocolo para que agentes de IA se comuniquen entre ellos sin intervención humana. Es el protocolo más nuevo — y el más loco — de los tres.

Imagínate: un agente hace la investigación, se la pasa a otro que escribe el reporte, que se lo pasa a otro que lo formatea y lo manda — todo autónomo, todo coordinado. Sin humano en medio. Eso es A2A.

La analogía del equipo de trabajo

Imagínate un equipo en una empresa. El investigador hace la investigación y se la pasa al redactor. El redactor escribe el reporte y se lo pasa al diseñador. El diseñador lo formatea y se lo pasa al gerente de entregas. El gerente lo manda al cliente.

Cada persona tiene su rol, y el trabajo fluye de uno a otro sin que el jefe tenga que estar supervisando cada paso. Eso es A2A — pero con agentes de IA en vez de personas.

Cómo funciona

Un agente principal recibe una tarea compleja.
La descompone en subtareas y las asigna a agentes especializados.
Los agentes se comunican entre sí usando el protocolo A2A.
Cada agente completa su parte y pasa el resultado al siguiente.
El resultado final se entrega sin que un humano haya intervenido en los pasos intermedios.

Agente investigador → busca datos → pasa a Agente redactorAgente redactor → escribe reporte → pasa a Agente formateadorAgente formateador → formatea y manda → resultado final entregado

Detalle técnico — Agent Cards y Task Objects

El protocolo A2A tiene dos conceptos clave:

Agent Card

Cada agente publica una "tarjeta" en /.well-known/agent.json que describe quién es, qué sabe hacer y cómo contactarlo. Es como un currículum que otros agentes leen para saber si le pueden delegar una tarea.

{
  "name": "Research Agent",
  "description": "Investiga temas y entrega resúmenes",
  "skills": ["web_search", "summarize", "cite_sources"],
  "endpoint": "https://agent.example.com/a2a"
}

Task Object

Cuando un agente le pide algo a otro, crea un objeto Task con un ID único, el mensaje, y un estado que va cambiando: submitted → working → completed. El agente receptor actualiza el estado conforme avanza.

Ejemplos reales

Generación de reportes

Un agente investiga un tema, otro escribe el reporte, otro lo envía por correo — todo sin intervención.

Corrección de bugs

Un agente detecta un bug, otro propone el fix, otro lo prueba y lo mergea al repositorio.

Monitoreo de mercado

Un agente monitorea precios, otro decide cuándo actuar, otro ejecuta la acción.

Dónde encontrar A2A

Google A2A Protocol — especificación oficial de Google.
GitHub (google/A2A) — repositorio oficial del protocolo.
Frameworks multi-agente — LangGraph, CrewAI, AutoGen implementan patrones A2A.

¿Cómo sé si algo usa A2A? Pregúntate: ¿hay múltiples IAs pasándose trabajo entre ellas sin que yo intervenga en cada paso? Si la respuesta es sí, estás viendo A2A en acción.

05 guía práctica

Cómo identificar cuál es cuál

La pregunta clave siempre es la misma: ¿quién habla con quién?

Pregunta	Si la respuesta es sí...
¿Mi app manda un mensaje y recibe una respuesta de un modelo?	API
¿La IA accede a mis herramientas o datos directamente?	MCP
¿Múltiples IAs se coordinan entre ellas?	A2A

Tabla comparativa detallada

Característica	API	MCP	A2A
Creador	Estándar de la industria	Anthropic	Google
Año	Desde siempre	2024	2025
Dirección	App → IA	IA → Herramientas	IA → IA
Requiere humano	Sí (envía la petición)	No (la IA busca sola)	No (los agentes se coordinan)
Complejidad	Baja	Media	Alta
Ejemplo típico	ChatGPT respondiendo	Claude leyendo tu calendario	Equipo de agentes escribiendo un reporte

Para un niño de 5 años

API es como pedirle algo a tu mamá. Tú le pides, ella te lo da.
MCP es como darle a tu mamá las llaves de tu cuarto. Ella puede ir a buscar tus juguetes sin que tú se los traigas.
A2A es como tus muñecos jugando entre ellos mientras tú duermes. Se pasan la pelota, arman cosas y hacen todo solos.

06 el futuro

El stack completo

Los tres protocolos no compiten — se complementan. Juntos forman el stack de comunicación de la IA moderna:

Capa 1: API

La base. Tu app habla con la IA.

Capa 2: MCP

La extensión. La IA habla con tus herramientas.

Capa 3: A2A

La coordinación. La IA habla con otra IA.

Piénsalo así:

Sin API, no hay IA.
Sin MCP, la IA es ciega — solo sabe lo que tú le dices.
Sin A2A, la IA trabaja sola — no puede delegar ni coordinar.

Los tres juntos te dan un sistema donde tú le dices a la IA qué quieres, la IA accede a tus herramientas para obtener contexto, y si la tarea es grande, coordina con otros agentes para completarla.

¿Hacia dónde va esto?

El stack casi está completo. API fue la primera capa. MCP le dio ojos y manos a la IA. A2A le dio la capacidad de trabajar en equipo. Lo que viene después todavía no tiene nombre — pero la dirección es clara: sistemas de IA cada vez más autónomos, más conectados y más capaces.

Próximos pasos

Crea tu primera llamada al API de Claude — ve a la documentación oficial y sigue el quickstart.
Instala tu primer servidor MCP — prueba con el filesystem o el de GitHub.
Experimenta con multi-agentes — prueba LangGraph o CrewAI para ver A2A en acción.
Lee las especificaciones — modelcontextprotocol.io para MCP, google.github.io/A2A para A2A.