Tutorial: Construindo Dois Agentes Python com o Protocolo A2A do Google Passo a Passo

Name: Elwynn AI

Updated on 10/04/2025

Aprenda a construir dois agentes Python simples usando o protocolo A2A do Google. Este tutorial passo a passo cobre a configuração, exemplos de código e comunicação entre agentes. A2A é um padrão aberto para comunicação agente-agente, permitindo interoperabilidade entre diferentes frameworks e fornecedores.

O protocolo Agent-to-Agent (A2A) do Google é um padrão aberto que permite que diferentes agentes de IA se comuniquem e trabalhem juntos, independentemente do framework ou fornecedor de onde eles vêm (GitHub - google/A2A (opens in a new tab)). Em termos mais simples, o A2A oferece aos seus agentes uma linguagem comum para interação. Este tutorial irá guiá-lo na criação de dois agentes Python simples – um atuando como um servidor A2A e outro como um cliente A2A – que se comunicam entre si usando o protocolo A2A. Vamos cobrir a configuração, explicar como o A2A funciona em um nível básico e fornecer exemplos de código anotados para ambos os agentes. Nenhuma experiência prévia com A2A é necessária, e evitaremos conceitos avançados como cadeias de ferramentas complexas ou orquestração de múltiplos agentes para manter as coisas amigáveis para iniciantes.

O que é o Protocolo A2A?

Em sua essência, o A2A é um protocolo (construído sobre HTTP) que padroniza como os agentes trocam mensagens, solicitações e dados. Aqui estão alguns conceitos-chave do A2A:

Cartão do Agente: Um arquivo de metadados público (geralmente hospedado em /.well-known/agent.json) descrevendo as capacidades, habilidades, URL do ponto de extremidade e requisitos de autenticação de um agente. Outros agentes ou clientes buscam este cartão para descobrir o que o agente pode fazer (GitHub - google/A2A (opens in a new tab)). É essencialmente o “cartão de visita” do agente na rede A2A.
Servidor A2A: Um agente que expõe um endpoint API HTTP implementando métodos A2A (por exemplo, endpoints para enviar tarefas). Ele recebe solicitações e executa tarefas em nome de outros agentes (GitHub - google/A2A (opens in a new tab)).
Cliente A2A: Uma aplicação ou agente que envia solicitações ao URL de um servidor A2A para iniciar tarefas ou conversas (GitHub - google/A2A (opens in a new tab)). Em um cenário agente-para-agente, o componente cliente de um agente chamará o componente servidor de outro agente via A2A.
Tarefa: A unidade de trabalho fundamental no A2A. Um cliente inicia uma tarefa enviando uma mensagem (usando uma solicitação tasks/send) para um agente. Cada tarefa tem um ID único e passa por um ciclo de vida de estados (por exemplo, submitted, working, input-required, completed, etc.) (GitHub - google/A2A (opens in a new tab)).
Mensagem: Uma única rodada na comunicação entre o cliente (papel "user") e o agente (papel "agent"). A solicitação do cliente é uma mensagem (do “usuário”), e a resposta do agente é uma mensagem (do “agente”) (GitHub - google/A2A (opens in a new tab)).
Parte: Um pedaço de conteúdo dentro de uma mensagem. Uma mensagem é composta por uma ou mais partes. Partes podem ser texto, arquivos ou dados estruturados. Por exemplo, uma parte de texto (TextPart) carrega texto simples, enquanto uma parte de arquivo pode carregar uma imagem ou outros dados binários (GitHub - google/A2A (opens in a new tab)). Neste tutorial, nos ateremos a partes de texto simples para clareza.

Como a Comunicação A2A Funciona (Fluxo Básico): Quando um agente quer se comunicar com outro via A2A, a interação tipicamente segue um fluxo padronizado:

