Introdução
A Inteligência Artificial está avançando para além da ideia de modelos que apenas respondem comandos isolados. Hoje falamos em agentes inteligentes, sistemas capazes de decidir o que fazer, executar ações, usar ferramentas externas e até mesmo colaborar em equipes.
O Agent Development Kit (ADK), desenvolvido pelo Google, é uma dessas ferramentas. Ele oferece uma estrutura para criar e coordenar times de agentes, combinando modelos de linguagem (LLMs) com fluxos de trabalho claros.
Mas a grande pergunta é: o que isso significa para economistas e cientistas de dados econômicos? Significa a possibilidade de automatizar rotinas, desde consultas de dados em APIs como o Banco Central até geração de relatórios econômicos, de forma inteligente e autônoma.
Conceito de Agentes
Um Agente é uma unidade de execução independente, projetada para atuar de forma autônoma e atingir objetivos específicos. Os agentes podem executar tarefas, interagir com usuários, utilizar ferramentas externas e coordenar-se com outros agentes.
A base para todos os agentes no ADK é a BaseAgentclasse. Ela serve como o modelo fundamental. Para criar agentes funcionais, normalmente você os expande BaseAgentde uma das três maneiras principais, atendendo a diferentes necessidades – do raciocínio inteligente ao controle estruturado de processos.
O ADK organiza os agentes em três categorias principais:
- LLM Agents → utilizam modelos de linguagem (ex: Gemini, GPT) para interpretar comandos em linguagem natural e decidir quais ações tomar. Exemplo: interpretar a pergunta “Qual foi a inflação acumulada em 12 meses?” e decidir consultar a API do BCB.
- Workflow Agents → seguem fluxos mais estruturados, como sequências, loops ou execução em paralelo. Exemplo: fluxo que coleta séries temporais, aplica um modelo de previsão e gera gráficos, sempre nessa ordem.
- Custom Agents → permitem programar comportamentos específicos. Exemplo: um agente especializado em processar planilhas da PNAD ou relatórios trimestrais do BCB.
Em sistemas mais avançados, podemos inclusive combinar diferentes agentes em equipes multiagentes, onde cada um é responsável por uma parte da tarefa.
Ferramentas (Tools)
No contexto do ADK, uma Ferramenta representa uma capacidade específica fornecida a um agente de IA, permitindo-lhe realizar ações e interagir com o mundo além de suas habilidades básicas de geração de texto e raciocínio. O que distingue agentes capazes de modelos de linguagem básicos é frequentemente o uso eficaz de ferramentas.
Tecnicamente, uma ferramenta é normalmente um componente de código modular — como uma função Python, um método de classe ou até mesmo outro agente especializado — projetado para executar uma tarefa distinta e predefinida. Essas tarefas geralmente envolvem a interação com sistemas ou dados externos.
Entre as ferramentas, temos:
- Function Tools → permitem que o agente chame funções Python.
- Built-in Tools → ferramentas nativas do ADK (como busca na web).
- Third-Party Tools → integrações com APIs externas, como o Banco Central, IBGE ou FRED.
- Performance Tools → monitoram tempo e custo de execução.
- Confirmation Tools → pedem confirmação antes de executar uma ação crítica.
Isso significa que um agente pode, por exemplo, consultar dados no SGS/BCB, rodar uma transformação em Python e, em seguida, escrever um parágrafo explicativo sobre o resultado.
Exemplo: Agente coletor de dados do IPCA
Modelos de linguagem como Gemini e GPT já são capazes de responder perguntas, mas o próximo passo é coordenar times de agentes inteligentes.
O Agent Development Kit (ADK), desenvolvido pelo Google, fornece uma base para criar agentes que pensam, agem e colaboram, usando ferramentas externas e memória de contexto.
Neste tutorial, você vai aprender a:
- Instalar o ADK no Google Colab.
- Configurar o Gemini 2.0 Flash como modelo de linguagem.
- Criar um agente simples para consultar o IPCA no SGS/BCB usando
python-bcb.
Passo 1: Configuração no Google Colab
# Instalar pacotes necessários
!pip install google-adkimport google.generativeai as genai
from google.adk.agents import LlmAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from bcb import sgs
import pandas as pdPasso 2: Configurar Gemini 2.0 Flash
import getpass
import os
if not os.environ.get("GOOGLE_API_KEY"):
os.environ["GOOGLE_API_KEY"] = getpass.getpass("Enter API key for Google Gemini: ")# Definir o modelo Gemini 2.0 Flash
MODEL = "gemini-2.0-flash"Passo 3: Criar uma Função de Consulta ao IPCA
# Função que consulta o IPCA acumulado em 12 meses
def get_ipca_12m(series_id: int = 433, start: str = "2015-01-01") -> dict:
"""
Consulta o IPCA no SGS/BCB e calcula a variação acumulada em 12 meses.
Parâmetros
----------
series_id : int
ID da série do SGS (default=433 para IPCA).
start : str
Data de início no formato YYYY-MM-DD.
Retorno
-------
dict
Exemplo:
{
"series_id": 433,
"date": "2025-08-31",
"ipca_12m": 3.45
}
"""
try:
# Baixar série do SGS
ipca = sgs.get({ "ipca": series_id }, start=start)
if ipca.empty:
raise ValueError("Nenhum dado retornado pela API do SGS.")
# Calcular inflação acumulada em 12 meses
dfr = ipca.rolling(12)
i12 = dfr.apply(lambda x: (1 + x/100).prod() - 1).dropna() * 100
# Selecionar último valor disponível
ultimo = i12.dropna().tail(1)
if ultimo.empty:
raise ValueError("Não foi possível calcular a inflação em 12 meses.")
resultado = {
"series_id": series_id,
"date": ultimo.index[0].strftime("%Y-%m-%d"),
"ipca_12m": round(float(ultimo["ipca"].values[0]), 2)
}
return resultado
except Exception as e:
return { "error": str(e) }Passo 4: Criar o Agente com Gemini
# Definir o agente de indicadores econômicos com descrição e instruções
economic_agent = LlmAgent(
name="ipca_collector",
model=MODEL,
tools=[get_ipca_12m],
description="""Agente especializado em indicadores econômicos do Brasil,
com foco na coleta e interpretação da inflação medida pelo IPCA.""",
instruction="""Responda a perguntas relacionadas à inflação do Brasil.
Use a ferramenta `get_ipca_12m` sempre que o usuário solicitar
a taxa de inflação acumulada em 12 meses.
Forneça a resposta em linguagem clara, incluindo a data do dado.
Se o usuário fizer perguntas fora do escopo (por exemplo, PIB ou câmbio),
informe que você só pode responder sobre inflação com base no IPCA."""
)Passo 5: Executar o Agente
# Define o nome do aplicativo que usará o ADK
APP_NAME = "my-adk-app"
# Define o identificador do usuário
USER_ID = "user123"
# Define o identificador da sessão
SESSION_ID = "session-abc"
# Cria um serviço de gerenciamento de sessões em memória
session_service = InMemorySessionService()
# Cria uma nova sessão associada ao app, usuário e ID da sessão
session = await session_service.create_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)
# Inicializa o Runner, responsável por executar o agente dentro do contexto da sessão
runner = Runner(agent=economic_agent, app_name=APP_NAME, session_service=session_service)# Importa biblioteca para lidar com tarefas assíncronas
import asyncio
# Importa tipos do Google GenAI para estruturar mensagens em formato ADK
from google.genai import types # Para criar Content/Parts da mensagem
# Define uma função assíncrona que envia uma consulta ao agente
async def call_agent_async(query: str):
"""Envia uma consulta ao agente e imprime a resposta final."""
# Exibe a consulta feita pelo usuário
print(f"\n>>> User Query: {query}")
# Prepara a mensagem do usuário no formato aceito pelo ADK
content = types.Content(role='user', parts=[types.Part(text=query)])
# Define a resposta padrão caso o agente não retorne nada
final_response_text = "Agent did not produce a final response."
# Executa a lógica do agente de forma assíncrona, gerando eventos
async for event in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=content):
# (Opcional) imprime todos os eventos recebidos durante a execução
# print(f" [Event] Author: {event.author}, Type: {type(event).__name__}, Final: {event.is_final_response()}, Content: {event.content}")
# Verifica se o evento é a resposta final do agente
if event.is_final_response():
# Caso o agente tenha retornado conteúdo textual
if event.content and event.content.parts:
final_response_text = event.content.parts[0].text
# Caso o agente tenha escalado a execução para erro ou exceção
elif event.actions and event.actions.escalate:
final_response_text = f"Agent escalated: {event.error_message or 'No specific message.'}"
# Interrompe o loop assim que a resposta final for encontrada
break
# Exibe a resposta final processada pelo agente
print(f"<<< Agent Response: {final_response_text}")# Define uma função assíncrona para rodar a conversa inicial
async def run_conversation():
# Faz a primeira pergunta ao agente sobre a taxa de inflação no Brasil
await call_agent_async("Qual a taxa de inflação do brasil?")
# Faz a segunda pergunta, esperando que o agente simule um erro ou escalonamento
await call_agent_async("A taxa de inflação acima da meta de 3% significa o que?") # Espera mensagem de erro da ferramenta
# Executa a função assíncrona de conversa
await run_conversation()Conclusão
Com poucos passos, criamos um bot de indicadores econômicos que:
- Entende linguagem natural via Gemini 2.0 Flash.
- Consulta dados reais do SGS/BCB.
- Retorna informações já processadas para análise.
Esse é apenas o início. Com o ADK, podemos criar equipes de agentes que:
- Buscam diferentes indicadores (PIB, Selic, câmbio).
- Executam previsões com modelos de séries temporais.
- Geram relatórios automáticos de conjuntura.
O futuro da análise econômica está em times de agentes autônomos.
