Tutorial Google ADK: Crie Agentes de IA do Zero à Produção

Tutorial Google ADK: Crie Agentes de IA do Zero à Produção

O Agent Development Kit (ADK) da Google é a estrutura que finalmente torna os sistemas multiagente acessíveis. Se tem construído agentes de IA com LangChain ou CrewAI e sentiu que estava a lutar mais contra a estrutura do que a construir com ela, este tutorial Google ADK guia-o através de tudo, desde o seu primeiro agente até à implementação no Cloud Run.

O Que É o Google ADK (E Por Que Deve Importar-se?)

O Agent Development Kit (ADK) da Google é uma estrutura Python de código aberto para criar, avaliar e implementar agentes de IA. Lançado em 2025, é otimizado para o Gemini, mas suporta mais de 100 modelos através do LiteLLM. A funcionalidade inovadora do ADK é a orquestração nativa multiagente, permitindo que os agentes deleguem tarefas a outros agentes sem necessidade de código de ligação ("glue code").

Após criar agentes com LangChain, CrewAI e agora ADK, eis o que se destaca: o ADK é opinativo nos sítios certos. Fornece-lhe uma estrutura de projeto, uma interface de utilizador de desenvolvimento integrada e um comando de implementação. Não precisa de juntar cinco bibliotecas diferentes para fazer um agente básico funcionar.

Se o LangChain é um canivete suíço de uso geral, o ADK é o kit de ferramentas específico da Google para fluxos de trabalho multiagente. O CrewAI está mais próximo na filosofia, com agentes baseados em funções que colaboram, mas o ADK vai mais longe com avaliação integrada, otimização nativa para Gemini e implementação no Cloud Run com um único comando. Para uma análise mais detalhada, consulte a nossa comparação aprofundada de estruturas de agentes.

Para quem é o ADK? Programadores Python que desejam sistemas multiagente estruturados. Equipas já integradas no Google Cloud ou no Gemini. Qualquer pessoa cansada de escrever lógica de orquestração repetitiva.

Eis como as estruturas se comparam num relance:

Em resumo: se procura o caminho mais rápido da "ideia" para o "sistema multiagente implementado", o ADK é difícil de superar neste momento.

Pré-requisitos e Instalação do Google ADK

Para começar com o Google ADK, precisa do Python 3.9+, uma chave API do Gemini (nível gratuito disponível no Google AI Studio) e o pacote google-adk. Instale com pip install google-adk, defina a sua chave API como uma variável de ambiente e estará pronto para criar o seu primeiro agente em menos de 5 minutos.

Eis a sua lista de verificação de configuração:

• Python 3.9+ (recomendado 3.10+ para suporte total de dicas de tipo)
• Uma chave API do Gemini, obtenha uma gratuitamente em aistudio.google.com. O nível gratuito oferece 15 pedidos por minuto, o que é suficiente para desenvolvimento.
• pip (ou uv se preferir velocidade, uv pip install google-adk também funciona)

Instale o pacote e defina a sua chave:

pip install google-adk

# Set your API key (add to .bashrc/.zshrc for persistence)
export GOOGLE_API_KEY="your-api-key-here"

O ADK espera uma estrutura de pastas específica. Cada agente reside no seu próprio diretório de pacote:

my_agent/
  __init__.py    # Exports root_agent
  agent.py       # Agent definition
.env             # Optional: GOOGLE_API_KEY=your-key

O nome da pasta torna-se o nome do pacote do seu agente, por isso escolha algo descritivo. Não lhe chame test ou agent, pois irá confundir o sistema de importação do Python.

Dica profissional: Se estiver a usar uv, crie primeiro um ambiente virtual com uv venv && source .venv/bin/activate. É notavelmente mais rápido do que o pip regular para resolução de dependências.

Criar o Seu Primeiro Agente Google ADK