Descoberta: O agente cliente primeiro descobre o outro agente buscando seu Cartão de Agente (geralmente a partir do URL /.well-known/agent.json do servidor) (GitHub - google/A2A (opens in a new tab)). Este cartão informa ao cliente como o agente é chamado, o que ele pode fazer e onde enviar solicitações.
Iniciação: O cliente então envia uma solicitação para o endpoint A2A do agente servidor para iniciar uma tarefa – geralmente via POST para o endpoint tasks/send. Esta solicitação inicial inclui um ID de tarefa único e a primeira mensagem do usuário (por exemplo, uma pergunta ou comando) (GitHub - google/A2A (opens in a new tab)).
Processamento: O agente servidor recebe a solicitação de tarefa e a processa. Se o agente suportar respostas em streaming, ele pode transmitir atualizações intermediárias de volta (usando Eventos Enviados pelo Servidor) enquanto trabalha, embora em nosso exemplo simples não usaremos streaming. Caso contrário, o agente processará a tarefa e enviará de volta uma resposta final quando concluída (GitHub - google/A2A (opens in a new tab)). A resposta conterá o resultado da tarefa – tipicamente uma ou mais mensagens do agente (e opcionalmente artefatos como arquivos, se isso fizer parte da tarefa). Para interações básicas de texto, a resposta final incluirá apenas a mensagem de resposta do agente.

Para resumir, o A2A define um ciclo claro de solicitação-resposta para agentes: um cliente encontra as capacidades de um agente (Cartão do Agente), envia-lhe uma tarefa (com uma mensagem inicial do usuário) e recebe a resposta do agente (como mensagens e artefatos), tudo em um formato JSON consistente. Agora, vamos configurar nosso ambiente e construir um exemplo mínimo para ver isso em ação.

Instalação e Configuração

Antes de escrever qualquer código, certifique-se de que você tem as ferramentas necessárias instaladas:

Python 3.12 ou superior – as amostras do A2A recomendam Python 3.12+ (mesmo Python 3.13) para compatibilidade (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).
UV (gerenciador de pacotes Python) – esta é uma ferramenta opcional, mas recomendada pelo projeto A2A para gerenciar dependências e executar as amostras (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)). UV é um gerenciador de pacotes moderno; no entanto, se preferir, você também pode usar pip/venv para instalar as dependências manualmente. Neste tutorial, manteremos as coisas simples e usaremos ferramentas padrão do Python.
Repositório A2A do Google – obtenha o código oficial do A2A clonando o repositório do GitHub:
```
git clone https://github.com/google/A2A.git
```
Isso irá baixar o projeto para o seu computador. Nosso código do tutorial fará referência a partes deste repositório (particularmente as utilidades de cliente de exemplo do A2A).
Dependências – se você usar o UV, pode deixar que ele gerencie as dependências automaticamente. Por exemplo, a partir do diretório samples/python do repositório, você pode executar uv sync (para instalar as dependências) ou executar comandos como uv run ... conforme mostrado no README oficial. Se preferir usar pip, certifique-se de instalar as bibliotecas necessárias para o nosso código de exemplo:
```
pip install flask requests
```
A biblioteca Flask será usada para criar um servidor HTTP simples para nosso agente, e requests será usada para o cliente chamar o agente. (O código de exemplo oficial do A2A usa FastAPI/UVICorn e uma biblioteca cliente interna, mas para uma abordagem amigável para iniciantes usamos Flask e requests para clareza.)

Criando um Agente Servidor A2A Simples

Primeiro, construiremos o lado do servidor: um agente que escuta por tarefas recebidas e responde. Nosso agente será extremamente simples – aceitará um prompt de texto e apenas o repetirá com uma mensagem amigável. Apesar de sua simplicidade, ele seguirá a estrutura do protocolo A2A para que qualquer cliente A2A possa se comunicar com ele.

Capacidades do Agente e Cartão do Agente: Para que nosso agente seja descoberto, ele precisa fornecer um Cartão do Agente. Em uma implantação real, hospedaríamos um arquivo JSON em /.well-known/agent.json no servidor. Para nosso aplicativo Flask, podemos servir esses dados por meio de um endpoint. O Cartão do Agente tipicamente inclui campos como o nome do agente, descrição, URL do seu endpoint A2A, recursos suportados (capacidades), etc. (GitHub - google/A2A (opens in a new tab)). Construiremos um Cartão do Agente mínimo com apenas alguns campos principais.

Endpoint tasks/send: O A2A espera que o agente implemente certos endpoints de API. O mais importante é o tasks/send, que o cliente chamará (HTTP POST) para enviar uma nova tarefa (com uma mensagem do usuário) para o agente (GitHub - google/A2A (opens in a new tab)). Nosso aplicativo Flask definirá uma rota para /tasks/send para lidar com estas solicitações. Ele irá analisar o JSON recebido (que contém o ID da tarefa e a mensagem do usuário), processá-lo (em nosso caso, apenas gerar uma resposta de eco) e retornar uma resposta em JSON seguindo o formato A2A.

