Interoperabilidad de herramientas de codificación con MCP y A2A

Inicio » Python » Interoperabilidad de herramientas de codificación con MCP y A2A

Los agentes de IA ya no son solo chatbots sofisticados que responden preguntas en una sola ventana. Se están transformando en sistemas distribuidos capaces de leer y escribir código, llamar a API, coordinarse con otros servicios e incluso negociar con otros agentes para realizar tareas. En cuanto se pasa de un "asistente inteligente" a una "red de agentes", surge un problema crucial: ¿cómo se comunican entre sí todos estos componentes sin caer en el caos?

Ese es precisamente el vacío que MCP (Protocolo de Contexto de Modelo) y A2A (Protocolo de Agente a Agente) intentan llenar. MCP se centra en cómo un agente se conecta a herramientas, datos y contexto, mientras que A2A se centra en cómo los agentes se comunican y colaboran entre sí. Si bien comparten una idea común, operan en niveles diferentes. En este artículo, profundizaremos en la función de cada uno, cómo se complementan, cómo se utilizan actualmente en sistemas reales y qué implicaciones tiene esto para el futuro de las herramientas de codificación y las arquitecturas multiagente.

Lo que realmente es MCP en la práctica

En esencia, MCP es una forma estándar de exponer herramientas, recursos y sugerencias a un agente de IA para que este pueda utilizarlos de forma segura y coherente. En lugar de conectar cada herramienta directamente a cada agente con código de enlace personalizado, se exponen esas herramientas detrás de un servidor MCP y se permite que los clientes MCP (los agentes) las descubran e invoquen a través de un protocolo unificado.

MCP sigue una arquitectura cliente-servidor clara: Una aplicación anfitriona (como un editor, una interfaz de línea de comandos o un entorno de ejecución de agente) incorpora un cliente MCP, y dicho cliente establece conexiones individuales con uno o más servidores MCP. Cada servidor es simplemente un proceso ligero que expone un conjunto de funcionalidades, normalmente herramientas, recursos de solo lectura y mensajes reutilizables.

La inspiración es muy similar al Protocolo de Servidor de Lenguaje (LSP). LSP abstrajo el problema "editor ↔ características del lenguaje", por lo que no tuvimos que escribir integraciones personalizadas entre cada editor y cada lenguaje de programación. Si se implementa un servidor de lenguaje una sola vez, cualquier editor compatible con LSP puede comunicarse con él. MCP toma la misma idea y la aplica a las herramientas y el contexto para los sistemas de gestión de lenguajes: se implementa una herramienta una sola vez como servidor MCP, y cualquier agente compatible con MCP puede usarla.

Desde el punto de vista del transporte, MCP es flexible pero lo suficientemente firme como para ser práctico. Utiliza JSON-RPC 2.0 como formato de mensaje y admite múltiples protocolos de transporte: stdio para procesos locales (ideal para aplicaciones de escritorio y desarrollo local) y HTTP o SSE para servidores remotos (perfecto para Cloud Run o implementaciones en contenedores). El protocolo también define cómo un cliente descubre las capacidades y cómo se describen las herramientas mediante JSON Schema, de modo que un LLM pueda decidir cuándo y cómo invocarlas.

Fundamentalmente, MCP no intenta controlar el razonamiento de su agente. No decide cuándo Se debe invocar una herramienta o cómo se deben encadenar las herramientas. MCP es la capa de conexión: pone a disposición herramientas, recursos y sugerencias de forma estructurada y fácil de descubrir, dejando la toma de decisiones en manos de su marco de agentes, planificador o ingeniería de sugerencias.

Componentes básicos del MCP: herramientas, recursos y sugerencias

Los servidores MCP giran en torno a tres elementos básicos principales: herramientas, recursos y mensajes. Estos tres conceptos son suficientes para cubrir la mayoría de las necesidades reales de los agentes sin necesidad de convertir el protocolo en un marco de orquestación completo.

