Esta página foi traduzida pela API Cloud Translation.

Criar sistemas multiagente com o ADK

1. Introdução

Visão geral

Neste laboratório, você vai aprender a orquestrar sistemas multiagentes complexos usando o Kit de Desenvolvimento de Agente (ADK) do Google. Você vai passar de hierarquias de agentes simples para a criação de fluxos de trabalho automatizados e colaborativos.

O que você vai criar

Você vai criar dois sistemas multiagentes distintos:

Um agente de planejamento de viagens simples que aprende a transferir conversas entre um agente de "brainstorming" e um agente de "planejamento de atrações".
Um gerador de apresentação de filme mais avançado que usa uma "sala de roteiristas" de agentes automatizados (como um pesquisador, roteirista e crítico) para trabalhar em conjunto em um loop e criar um enredo completo de filme.

O que você vai aprender

Como criar hierarquias de agente principal e subagente.
Como gravar dados na sessão state usando uma ferramenta.
Como ler do state usando modelos de chave (por exemplo, {my_key?}).
Como usar um SequentialAgent para fluxos de trabalho detalhados.
Como usar um LoopAgent para criar ciclos de refinamento iterativo.
Como usar uma ParallelAgent para executar tarefas independentes simultaneamente.

2. Sistemas multiagentes

Com o Kit de Desenvolvimento de Agente (ADK), os desenvolvedores alcançam comportamentos mais confiáveis, sofisticados e multietapas dos modelos generativos. Em vez de um comando complexo, o ADK permite criar um fluxo de vários agentes mais simples que colaboram em um problema dividindo o trabalho.

Essa abordagem tem várias vantagens em relação ao uso de um único comando monolítico:

Design mais simples:é mais fácil projetar e organizar um fluxo de agentes pequenos e especializados do que criar um comando grande e complexo.
Confiabilidade:os agentes especializados são mais confiáveis em suas tarefas específicas do que um agente grande e complexo.
Manutenção:é mais fácil corrigir ou melhorar um agente pequeno e especializado sem prejudicar outras partes do sistema.
Modularidade:os agentes criados para um fluxo de trabalho podem ser facilmente reutilizados em outros.

A árvore hierárquica de agentes

Estrutura em árvore mostrando agentes hierárquicos

No ADK, você organiza os agentes em uma estrutura em árvore. Essa hierarquia é fundamental para controlar o fluxo da conversa, já que limita qual agente pode "passar" a conversa para qual outro agente. Isso torna o comportamento do sistema mais previsível e fácil de depurar. Alguns dos benefícios são:

Design intuitivo:a estrutura é inspirada em equipes do mundo real, o que facilita o raciocínio.
Fluxo controlado:a hierarquia oferece controle preciso sobre a delegação de tarefas, o que ajuda na depuração. Por exemplo, a estrutura em árvore garante que o agente de redação de relatórios correto seja chamado, mesmo que você tenha dois com descrições semelhantes.

Toda a estrutura começa com o root_agent. Esse agente atua como um pai e pode ter um ou mais subagentes, que, por sua vez, também podem ser pais dos próprios subagentes, formando a árvore.

3. Configurar o projeto

Conta do Google

Se você ainda não tiver uma Conta do Google pessoal, crie uma.

Use uma conta pessoal em vez de uma conta escolar ou de trabalho.

Faça login no console do Google Cloud usando uma Conta do Google pessoal.

Ativar faturamento

Resgatar US $5 em créditos do Google Cloud (opcional)

Para fazer este workshop, você precisa de uma conta de faturamento com algum crédito. Se você planeja usar seu próprio faturamento, pule esta etapa.

Clique neste link e faça login com uma Conta do Google pessoal.Você vai ver algo assim:
Clique no botão CLIQUE AQUI PARA ACESSAR SEUS CRÉDITOS. Isso vai abrir uma página para configurar seu perfil de faturamento.
Clique em Confirmar.

Agora você está conectado a uma conta de faturamento de avaliação do Google Cloud Platform.

Captura de tela da visão geral do faturamento

Configurar uma conta de faturamento pessoal

Se você configurou o faturamento usando créditos do Google Cloud, pule esta etapa.

Para configurar uma conta de faturamento pessoal, acesse este link para ativar o faturamento no console do Cloud.

Algumas observações:

A conclusão deste laboratório custa menos de US $1 em recursos do Cloud.
Siga as etapas no final deste laboratório para excluir recursos e evitar mais cobranças.
Novos usuários podem aproveitar a avaliação sem custos financeiros de US$300.

Criar um projeto (opcional)

Se você não tiver um projeto atual que gostaria de usar para este laboratório, crie um novo aqui.

4. Abrir editor do Cloud Shell

Clique neste link para navegar diretamente até o editor do Cloud Shell.
Se for preciso autorizar em algum momento, clique em Autorizar para continuar.
Se o terminal não aparecer na parte de baixo da tela, abra-o:
- Clique em Visualizar.
- Clique em Terminal.

No terminal, defina o projeto com este comando:

gcloud config set project [PROJECT_ID]

Exemplo:

gcloud config set project lab-project-id-example

Se você não se lembrar do ID do projeto, liste todos os IDs com:
```
gcloud projects list
```

Você vai receber esta mensagem:
```
Updated property [core/project].
```
Se você vir um WARNING e for perguntado Do you want to continue (Y/n)?, provavelmente inseriu o ID do projeto incorretamente. Pressione n, Enter e tente executar o comando gcloud config set project novamente.

5. Ativar APIs

Para usar a API Vertex AI e interagir com o modelo Gemini, ative a API Vertex AI no seu projeto do Google Cloud.

No terminal, ative a API:

gcloud services enable aiplatform.googleapis.com

Confira as seções atualizadas, substituindo a criação manual de arquivos por instruções para clonar o repositório do GitHub e instalar as dependências.

Introdução ao SDK da Vertex AI para Python

Para interagir com modelos hospedados na Vertex AI no seu aplicativo Python, use o SDK da Vertex AI para Python. Esse SDK simplifica o processo de envio de comandos, especificação de parâmetros do modelo e recebimento de respostas sem precisar lidar diretamente com as complexidades das chamadas de API subjacentes.

Encontre a documentação completa do SDK da Vertex AI para Python aqui: Introdução ao SDK da Vertex AI para Python | Google Cloud.

6. configurar o ambiente do projeto

Clone o repositório

No terminal, clone o repositório que contém os arquivos iniciais.
```
git clone --depth 1 https://github.com/GoogleCloudPlatform/devrel-demos.git
```
A flag --depth 1 clona apenas a versão mais recente, o que é mais rápido.

No terminal, navegue até o diretório de trabalho correto deste laboratório.

cd devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems

Ativar um ambiente virtual

No terminal, crie e ative um ambiente virtual usando uv:
```
uv venv
source .venv/bin/activate
```
No terminal, instale o google-adk e as outras dependências do arquivo requirements.txt:
```
uv pip install -r requirements.txt
```

Revise a estrutura de arquivos

Agora que todos os arquivos foram criados, abra a pasta adk_multiagent_systems no Explorer para ver a estrutura completa.

No menu do editor do Cloud Shell, selecione Arquivo > Abrir pasta....
Na caixa que aparece, adicione as seguintes informações de pasta depois do seu nome de usuário: devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems/. Clique em OK.
Ele vai ficar assim:
O painel do explorador à esquerda será atualizado. Agora você vai ver a estrutura completa do projeto, com os subdiretórios parent_and_subagents e workflow_agents, pronta para as próximas etapas.

Configurar variáveis de ambiente

Você já está no diretório adk_multiagent_systems. No terminal, crie um arquivo .env para armazenar suas variáveis de ambiente:
```
cloudshell edit .env
```

Cole o seguinte no arquivo .env que será aberto no editor:

GOOGLE_GENAI_USE_VERTEXAI=TRUE
GOOGLE_CLOUD_PROJECT="[YOUR-PROJECT-ID]"
GOOGLE_CLOUD_LOCATION=global
MODEL="gemini-2.5-flash"

Substitua [YOUR-PROJECT-ID] pelo ID do projeto do Google Cloud. (por exemplo, PROJECT_ID = "google-cloud-labs")
Se você não se lembrar do ID do projeto, execute o seguinte comando no terminal. Uma lista de todos os seus projetos e IDs vai aparecer.
```
gcloud projects list
```
No terminal, copie este arquivo .env para os diretórios de subagentes para que eles também possam acessar as variáveis:
```
cp .env parent_and_subagents/.env
cp .env workflow_agents/.env
```
A estrutura do arquivo agora deve ser assim:

7. criar transferências entre os agentes principais, secundários e pares

A conversa sempre começa com o root_agent. Por padrão, um agente principal usa o description dos subagentes para decidir quando transferir a conversa. Você também pode orientar essas transferências explicitamente no instruction do agente principal usando o name dos subagentes.

Vamos fazer um teste.

No editor do Cloud Shell, abra adk_multiagent_systems/parent_and_subagents/agent.py. Observe os três agentes no arquivo agent.py:
- root_agent (chamado de steering): faz uma pergunta ao usuário para decidir a qual subagente transferir. Inicialmente, ele depende apenas das description dos subagentes.
- travel_brainstormer: ajuda o usuário a pensar em destinos.
- attractions_planner: ajuda o usuário a listar coisas para fazer em um país específico.
Dica:para ler um arquivo agent.py na ordem do fluxo de conversa, geralmente é mais fácil começar a ler pelo root_agent na parte de baixo e subir. Isso porque o código Python exige que os subagentes sejam definidos antes de serem adicionados a um agente.
Deixe travel_brainstormer e attractions_planner abaixo do root_agent. Para isso, adicione a seguinte linha à criação do root_agent:
```
    sub_agents=[travel_brainstormer, attractions_planner]
```
Observação: a hierarquia de agentes é definida apenas pela lista sub_agents do agente principal. Os subagentes não precisam de um parâmetro parent.

No terminal, converse com o agente:

cd ~/devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems
adk run parent_and_subagents

No prompt [user]: do terminal, digite:

hello

Exemplo de resposta (a sua pode ser um pouco diferente):

[steering]: Hi there! Do you already have a country in mind for your trip, or would you like some help deciding where to go?

Agora, diga ao agente no terminal:
```
I could use some help deciding.
```
Exemplo de resposta (a sua pode ser um pouco diferente):
```
[travel_brainstormer]: Okay! To give you the best recommendations, I need to understand what you're looking for in a trip.
...
```
Observe a tag [travel_brainstormer]. O controle transferido de root_agent foi baseado apenas no description do subagente.
No comando user: do terminal, digite exit e pressione ENTER para encerrar a conversa.

Agora, vamos ser mais explícitos. Em agent.py, adicione o seguinte ao instruction do root_agent:

        If they need help deciding, send them to 'travel_brainstormer'.
        If they know what country they'd like to visit, send them to the 'attractions_planner'.

No terminal, execute o agente novamente:
```
adk run parent_and_subagents
```
No prompt [user]: do terminal, digite:
```
hello
```
Responda com:
```
I would like to go to Japan.
```
Exemplo de resposta (a sua pode ser um pouco diferente):
```
[attractions_planner]: Okay, I can help you with that! Here are some popular attractions in Japan:
...
```
Observe a transferência para attractions_planner, conforme orientado pelas novas instruções.
Agora responda com:
```
Actually I don't know what country to visit.
```
Exemplo de resposta (a sua pode ser um pouco diferente):
```
[travel_brainstormer]: Okay! I can help you brainstorm some countries for travel...
```
Você foi transferido para travel_brainstormer, um par de attractions_planner. Isso é permitido por padrão.
Se você quiser impedir a transferência, defina disallow_transfer_to_peers=True no agente attractions_planner.
Para encerrar a sessão, basta digitar exit no prompt do usuário.

Recapitulação

Nesta seção, você aprendeu os fundamentos da hierarquia de agentes e do fluxo de conversa:

A conversa sempre começa com o root_agent.
Um agente principal pode ser transferido automaticamente para um subagente com base no description.
Você pode controlar explicitamente esse fluxo, fornecendo ao agente pai instruction para transferir para um subagente por meio de seu name.
Por padrão, os agentes podem ser transferidos para os agentes peer (irmãos na hierarquia).

8. usar o estado da sessão para armazenar e recuperar informações

Cada conversa do ADK tem um Session, que inclui um dicionário de estado da sessão. Esse estado é acessível a todos os agentes, o que o torna a maneira perfeita de transmitir informações entre eles ou manter dados (como uma lista) durante toda a conversa.

Aprender a adicionar e ler o estado:

Volte para o arquivo adk_multiagent_systems/parent_and_subagents/agent.py.

Cole a seguinte definição de função após o cabeçalho # Tools:

def save_attractions_to_state(
tool_context: ToolContext,
attractions: List[str]
) -> dict[str, str]:
    """Saves the list of attractions to state["attractions"].

    Args:
        attractions [str]: a list of strings to add to the list of attractions

    Returns:
        None
    """
    # Load existing attractions from state. If none exist, start an empty list
    existing_attractions = tool_context.state.get("attractions", [])

    # Update the 'attractions' key with a combo of old and new lists.
    # When the tool is run, ADK will create an event and make
    # corresponding updates in the session's state.
    tool_context.state["attractions"] = existing_attractions + attractions

    # A best practice for tools is to return a status message in a return dict
    return {"status": "success"}

Neste código, observe:

A função recebe tool_context: ToolContext. Esse objeto é o gateway para a sessão.
A linha tool_context.state["attractions"] = ... lê e grava diretamente no dicionário de estado da sessão. O ADK cuida do resto.

Adicione a ferramenta ao agente attractions_planner adicionando o parâmetro tools:
```
    tools=[save_attractions_to_state]
```
Adicione os seguintes marcadores à instruction atual do agente attractions_planner:
```
        - When they reply, use your tool to save their selected attraction and then provide more possible attractions.
        - If they ask to view the list, provide a bulleted list of { attractions? } and then suggest some more.
```
Observe a seção entre chaves: { attractions? }. Esse recurso do ADK, o modelo de chave, injeta o valor da chave attractions do estado no comando do agente. O ? torna isso opcional, evitando erros se a chave ainda não existir.

Inicie a interface da Web do Kit de Desenvolvimento de Agente com o seguinte comando no terminal:

adk web

Saída

INFO:     Started server process [2434]
INFO:     Waiting for application startup.
+-------------------------------------------------------+
| ADK Web Server started                                |
|                                                       |
| For local testing, access at http://localhost:8000.   |
+-------------------------------------------------------+

INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

No terminal do Cloud Shell, clique no botão Visualização na Web e selecione Alterar porta para abrir a interface da Web em uma nova guia.
Insira o número da porta 8000 e clique em Alterar e visualizar. Uma nova guia do navegador será aberta com a interface de desenvolvimento do ADK.
No menu suspenso Selecionar um agente à esquerda, escolha parent_and_subagents.
Comece a conversa com: hello
Depois que o agente cumprimentar você, responda com:
```
I'd like to go to Egypt.
```
Você será transferido para o attractions_planner e receberá uma lista de atrações.
Escolha uma atração, por exemplo:
```
I'll go to the Sphinx
```
Você vai receber uma resposta como: Ok, salvei "A Esfinge" na sua lista...
Clique na caixa de ferramentas de resposta (selecionada com uma marca de seleção) para visualizar o evento criado usando a resposta da ferramenta.
Observe que ele inclui um campo actions que inclui stateDelta descrevendo as mudanças no estado.
Responda com outra atração da lista do agente.
No menu de navegação à esquerda, clique no "X" para sair do foco no evento que você inspecionou anteriormente.
Na barra lateral à esquerda, clique na guia Estado. Agora você pode conferir a matriz attractions no estado da sessão, que deve conter os dois itens selecionados.
Envie esta mensagem ao agente:
```
What is on my list?
```
O agente vai ler o estado e retornar sua lista.
Quando terminar de testar o agente, feche a guia do navegador da Web e pressione CTRL + C no terminal do Cloud Shell para interromper o servidor.

Recapitulação da seção

Nesta seção, você aprendeu a usar o estado Session para compartilhar dados:

Para gravar o estado: você grava no dicionário de estado de dentro de uma ferramenta usando o objeto tool_context.state (por exemplo, tool_context.state["my_list"] = [...]).
Para ler o estado: você injeta dados de estado diretamente no instruction de um agente usando a criação de modelos de chave (por exemplo, Here is your list: {my_list?}).
Para inspecionar o estado: é possível monitorar o estado da sessão ao vivo na interface do desenvolvedor do ADK usando a guia "Estado".

9. Agentes de fluxo de trabalho

Até agora, você viu como um agente principal transfere para um subagente e aguarda o usuário. Os agentes de fluxo de trabalho são diferentes: eles executam os subagentes um após o outro em um fluxo automatizado, sem esperar a entrada do usuário.

Isso é perfeito para tarefas automatizadas de várias etapas, como um pipeline "Planejar e executar" ou "Escrever e revisar". O ADK oferece três agentes de fluxo de trabalho integrados para gerenciar isso:

SequentialAgent
LoopAgent
ParallelAgent

O restante deste laboratório vai se concentrar na criação de um sistema multiagente usando esses três agentes de fluxo de trabalho.

Você vai criar um agente que desenvolve um documento de apresentação para um novo filme sobre um personagem histórico. Seus agentes vão cuidar da pesquisa, da escrita iterativa e da geração de relatórios.

No final, seu sistema vai ficar assim:

Diagrama de um sistema multiagente film_concept_team

Você vai criar esse sistema uma etapa por vez, começando com o fluxo de trabalho mais simples.

10. Criar um sistema multiagente com um SequentialAgent

Um SequentialAgent é um agente de fluxo de trabalho que executa os subagentes em uma sequência linear simples. Cada agente na lista sub_agents é executado um após o outro, em ordem. Isso é perfeito para pipelines em que as tarefas precisam ser realizadas em uma ordem específica, como o agente de sugestão de filmes que você vai criar agora.

A primeira versão será estruturada assim:

Sistema multiagente do film_concept_team etapa 1

Um root_agent (greeter) vai receber o usuário e descobrir o assunto do filme.
Em seguida, ele será transferido para um SequentialAgent chamado film_concept_team, que vai:
1. Execute um agente researcher para receber fatos da Wikipédia.
2. Execute um agente screenwriter para usar esses fatos e escrever um enredo.
3. Execute um agente file_writer para salvar o gráfico final em um arquivo.

Vamos executar.

No Editor do Cloud Shell, abra adk_multiagent_systems/workflow_agents/agent.py.
Leia este arquivo de definição de agente. Como os subagentes precisam ser definidos antes de serem atribuídos a um agente principal, para ler o arquivo na ordem do fluxo da conversa, você pode ler os agentes de baixo para cima.
Observe a ferramenta append_to_state. Essa função auxiliar permite que os agentes anexem dados a uma lista no estado da sessão, que é como o researcher e o screenwriter vão passar o trabalho deles.
Teste o agente. No terminal, inicie a interface da Web com o recarregamento dinâmico ativado:
```
cd ~/devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems
adk web --reload_agents
```
Observação:se a porta 8000 estiver em uso, execute em uma porta diferente, por exemplo: adk web --reload_agents --port 8001.
No terminal do Cloud Shell, clique no botão Visualização na Web e selecione Alterar porta para abrir a interface da Web em uma nova guia.
Insira o número da porta 8000 e clique em Alterar e visualizar. Uma nova guia do navegador será aberta com a interface de desenvolvimento do ADK.
No menu suspenso Selecionar um agente, escolha workflow_agents.
Comece a conversa com: hello. O agente greeter vai responder.
Quando solicitado, insira uma figura histórica. Você pode usar uma destas opções ou a sua própria:
- Zhang Zhongjing
- Ada Lovelace
- Marcus Aurelius
O SequentialAgent vai assumir o controle. Você não vai ver nenhuma mensagem intermediária. Os comandos researcher, screenwriter e file_writer serão executados um após o outro. O agente só vai responder quando toda a sequência estiver concluída.
Se isso não funcionar, clique em + Nova sessão no canto superior direito e tente de novo.
Depois que o agente confirmar que o arquivo foi gravado, encontre e abra o novo arquivo .txt no diretório movie_pitches no editor do Cloud Shell para conferir a saída.
Na interface de desenvolvimento do ADK, clique no último ícone do agente no histórico de chat para abrir a visualização de eventos.
A visualização de eventos mostra um gráfico visual da árvore de agentes. Você pode ver como o greeter chamou o film_concept_team, que chamou cada um dos subagentes em ordem.
Clique nas guias Solicitação e Resposta de qualquer agente no gráfico para inspecionar os dados exatos que foram transmitidos, incluindo o estado da sessão.

Recapitulação da seção

Nesta seção, você aprendeu a usar um agente de fluxo de trabalho:

Um SequentialAgent executa os subagentes um por um, em ordem, sem esperar a entrada do usuário entre as etapas.
Esse é um "fluxo de trabalho" porque o usuário conversa com o root_agent, que transfere o trabalho para o SequentialAgent concluir.
Os subagentes na sequência usam o estado da sessão (por exemplo, { PLOT_OUTLINE? }) para acessar o trabalho de agentes anteriores.
É possível usar o gráfico de eventos na interface de desenvolvimento para visualizar e depurar todo o fluxo de trabalho de agente para agente.