Vamos escrever o código para nosso agente servidor A2A simples usando Flask:

from flask import Flask, request, jsonify
 
app = Flask(__name__)
 
# Define o Cartão do Agente (metadados sobre este agente)
AGENT_CARD = {
    "name": "EchoAgent",
    "description": "Um agente simples que repete de volta as mensagens dos usuários.",
    "url": "http://localhost:5000",  # A URL base onde este agente está hospedado
    "version": "1.0",
    "capabilities": {
        "streaming": False,           # Este agente não suporta respostas em streaming
        "pushNotifications": False    # Sem notificações push neste exemplo simples
    }
    # (Em um Cartão do Agente completo, poderiam haver mais campos como informações de autenticação, etc.)
}
 
# Servir o Cartão do Agente na URL bem conhecida.
@app.get("/.well-known/agent.json")
def get_agent_card():
    """Endpoint para fornecer os metadados deste agente (Cartão do Agente)."""
    return jsonify(AGENT_CARD)
 
# Lidar com solicitações de tarefas recebidas no endpoint A2A.
@app.post("/tasks/send")
def handle_task():
    """Endpoint para clientes A2A enviarem uma nova tarefa (com uma mensagem inicial do usuário)."""
    task_request = request.get_json()  # analisa a solicitação JSON recebida
    # Extrair o ID da tarefa e o texto da mensagem do usuário da solicitação.
    task_id = task_request.get("id")
    user_message = ""
    try:
        # De acordo com a especificação A2A, a mensagem do usuário está em task_request["message"]["parts"][0]["text"]
        user_message = task_request["message"]["parts"][0]["text"]
    except Exception as e:
        return jsonify({"error": "Formato de solicitação inválido"}), 400
 
    # Para este agente simples, o "processamento" é apenas repetir a mensagem de volta.
    agent_reply_text = f"Olá! Você disse: '{user_message}'"
 
    # Formular a resposta no formato de Tarefa A2A.
    # Retornaremos um objeto de Tarefa com estado final = 'completed' e a mensagem do agente.
    response_task = {
        "id": task_id,
        "status": {"state": "completed"},
        "messages": [
            task_request.get("message", {}),             # incluir a mensagem original do usuário no histórico
            {
                "role": "agent",                        # a resposta do agente
                "parts": [{"text": agent_reply_text}]   # conteúdo da mensagem do agente como TextPart
            }
        ]
        # Também poderíamos incluir um campo "artifacts" se o agente retornasse arquivos ou outros dados.
    }
    return jsonify(response_task)
 
# Executar o aplicativo Flask (servidor A2A) se este script for executado diretamente.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Compreendendo o Código do Servidor: Vamos analisar o que está acontecendo no código acima:

Criamos um aplicativo Flask e definimos um dicionário global AGENT_CARD. Isso contém informações básicas sobre nosso agente. Notavelmente, ele tem um nome, descrição, uma URL (apontando para si mesmo no localhost e porta 5000) e uma seção de capacidades. Configuramos streaming: False porque nosso agente fará apenas respostas síncronas simples (se um agente suportasse streaming, ele trataria tasks/sendSubscribe e transmitiria resultados parciais, o que não estamos abordando aqui).
Configuramos uma rota /.well-known/agent.json que retorna o cartão do agente em JSON. Isso imita o local padrão onde se espera encontrar o cartão de um agente para descoberta (GitHub - google/A2A (opens in a new tab)).
Definimos uma rota POST para /tasks/send. Quando um cliente A2A envia uma tarefa, o Flask chamará handle_task(). Dentro desta função:
- Analisamos o corpo JSON da solicitação em task_request. De acordo com o esquema A2A, isso incluirá um "id" (ID da tarefa) e um objeto "message" representando a mensagem inicial do usuário.
- Extraímos o texto da mensagem do usuário. No A2A, uma mensagem pode ter múltiplas partes (por exemplo, texto, arquivos). Aqui assumimos que a primeira parte é o texto e pegamos task_request["message"]["parts"][0]["text"]. Em uma implementação mais robusta, verificaríamos o tipo da parte e trataríamos erros (nosso código faz um simples try/except e retorna um erro 400 se o formato não for o esperado).
- Em seguida, geramos a resposta do agente. Nossa lógica é trivial: pegamos o texto do usuário e precedemos com "Olá! Você disse: ...". Em um agente real, é aqui que a lógica central de IA iria (chamando um LLM, realizando cálculos, etc.).
- Depois, construímos o objeto de resposta Tarefa. Devemos ecoar de volta o id (para que o cliente saiba de qual tarefa se trata), definir o status.state para "completed" (já que terminamos a tarefa) e fornecer uma lista de messages. Incluímos a mensagem original do usuário (para contexto/histórico) e adicionamos a resposta do agente como outra mensagem. Cada mensagem tem um role ("user" ou "agent") e uma lista de parts. Usamos uma única TextPart contendo nosso texto de resposta para a mensagem do agente.
- Finalmente, retornamos isso como JSON. O Flask irá serializar o dicionário Python em JSON para nós.