Las herramientas son acciones discretas que un agente puede activar. Pensar "get_weather,search_inventory,book_flight,run_sql_query" o "get_exchange_rateCada herramienta se declara con un nombre, una descripción legible para humanos y un esquema de entrada. Ese esquema es lo que permite al LLM comprender qué parámetros debe pasar, y también protege su sistema backend validando los argumentos antes de la ejecución.

Los recursos representan datos de solo lectura que un servidor puede proporcionar bajo demanda. Archivos, registros, filas de bases de datos, fragmentos de documentación, archivos de configuración: cualquier información que se modele mejor como "obtener este elemento" que como "ejecutar esta función". Los recursos pueden ser grandes, por lo que MCP define formas de paginarlos y transmitirlos, lo cual es fundamental al proporcionar contexto a un modelo con una ventana de tiempo limitada.

Las indicaciones son plantillas reutilizables que los servidores pueden mostrar a los clientes. En lugar de codificar manualmente cadenas de mensajes largas y frágiles en su agente, puede centralizarlas como mensajes MCP. El servidor los expone con nombres, descripciones y espacios para parámetros, y el cliente completa esos espacios en tiempo de ejecución. Esto resulta sorprendentemente eficaz cuando varios agentes necesitan compartir los mismos patrones para interactuar con una herramienta específica o cumplir con las normas de seguridad y cumplimiento de toda la empresa.

Cuando un cliente se conecta a un servidor, realiza un paso de descubrimiento de capacidades. El servidor responde con un catálogo de herramientas, recursos y sugerencias, cada uno con metadatos detallados. Ese catálogo se introduce luego en el LLM (normalmente en forma resumida) para que el modelo pueda razonar: "Puedo usar get_exchange_rate Para responder a esta pregunta sobre la conversión de divisas, no debería intentar inventar la respuesta.”

Dado que todo esto es declarativo, se pueden agregar o eliminar nuevas funcionalidades sin modificar la lógica central del agente. Agregue una nueva herramienta al servidor, vuelva a implementarla y todos los clientes MCP que se conecten la verán en la siguiente negociación de capacidades. Este es el momento de "conectar un dispositivo USB más" para las herramientas de IA.

Un ejemplo concreto de MCP: una herramienta de conversión de divisas

La demostración del agente de divisas del kit de desarrollo de agentes (ADK) de Google es un ejemplo perfecto de MCP en acción. Comienza por construir un pequeño servidor MCP que expone una sola herramienta, get_exchange_rate, respaldado por la API pública de Frankfurter. En disco es solo un pequeño script de Python que utiliza fastmcp.

El servidor define la herramienta con argumentos tipados para currency_from, currency_to y currency_dateAdemás, cuenta con un sólido sistema de registro y manejo de errores. Cuando el agente realiza la llamada, el servidor se conecta a Frankfurter a través de HTTP, valida la respuesta y devuelve una carga útil JSON con el tipo de cambio o un objeto de error. Nada de esto es específico de la IA; MCP simplemente estandariza la forma en que se describe e invoca esta funcionalidad.

Localmente, ejecutas el servidor con un comando simple y este escucha en http://localhost:8080. Un cliente de prueba independiente, que también utiliza MCP, se conecta y descubre. get_exchange_rate y activa una llamada para USD → EUR. El registro muestra la invocación de la herramienta, la solicitud HTTP saliente, la respuesta exitosa y el JSON devuelto. Desde el punto de vista de su agente, simplemente preguntó "¿qué herramientas tengo?" y luego "por favor, llame a esta".

Implementar el mismo servidor en Cloud Run apenas cambia la situación. Usted crea un contenedor para el servidor MCP, lo implementa con --no-allow-unauthenticated por lo que requiere autenticación respaldada por IAM y luego abrir un túnel seguro desde su máquina local usando el comando proxy de Cloud Run. Localmente, su cliente MCP todavía cree que se está comunicando con http://127.0.0.1:8080El proxy gestiona la autenticación y los saltos de red de forma transparente.