O seu primeiro agente ADK precisa apenas de três coisas: um nome, um modelo (como gemini-2.0-flash) e uma cadeia de instruções. Defina-o em agent.py, coloque-o dentro de uma pasta com um __init__.py e execute adk web para conversar com ele numa interface de navegador. Toda a configuração leva cerca de 10 linhas de Python.

Crie uma pasta chamada my_agent e adicione dois ficheiros. Primeiro, a definição do agente:

# my_agent/agent.py
from google.adk.agents import LlmAgent

root_agent = LlmAgent(
    name="my_assistant",
    model="gemini-2.0-flash",
    instruction="""You are a helpful coding assistant. 
    You explain concepts clearly and provide working code examples.
    Keep responses concise but thorough.""",
    description="A coding assistant that explains concepts and writes code"
)

Depois, o ficheiro init que exporta o seu agente:

# my_agent/__init__.py
from .agent import root_agent

Esse nome de variável é importante, o ADK procura especificamente por root_agent. Se falhar isto, receberá um erro "agente não encontrado" que não explica o motivo.

Agora execute-o. Tem duas opções:

# CLI mode -- chat in your terminal
adk run my_agent

# Web UI mode -- opens a browser interface
adk web my_agent

A interface adk web é genuinamente útil. Mostra-lhe o registo completo da conversa, quais ferramentas o agente chamou, o que o modelo recebeu e o que devolveu. Pense nisso como as Ferramentas de Programador do Chrome para o seu agente. Quando começar a construir sistemas multiagente mais tarde, isto torna-se essencial para compreender o fluxo de delegação.

Tente modificar a instrução para ver como o comportamento muda. Faça dele um pirata. Faça com que responda apenas em haiku. Compreender como as instruções moldam o comportamento é a base para tudo o resto neste tutorial.

Adicionar Ferramentas Personalizadas ao Seu Agente Google ADK

Os agentes ADK tornam-se úteis quando lhes dá ferramentas. Defina uma função Python com uma docstring clara, e o ADK converte-a automaticamente numa ferramenta que o agente pode chamar. A docstring é crítica, pois informa o modelo sobre o que a ferramenta faz e quando a deve usar. O ADK também inclui ferramentas integradas como a Pesquisa Google e execução de código.

As ferramentas são as mãos de um agente. Sem elas, o seu agente só pode falar. Com elas, pode verificar bases de dados, chamar APIs, executar cálculos e interagir com sistemas externos. Se quiser entender como funciona a chamada de funções nos bastidores, temos um artigo aprofundado separado sobre isso.

Ferramentas de Função Personalizadas

Eis um exemplo prático, uma ferramenta que consulta preços de ações:

# my_agent/agent.py
from google.adk.agents import LlmAgent

def get_stock_price(ticker: str) -> dict:
    """Get the current stock price for a given ticker symbol.
    
    Args:
        ticker: The stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT')
    
    Returns:
        A dictionary with the ticker and its current price.
    """
    # In production, you'd call a real API here
    mock_prices = {"AAPL": 198.50, "GOOGL": 175.20, "MSFT": 425.80}
    price = mock_prices.get(ticker.upper(), None)
    if price:
        return {"ticker": ticker.upper(), "price": price, "currency": "USD"}
    return {"error": f"Ticker {ticker} not found"}

root_agent = LlmAgent(
    name="finance_assistant",
    model="gemini-2.0-flash",
    instruction="You help users check stock prices. Use the get_stock_price tool when asked about any stock.",
    tools=[get_stock_price],
    description="A financial assistant that looks up stock prices"
)

Note as dicas de tipo e a docstring. Estas não são meros detalhes opcionais, o ADK usa-as para gerar o esquema da ferramenta que o modelo vê. Ignore a docstring e o modelo não saberá quando chamar a sua função. Ignore as dicas de tipo e obterá um erro de assinatura.

Ferramentas Integradas (Pesquisa Google, Execução de Código)

O ADK inclui ferramentas que pode utilizar sem escrever qualquer código:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search, code_execution