Com este servidor em execução, nosso agente está efetivamente “ativo” em http://localhost:5000. Ele pode servir seu Cartão do Agente e lidar com solicitações de tarefas.

Criando um Agente Cliente A2A Simples

Agora que temos um agente servidor, precisamos de um cliente que possa falar com ele. Este cliente pode ser outro agente ou apenas uma aplicação voltada para o usuário. Em termos de A2A, ele é um cliente A2A porque irá consumir a API A2A de nosso agente servidor (GitHub - google/A2A (opens in a new tab)). Para nosso tutorial, escreveremos um pequeno script Python que desempenha o papel de um segundo agente (ou usuário) enviando uma pergunta ao nosso EchoAgent e recebendo a resposta.

Passos para o Cliente:

Descobrir o agente: O cliente deve buscar o Cartão do Agente do agente servidor para saber sobre seu endpoint e capacidades. Sabemos que nosso cartão de agente está em http://localhost:5000/.well-known/agent.json. Podemos usar a biblioteca Python requests para fazer uma requisição GET nesta URL.
Enviar uma tarefa: Em seguida, o cliente enviará uma requisição POST para o endpoint tasks/send do agente com um payload JSON representando a tarefa. Este payload deve incluir:
- um "id" único para a tarefa (qualquer string ou número único; por exemplo, "task1"),
- um objeto "message" com role: "user" e uma lista de parts contendo a consulta do usuário como um TextPart.
Receber a resposta: O agente irá responder com um JSON representando a Tarefa (incluindo a mensagem de resposta do agente). O cliente deve ler isso e extrair a resposta do agente.

Vamos escrever o código do cliente para executar esses passos:

import requests
import uuid
 
# 1. Descobrir o agente buscando seu Cartão do 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"Falha ao obter cartão do agente: {response.status_code}")
agent_card = response.json()
print("Agente Descoberto:", agent_card["name"], "-", agent_card.get("description", ""))
 
# 2. Preparar uma solicitação de tarefa para o agente
task_id = str(uuid.uuid4())  # gera um ID de tarefa único aleatório
user_text = "Qual é o significado da vida?"
task_payload = {
    "id": task_id,
    "message": {
        "role": "user",
        "parts": [
            {"text": user_text}
        ]
    }
}
print(f"Enviando tarefa {task_id} para o agente com mensagem: '{user_text}'")
 
# 3. Enviar a tarefa para o endpoint tasks/send do 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"Solicitação de tarefa falhou: {result.status_code}, {result.text}")
task_response = result.json()
 
# 4. Processar a resposta do agente
# A resposta deve conter o ID da tarefa, status e as mensagens (incluindo a resposta do agente).
if task_response.get("status", {}).get("state") == "completed":
    # A última mensagem na lista deve ser a resposta do agente (já que nosso agente incluiu o histórico nas mensagens).
    messages = task_response.get("messages", [])
    if messages:
        agent_message = messages[-1]  # última mensagem (do agente)
        agent_reply_text = ""
        # Extrair texto das partes da mensagem do agente
        for part in agent_message.get("parts", []):
            if "text" in part:
                agent_reply_text += part["text"]
        print("Resposta do Agente:", agent_reply_text)
    else:
        print("Sem mensagens na resposta!")
else:
    print("Tarefa não concluída. Status:", task_response.get("status"))

Compreendendo o Código do Cliente: Aqui está o que o cliente faz:

Ele usa requests.get para recuperar o cartão do agente a partir de http://localhost:5000/.well-known/agent.json. Com sucesso, analisamos o JSON e imprimimos o nome e descrição do agente para verificar se encontramos o agente correto.
Geramos um ID de tarefa único usando uuid.uuid4(). Isso é apenas para garantir que não reutilizamos um ID (em cenários reais, o cliente deve garantir que cada tarefa que envia tem um ID único).
Criamos o payload da tarefa como um dicionário Python. Este payload segue o esquema A2A: tem um "id" (nosso ID gerado) e uma "message" para a consulta do usuário. A mensagem tem role: "user" e uma parte contendo o texto "Qual é o significado da vida?" (você pode alterar este texto para qualquer coisa – o EchoAgent apenas o repetirá).
Enviamos este payload para o endpoint tasks/send do agente usando requests.post. Note que usamos o parâmetro json=..., que instrui a biblioteca requests a enviar o dicionário como JSON.
Verificamos uma resposta 200 OK. Se o status não for 200, levantamos um erro. (Em um script mais tolerante, você poderia lidar com respostas não-200 de forma mais graciosa.)
Se a chamada teve sucesso, analisamos a resposta JSON em task_response. Este deve ser o objeto Tarefa retornado por nosso agente. Depois examinamos:
- Verificamos se status.state é "completed" – em nosso design, o agente irá marcá-la como concluída após uma resposta. Se, por exemplo, o agente precisasse de mais entrada ("input-required") ou falhasse, lidaríamos com esses casos. Para simplicidade, assumimos conclusão.
- Depois, recuperamos a lista de messages da resposta. Esperamos que a última mensagem nesta lista seja a resposta do agente (já que nosso código de servidor acrescentou a mensagem do agente após a do usuário). Extraímos o texto das partes da mensagem do agente. Neste caso, deve ser a resposta de eco que construímos.
- Finalmente, imprimimos a resposta do agente.

Neste ponto, nosso cliente terá impresso a resposta do agente. Na próxima seção, vamos executar tanto o servidor quanto o cliente para ver toda a troca.

Executando e Testando os Agentes

Para testar nossos dois agentes, siga estes passos:

Iniciar o agente servidor: Execute o script do servidor Flask (vamos chamá-lo echo_agent.py). Por exemplo, no seu terminal:
```
python echo_agent.py
```
Isso deve iniciar o servidor de desenvolvimento do Flask em http://localhost:5000. Você deve ver uma mensagem como “Running on http://0.0.0.0:5000/” (opens in a new tab). O agente agora está ouvindo requisições. (Certifique-se de que nada mais já está usando a porta 5000, ou altere a porta no código se necessário.)
Executar o script do cliente: Abra outro terminal e execute o script do cliente (por exemplo, client_agent.py):
```
python client_agent.py
```
O cliente deve imprimir algo como:
```
Agente Descoberto: EchoAgent – Um agente simples que repete de volta as mensagens dos usuários.
Enviando tarefa 3f8ae8ac-... para o agente com mensagem: 'Qual é o significado da vida?'
Resposta do Agente: Olá! Você disse: 'Qual é o significado da vida?'
```
Isso indica que o cliente descobriu o agente com sucesso, enviou uma pergunta e recebeu a resposta. A resposta do agente é a mensagem ecoada que esperávamos.
Verificar a interação: Você também pode verificar a saída do console do servidor. O Flask irá registrar as requisições que ele tratou. Você deve ver uma requisição GET para /.well-known/agent.json e um POST para /tasks/send, junto com um status 200 para cada. Isso confirma o fluxo do protocolo:
- Descoberta (cliente faz GET do cartão do agente) → Iniciação (cliente faz POST da tarefa) → Processamento/Conclusão (servidor responde com resposta).

Parabéns! Você acabou de implementar uma comunicação básica agente-para-agente usando o protocolo A2A. Um agente atuou como serviço (EchoAgent) e o outro como cliente que o consultou. Embora este exemplo seja simplista (a “IA” apenas repete a entrada), ele demonstra a infraestrutura necessária para qualquer interação A2A.

Usando a Biblioteca Cliente A2A (Opcional)