Este patrón resulta muy eficaz en equipos: se puede ejecutar un servidor MCP centralizado para herramientas compartidas como tipos de cambio, API internas o bases de datos propietarias. Cada agente desarrollador de la organización puede conectarse a ese servidor a través de un transporte seguro, en lugar de enviar su propio envoltorio ligeramente diferente y con mantenimiento parcial alrededor de la misma API.

Creación de agentes sobre MCP: desde herramientas individuales hasta flujos de trabajo completos.

MCP se vuelve realmente interesante cuando se integra en un marco de agentes como el ADK de Google. En el ejemplo del agente de divisas, el ADK se utiliza para crear un agente LLM especializado cuyo único trabajo es responder preguntas sobre tipos de cambio utilizando la herramienta MCP. La instrucción del sistema del agente le dice literalmente: “su único propósito es utilizar el get_exchange_rate herramienta".

El ADK conecta esta instrucción, el modelo elegido (por ejemplo gemini-2.5-flash) y un MCPToolset instancia que apunta a la URL del servidor MCP. A partir de ese momento, cuando un usuario pregunta "¿Cuánto son 250 CAD en USD?", el agente evalúa si necesita realizar una llamada a una herramienta, completa los parámetros de la herramienta, envía la solicitud a través de MCP y luego escribe una respuesta fácil de usar utilizando el JSON devuelto.

Este mismo patrón se aplica a agentes mucho más complejos. En lugar de una única API de moneda, puede integrar varios servidores: uno para bases de datos internas, otro para SaaS de terceros, otro para búsqueda de documentos y un servidor que exponga mensajes reutilizables o flujos de trabajo RAG. A MCP no le importa si esos servidores se ejecutan localmente, en Cloud Run, en Kubernetes o detrás de una VPN, siempre que el transporte sea compatible y la autenticación esté configurada correctamente.

El ADK también añade una perspectiva centrada en el agente que MCP evita deliberadamente. Trata a los agentes como componentes de software componibles: se pueden definir agentes basados ​​en LLM, agentes con muchas herramientas, agentes de evaluación y orquestadores, todos ellos capaces de comunicarse con MCP de forma nativa. El resultado es que "crear un agente" se parece mucho más a "crear un microservicio" y mucho menos a "modificar una línea de comandos interminable en un cuaderno".

Qué es A2A y por qué MCP por sí solo no es suficiente

Si MCP trata de conectar agentes a herramientas, A2A trata de conectar agentes a otros agentes. Cuando se dispone de varios agentes, cada uno especializado en una tarea concreta, es necesario un sistema que les permita encontrarse, intercambiar tareas y mantenerse sincronizados durante el desarrollo del trabajo. Para este tipo de problemas se ha diseñado A2A.

A2A, iniciativa de Google Cloud y ahora bajo el amparo de la Linux Foundation, es un estándar abierto para la interoperabilidad entre agentes. Utiliza tecnologías conocidas (HTTP(S), JSON-RPC 2.0 y SSE para transmisión de datos), pero las integra en un modelo de dominio que comprende agentes, habilidades, tareas, artefactos y capacidades. En lugar de simples "llamadas a herramientas", se obtiene un lenguaje de colaboración de alto nivel.

Las dos ideas centrales de A2A son las Tarjetas de Agente y las Tareas. Una tarjeta de agente es un documento JSON, generalmente localizable en /.well-known/agent.json —que describe lo que un agente puede hacer, cómo acceder a él, qué autenticación requiere y qué modos de entrada/salida admite. Las tareas son las unidades de trabajo que un agente puede enviar a otro, con un ciclo de vida bien definido y resultados estructurados.