root_agent = LlmAgent(
    name="research_agent",
    model="gemini-2.0-flash",
    instruction="You research topics using Google Search and can run Python code to analyze data.",
    tools=[google_search, code_execution],
    description="A research agent with search and code execution capabilities"
)

google_search permite ao agente consultar a web em tempo real. code_execution fornece-lhe um ambiente Python isolado para executar cálculos. Estas duas sozinhas cobrem um número surpreendente de casos de uso.

Sistemas Multiagente: Como os Agentes Google ADK Delegam Trabalho

O sistema multiagente do ADK utiliza um agente raiz que delega tarefas a subagentes especializados. Cada subagente trata de um domínio: pesquisa, escrita, programação. O agente raiz decide qual subagente chamar com base no pedido do utilizador. Também pode usar o padrão agente-como-ferramenta, onde um agente chama outro como se fosse uma função. O blogue oficial da Google sobre sistemas multiagente aprofunda os padrões arquiteturais.

Pense nisso como um gestor de projeto a delegar para especialistas. O agente raiz lê o pedido do utilizador, descobre qual especialista deve tratá-lo e encaminha adequadamente. Os especialistas não sabem uns dos outros, apenas fazem o seu trabalho e reportam de volta.

Padrão Agente Raiz + Subagentes

Eis um exemplo funcional com um agente raiz que delega para um agente de pesquisa e um agente de escrita:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search

# Sub-agent 1: handles research
research_agent = LlmAgent(
    name="researcher",
    model="gemini-2.0-flash",
    instruction="You research topics thoroughly using Google Search. Return factual, well-sourced information.",
    tools=[google_search],
    description="Researches topics and returns factual information"
)

# Sub-agent 2: handles writing
writing_agent = LlmAgent(
    name="writer",
    model="gemini-2.0-flash",
    instruction="You write clear, engaging content based on provided information. Focus on readability and accuracy.",
    description="Writes polished content from research notes"
)

# Root agent: delegates to the right sub-agent
root_agent = LlmAgent(
    name="content_manager",
    model="gemini-2.0-flash",
    instruction="""You manage content creation. 
    - When the user wants information gathered, delegate to the researcher.
    - When the user wants content written or edited, delegate to the writer.
    - You can chain both: research first, then write.""",
    sub_agents=[research_agent, writing_agent],
    description="Manages content creation by delegating to research and writing specialists"
)

O campo description em cada subagente é a forma como o agente raiz compreende o que eles podem fazer. Escreva descrições claras, descrições vagas levam a decisões de encaminhamento ruins.

Padrão Agente-como-Ferramenta

Por vezes, deseja mais controlo sobre como um agente chama outro. O padrão agente-como-ferramenta envolve um subagente como uma ferramenta invocável:

from google.adk.tools import agent_tool

research_tool = agent_tool.AgentTool(agent=research_agent)

root_agent = LlmAgent(
    name="writer_with_research",
    model="gemini-2.0-flash",
    instruction="You write articles. Use the research tool to gather facts before writing.",
    tools=[research_tool],
    description="A writer that can research topics on demand"
)

Use subagentes quando quiser que o agente raiz delegue totalmente o controlo. Use agente-como-ferramenta quando quiser que o agente chamador mantenha o controlo e apenas use a saída do subagente como entrada. Se estiver a construir sistemas onde os agentes precisam de contexto partilhado, consulte o nosso guia abrangente sobre arquiteturas de memória de agentes.

Agentes de Fluxo de Trabalho: Sequencial, Paralelo e Loop

Além da delegação orientada por LLM, o ADK oferece três tipos de agentes de fluxo de trabalho para orquestração determinística: SequentialAgent executa subagentes um após o outro, ParallelAgent executa-os simultaneamente e LoopAgent repete uma sequência até que uma condição seja satisfeita. Estes são úteis quando precisa de uma ordem de execução previsível em vez de deixar o LLM decidir.

A distinção é importante. A delegação orientada por LLM (o padrão sub_agents acima) permite que o modelo escolha quem chamar. Os agentes de fluxo de trabalho dão-lhe controlo programático. Use agentes de fluxo de trabalho quando a ordem de execução for conhecida antecipadamente.