Em nosso código do cliente, criamos manualmente requisições HTTP usando requests. O repositório oficial do A2A no GitHub fornece classes auxiliares para simplificar este processo. Por exemplo, há uma classe A2AClient que pode lidar com a busca do cartão do agente e envio de tarefas para você, assim como um A2ACardResolver para descobrir o cartão do agente. Aqui está como poderíamos usar esses (para aqueles interessados em uma abordagem mais idiomática):

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):
    # Buscar cartão do agente automaticamente
    card_resolver = A2ACardResolver(agent_url)
    agent_card = card_resolver.get_agent_card()
    print("Agente Descoberto:", agent_card.name)
    # Criar cliente A2A com o cartão do agente
    client = A2AClient(agent_card=agent_card)
    # Preparar parâmetros de Tarefa (usando classes de tipo A2A)
    payload = TaskSendParams(
        id=str(uuid.uuid4()),
        message=Message(role="user", parts=[TextPart(text=user_text)])
    )
    # Enviar a tarefa e aguardar a conclusão
    result_task = await client.send_task(payload)  # send_task é um método assíncrono
    # Extrair resposta do agente do result_task
    if result_task.status.state.value == "completed":
        # O objeto Tarefa do A2A pode ser inspecionado para mensagens e artefatos
        for msg in result_task.messages:
            if msg.role == "agent":
                # Imprimir partes de texto da mensagem do agente
                print("Resposta do Agente:", " ".join(part.text for part in msg.parts if hasattr(part, "text")))

No trecho acima, A2ACardResolver e A2AClient vêm da biblioteca de amostra do A2A (localizada no diretório samples/python/common do repositório). Os TaskSendParams, Message e TextPart são classes de dados (provavelmente baseada em modelos Pydantic) correspondendo a partes do esquema JSON A2A. Usando essas classes, não precisamos construir dicionários manualmente; criamos objetos Python e a biblioteca irá lidar com a serialização JSON e chamadas HTTP. O método send_task do cliente é assíncrono (por isso usamos await), e retorna um objeto Task. Nosso exemplo mostra como você pode buscar a resposta do agente desse objeto.

Nota: O código acima é para ilustração e requer que o código do repositório A2A esteja acessível no seu caminho Python. Se você clonou o repositório e instalou seus requisitos (via UV ou pip), você poderia integrar isso em seu cliente. A ferramenta de linha de comando oficial no repositório A2A essencialmente faz estes passos – ela lê o Cartão do Agente e entra em um loop para enviar tarefas e imprimir respostas (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).

📚

Conclusão

Neste tutorial, cobrimos o básico do protocolo A2A do Google e demonstramos uma comunicação simples entre dois agentes. Configuramos um servidor A2A mínimo (EchoAgent) e um cliente que interage com ele. Ao longo do caminho, aprendemos sobre Cartões de Agente (para descoberta) e como as tarefas e mensagens são estruturadas no A2A.

Embora nosso exemplo fosse um agente de eco trivial, agora você tem a base para construir agentes mais complexos. Por exemplo, você poderia substituir a lógica de eco por uma chamada a um modelo de linguagem ou uma API para fazer o agente realmente resolver um problema ou responder a perguntas. A beleza do A2A é que, desde que seu agente obedeça ao protocolo (sirva um cartão de agente e implemente os endpoints de tarefa), qualquer outro agente ou ferramenta compatível com A2A pode se integrar a ele.

Próximos Passos: Você pode explorar as amostras do repositório oficial A2A para padrões mais avançados. Por exemplo, as amostras do Google incluem um agente que gera imagens a partir de texto e as retorna como artefatos de imagem (A2A/samples/python/agents/crewai/README.md at main · google/A2A · GitHub (opens in a new tab)), e outro que trata diálogos de preenchimento de formulários de múltiplas voltas. Você também pode experimentar a interface de linha de comando (CLI) ou demonstração web fornecida para conversar com seu agente. Para usar o CLI com nosso EchoAgent, você poderia executar: uv run hosts/cli --agent http://localhost:5000 (se você tiver UV e a configuração do repositório) para iniciar um bate-papo no estilo REPL com o agente (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).

Ao padronizar a comunicação entre agentes, o A2A abre portas para um rico ecossistema de agentes de IA interoperáveis. Nós apenas arranhamos a superfície aqui com um exemplo básico. Bom experimento com A2A – e que seus agentes colaborem efetivamente!

Fontes:

Google A2A GitHub – README do Protocolo Agent2Agent (Visão Geral Conceitual) (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))
Google A2A GitHub – Amostras e Uso do 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))
Google A2A GitHub – README do Exemplo CrewAI (capacidades do agente via A2A) (A2A/samples/python/agents/crewai/README.md at main · google/A2A · GitHub (opens in a new tab)) (para exploração adicional)

📚

Nota de Pesquisa: Explorando o Lançamento GPT-4.5 da OpenAI