En una interacción A2A, un agente asume el rol de "agente cliente" y otro actúa como "agente remoto". El cliente descubre la tarjeta del agente remoto, decide si es el socio adecuado para la tarea y, a continuación, crea una solicitud de tarea. El agente remoto recibe la tarea, utiliza su propio LLM y herramientas internas (a menudo mediante MCP) para ejecutarla y, posteriormente, envía actualizaciones del progreso y los resultados finales.

Este diseño hace que A2A sea nativamente punto a punto, asíncrono y compatible con redes. En el fondo, las implementaciones de Python se basan en marcos ASGI como Starlette (a través de A2AStarletteApplication) y uvicorn, con artefactos y actualizaciones de tareas que fluyen a través de JSON-RPC y SSE. Esto significa que las tareas pueden ejecutarse durante segundos u horas sin bloquear una sola solicitud HTTP, lo cual es esencial para los flujos de trabajo multiagente del mundo real.

Un ejemplo de A2A: exponer un agente "Hola" y más allá

El ejemplo canónico de A2A, "HelloWorldAgent", muestra la mecánica de forma simplificada. Tú defines un AgentExecutor subclase que implementa una execute Método. En su interior, se agrega un único mensaje de texto —“¡Hola de A2A!”— a la cola de eventos como resultado de la tarea. La cancelación no tiene efecto en este caso sencillo, pero el mecanismo está disponible para cargas de trabajo reales.

A continuación, crea un AgentSkill describiendo lo que este agente puede hacer. En el ejemplo, la habilidad hello lleva un nombre, una descripción, un conjunto de etiquetas y consultas de usuario representativas. Esa habilidad luego se agrupa en un AgentCard junto con el nombre del agente, la versión, la URL, las capacidades y los modos de entrada/salida compatibles.

Finalmente, conectas todo a un A2AStarletteApplication con DefaultRequestHandler y ejecútalo bajo uvicorn. En lo que respecta al mundo exterior, ahora tienes un agente A2A completamente capacitado escuchando. http://localhost:9000Cualquier cliente compatible con A2A puede obtener /.well-known/agent.json, comprende lo que ofrece este agente y envíale tareas.

En implementaciones más realistas, este mismo patrón se extiende a escenarios de orquestación como la reserva de viajes, la incorporación de nuevos usuarios o la automatización del soporte. Un agente de viajes podría descubrir y comunicarse con un agente de vuelos, un agente de hoteles y un agente de alquiler de coches, cada uno operando tras su propio punto final A2A y ocultando sus herramientas internas y contratos API específicos del proveedor. El agente de viajes solo ve tareas, habilidades y artefactos.

Aquí es donde brilla la separación de responsabilidades de A2A. Cada agente descendente puede elegir sus propios modelos, marcos y herramientas (un agente hotelero creado con ADK y MCP, un agente de aerolíneas creado con otra pila tecnológica, un agente de alquiler de coches ubicado en la infraestructura de un socio) y todos seguirán colaborando sin problemas a través de la interfaz A2A.

Integración de MCP y A2A en una única arquitectura.

Sobre el papel, la división suena bien (MCP para herramientas, A2A para agentes), pero en la práctica los límites se difuminan rápidamente. Los sistemas reales suelen querer ocultar A2A tras MCP, superponer MCP dentro de A2A o combinar ambos en el mismo proceso. Los ejemplos oficiales de A2A incluso encapsulan la comunicación A2A como herramientas MCP expuestas desde un único servidor, de modo que un LLM ve "un único conjunto de herramientas MCP" en lugar de dos pilas de protocolos paralelas.

Un patrón común consiste en tratar a MCP como el cableado interno de cada agente y a A2A como la red externa entre agentes. Dentro de un agente, su LLM llama a las herramientas de MCP para acceder a bases de datos, API o almacenes de documentos. Externamente, su orquestador se comunica con ese agente mediante A2A, transfiriendo tareas y leyendo los artefactos recibidos. Desde la perspectiva del orquestador, el agente es un servicio de caja negra con una interfaz clara y tipada.