from google.adk.agents import SequentialAgent, ParallelAgent, LlmAgent

# Three agents that must run in order
research_agent = LlmAgent(name="researcher", model="gemini-2.0-flash",
    instruction="Research the given topic.", description="Researches topics")
    
draft_agent = LlmAgent(name="drafter", model="gemini-2.0-flash",
    instruction="Write a draft based on the research.", description="Writes drafts")
    
review_agent = LlmAgent(name="reviewer", model="gemini-2.0-flash",
    instruction="Review the draft for accuracy and clarity.", description="Reviews content")

# Pipeline: research -> draft -> review
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Para tarefas independentes que podem ser executadas ao mesmo tempo, o ParallelAgent poupa tempo real:

# Three data fetchers that run concurrently
fetch_news = LlmAgent(name="news_fetcher", model="gemini-2.0-flash",
    instruction="Fetch latest tech news.", description="Fetches news")
    
fetch_stocks = LlmAgent(name="stock_fetcher", model="gemini-2.0-flash",
    instruction="Fetch stock market summary.", description="Fetches stocks")
    
fetch_weather = LlmAgent(name="weather_fetcher", model="gemini-2.0-flash",
    instruction="Fetch weather forecast.", description="Fetches weather")

morning_briefing = ParallelAgent(
    name="morning_briefing",
    sub_agents=[fetch_news, fetch_stocks, fetch_weather],
    description="Gathers morning briefing data in parallel"
)

Gerir Estado e Memória

O ADK gere o estado do agente em dois níveis: estado da sessão (dados dentro de uma conversa, como preferências do utilizador recolhidas durante o chat) e serviços de memória (dados que persistem entre conversas). O estado da sessão é um simples armazenamento chave-valor acedido via context.state. A memória utiliza serviços como InMemoryMemoryService ou VertexAIMemoryBankService para produção.

O estado da sessão é o mais simples. É um dicionário associado a cada conversa:

from google.adk.agents import LlmAgent

def save_preference(key: str, value: str, context) -> str:
    """Save a user preference to session state.
    
    Args:
        key: The preference name (e.g., 'language', 'theme')
        value: The preference value
        context: The ADK context object
    
    Returns:
        Confirmation message
    """
    context.state[key] = value
    return f"Saved preference: {key} = {value}"

def get_preference(key: str, context) -> str:
    """Retrieve a user preference from session state.
    
    Args:
        key: The preference name to look up
        context: The ADK context object
    
    Returns:
        The preference value or a not-found message
    """
    value = context.state.get(key, "Not set")
    return f"{key} = {value}"

root_agent = LlmAgent(
    name="personalized_assistant",
    model="gemini-2.0-flash",
    instruction="You remember user preferences. Save them when told, recall them when asked.",
    tools=[save_preference, get_preference],
    description="An assistant that remembers user preferences"
)

Para memória entre conversas, o tipo em que o seu agente se lembra de um utilizador da última terça-feira, precisa de um serviço de memória:

from google.adk.memory import InMemoryMemoryService

# For development (data lost on restart)
memory_service = InMemoryMemoryService()

# For production, use VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="your-project")

Quando precisa de memória vs estado da sessão? Se for dentro de uma única conversa (carrinho de compras, contexto da tarefa atual), use estado da sessão. Se precisar de sobreviver entre conversas (preferências do utilizador, interações passadas), use um serviço de memória. Consulte o nosso guia abrangente sobre arquiteturas de memória de agentes para padrões de produção.

Callbacks: Controlar o Comportamento do Agente

Os callbacks do ADK permitem-lhe interceptar e modificar o comportamento do agente em quatro pontos: before_model_callback (antes da chamada LLM), after_model_callback (após a resposta LLM), before_tool_callback (antes da execução da ferramenta) e after_tool_callback (após o resultado da ferramenta). Use-os para validação de entrada, filtragem de segurança, registo ou modificação de respostas antes de chegarem ao utilizador.