11. adicionar um LoopAgent para trabalho iterativo

O LoopAgent é um agente de fluxo de trabalho que executa os subagentes em uma sequência e depois repete, começando do início. Esse "loop" continua até que uma condição seja atendida, como atingir uma contagem de max_iterations ou um subagente chamar a ferramenta exit_loop integrada.

É útil para tarefas que exigem refinamento iterativo. Você vai adicionar esse LoopAgent para criar uma "sala de roteiristas" para o agente de apresentação do filme. Isso permite que um researcher, um screenwriter e um novo agente critic trabalhem em um loop, melhorando a trama a cada passagem até que o critic decida que está tudo pronto. Isso também ajuda o agente a lidar com entradas de usuários mais vagas (como "um médico antigo") ao permitir que ele pesquise e refine uma ideia.

Sistema multiagente do film_concept_team etapa 2

Para fazer essas mudanças:

Em adk_multiagent_systems/workflow_agents/agent.py, adicione a importação de exit_loop (perto das outras importações de google.adk):
```
from google.adk.tools import exit_loop
```

Adicione o novo agente critic. Esse agente vai analisar o enredo. Se for bom, ele vai chamar exit_loop. Caso contrário, ele adiciona feedback ao estado para o próximo loop.
Cole a seguinte definição de agente na seção # Agents:

critic = Agent(
    name="critic",
    model=model_name,
    description="Reviews the outline so that it can be improved.",
    instruction="""
    INSTRUCTIONS:
    Consider these questions about the PLOT_OUTLINE:
    - Does it meet a satisfying three-act cinematic structure?
    - Do the characters' struggles seem engaging?
    - Does it feel grounded in a real time period in history?
    - Does it sufficiently incorporate historical details from the RESEARCH?

    If the PLOT_OUTLINE does a good job with these questions, exit the writing loop with your 'exit_loop' tool.
    If significant improvements can be made, use the 'append_to_state' tool to add your feedback to the field 'CRITICAL_FEEDBACK'.
    Explain your decision and briefly summarize the feedback you have provided.

    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    RESEARCH:
    { research? }
    """,
    before_model_callback=log_query_to_model,
    after_model_callback=log_model_response,
    tools=[append_to_state, exit_loop]
)

Crie o writers_room LoopAgent. Ele vai conter os três agentes que vão trabalhar no loop.
Cole o seguinte código acima da definição do agente film_concept_team:

writers_room = LoopAgent(
    name="writers_room",
    description="Iterates through research and writing to improve a movie plot outline.",
    sub_agents=[
        researcher,
        screenwriter,
        critic
    ],
    max_iterations=5,
)

Atualize o film_concept_team SequentialAgent para usar o novo loop writers_room. Substitua researcher e screenwriter pelo único agente writers_room.Substitua a definição film_concept_team atual por esta:

film_concept_team = SequentialAgent(
    name="film_concept_team",
    description="Write a film plot outline and save it as a text file.",
    sub_agents=[
        writers_room,
        file_writer
    ],
)

Volte para a guia da interface de desenvolvimento do ADK e clique em + Nova sessão no canto superior direito.
Comece uma nova conversa com: hello
Quando solicitado, dê ao agente um tema mais amplo desta vez. Algumas ideias:
- um designer industrial que criou produtos para as massas
- um cartógrafo (uma pessoa que faz mapas)
- aquele cara que fez as plantações produzirem mais alimentos
O agente vai percorrer o loop. Na interface de desenvolvimento do ADK, os registros vão aparecer quando os agentes forem executados várias vezes (por exemplo, "[pesquisador]", "[roteirista]", "[crítico]", "[pesquisador]", "[roteirista]", "[crítico]...").
Quando o loop for concluído, o agente vai gravar o arquivo. Revise o arquivo gerado no diretório adk_multiagent_systems/movie_pitches.
Inspecione o gráfico de eventos na interface de desenvolvimento para conferir a estrutura do loop.

Recapitulação da seção

Nesta seção, você aprendeu a usar o LoopAgent:

Um LoopAgent é um agente de fluxo de trabalho que repete a sequência de subagentes, criando um "loop interno" para tarefas iterativas.
Os agentes dentro do loop usam o estado da sessão para transmitir o trabalho (por exemplo, PLOT_OUTLINE) e feedback (por exemplo, CRITICAL_FEEDBACK) entre si em passagens subsequentes.
O loop pode ser interrompido ao atingir um limite de max_iterations ou quando um agente chama a ferramenta exit_loop.

12. Usar um ParallelAgent para "distribuição e coleta"

O ParallelAgent é um agente de fluxo de trabalho que executa todos os subagentes ao mesmo tempo (simultaneamente). Isso é útil para tarefas que podem ser divididas em subtarefas independentes, como executar dois jobs de pesquisa diferentes.

Você vai usar um ParallelAgent para criar uma "equipe de pré-produção" que trabalha em paralelo. Um agente vai pesquisar o potencial de bilheteria enquanto outro faz um brainstorming de ideias de elenco. Isso geralmente é chamado de padrão "fan out and gather": o ParallelAgent "distribui" o trabalho, e um agente posterior (nosso file_writer) "coleta" os resultados.

Sistema multiagente do film_concept_team etapa 3

O fluxo final do agente será:

O greeter (raiz) inicia o chat.
Ele é transferido para o film_concept_team (SequentialAgent), que executa:
- O writers_room (LoopAgent) para criar o gráfico.
- O novo preproduction_team (ParallelAgent) para pesquisar bilheteria e elenco ao mesmo tempo.
- O file_writer para reunir todos os resultados e salvar o arquivo.

Para fazer essas mudanças:

Em adk_multiagent_systems/workflow_agents/agent.py, cole o novo ParallelAgent e os subagentes dele no cabeçalho # Agents.

box_office_researcher = Agent(
    name="box_office_researcher",
    model=model_name,
    description="Considers the box office potential of this film",
    instruction="""
    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    INSTRUCTIONS:
    Write a report on the box office potential of a movie like that described in PLOT_OUTLINE based on the reported box office performance of other recent films.
    """,
    output_key="box_office_report"
)

casting_agent = Agent(
    name="casting_agent",
    model=model_name,
    description="Generates casting ideas for this film",
    instruction="""
    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    INSTRUCTIONS:
    Generate ideas for casting for the characters described in PLOT_OUTLINE
    by suggesting actors who have received positive feedback from critics and/or
    fans when they have played similar roles.
    """,
    output_key="casting_report"
)

preproduction_team = ParallelAgent(
    name="preproduction_team",
    sub_agents=[
        box_office_researcher,
        casting_agent
    ]
)

Atualize a lista sub_agents do SequentialAgent film_concept_team para incluir o novo preproduction_team (entre writers_room e file_writer).Substitua a definição de film_concept_team atual por esta:

film_concept_team = SequentialAgent(
    name="film_concept_team",
    description="Write a film plot outline and save it as a text file.",
    sub_agents=[
        writers_room,
        preproduction_team,
        file_writer
    ],
)

Atualize o instruction do agente file_writer para que ele "reúna" os novos relatórios do estado e os adicione ao arquivo.
Substitua a string instruction do file_writer por:

    instruction="""
    INSTRUCTIONS:
    - Create a marketable, contemporary movie title suggestion for the movie described in the PLOT_OUTLINE.
    If a title has been suggested in PLOT_OUTLINE, you can use it, or replace it with a better one.
    - Use your 'write_file' tool to create a new txt file with the following arguments:
    - for a filename, use the movie title
    - Write to the 'movie_pitches' directory.
    - For the 'content' to write, include:
    - The PLOT_OUTLINE
    - The BOX_OFFICE_REPORT
    - The CASTING_REPORT

    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    BOX_OFFICE_REPORT:
    { box_office_report? }

    CASTING_REPORT:
    { casting_report? }
    """,

Volte para a guia da interface de desenvolvimento do ADK e clique em + Nova sessão.
Digite hello para iniciar a conversa.
Quando solicitado, insira uma nova ideia de personagem. Algumas ideias:
- aquela atriz que inventou a tecnologia do Wi-Fi
- um chef incrível
- melhores atores no mundo de feira de exibições
Quando o agente terminar o trabalho, inspecione o arquivo final no diretório adk_multiagent_systems/movie_pitches. Ele agora deve conter o enredo, o relatório de bilheteria e o relatório de elenco em um único documento.

Recapitulação da seção