El modelo inverso —presentar A2A como herramientas MCP— resulta atractivo desde el punto de vista de la integración. Muchos proveedores de LLM ya cuentan con herramientas sofisticadas para MCP: herramientas para desarrolladores, demostraciones de interfaz de usuario, SDK y guías de seguridad. Al exponer la opción "contactar con el agente remoto X" como una única herramienta MCP, permite que LLM inicie una interacción A2A con una configuración mínima. Solo necesita registrar un servidor MCP, pero, internamente, ese servidor puede gestionar tareas en toda una red A2A.

Esto es precisamente lo que demuestran algunos repositorios de ejemplo: en lugar de conectar cada agente A2A remoto directamente al modelo, un servidor MCP ofrece un conjunto compacto de herramientas que se comunican directamente entre sí (A2A). Esto rompe con el modelo mental ingenuo ("MCP y A2A deben estar totalmente separados"), pero simplifica enormemente la integración práctica y mantiene la interfaz de LLM pequeña y bien organizada.

Tampoco hay nada que te impida usar MCP y A2A de forma aislada cuando tenga sentido. Muchos proyectos solo necesitarán MCP para conectar un único agente a unas pocas herramientas. Otros, sobre todo al integrar proveedores o equipos internos, dependerán en gran medida de A2A para la coordinación interorganizacional, utilizando su propia infraestructura interna en lugar de MCP. Lo importante es que los protocolos no compiten, sino que se complementan.

Interoperabilidad, marcos de trabajo y la “gran estructura” que falta.

Los protocolos por sí solos no garantizan la interoperabilidad si todos los sistemas los integran en arquitecturas de nivel superior muy diferentes. Puedes dominar a la perfección MCP y A2A y aun así acabar con un conjunto caótico de patrones de agentes mutuamente incompatibles que reinventan la planificación, la memoria, el manejo de errores y la gobernanza.

El siguiente paso probable en el ecosistema es una capa de marcos de trabajo construidos sobre MCP y A2A que estandaricen no solo los cables, sino también la estructura general. Pensemos en cómo surgieron los frameworks web sobre HTTP o cómo se construyeron los ORM sobre SQL. Estamos empezando a ver esto con ADK, orquestadores tipo LangGraph, plataformas gestionadas como Vertex AI Agent Engine y pasarelas de IA que entienden ambos protocolos.

Una vez que la industria converja en un puñado de patrones pragmáticos —“así es como se estructura un flujo de trabajo multiagente sobre A2A y MCP”, “así es como se exponen las herramientas de los equipos detrás de MCP”— la preocupación sobre si algo “debería estar detrás de MCP o A2A” comenzará a desvanecerse. La mayoría de los desarrolladores simplemente eligen un framework, conectan uno o dos servidores y obtienen configuraciones predeterminadas razonables.

El problema más complejo y lento reside en la ingeniería rápida y la interoperabilidad inmediata. Incluso con protocolos perfectos, al conectar sistemas mediante MCP y A2A, se permite que mensajes arbitrarios (instrucciones del sistema, descripciones de herramientas, medidas de seguridad) se filtren e interactúen entre sí. Si estos mensajes están desalineados, son redundantes o directamente contradictorios, el rendimiento se verá afectado mucho antes de que surjan problemas de seguridad.

En la práctica, las indicaciones e instrucciones mal diseñadas en una pila MCP + A2A pueden producir una latencia enorme, alucinaciones e inestabilidad. Cada agente puede recibir indicaciones adecuadas localmente, pero al superponerlas, los flujos pueden volverse frágiles: las herramientas se priorizan incorrectamente, las ventanas de contexto se desperdician y las expectativas del usuario se ven frustradas. A2A puede coordinar tareas, MCP puede exponer herramientas, pero ninguna de las dos obliga a mantener la coherencia en las indicaciones.