Os callbacks são onde adiciona barreiras de proteção. Pense neles como middleware para o seu agente, cada pedido e resposta passa por eles, e pode inspecionar, modificar ou bloquear qualquer coisa.

from google.adk.agents import LlmAgent

def safety_filter(callback_context, llm_request):
    """Block requests containing harmful content patterns."""
    user_message = str(llm_request)
    blocked_patterns = ["ignore your instructions", "pretend you are"]
    
    for pattern in blocked_patterns:
        if pattern.lower() in user_message.lower():
            # Return a response directly, skipping the model call
            return {"blocked": True, "reason": "Request matched safety filter"}
    
    # Return None to proceed normally
    return None

def log_tool_usage(callback_context, tool_name, tool_result):
    """Log every tool call for monitoring."""
    print(f"[TOOL LOG] {tool_name}: {tool_result}")
    return None  # Don't modify the result

root_agent = LlmAgent(
    name="safe_assistant",
    model="gemini-2.0-flash",
    instruction="You are a helpful assistant.",
    before_model_callback=safety_filter,
    after_tool_callback=log_tool_usage,
    description="A safety-filtered assistant with tool logging"
)

O before_model_callback é o mais importante para produção. Executa antes de cada chamada LLM, dando-lhe a oportunidade de bloquear injeções de prompt, validar entradas ou adicionar contexto do sistema. Se devolver um objeto de resposta, o ADK ignora completamente o modelo. Devolva None para permitir que o pedido prossiga. Para mais padrões, veja padrões mais profundos para barreiras de segurança LLM.

Testar e Avaliar os Seus Agentes ADK

O ADK inclui uma estrutura de avaliação integrada com dois tipos de avaliadores: ResponseEvaluator verifica se a resposta final do agente está correta, e TrajectoryEvaluator verifica se o agente tomou os passos certos, chamou as ferramentas certas na ordem certa. Escreva casos de teste como ficheiros JSON e execute-os com pytest para detetar regressões antes da implementação.

Porque se dar ao trabalho de testar agentes? Porque são não determinísticos. A mesma entrada pode produzir saídas diferentes, e uma pequena alteração na sua instrução pode quebrar a chamada de ferramentas de formas subtis. Na nossa experiência, agentes que passam na avaliação de trajetória são muito mais fiáveis em produção do que aqueles testados apenas na qualidade da saída final. Para estratégias de avaliação mais amplas, veja o nosso guia de estratégias de avaliação LLM.

Os seus casos de teste vão num ficheiro JSON:

[
  {
    "input": "What's the stock price of AAPL?",
    "expected_output": "198.50",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}}
    ]
  },
  {
    "input": "Compare AAPL and GOOGL prices",
    "expected_output": "AAPL.*198.*GOOGL.*175",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}},
      {"tool_name": "get_stock_price", "args": {"ticker": "GOOGL"}}
    ]
  }
]

Depois execute avaliações com pytest. O repositório Python do ADK tem a referência completa da API de avaliação:

# test_agent.py
import pytest
from google.adk.evaluation import ResponseEvaluator, TrajectoryEvaluator

def test_stock_agent_response():
    evaluator = ResponseEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.8, f"Response pass rate too low: {results.pass_rate}"

def test_stock_agent_trajectory():
    evaluator = TrajectoryEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.9, f"Trajectory pass rate too low: {results.pass_rate}"

Execute com pytest test_agent.py -v. Defina os seus limiares com base na criticidade -- 80% de precisão de resposta pode ser aceitável para um agente de escrita criativa, mas desejará 95%+ para qualquer coisa que lide com dados financeiros.

Implementar o Seu Agente Google ADK em Produção

Implemente o seu agente ADK no Google Cloud Run com um comando: adk deploy cloud_run --project SEU_PROJETO --region us-central1. O ADK empacota o seu código, constrói um contentor e lança um ponto de extremidade sem servidor. Para alojamento gerido, use o Vertex AI Agent Engine. Para infraestrutura personalizada, o ADK também suporta contentorização Docker.

