Tutorial: Construcción de Dos Agentes en Python con el Protocolo A2A de Google Paso a Paso

Name: Elwynn AI

Updated on 10/4/2025

Aprende a construir dos simples agentes en Python utilizando el protocolo A2A de Google. Este tutorial paso a paso cubre la configuración, ejemplos de código y la comunicación entre agentes. A2A es un estándar abierto para la comunicación de agente a agente, permitiendo la interoperabilidad entre distintos marcos de trabajo y proveedores.

El protocolo Agent-to-Agent (A2A) de Google es un estándar abierto que permite a diferentes agentes de inteligencia artificial comunicarse y trabajar juntos, sin importar de qué marco o proveedor provengan (GitHub - google/A2A (opens in a new tab)). En términos más simples, A2A les da a tus agentes un lenguaje común para interactuar. Este tutorial te guiará para crear dos simples agentes en Python: uno actuando como servidor A2A y otro como cliente A2A, que se comunican entre sí usando el protocolo A2A. Cubriremos la configuración, explicaremos cómo funciona A2A a un nivel básico y proporcionaremos ejemplos de código comentados para ambos agentes. No se asume experiencia previa con A2A, y evitaremos conceptos avanzados como cadenas de herramientas complejas o orquestación multi-agente para mantener las cosas amigables para principiantes.

¿Qué es el Protocolo A2A?

En esencia, A2A es un protocolo (construido sobre HTTP) que estandariza cómo los agentes intercambian mensajes, solicitudes y datos. Aquí hay algunos conceptos clave en A2A:

Tarjeta del Agente: Un archivo público de metadatos (usualmente alojado en /.well-known/agent.json) que describe las capacidades, habilidades, URL de endpoint y requisitos de autenticación de un agente. Otros agentes o clientes recuperan esta tarjeta para descubrir lo que el agente puede hacer (GitHub - google/A2A (opens in a new tab)). Es esencialmente la “tarjeta de visita” del agente en la red A2A.
Servidor A2A: Un agente que expone un endpoint API HTTP que implementa métodos A2A (por ejemplo, endpoints para enviar tareas). Recibe solicitudes y ejecuta tareas en nombre de otros agentes (GitHub - google/A2A (opens in a new tab)).
Cliente A2A: Una aplicación o agente que envía solicitudes a la URL del servidor A2A para iniciar tareas o conversaciones (GitHub - google/A2A (opens in a new tab)). En un escenario de agente a agente, el componente cliente de un agente llamará al componente servidor de otro agente a través de A2A.
Tarea: La unidad fundamental de trabajo en A2A. Un cliente inicia una tarea enviando un mensaje (usando una solicitud tasks/send) a un agente. Cada tarea tiene un ID único y pasa por un ciclo de vida de estados (por ejemplo, submitted, working, input-required, completed, etc.) (GitHub - google/A2A (opens in a new tab)).
Mensaje: Un solo turno en la comunicación entre el cliente (rol "user") y el agente (rol "agent"). La solicitud del cliente es un mensaje (del “usuario”), y la respuesta del agente es un mensaje (del “agente”) (GitHub - google/A2A (opens in a new tab)).
Parte: Una pieza de contenido dentro de un mensaje. Un mensaje está compuesto por una o más partes. Las partes pueden ser texto, archivos o datos estructurados. Por ejemplo, una parte de texto (TextPart) lleva texto plano, mientras que una parte de archivo podría llevar una imagen u otro dato binario (GitHub - google/A2A (opens in a new tab)). En este tutorial, nos centraremos en partes de texto simples para mayor claridad.

Cómo Funciona la Comunicación A2A (Flujo Básico): Cuando un agente quiere comunicarse con otro vía A2A, la interacción típicamente sigue un flujo estandarizado:

Descubrimiento: El agente cliente primero descubre al otro agente recuperando su Tarjeta del Agente (usualmente desde la URL /.well-known/agent.json del servidor) (GitHub - google/A2A (opens in a new tab)). Esta tarjeta le dice al cliente cómo se llama el agente, qué puede hacer y dónde enviar solicitudes.
Inicio: Luego, el cliente envía una solicitud al endpoint A2A del agente servidor para iniciar una tarea, usualmente vía un POST al endpoint tasks/send. Esta solicitud inicial incluye un ID único de tarea y el primer mensaje del usuario (por ejemplo, una pregunta o comando) (GitHub - google/A2A (opens in a new tab)).
Procesamiento: El agente servidor recibe la solicitud de tarea y la procesa. Si el agente soporta respuestas continuas, puede transmitir actualizaciones intermedias de vuelta (usando Eventos Emitidos por el Servidor) mientras trabaja, aunque en nuestro ejemplo simple no usaremos streaming. De lo contrario, el agente procesará la tarea y enviará una respuesta final cuando esté lista (GitHub - google/A2A (opens in a new tab)). La respuesta contendrá el resultado de la tarea, típicamente uno o más mensajes del agente (y opcionalmente artefactos como archivos si eso es parte de la tarea). Para interacciones de texto básico, la respuesta final solo incluirá el mensaje de respuesta del agente.

Para resumir, A2A define un ciclo claro de solicitud-respuesta para los agentes: un cliente encuentra las capacidades de un agente (Tarjeta del Agente), le envía una tarea (con un mensaje inicial del usuario) y recibe la respuesta del agente (como mensajes y artefactos), todo en un formato JSON consistente. Ahora, configuremos nuestro entorno y construyamos un ejemplo mínimo para ver esto en acción.

Instalación y Configuración

Antes de escribir cualquier código, asegúrate de tener las herramientas requeridas instaladas:

Python 3.12 o superior – las muestras de A2A recomiendan Python 3.12+ (incluso Python 3.13) para compatibilidad (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).
UV (gestor de paquetes de Python) – este es un herramienta optativa pero recomendada por el proyecto A2A para gestionar dependencias y ejecutar las muestras (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)). UV es un gestor de paquetes moderno; sin embargo, si lo prefieres, también puedes usar pip/venv para instalar dependencias manualmente. En este tutorial, mantendremos las cosas simples y usaremos herramientas estándar de Python.
Repositorio Google A2A – obtiene el código oficial de A2A clonando el repositorio de GitHub:
```
git clone https://github.com/google/A2A.git
```
Esto descargará el proyecto en tu máquina. Nuestro código de tutorial hará referencia a partes de este repositorio (particularmente las utilidades de cliente A2A de muestra).
Dependencias – si usas UV, puedes dejar que maneje las dependencias automáticamente. Por ejemplo, desde el directorio samples/python del repositorio, puedes ejecutar uv sync (para instalar dependencias) o ejecutar comandos como uv run ... como se muestra en el README oficial. Si prefieres usar pip, asegúrate de instalar cualquier biblioteca necesaria para nuestro código de ejemplo:
```
pip install flask requests
```
La biblioteca Flask se utilizará para crear un servidor HTTP simple para nuestro agente, y requests se usará para que el cliente llame al agente. (El código de muestra oficial de A2A usa FastAPI/UVICorn y una biblioteca de cliente interna, pero para un enfoque amigable para principiantes usamos Flask y requests por claridad.)

Creación de un Agente Servidor A2A Sencillo

Primero, construiremos el lado del servidor: un agente que escuche las tareas entrantes y responda. Nuestro agente será extremadamente simple: aceptará un mensaje de texto y lo devolverá con un mensaje amistoso. A pesar de su simplicidad, seguirá la estructura del protocolo A2A para que cualquier cliente A2A pueda comunicarse con él.