Por eso, los equipos que han lanzado productos LLM a gran escala tienden a considerar la ingeniería rápida como una cuestión de ingeniería de primer orden, y no como un ajuste de última hora. Los responsables de negocio suelen ver las indicaciones como una solución mágica para todo; los ingenieros, en cambio, a veces las descartan como un detalle secundario comparado con el código. La realidad es un punto intermedio: las indicaciones no convertirán un mal sistema en uno bueno, pero unas indicaciones mal diseñadas pueden arruinar por completo una arquitectura que, de otro modo, sería sólida.

Seguridad, identidad y gobernanza en MCP y A2A

Una vez que se empieza a permitir que los agentes actúen en nombre de los humanos a través de los límites de MCP y A2A, la identidad y la autorización se convierten rápidamente en problemas centrales. Una sola solicitud puede atravesar varias capas de delegación: un usuario se comunica con un agente orquestador, que llama a una herramienta a través de MCP, que internamente invoca otros servidores MCP o agentes A2A que requieren credenciales separadas.

En todas partes surgen situaciones concretas: Una aplicación SaaS expone un servidor MCP que requiere tokens OAuth; un agente interno de RR. HH. que utiliza autenticación A2A consume identidades LDAP corporativas; una herramienta de análisis de terceros utiliza su propio SSO. El usuario espera "iniciar sesión una vez y realizar sus tareas", pero en segundo plano, es necesario federar múltiples sistemas de identidad.

La documentación A2A de Google señala explícitamente la federación de identidades múltiples como un desafío fundamental. Un usuario U podría estar interactuando con el Agente A, que requiere la identidad del sistema A (por ejemplo, LDAP empresarial), mientras que internamente el Agente A necesita delegar en el Agente B, que requiere la identidad del sistema B (por ejemplo, un proveedor SaaS externo). Los protocolos deben admitir el transporte y la delimitación de estas identidades sin obligar a los usuarios a autenticarse manualmente en cada salto.

Los proveedores de identidad y las plataformas OAuth/OIDC se están adaptando rápidamente a esta nueva realidad. Infraestructuras como Logto, Auth0 o los proveedores de identidad internos ya pueden emitir tokens que los agentes utilizan en las llamadas MCP y A2A. La cuestión no es si esto es posible —claramente lo es— sino cómo estandarizar los patrones para que una herramienta creada hoy no se convierta en un problema de seguridad o gobernanza mañana.

Además de la autenticación, es probable que la observabilidad y la aplicación de políticas se trasladen a "pasarelas de agente" compartidas. Estas pasarelas pueden finalizar el tráfico MCP y A2A, centralizar el registro, aplicar límites de velocidad, vincular identidades de usuarios y agentes, e incluso filtrar qué herramientas o agentes son accesibles en qué contextos. Esto se asemeja mucho a las pasarelas API, solo que optimizadas para el tráfico de IA en lugar del HTTP estándar.

En retrospectiva, MCP y A2A están transformando discretamente nuestra forma de concebir la integración de software y las herramientas de codificación. Para los desarrolladores, un asistente de codificación conectado a MCP y ACP (el protocolo cliente-agente para IDE) puede descubrir herramientas, llamar a servidores de lenguaje, integrarse con el control de versiones y comunicarse con los agentes de otros programadores, todo ello mediante protocolos estándar. Para las empresas, los sistemas multiagente pueden interoperar entre equipos y proveedores sin necesidad de reconfigurar todo para cada nuevo caso de uso.

El cambio a largo plazo va de las "aplicaciones cableadas" a los "ecosistemas de agentes". Así como USB y HTTP permitieron conectar dispositivos y servicios arbitrarios, MCP y A2A buscan que las herramientas y los agentes sean integrables. Los equipos que triunfen serán aquellos que consideren estos protocolos no como simples logotipos llamativos, sino como la infraestructura fundamental para la comunicación, la colaboración y la evolución de sus sistemas a lo largo del tiempo.