Implementámos agentes ADK no Cloud Run para ferramentas internas, e os tempos de arranque a frio são surpreendentemente rápidos, menos de 3 segundos para um agente básico. Para sistemas de produção, considere emparelhar a sua implementação com ferramentas de monitorização para agentes de produção.

Implementar no Cloud Run (Recomendado para a Maioria)

O Cloud Run é o caminho mais simples. Um comando, e o seu agente está ativo com um ponto de extremidade HTTPS:

adk deploy cloud_run \
  --project your-gcp-project-id \
  --region us-central1 \
  --service-name my-agent-service \
  --with_ui

A flag --with_ui implementa a interface Web do ADK juntamente com o seu agente, pelo que obtém um chat baseado no navegador para testes em produção. Nos bastidores, o ADK constrói uma imagem de contentor, envia-a para o Google Artifact Registry e cria um serviço Cloud Run. O fluxo completo de implementação está documentado no início rápido do Cloud Run da Google para ADK.

Para infraestrutura personalizada, eis um Dockerfile mínimo:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8080
CMD ["adk", "api_server", "--port", "8080", "my_agent"]

Alternativa: Vertex AI Agent Engine

Para equipas empresariais que precisam de escalabilidade gerida, monitorização e versionamento, o Vertex AI Agent Engine trata inteiramente da infraestrutura. Troca flexibilidade por conveniência, sem contentores para gerir, escalabilidade automática, analíticas integradas.

Considerações de Custo

Números reais que deve conhecer:

• Nível gratuito da API Gemini: 15 pedidos por minuto, 1 milhão de tokens/dia. Suficiente para desenvolvimento e demonstrações leves.
• Gemini 2.0 Flash (pago): $0,10 por milhão de tokens de entrada, $0,40 por milhão de tokens de saída. Suficientemente barato para produção.
• Nível gratuito do Cloud Run: 2 milhões de pedidos/mês, 360.000 GB-segundos de computação. Um agente básico a lidar com 1.000 pedidos/dia mantém-se bem dentro do nível gratuito.
• Dica de otimização: Use gemini-2.0-flash (não gemini-2.0-pro) para subagentes que fazem encaminhamento ou formatação simples. Reserve os modelos mais capazes para agentes que fazem raciocínio complexo.

Como a Techsy Aborda o Desenvolvimento de Agentes de IA

Na Techsy, construímos sistemas multiagente para clientes usando ADK, LangGraph e CrewAI. A escolha da estrutura depende da sua stack: se já está no Google Cloud, o ADK elimina muita fricção de integração. Se precisa de suporte LLM multi-fornecedor desde o primeiro dia, o LangGraph oferece-lhe mais flexibilidade.

O nosso envolvimento típico começa com consultoria de arquitetura, mapeando o seu caso de uso para os padrões de agente corretos, seguido de desenvolvimento de protótipo e implementação no Cloud Run. Descobrimos que as equipas poupam 2-3 semanas ao acertar a arquitetura desde o início em vez de refatorizar mais tarde.

A construir agentes de IA para a sua equipa? Obtenha uma consulta gratuita, ajudamo-lo a escolher a estrutura e estratégia de implementação corretas.

Erros Comuns e Resolução de Problemas

Estes são os erros que encontramos com mais frequência ao começar com o ADK. Poupe tempo de depuração:

Dica de depuração: adk web é o seu melhor amigo aqui. Mostra o registo completo da conversa, cada chamada de modelo, invocação de ferramenta e delegação de agente, em tempo real. Quando algo corre mal num sistema multiagente, a interface web mostra-lhe exatamente onde a cadeia quebrou.

FAQ

O que é o Google ADK?

