Aprenda a criar seu primeiro agente de IA com Google ADK. Tutorial completo com anatomia do agent.py, parâmetros essenciais, execução e depuração de eventos.
Insights
- O nome da variável do agente em agent.py deve corresponder exatamente ao nome da pasta do agente, caso contrário o ADK não encontra o agente
- O parâmetro
instructioné onde você define a personalidade e comportamento do agente, funcionando como um system prompt persistente - Eventos são a unidade fundamental de comunicação no ADK, cada ação do agente gera eventos que podem ser inspecionados para debugging
- O Runner é o orquestrador central que conecta agente, sessão e modelo, gerenciando todo o ciclo de vida da execução
- O parâmetro
descriptioné usado por outros agentes em sistemas multi-agentes para decidir quando delegar tarefas
Criar um agente de IA com o Google ADK é surpreendentemente simples quando você entende a anatomia do arquivo agent.py. O framework foi projetado para que desenvolvedores Python se sintam em casa desde o primeiro momento. Quatro parâmetros são suficientes para um agente funcional: name identifica o agente, model define qual LLM será usado, description resume o propósito e instruction estabelece o comportamento. Com esses elementos configurados corretamente, você tem um agente pronto para interagir.
A execução pode acontecer de duas formas complementares. O comando adk web oferece interface visual para desenvolvimento e testes rápidos, permitindo conversar com o agente e inspecionar eventos em tempo real. Para integração em aplicações, o Runner executa o agente programaticamente, emitindo eventos assíncronos que você processa conforme necessário. Entender esse fluxo de eventos é fundamental para debugging e para construir experiências de usuário responsivas.
A Estrutura mínima já está pronta
No artigo anterior, configuramos o ambiente e criamos a estrutura de pastas obrigatória. Vamos recapitular rapidamente o que temos:
|
1 2 3 4 5 |
meu_projeto/ └── greeting_agent/ ├── __init__.py ├── .env └── agent.py |
O arquivo .env já contém sua API Key do Google AI Studio. O arquivo __init__.py existe e está vazio. O arquivo agent.py é onde vamos trabalhar agora.
Se você ainda não tem essa estrutura, volte ao artigo anterior e configure o ambiente primeiro. Todo o código deste artigo assume que a configuração está completa.
A anatomia do agent.py
O arquivo agent.py é o coração do seu agente. Ele contém a definição que o ADK carrega e executa. Vamos construí-lo passo a passo.
A importação essencial
|
1 2 |
from google.adk.agents import Agent |
A classe Agent (também conhecida como LlmAgent na documentação) é o componente central. Ela representa um agente que utiliza um Large Language Model para raciocínio e geração de respostas.
A definição mínima
|
1 2 3 4 5 6 7 8 |
from google.adk.agents import Agent greeting_agent = Agent( name="greeting_agent", model="gemini-2.0-flash", description="Um agente amigável que cumprimenta usuários", instruction="Você é um assistente amigável e prestativo. Cumprimente o usuário de forma calorosa e pergunte como pode ajudar." ) |
Esse é um agente funcional. Quatro linhas de configuração e você tem um assistente que conversa.
A correspondência de nomes é obrigatória
Observe que a variável se chama greeting_agent e a pasta também se chama greeting_agent. Isso não é coincidência. O ADK procura uma variável com o mesmo nome da pasta dentro do arquivo agent.py.
Se a pasta é meu_agente, o código deve ter:
|
1 |
meu_agente = Agent(name="meu_agente", ...) |
Se os nomes não corresponderem, o ADK não encontrará o agente e você verá erro na interface web.
Os Parâmetros essenciais em profundidade
Cada parâmetro do Agent tem propósito específico. Entendê-los é fundamental para criar agentes efetivos.
name: O identificador único
|
1 |
name="greeting_agent" |
O parâmetro name é o identificador único do agente. Ele é usado internamente pelo ADK para:
- Identificar o autor de eventos no histórico
- Referenciar agentes em sistemas multi-agentes
- Delegar tarefas entre agentes
- Logging e debugging
Boas práticas para nomes:
- Use snake_case (palavras separadas por underscore)
- Seja descritivo:
customer_support_agenté melhor queagent1 - Mantenha consistência: o nome deve corresponder à pasta e à variável
model: O cérebro do agente
|
1 |
model="gemini-2.0-flash" |
O parâmetro model define qual Large Language Model o agente utilizará para raciocínio. O ADK é otimizado para modelos Gemini, mas suporta outros via LiteLLM.
Modelos Gemini disponíveis:
| Modelo | Características |
|---|---|
gemini-2.0-flash | Rápido, econômico, ideal para maioria dos casos |
gemini-2.0-flash-lite | Ainda mais rápido e econômico |
gemini-1.5-pro | Maior capacidade de raciocínio |
gemini-1.5-flash | Versão anterior, ainda suportada |
Para desenvolvimento e aprendizado, gemini-2.0-flash oferece excelente equilíbrio entre capacidade e custo. É o modelo recomendado para começar.
description: O cartão de visita
|
1 |
description="Um agente amigável que cumprimenta usuários" |
O parâmetro description é uma descrição concisa do que o agente faz. Pode parecer apenas documentação, mas tem função crítica em sistemas multi-agentes.
Quando você tem múltiplos agentes e um agente coordenador precisa decidir para qual especialista delegar uma tarefa, ele lê as descrições de cada agente disponível. Uma descrição clara e específica ajuda o coordenador a fazer a escolha correta.
Descrições efetivas:
- “Responde perguntas sobre políticas de devolução e reembolso”
- “Analisa dados de vendas e gera relatórios em formato tabular”
- “Agenda reuniões verificando disponibilidade no calendário”
Descrições fracas:
- “Um agente útil” (vago demais)
- “Faz várias coisas” (não ajuda na delegação)
instruction: A personalidade e o comportamento
|
1 |
instruction="Você é um assistente amigável e prestativo. Cumprimente o usuário de forma calorosa e pergunte como pode ajudar." |
O parâmetro instruction é o mais poderoso. Ele define como o agente se comporta, funcionando como um system prompt que persiste durante toda a conversa.
O que incluir nas instruções:
- Persona ou personalidade do agente
- Tarefa principal ou objetivo
- Restrições e limitações
- Formato de resposta esperado
- Diretrizes de uso de ferramentas
Exemplo de instrução elaborada:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
instruction="""Você é um especialista em suporte técnico para produtos de software. Seu objetivo é ajudar usuários a resolver problemas técnicos de forma clara e paciente. Diretrizes: - Faça perguntas para entender o problema antes de sugerir soluções - Explique conceitos técnicos em linguagem simples - Ofereça passos numerados quando a solução envolver múltiplas etapas - Se não souber a resposta, admita e sugira onde o usuário pode encontrar ajuda Nunca: - Invente informações que você não tem certeza - Seja condescendente ou impaciente - Assuma que o usuário tem conhecimento técnico avançado""" |
Instruções dinâmicas com variáveis de estado
As instruções suportam variáveis dinâmicas que são substituídas em tempo de execução:
|
1 2 3 4 5 6 7 |
instruction="""Você é um assistente pessoal para {user_name}. Preferências do usuário: - Idioma: {user_language} - Estilo de comunicação: {communication_style} Responda sempre respeitando essas preferências.""" |
As variáveis entre chaves ({user_name}, {user_language}) são substituídas por valores do estado da sessão. Isso permite personalização sem modificar o código do agente.
O Código completo do primeiro agente
Vamos criar um agente mais elaborado que demonstra boas práticas:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
<em># greeting_agent/agent.py</em> from google.adk.agents import Agent greeting_agent = Agent( name="greeting_agent", model="gemini-2.0-flash", description="Agente especializado em cumprimentos e boas-vindas, capaz de adaptar o tom conforme o contexto", instruction="""Você é um assistente de boas-vindas amigável e profissional. Seu papel é: 1. Cumprimentar o usuário de forma calorosa 2. Apresentar-se brevemente 3. Perguntar como pode ajudar Diretrizes de comunicação: - Seja cordial mas não excessivamente informal - Use linguagem clara e acessível - Mantenha respostas concisas (2-3 frases por mensagem) - Adapte o tom conforme o usuário (mais formal se ele for formal, mais descontraído se ele for casual) Se o usuário fizer perguntas fora do seu escopo (que não sejam sobre boas-vindas ou como você pode ajudar), gentilmente explique que você é especializado em dar boas-vindas e direcione a conversa.""" ) |
Executando com adk web
A interface web é a forma mais rápida de testar seu agente durante o desenvolvimento.
Iniciando a Interface
Navegue até a pasta pai do agente e execute:
|
1 2 |
cd meu_projeto adk web |
O terminal exibirá:
|
1 2 3 4 |
INFO: Started server process [12345] INFO: Waiting for application startup. INFO: Application startup complete. INFO: Uvicorn running on http://localhost:8000 |
Navegando na interface
Abra http://localhost:8000 no navegador. A interface apresenta:
Seletor de Agente: Dropdown no topo listando todos os agentes encontrados. Selecione greeting_agent.
Área de Chat: Campo de entrada na parte inferior e histórico de mensagens acima.
Painel de Eventos: Lado direito (ou aba separada) mostrando eventos em tempo real.
Inspetor de Estado: Visualização do estado atual da sessão.
Primeira interação
Com greeting_agent selecionado:
- Digite “Olá!” no campo de mensagem
- Pressione Enter ou clique no botão de enviar
- Observe a resposta aparecer no chat
Se tudo estiver configurado corretamente, você verá uma saudação amigável do agente.
Inspecionando eventos na interface
O painel de eventos mostra cada passo da execução:
- Evento de entrada: Sua mensagem “Olá!” com author “user”
- Evento de resposta: Resposta do agente com author “greeting_agent”
Clique em cada evento para expandir detalhes como timestamp, invocation_id e conteúdo completo.
Executando programaticamente com runner
Para integrar agentes em aplicações, você precisa executá-los via código. O Runner é o componente que orquestra essa execução.
O script completo
Crie um arquivo run_agent.py na raiz do projeto:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
<em># run_agent.py</em> import asyncio from dotenv import load_dotenv <em># Carregar variáveis de ambiente</em> load_dotenv("greeting_agent/.env") from google.adk.runners import Runner from google.adk.sessions import InMemorySessionService from google.genai import types <em># Importar o agente</em> from greeting_agent.agent import greeting_agent async def main(): <em># 1. Criar serviço de sessão</em> session_service = InMemorySessionService() <em># 2. Criar uma sessão</em> session = await session_service.create_session( app_name="meu_app", user_id="usuario_001" ) print(f"Sessão criada: {session.id}") print("-" * 50) <em># 3. Criar o Runner</em> runner = Runner( agent=greeting_agent, app_name="meu_app", session_service=session_service ) <em># 4. Preparar mensagem do usuário</em> user_message = types.Content( role="user", parts=[types.Part.from_text("Olá! Tudo bem?")] ) <em># 5. Executar e processar eventos</em> print("Usuário: Olá! Tudo bem?") print("Agente: ", end="", flush=True) async for event in runner.run_async( user_id="usuario_001", session_id=session.id, new_message=user_message ): <em># Verificar se o evento tem conteúdo de texto</em> if event.content and event.content.parts: for part in event.content.parts: if hasattr(part, 'text') and part.text: print(part.text, end="", flush=True) print("\n" + "-" * 50) <em># 6. Continuar a conversa</em> second_message = types.Content( role="user", parts=[types.Part.from_text("Pode me contar uma curiosidade interessante?")] ) print("Usuário: Pode me contar uma curiosidade interessante?") print("Agente: ", end="", flush=True) async for event in runner.run_async( user_id="usuario_001", session_id=session.id, new_message=second_message ): if event.content and event.content.parts: for part in event.content.parts: if hasattr(part, 'text') and part.text: print(part.text, end="", flush=True) print() if __name__ == "__main__": asyncio.run(main()) |
Executando o Script
|
1 |
python run_agent.py |
Output esperado:
|
1 2 3 4 5 6 7 |
Sessão criada: abc123-def456-... -------------------------------------------------- Usuário: Olá! Tudo bem? Agente: Olá! Tudo ótimo por aqui! Sou seu assistente de boas-vindas. Como posso ajudar você hoje? -------------------------------------------------- Usuário: Pode me contar uma curiosidade interessante? Agente: Claro! Aqui vai uma: o mel nunca estraga... |
Entendendo Cada Componente
InMemorySessionService: Armazena sessões na memória RAM. Dados são perdidos quando o programa termina. Adequado para desenvolvimento e testes.
|
1 |
session_service = InMemorySessionService() |
Session: Representa uma conversa individual. Mantém histórico de mensagens e estado.
|
1 2 3 4 |
session = await session_service.create_session( app_name="meu_app", user_id="usuario_001" ) |
Runner: O motor de execução. Conecta agente, sessão e modelo.
|
1 2 3 4 5 |
runner = Runner( agent=greeting_agent, app_name="meu_app", session_service=session_service ) |
Content: Estrutura de mensagem do Gemini. Contém role (quem está falando) e parts (conteúdo).
|
1 2 3 4 |
user_message = types.Content( role="user", parts=[types.Part.from_text("Olá!")] ) |
run_async: Método assíncrono que executa o agente e retorna gerador de eventos.
|
1 2 3 4 5 6 |
async for event in runner.run_async( user_id="usuario_001", session_id=session.id, new_message=user_message ): <em># Processar cada evento</em> |
Depuração e Inspeção de Eventos
Eventos são a unidade fundamental de informação no ADK. Cada ação gera eventos que podem ser inspecionados para entender o que está acontecendo.
Estrutura de um Evento
Um evento contém:
| Campo | Descrição |
|---|---|
author | Quem gerou o evento: “user” ou nome do agente |
content | Conteúdo da mensagem (texto, chamadas de função, etc.) |
invocation_id | ID único da interação completa |
id | ID único do evento específico |
timestamp | Momento de criação |
partial | Se True, é chunk de streaming (incompleto) |
actions | Mudanças de estado, artifacts, sinais de controle |
Script de Depuração Completo
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
<em># debug_agent.py</em> import asyncio from dotenv import load_dotenv load_dotenv("greeting_agent/.env") from google.adk.runners import Runner from google.adk.sessions import InMemorySessionService from google.genai import types from greeting_agent.agent import greeting_agent async def main(): session_service = InMemorySessionService() session = await session_service.create_session( app_name="debug_app", user_id="debug_user" ) runner = Runner( agent=greeting_agent, app_name="debug_app", session_service=session_service ) user_message = types.Content( role="user", parts=[types.Part.from_text("Olá, como você funciona?")] ) print("=" * 60) print("DEPURAÇÃO DE EVENTOS") print("=" * 60) event_count = 0 async for event in runner.run_async( user_id="debug_user", session_id=session.id, new_message=user_message ): event_count += 1 print(f"\n--- Evento #{event_count} ---") print(f"Author: {event.author}") print(f"ID: {event.id}") print(f"Invocation ID: {event.invocation_id}") print(f"Partial: {event.partial}") <em># Verificar conteúdo</em> if event.content: print(f"Content Role: {event.content.role if hasattr(event.content, 'role') else 'N/A'}") if event.content.parts: for i, part in enumerate(event.content.parts): print(f" Part {i}:") <em># Texto</em> if hasattr(part, 'text') and part.text: text_preview = part.text[:100] + "..." if len(part.text) > 100 else part.text print(f" Text: {text_preview}") <em># Chamada de função</em> if hasattr(part, 'function_call') and part.function_call: print(f" Function Call: {part.function_call.name}") print(f" Args: {part.function_call.args}") <em># Resposta de função</em> if hasattr(part, 'function_response') and part.function_response: print(f" Function Response: {part.function_response.name}") <em># Verificar ações</em> if event.actions: if hasattr(event.actions, 'state_delta') and event.actions.state_delta: print(f"State Delta: {event.actions.state_delta}") <em># Verificar se é resposta final</em> if hasattr(event, 'is_final_response') and event.is_final_response(): print(">>> Esta é a resposta final <<<") print("\n" + "=" * 60) print(f"Total de eventos: {event_count}") print("=" * 60) if __name__ == "__main__": asyncio.run(main()) |
Executando a depuração
|
1 |
python debug_agent.py |
Output típico:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
============================================================ DEPURAÇÃO DE EVENTOS ============================================================ --- Evento #1 --- Author: greeting_agent ID: evt_abc123 Invocation ID: inv_xyz789 Partial: False Content Role: model Part 0: Text: Olá! Que bom receber você! Sou um assistente... >>> Esta é a resposta final <<< ============================================================ Total de eventos: 1 ============================================================ |
Identificando tipos de eventos
Para agentes simples sem ferramentas, você verá principalmente eventos de texto. Quando adicionarmos ferramentas nos próximos artigos, veremos:
Evento de chamada de função:
|
1 2 3 |
Part 0: Function Call: get_weather Args: {"city": "São Paulo"} |
Evento de resposta de função:
|
1 2 |
Part 0: Function Response: get_weather |
Evento de mudança de estado:
|
1 |
State Delta: {"last_query": "clima em São Paulo"} |
Usando is_final_response()
O método is_final_response() identifica quando um evento é a resposta final que deve ser mostrada ao usuário:
|
1 2 3 |
if event.is_final_response(): <em># Este é o evento para mostrar ao usuário</em> final_text = event.content.parts[0].text |
Retorna True quando:
- É uma mensagem completa (não parcial)
- Não contém chamadas de função pendentes
- Não é apenas resultado de ferramenta
Parâmetros Adicionais do Agent
Além dos quatro parâmetros essenciais, o Agent aceita configurações adicionais para casos avançados. Vamos conhecer os mais úteis.
output_key: Salvando Resposta no Estado
|
1 2 3 4 5 6 7 |
agent = Agent( name="summary_agent", model="gemini-2.0-flash", description="Gera resumos de textos", instruction="Resuma o texto fornecido em 2-3 frases.", output_key="summary" ) |
Com output_key="summary", a resposta final do agente é automaticamente salva no estado da sessão sob a chave “summary”. Útil para passar dados entre agentes em workflows.
generate_content_config: Ajustando a Geração
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from google.genai.types import GenerateContentConfig agent = Agent( name="creative_agent", model="gemini-2.0-flash", description="Gera conteúdo criativo", instruction="Seja criativo e surpreendente nas respostas.", generate_content_config=GenerateContentConfig( temperature=0.9, <em># Mais criatividade (0.0 a 1.0)</em> max_output_tokens=500 <em># Limitar tamanho da resposta</em> ) ) |
Parâmetros de geração disponíveis:
temperature: Controla aleatoriedade (0.0 = determinístico, 1.0 = mais criativo)max_output_tokens: Limite máximo de tokens na respostatop_p: Nucleus samplingtop_k: Limita vocabulário considerado
include_contents: Controlando Contexto
|
1 2 3 4 5 6 7 |
agent = Agent( name="stateless_agent", model="gemini-2.0-flash", description="Agente que não precisa de histórico", instruction="Responda apenas à pergunta atual.", include_contents="none" <em># Não recebe histórico</em> ) |
Valores possíveis:
"default": Recebe histórico completo da conversa"none": Opera apenas com a mensagem atual (stateless)
Tratamento de Erros
Agentes podem falhar por diversos motivos: API indisponível, limite de tokens excedido, erro de rede. É importante tratar essas situações.
Script com Tratamento de Erros
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 |
<em># safe_run.py</em> import asyncio from dotenv import load_dotenv load_dotenv("greeting_agent/.env") from google.adk.runners import Runner from google.adk.sessions import InMemorySessionService from google.genai import types from greeting_agent.agent import greeting_agent async def run_with_error_handling(): try: session_service = InMemorySessionService() session = await session_service.create_session( app_name="safe_app", user_id="user_001" ) runner = Runner( agent=greeting_agent, app_name="safe_app", session_service=session_service ) user_message = types.Content( role="user", parts=[types.Part.from_text("Olá!")] ) response_text = "" async for event in runner.run_async( user_id="user_001", session_id=session.id, new_message=user_message ): <em># Verificar erros no evento</em> if hasattr(event, 'error_code') and event.error_code: print(f"Erro no evento: {event.error_code}") print(f"Mensagem: {event.error_message}") continue <em># Coletar texto</em> if event.content and event.content.parts: for part in event.content.parts: if hasattr(part, 'text') and part.text: response_text += part.text if response_text: print(f"Resposta: {response_text}") else: print("Nenhuma resposta recebida") except Exception as e: print(f"Erro durante execução: {type(e).__name__}: {e}") if __name__ == "__main__": asyncio.run(run_with_error_handling()) |
Erros Comuns e Soluções
“API key not valid”: API Key incorreta ou expirada.
- Solução: Verifique o arquivo
.enve gere nova chave se necessário.
“Resource exhausted”: Limite de requisições excedido.
- Solução: Aguarde alguns segundos e tente novamente. Considere implementar retry com backoff.
“Agent not found”: ADK não encontrou o agente.
- Solução: Verifique se nome da variável corresponde ao nome da pasta.
“Model not found”: Modelo especificado não existe.
- Solução: Verifique a grafia do modelo. Use
gemini-2.0-flashem vez de variações.
Conversação real com Agentes de IA
Uma conversa real envolve múltiplas trocas de mensagens. O ADK mantém contexto automaticamente através das sessões.
Exemplo de conversa completa
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
<em># conversation.py</em> import asyncio from dotenv import load_dotenv load_dotenv("greeting_agent/.env") from google.adk.runners import Runner from google.adk.sessions import InMemorySessionService from google.genai import types from greeting_agent.agent import greeting_agent async def get_response(runner, session_id, user_id, message_text): """Envia mensagem e retorna resposta completa.""" user_message = types.Content( role="user", parts=[types.Part.from_text(message_text)] ) response_parts = [] async for event in runner.run_async( user_id=user_id, session_id=session_id, new_message=user_message ): if event.content and event.content.parts: for part in event.content.parts: if hasattr(part, 'text') and part.text: response_parts.append(part.text) return "".join(response_parts) async def main(): session_service = InMemorySessionService() session = await session_service.create_session( app_name="chat_app", user_id="user_001" ) runner = Runner( agent=greeting_agent, app_name="chat_app", session_service=session_service ) <em># Conversa de múltiplos turnos</em> messages = [ "Oi, tudo bem?", "Qual é o seu nome?", "O que você consegue fazer?", "Obrigado pela ajuda!" ] print("=== Conversa com o Agente ===\n") for msg in messages: print(f"Você: {msg}") response = await get_response( runner, session.id, "user_001", msg ) print(f"Agente: {response}\n") print("=== Fim da Conversa ===") if __name__ == "__main__": asyncio.run(main()) |
O agente mantém contexto entre as mensagens. Se você perguntar “qual é seu nome?” e depois “você pode repetir?”, ele entenderá que deve repetir o nome mencionado anteriormente.
FAQ: Perguntas Frequentes
1. Por que meu agente não aparece na lista do adk web?
Verifique três coisas: (1) a pasta do agente contém agent.py e __init__.py, (2) o nome da variável no agent.py corresponde exatamente ao nome da pasta, (3) você está executando adk web da pasta pai correta (a pasta que contém a pasta do agente).
2. Qual a diferença entre instruction e description?
instruction define como o agente se comporta internamente, é o system prompt que guia todas as respostas. description é usado externamente por outros agentes para entender o que este agente faz e decidir quando delegar tarefas para ele.
3. Posso usar português nas instruções do agente?
Sim. Os modelos Gemini entendem português fluentemente. Você pode escrever instruções, descrições e interagir completamente em português. O agente responderá no idioma das instruções ou no idioma que o usuário usar.
4. O que acontece com a sessão quando o programa termina?
Com InMemorySessionService, todos os dados são perdidos quando o programa termina. Para persistência, use DatabaseSessionService com SQLite ou outro banco de dados. Isso será coberto em artigos futuros sobre estado e persistência.
5. Como faço para o agente responder de forma mais criativa ou mais precisa?
Use o parâmetro generate_content_config com temperature. Valores baixos (0.1-0.3) produzem respostas mais determinísticas e focadas. Valores altos (0.7-0.9) produzem respostas mais variadas e criativas. O padrão é geralmente em torno de 0.7.