Capacidades del Agente y Tarjeta del Agente: Para que nuestro agente sea descubrible, necesita proporcionar una Tarjeta del Agente. En un despliegue real, alojaríamos un archivo JSON en /.well-known/agent.json en el servidor. Para nuestra aplicación Flask, podemos servir estos datos a través de un endpoint. La Tarjeta del Agente típicamente incluye campos como el nombre del agente, descripción, la URL de su endpoint A2A, funciones soportadas (capacidades), etc. (GitHub - google/A2A (opens in a new tab)). Construiremos una Tarjeta del Agente mínima con solo algunos campos clave.

Endpoint tasks/send: A2A espera que el agente implemente ciertos endpoints API. El más importante es tasks/send, que el cliente llamará (HTTP POST) para enviar una nueva tarea (con un mensaje del usuario) al agente (GitHub - google/A2A (opens in a new tab)). Nuestra aplicación Flask definirá una ruta para /tasks/send para manejar estas solicitudes. Procesará el JSON entrante (que contiene el ID de la tarea y el mensaje del usuario), lo procesará (en nuestro caso, solo generará una respuesta de eco) y devolverá una respuesta JSON siguiendo el formato A2A.

Escribamos el código para nuestro agente servidor A2A sencillo usando Flask:

from flask import Flask, request, jsonify
 
app = Flask(__name__)
 
# Define los datos de la Tarjeta del Agente (metadatos sobre este agente)
AGENT_CARD = {
    "name": "EchoAgent",
    "description": "Un agente simple que devuelve mensajes del usuario.",
    "url": "http://localhost:5000",  # La URL base donde se aloja este agente
    "version": "1.0",
    "capabilities": {
        "streaming": False,           # Este agente no soporta respuestas continuas
        "pushNotifications": False    # No hay notificaciones push en este ejemplo simple
    }
    # (En una Tarjeta del Agente completa, podría haber más campos como información de autenticación, etc.)
}
 
# Sirve la Tarjeta del Agente en la URL conocida.
@app.get("/.well-known/agent.json")
def get_agent_card():
    """Endpoint para proporcionar los metadatos de este agente (Tarjeta del Agente)."""
    return jsonify(AGENT_CARD)
 
# Maneja las solicitudes de tarea entrantes en el endpoint A2A.
@app.post("/tasks/send")
def handle_task():
    """Endpoint para que los clientes A2A envíen una nueva tarea (con un mensaje inicial del usuario)."""
    task_request = request.get_json()  # analiza la solicitud JSON entrante
    # Extrae el ID de la tarea y el texto del mensaje del usuario de la solicitud.
    task_id = task_request.get("id")
    user_message = ""
    try:
        # Según la especificación A2A, el mensaje del usuario está en task_request["message"]["parts"][0]["text"]
        user_message = task_request["message"]["parts"][0]["text"]
    except Exception as e:
        return jsonify({"error": "Formato de solicitud no válido"}), 400
 
    # Para este agente simple, el "procesamiento" es simplemente devolver el mensaje.
    agent_reply_text = f"¡Hola! Dijiste: '{user_message}'"
 
    # Formula la respuesta en formato de Tarea de A2A.
    # Devolveremos un objeto Tarea con el estado final = 'completed' y el mensaje del agente.
    response_task = {
        "id": task_id,
        "status": {"state": "completed"},
        "messages": [
            task_request.get("message", {}),             # incluye el mensaje original del usuario en el historial
            {
                "role": "agent",                        # la respuesta del agente
                "parts": [{"text": agent_reply_text}]   # contenido del mensaje del agente como una TextPart
            }
        ]
        # También podríamos incluir un campo "artifacts" si el agente devuelviera archivos u otros datos.
    }
    return jsonify(response_task)
 
# Ejecuta la aplicación Flask (servidor A2A) si este script se ejecuta directamente.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Entendiendo el Código del Servidor: Desglosamos lo que está sucediendo en el código anterior:

Creamos una aplicación Flask y definimos un diccionario global AGENT_CARD. Este contiene información básica sobre nuestro agente. Notablemente, tiene un nombre, descripción, una URL (apuntando a sí mismo en localhost y puerto 5000), y una sección de capacidades. Hemos establecido streaming: False porque nuestro agente solo hará respuestas sincrónicas simples (si un agente soportara streaming, manejaría tasks/sendSubscribe y transmitiría resultados parciales, lo cual no cubrimos aquí).
Configuramos una ruta /.well-known/agent.json que devuelve el JSON de la tarjeta del agente. Esto imita la ubicación estándar donde se espera encontrar la tarjeta de un agente para descubrimiento (GitHub - google/A2A (opens in a new tab)).
Definimos una ruta POST para /tasks/send. Cuando un cliente A2A envía una tarea, Flask llamará a handle_task(). Dentro de esta función:
- Analizamos el cuerpo JSON de la solicitud en task_request. Según el esquema A2A, esto incluirá un "id" (ID de la tarea) y un objeto "message" que representa el mensaje inicial del usuario.
- Extraemos el texto del mensaje del usuario. En A2A, un mensaje puede tener múltiples partes (por ejemplo, texto, archivos). Aquí asumimos que la primera parte es texto y capturamos task_request["message"]["parts"][0]["text"]. En una implementación más robusta, verificaríamos el tipo de parte y manejaríamos errores (nuestro código hace un simple try/except y devuelve un error 400 si el formato no es el esperado).
- Luego generamos la respuesta del agente. Nuestra lógica es trivial: tomamos el texto del usuario y anteponemos "¡Hola! Dijiste: ...". En un agente real, aquí es donde iría la lógica central de IA (llamando a un LLM, realizando cálculos, etc.).
- A continuación, construimos el objeto de Tarea de respuesta. Debemos devolver el id (para que el cliente sepa qué tarea es), establecer status.state en "completed" (ya que terminamos la tarea), y proporcionar una lista de messages. Incluimos el mensaje original del usuario (para contexto/historial) y luego añadimos nuestra respuesta del agente como otro mensaje. Cada mensaje tiene un role ("user" o "agent") y una lista de parts. Usamos una sola TextPart que contiene nuestro texto de respuesta para el mensaje del agente.
- Finalmente, devolvemos esto como JSON. Flask se encargará de serializar el diccionario de Python en JSON por nosotros.

Con este servidor en funcionamiento, nuestro agente está efectivamente “activo” en http://localhost:5000. Puede servir su Tarjeta del Agente y manejar solicitudes de tareas.

Creación de un Agente Cliente A2A Sencillo

Ahora que tenemos un agente servidor, necesitamos un cliente que pueda hablar con él. Este cliente podría ser otro agente o simplemente una aplicación orientada al usuario. En términos de A2A, es un cliente A2A porque consumirá la API A2A de nuestro agente servidor (GitHub - google/A2A (opens in a new tab)). Para nuestro tutorial, escribiremos un pequeño script en Python que haga el papel de un segundo agente (o usuario) enviando una pregunta a nuestro EchoAgent y recibiendo la respuesta.

Pasos para el Cliente:

Descubrir el agente: El cliente debe recuperar la Tarjeta del Agente del servidor para conocer su endpoint y capacidades. Sabemos que nuestra tarjeta del agente está en http://localhost:5000/.well-known/agent.json. Podemos usar la biblioteca requests de Python para obtener esta URL.
Enviar una tarea: A continuación, el cliente enviará una solicitud POST al endpoint tasks/send del agente con una carga JSON que represente la tarea. Esta carga debe incluir:
- un "id" único para la tarea (cualquier cadena o número único; por ejemplo, "tarea1"),
- un objeto "message" con role: "user" y una lista parts que contenga la consulta del usuario como un TextPart.
Recibir la respuesta: El agente responderá con un JSON que representa la Tarea (incluyendo el mensaje de respuesta del agente). El cliente debe leer esto y extraer la respuesta del agente.

Escribamos el código del cliente para realizar estos pasos:

import requests
import uuid
 