O Agent Development Kit (ADK) da Google é uma estrutura Python de código aberto para criar, avaliar e implementar agentes de IA. É otimizado para modelos Google Gemini, mas suporta mais de 100 LLMs através da integração LiteLLM. O ponto forte do ADK é a orquestração nativa multiagente com ferramentas integradas, uma IU de desenvolvimento e implementação no Cloud Run com um único comando.

O Google ADK é gratuito?

Sim. O próprio ADK é de código aberto sob a licença Apache 2.0. Precisa de uma chave API do Gemini, que tem um nível gratuito oferecendo 15 pedidos por minuto e 1 milhão de tokens por dia. Os custos de implementação na nuvem dependem da sua escolha de alojamento, o nível gratuito do Cloud Run cobre 2 milhões de pedidos por mês.

Qual é a diferença entre Google ADK e LangChain?

O ADK é a estrutura opinativa da Google otimizada para Gemini com orquestração multiagente nativa e ferramentas de implementação integradas. O LangChain é agnóstico quanto ao modelo, com integrações de terceiros mais amplas, mas significativamente mais complexidade. O ADK é melhor para equipas focadas no Gemini que desejam implementação rápida; o LangChain adequa-se a configurações multi-fornecedor que necessitam de máxima flexibilidade.

O Google ADK suporta sistemas multiagente?

Sim, e é a funcionalidade principal do ADK. Cria um agente raiz que delega para subagentes especializados com base nos pedidos do utilizador. O ADK também oferece SequentialAgent, ParallelAgent e LoopAgent para orquestração de fluxo de trabalho determinística. O padrão agente-como-ferramenta permite que os agentes chamem outros agentes como funções invocáveis.

Como implemento um agente Google ADK?

Execute adk deploy cloud_run --project SEU_PROJETO --region us-central1 para implementação sem servidor no Google Cloud Run. Adicione --with_ui para incluir a interface de chat baseada no navegador. Também pode implementar no Vertex AI Agent Engine para alojamento gerido, ou construir um contentor Docker para infraestrutura personalizada.

O Google ADK pode usar modelos além do Gemini?

Sim. O ADK suporta mais de 100 modelos através da integração LiteLLM, incluindo Anthropic Claude, OpenAI GPT-4, Meta Llama e Mistral. Defina o parâmetro do modelo para a cadeia do modelo LiteLLM, por exemplo, litellm/anthropic/claude-3-sonnet ou litellm/openai/gpt-4o. Os modelos Gemini funcionam nativamente sem o prefixo LiteLLM.

O que é a IU Web do ADK?

Uma interface de depuração baseada no navegador lançada com adk web sua_pasta_agente. Exibe registos de conversa em tempo real, chamadas de ferramentas, cadeias de delegação de agentes e alterações de estado à medida que ocorrem. A IU Web é essencial para depurar sistemas multiagente porque mostra exatamente qual subagente tratou cada pedido.

O Google ADK suporta MCP (Model Context Protocol)?

Sim. O ADK tem suporte nativo para Model Context Protocol, permitindo que os agentes se conectem a qualquer servidor de ferramentas compatível com MCP para ferramentas externas e fontes de dados. Isto torna os agentes ADK interoperáveis com o ecossistema MCP em crescimento. Para antecedentes sobre o protocolo, veja o nosso guia MCP.

Como testo agentes ADK?

O ADK inclui avaliadores integrados: ResponseEvaluator para verificar a qualidade da saída em relação às respostas esperadas, e TrajectoryEvaluator para verificar se o agente chamou as ferramentas certas na ordem certa. Escreva casos de teste como ficheiros JSON definindo entradas, saídas esperadas e sequências de chamadas de ferramentas esperadas, depois execute-os com pytest.

Que versão do Python o Google ADK requer?

O ADK requer Python 3.9 ou superior. Python 3.10+ é recomendado para suporte total de dicas de tipo, o que é importante porque o ADK usa dicas de tipo para gerar esquemas de ferramentas. Python 3.11 ou 3.12 também oferecem melhorias de desempenho significativas para cargas de trabalho de agentes. Instale com pip install google-adk.