Nesta seção, você aprendeu a usar o ParallelAgent:

Um ParallelAgent "abre" o trabalho, executando todos os subagentes ao mesmo tempo, em vez de em uma sequência.
Isso é muito eficiente para tarefas que não dependem umas das outras, como pesquisar dois assuntos diferentes.
Os resultados dos agentes paralelos são "reunidos" por um agente posterior. Isso é feito fazendo com que os agentes paralelos salvem o trabalho no estado da sessão (usando output_key) e um agente final (como file_writer) leia essas chaves.

13. Agentes de fluxo de trabalho personalizados

Quando os agentes de fluxo de trabalho predefinidos de SequentialAgent, LoopAgent e ParallelAgent não são suficientes para suas necessidades, o CustomAgent oferece a flexibilidade de implementar uma nova lógica de fluxo de trabalho.

É possível definir padrões para controle de fluxo, execução condicional ou gerenciamento de estado entre subagentes. Isso é útil para fluxos de trabalho complexos, orquestrações com estado ou integração de lógica de negócios personalizada na camada de orquestração do framework.

A criação de um CustomAgent está fora do escopo deste laboratório, mas é bom saber que ele existe caso você precise dele.

14. Parabéns!

Você criou um sistema multiagente sofisticado usando o Kit de Desenvolvimento de Agente (ADK) do Google. Você passou de uma simples relação de agente pai-filho para a organização de fluxos de trabalho complexos e automatizados que podem pesquisar, escrever e refinar um projeto criativo.

Recapitulação

Neste laboratório, você:

Agentes organizados em uma árvore hierárquica com relações entre agente principal e subagente.
Transferências de agente para agente controladas, de forma automática (usando description) e explícita (usando instruction).
Usou uma ferramenta para gravar dados no dicionário tool_context.state.
Usou modelos de chave (por exemplo, { PLOT_OUTLINE? }) para ler o estado da sessão e orientar um comando do agente.
Implementamos um SequentialAgent para criar um fluxo de trabalho simples e gradual (pesquisar -> escrever -> salvar).
Usou um LoopAgent com um agente critic e a ferramenta exit_loop para criar um ciclo de refinamento iterativo.
Usamos um ParallelAgent para "abrir" tarefas independentes (como elenco e pesquisa de bilheteria) e executá-las simultaneamente.

Continuação do experimento

Há muitas maneiras de usar o que você aprendeu. Veja algumas ideias:

Adicione mais agentes:tente adicionar um novo agente ao seu preproduction_team ParallelAgent. Por exemplo, você pode criar um marketing_agent que escreva um slogan para o filme com base no PLOT_OUTLINE.
Adicionar mais ferramentas:dê mais ferramentas ao seu agente researcher. Você pode criar uma ferramenta que usa uma API de Pesquisa Google para encontrar informações que não estão na Wikipédia.
Explore CustomAgent:o laboratório mencionou o CustomAgent para fluxos de trabalho que não se encaixam nos modelos padrão. Tente criar um que, por exemplo, execute um agente condicionalmente apenas se uma chave específica existir no estado da sessão.

Criar sistemas multiagente com o ADK

1. Introdução

Visão geral

O que você vai criar

O que você vai aprender

2. Sistemas multiagentes

A árvore hierárquica de agentes

3. Configurar o projeto

Conta do Google

Fazer login no console do Google Cloud

Ativar faturamento

Resgatar US $5 em créditos do Google Cloud (opcional)

Configurar uma conta de faturamento pessoal

Criar um projeto (opcional)

4. Abrir editor do Cloud Shell

5. Ativar APIs

Introdução ao SDK da Vertex AI para Python

6. configurar o ambiente do projeto

Clone o repositório

Ativar um ambiente virtual

Revise a estrutura de arquivos

Configurar variáveis de ambiente

7. criar transferências entre os agentes principais, secundários e pares

Recapitulação

8. usar o estado da sessão para armazenar e recuperar informações

Recapitulação da seção

9. Agentes de fluxo de trabalho

10. Criar um sistema multiagente com um SequentialAgent

Recapitulação da seção

11. adicionar um LoopAgent para trabalho iterativo

Recapitulação da seção

12. Usar um ParallelAgent para "distribuição e coleta"

Recapitulação da seção

13. Agentes de fluxo de trabalho personalizados

14. Parabéns!

Recapitulação

Continuação do experimento