# 1. Descubrir el agente recuperando su Tarjeta del Agente
AGENT_BASE_URL = "http://localhost:5000"
agent_card_url = f"{AGENT_BASE_URL}/.well-known/agent.json"
response = requests.get(agent_card_url)
if response.status_code != 200:
    raise RuntimeError(f"Error al obtener tarjeta del agente: {response.status_code}")
agent_card = response.json()
print("Agente Descubierto:", agent_card["name"], "-", agent_card.get("description", ""))
 
# 2. Preparar una solicitud de tarea para el agente
task_id = str(uuid.uuid4())  # genera un ID único de tarea aleatorio
user_text = "¿Cuál es el significado de la vida?"
task_payload = {
    "id": task_id,
    "message": {
        "role": "user",
        "parts": [
            {"text": user_text}
        ]
    }
}
print(f"Enviando tarea {task_id} al agente con mensaje: '{user_text}'")
 
# 3. Enviar la tarea al endpoint tasks/send del agente
tasks_send_url = f"{AGENT_BASE_URL}/tasks/send"
result = requests.post(tasks_send_url, json=task_payload)
if result.status_code != 200:
    raise RuntimeError(f"Solicitud de tarea falló: {result.status_code}, {result.text}")
task_response = result.json()
 
# 4. Procesar la respuesta del agente
# La respuesta debe contener el ID de la tarea, el estado, y los mensajes (incluyendo la respuesta del agente).
if task_response.get("status", {}).get("state") == "completed":
    # El último mensaje en la lista debe ser la respuesta del agente (ya que nuestro agente incluyó historial en mensajes).
    messages = task_response.get("messages", [])
    if messages:
        agent_message = messages[-1]  # último mensaje (del agente)
        agent_reply_text = ""
        # Extraer texto de las partes del mensaje del agente
        for part in agent_message.get("parts", []):
            if "text" in part:
                agent_reply_text += part["text"]
        print("Respuesta del agente:", agent_reply_text)
    else:
        print("¡No hay mensajes en la respuesta!")
else:
    print("La tarea no se completó. Estado:", task_response.get("status"))

Entendiendo el Código del Cliente: Aquí está lo que hace el cliente:

Utiliza requests.get para recuperar la tarjeta del agente desde http://localhost:5000/.well-known/agent.json. En caso de éxito, analizamos el JSON e imprimimos el nombre y la descripción del agente para verificar que encontramos al agente correcto.
Generamos un ID único de tarea usando uuid.uuid4(). Esto es solo para asegurar que no reutilicemos un ID (en escenarios reales, el cliente debe asegurar que cada tarea que envía tiene un ID único).
Creamos la carga de la tarea como un diccionario de Python. Esta carga sigue el esquema A2A: tiene un "id" (nuestro ID generado) y un "message" para la consulta del usuario. El mensaje tiene role: "user" y una parte que contiene el texto "¿Cuál es el significado de la vida?" (puedes cambiar este texto a lo que sea – el EchoAgent simplemente lo devolverá).
Enviamos esta carga al endpoint tasks/send del agente usando requests.post. Nota que usamos el parámetro json=..., que instruye a la biblioteca requests a enviar el diccionario como JSON.
Verificamos que la respuesta sea 200 OK. Si el estado no es 200, levantamos un error. (En un script más indulgente, podrías manejar las respuestas no-200 más gráficamente.)
Si la llamada tuvo éxito, analizamos la respuesta JSON en task_response. Este debe ser el objeto Tarea devuelto por nuestro agente. Luego lo examinamos:
- Comprobamos si status.state es "completed" – en nuestro diseño, el agente marcará la tarea como completada después de una respuesta. Si, por ejemplo, el agente necesitara más información ("input-required") o fallara, manejaríamos esos casos. Para simplificar, asumimos la finalización.
- Luego recuperamos la lista de mensajes de la respuesta. Esperamos que el último mensaje en esta lista sea la respuesta del agente (ya que nuestro código del servidor agregó el mensaje del agente después del del usuario). Extraemos el texto de las partes del mensaje del agente. En este caso, debería ser la respuesta de eco que construimos.
- Finalmente, imprimimos la respuesta del agente.

En este punto, nuestro cliente habrá impreso la respuesta del agente. En la siguiente sección, ejecutaremos tanto el servidor como el cliente para ver todo el intercambio.

Ejecutando y Probando los Agentes

Para probar nuestros dos agentes, sigue estos pasos:

Inicia el agente servidor: Ejecuta el script del servidor Flask (llamémoslo echo_agent.py). Por ejemplo, en tu terminal:
```
python echo_agent.py
```
Esto debería iniciar el servidor de desarrollo de Flask en http://localhost:5000. Deberías ver un mensaje como “Running on http://0.0.0.0:5000/” (opens in a new tab). El agente ahora está escuchando las solicitudes. (Asegúrate de que nada más esté usando el puerto 5000, o cambia el puerto en el código si es necesario.)
Ejecuta el script del cliente: Abre otra terminal y ejecuta el script del cliente (por ejemplo client_agent.py):
```
python client_agent.py
```
El cliente debería imprimir algo así como:
```
Agente Descubierto: EchoAgent – Un agente simple que devuelve mensajes del usuario.
Enviando tarea 3f8ae8ac-... al agente con mensaje: '¿Cuál es el significado de la vida?'
Respuesta del agente: ¡Hola! Dijiste: '¿Cuál es el significado de la vida?'
```
Esto indica que el cliente descubrió el agente con éxito, envió una pregunta y recibió la respuesta. La respuesta del agente es el mensaje de eco que esperábamos.
Verifica la interacción: También puedes comprobar la salida de consola del servidor. Flask registrará las solicitudes que manejó. Deberías ver una solicitud GET para /.well-known/agent.json y un POST a /tasks/send, junto con un estado 200 para cada uno. Esto confirma el flujo del protocolo:
- Descubrimiento (cliente GET la tarjeta del agente) → Inicio (cliente POST la tarea) → Procesamiento/Finalización (servidor responde con respuesta).

¡Felicitaciones! Acabas de implementar una comunicación básica de agente a agente usando el protocolo A2A. Un agente actuó como un servicio (EchoAgent) y el otro como un cliente que lo interrogó. Aunque este ejemplo es simplista (la “IA” solo repite la entrada), demuestra la infraestructura necesaria para cualquier interacción A2A.

Uso de la Biblioteca de Cliente A2A (Opcional)

En nuestro código del cliente, construimos manualmente solicitudes HTTP usando requests. El repositorio oficial de A2A en GitHub proporciona clases helper para simplificar este proceso. Por ejemplo, hay una clase A2AClient que puede manejar la obtención de la tarjeta del agente y envío de tareas por ti, así como un A2ACardResolver para descubrir la tarjeta del agente. Aquí se muestra cómo podríamos usarlas (para aquellos interesados en un enfoque más idiomático):

import asyncio
from samples.python.common.client import A2AClient, A2ACardResolver
from samples.python.common.types import TaskSendParams, Message, TextPart
 
async def query_agent(agent_url, user_text):
    # Obtén la tarjeta del agente automáticamente
    card_resolver = A2ACardResolver(agent_url)
    agent_card = card_resolver.get_agent_card()
    print("Agente Descubierto:", agent_card.name)
    # Crea cliente A2A con la tarjeta del agente
    client = A2AClient(agent_card=agent_card)
    # Prepara parámetros de Tarea (usando clases de tipo A2A)
    payload = TaskSendParams(
        id=str(uuid.uuid4()),
        message=Message(role="user", parts=[TextPart(text=user_text)])
    )
    # Envía la tarea y espera la finalización
    result_task = await client.send_task(payload)  # send_task es un método asíncrono
    # Extrae la respuesta del agente de result_task
    if result_task.status.state.value == "completed":
        # El objeto Task de A2A puede ser inspeccionado por mensajes y artefactos
        for msg in result_task.messages:
            if msg.role == "agent":
                # Imprimir partes de texto del mensaje del agente
                print("Respuesta del agente:", " ".join(part.text for part in msg.parts if hasattr(part, "text")))

En el fragmento anterior, A2ACardResolver y A2AClient vienen de la biblioteca de muestras de A2A (ubicada en el directorio samples/python/common del repositorio). Los TaskSendParams, Message, y TextPart son clases de datos (probablemente basadas en modelos Pydantic) correspondientes a partes del esquema JSON de A2A. Usándolos, no tendremos que construir manualmente diccionarios; creamos objetos Python y la biblioteca se encargará de la serialización JSON y las llamadas HTTP. El método send_task del cliente es asíncrono (por eso usamos await), y devuelve un objeto Task. Nuestro ejemplo muestra cómo podrías obtener la respuesta del agente de ese objeto.

Nota: El código anterior es para ilustración y requiere que el código del repositorio A2A esté accesible en tu ruta de Python. Si has clonado el repositorio e instalado sus requisitos (vía UV o pip), podrías integrar esto en tu cliente. La herramienta CLI oficial en el repositorio A2A esencialmente realiza estos pasos – lee la Tarjeta del Agente y entra en un bucle para enviar tareas e imprimir respuestas (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).

📚

Conclusión

En este tutorial, cubrimos los conceptos básicos del protocolo A2A de Google y demostramos una simple comunicación entre dos agentes. Configuramos un servidor A2A mínimo (EchoAgent) y un cliente que interactúa con él. A lo largo del proceso, aprendimos sobre las Tarjetas del Agente (para descubrimiento) y cómo se estructuran las tareas y los mensajes en A2A.

Aunque nuestro ejemplo fue un agente trivial de eco, ahora tienes la base para construir agentes más complejos. Por ejemplo, podrías reemplazar la lógica de eco con una llamada a un modelo de lenguaje o una API para hacer que el agente realmente resuelva un problema o responda a preguntas. La belleza de A2A es que mientras tu agente adhiera al protocolo (sirva una tarjeta de agente e implemente los endpoints de tarea), cualquier otro agente o herramienta compatible con A2A puede integrarse con él.

Próximos Pasos: Podrías explorar las muestras del repositorio oficial de A2A para patrones más avanzados. Por ejemplo, las muestras de Google incluyen un agente que genera imágenes a partir de texto y las devuelve como artefactos de imagen (A2A/samples/python/agents/crewai/README.md at main · google/A2A · GitHub (opens in a new tab)), y otro que maneja diálogos de llenado de formularios multi-turnos. También puedes intentar usar la interfaz de línea de comandos proporcionada (CLI) o la demo web para chatear con tu agente. Para usar la CLI con nuestro EchoAgent, podrías ejecutar: uv run hosts/cli --agent http://localhost:5000 (si tienes UV y la configuración del repo) para iniciar un chat tipo REPL con el agente (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).

Al estandarizar la comunicación entre agentes, A2A abre la puerta a un rico ecosistema de agentes de IA interoperables. Solo hemos arañado la superficie aquí con un ejemplo básico. ¡Felices experimentos con A2A – y que tus agentes colaboren efectivamente!

Fuentes:

Repositorio de Google A2A – README del Protocolo Agent2Agent (Descripción Conceptual) (GitHub - google/A2A (opens in a new tab)) (GitHub - google/A2A (opens in a new tab)) (GitHub - google/A2A (opens in a new tab)) (GitHub - google/A2A (opens in a new tab))
Repositorio de Google A2A – Ejemplos y Uso del CLI (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)) (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab))
Repositorio de Google A2A – README de Ejemplo CrewAI (capacidades de agente vía A2A) (A2A/samples/python/agents/crewai/README.md at main · google/A2A · GitHub (opens in a new tab)) (para exploración adicional)

📚

Nota de Encuesta: Explorando el Lanzamiento de GPT-4.5 de OpenAI