Construindo Agentes de IA com Python: Pydantic AI, LangChain, Agno e Google ADK

Você já quis criar um assistente inteligente que não apenas responde perguntas, mas que também usa ferramentas, acessa dados e toma decisões? Essa é a ideia por trás de agentes de IA , sistemas que combinam modelos de linguagem (LLMs) com capacidade de agir no mundo real. Se você ainda não conhece o blog, dê uma olhada no post de introdução para entender o propósito deste espaço.

Mas com tantos frameworks surgindo, como escolher o certo? Neste artigo, vamos conhecer quatro frameworks Python para criar agentes, entender como cada um funciona com exemplos simples, e descobrir quando usar cada um.

1. O Que é um Agente de IA?

Antes de mergulhar nos frameworks, vamos ao conceito básico. Um agente de IA é diferente de um simples chatbot:

• Chatbot → recebe uma mensagem, responde. Só isso.
• Agente → recebe uma mensagem, pensa, escolhe uma ferramenta, executa uma ação, e então responde.

Pense num agente como um assistente pessoal inteligente: ele pode pesquisar na internet, consultar um banco de dados, fazer cálculos, ou chamar uma API , tudo por conta própria, guiado por um modelo de linguagem.

Para criar um agente, você precisa de:

• Um LLM (o "cérebro") , como GPT-4o, Claude, Gemini
• Instruções (o "prompt") , definindo o comportamento
• Ferramentas (as "mãos") , funções que o agente pode usar

Agora, vamos ver como cada framework implementa isso.

2. Pydantic AI , Type Safety para Agentes

O que é?

O Pydantic AI é um framework criado pela equipe do Pydantic (sim, o mesmo Pydantic que você usa no FastAPI). Ele traz segurança de tipos e validação automática para agentes de IA. Se você já usa Pydantic ou FastAPI, vai se sentir em casa.

Instalação

pip install pydantic-ai

Exemplo Simples: Seu Primeiro Agente

from pydantic_ai import Agent
 
# Criando um agente com instruções
agent = Agent(
    "openai:gpt-4o",
    instructions="Seja conciso. Responda em uma frase.",
)
 
# Executando o agente
result = agent.run_sync("De onde vem a expressão Olá Mundo?")
print(result.output)
# Saída: A primeira uso documentado de "hello, world" foi em 1974.

O que aconteceu aqui?

1. Criamos um agente com o modelo GPT-4o
2. Definimos instruções para ele ser conciso
3. Chamamos run_sync com uma pergunta
4. O agente respondeu diretamente

Exemplo com Ferramenta: Calculadora

from pydantic_ai import Agent
 
# Definindo uma ferramenta (tool)
def calcular(expressao: str) -> str:
    """Calcula uma expressão matemática."""
    return str(eval(expressao))
 
# Criando o agente com a ferramenta
agent = Agent(
    "openai:gpt-4o",
    instructions="Use a calculadora quando precisar fazer contas.",
    tools=[calcular],
)
 
# O agente decide quando usar a ferramenta
result = agent.run_sync("Quanto é 15 * 37 + 12?")
print(result.output)
# Saída: 567

Por que usar Pydantic AI?

• Type safety , erros de tipos pegos em tempo de desenvolvimento
• Saída estruturada , garante que o LLM retorne dados no formato certo
• Dependency injection , fácil de testar e conectar com bancos de dados
• Model-agnostic , funciona com OpenAI, Anthropic, Google, etc.

3. LangChain , O Gigante do Ecossistema

O que é?

O LangChain é o framework mais popular para aplicações com LLMs, com mais de 100.000 estrelas no GitHub. Ele oferece uma enorme coleção de integrações: vector stores, document loaders, output parsers, e muito mais. Para agentes, existe o LangGraph, que adiciona workflows com grafos.

Instalação

pip install langchain langchain-openai python-dotenv

Exemplo Simples: Agente com Ferramentas

from langchain.agents import create_agent
from langchain_core.tools import tool
 
# Definindo ferramentas com o decorator @tool
@tool
def calculadora(expressao: str) -> str:
    """Resolve expressões matemáticas. Use para fazer contas."""
    try:
        return str(eval(expressao))
    except Exception as e:
        return f"Erro: {e}"
 
@tool
def clima(cidade: str) -> str:
    """Retorna o clima atual de uma cidade."""
    # Simulando uma consulta de clima
    return f"Clima em {cidade}: 25°C, ensolarado"
 
# Criando o agente
agent = create_agent(
    "gpt-4o",
    tools=[calculadora, clima],
)
 
# Executando
resultado = agent.invoke({
    "messages": [{"role": "user", "content": "Quanto é 2 + 2? E como está o tempo em São Paulo?"}]
})
print(resultado["messages"][-1].content)

Como funciona por baixo?

1. O LLM recebe a mensagem do usuário
2. Ele analisa quais ferramentas são necessárias
3. Chama as ferramentas na ordem certa
4. Monta a resposta final

O LangChain cuida de toda a orquestração , você só precisa definir as ferramentas e o prompt.

Por que usar LangChain?

• Ecossistema gigantesco , 80+ provedores de modelo, dezenas de integrações
• RAG pronto , vector stores, document loaders, text splitters
• LangGraph , para workflows complexos e estado
• LangSmith , tracing e monitoramento em produção

4. Agno , Performance e Simplicidade

O que é?

O Agno (antigamente chamado Phidata) é um framework focado em performance e simplicidade. Ele se destaca por ser extremamente rápido , instantiate agentes em microssegundos , e por ter uma API limpa e direta. É uma ótima escolha para quem quer algo mais enxuto que LangChain.

Instalação

pip install agno openai

Exemplo Simples: Agente Básico

from agno.agent import Agent
from agno.models.openai import OpenAIChat
 
# Criando um agente
agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    description="Você é um repórter entusiasmado!",
    markdown=True,
)
 
# Executando com streaming
agent.print_response(
    "Conte uma notícia recente de tecnologia.",
    stream=True,
)

Exemplo com Ferramentas: Pesquisa Web

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
 
# Agente com ferramenta de pesquisa
agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    description="Você é um pesquisador inteligente.",
    tools=[DuckDuckGoTools()],
    show_tool_calls=True,
    markdown=True,
)
 
agent.print_response(
    "Quais são as tendências de IA em 2026?",
    stream=True,
)

Multi-Agent: Equipe de Especialistas

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.yfinance import YFinanceTools
 
# Agente de pesquisa web
web_agent = Agent(
    name="Pesquisador Web",
    role="Busca informações na internet",
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    instructions="Sempre inclua fontes.",
)
 
# Agente financeiro
finance_agent = Agent(
    name="Analista Financeiro",
    role="Busca dados financeiros",
    model=OpenAIChat(id="gpt-4o"),
    tools=[YFinanceTools()],
    instructions="Analise tendências de mercado.",
)
 
# Executando individualmente
web_agent.print_response("Últimas notícias sobre IA", stream=True)
finance_agent.print_response("Como está a ação da Nvidia?", stream=True)

Por que usar Agno?

• Performance , instantiate 500x mais rápido que LangGraph
• Simplicidade , API limpa, sem abstrações desnecessárias
• Multi-modal , suporta texto, imagens, áudio e vídeo
• AgentOS , runtime de produção com FastAPI incluído

5. Google ADK , Agentes com o Ecossistema Google

O que é?

O Google ADK (Agent Development Kit) é o framework oficial do Google para criar agentes. Ele é otimizado para modelos Gemini, mas funciona com qualquer modelo via LiteLLM. Seu grande diferencial é a orquestração multi-agente nativa e a integração direta com Vertex AI.

Instalação

pip install google-adk

Exemplo Simples: Agente com Ferramentas

from google.adk.agents import Agent
 
# Ferramenta: retorna o horário de uma cidade
def horario_atual(cidade: str) -> dict:
    """Retorna o horário atual em uma cidade.
 
    Args:
        cidade: Nome da cidade.
 
    Returns:
        Dicionário com status e horário.
    """
    return {"status": "sucesso", "cidade": cidade, "horario": "14:30"}
 
# Ferramenta: saudação
def cumprimentar() -> str:
    """Cumprimenta o usuário."""
    return "Olá! Como posso ajudar?"
 
# Criando o agente raiz
root_agent = Agent(
    model="gemini-2.0-flash",
    name="meu_assistente",
    description="Um assistente que responde perguntas e dá horários.",
    instruction="Responda de forma clara e amigável.",
    tools=[cumprimentar, horario_atual],
)

Executando com a Interface Web

# Criando o projeto
adk create meu_agente
 
# Rodando com interface web (para desenvolvimento)
adk web

O ADK oferece uma interface web de desenvolvimento que mostra exatamente o que cada agente disse, quais ferramentas chamou, e o estado da sessão em cada passo , excelente para debugar.

Multi-Agent: Pipeline Sequencial

from google.adk.agents import LlmAgent, SequentialAgent
 
# Agente 1: analisa código
analisador = LlmAgent(
    name="analisador_codigo",
    model="gemini-2.0-flash",
    description="Analisa qualidade do código Python.",
    instruction="Analise o código e extraia métricas de qualidade.",
    output_key="analise",
)
 
# Agente 2: sugere melhorias
sugeridor = LlmAgent(
    name="sugeridor_melhorias",
    model="gemini-2.0-flash",
    description="Gera sugestões de melhoria.",
    instruction="Leia a análise e gere 5 sugestões específicas.",
    output_key="sugestoes",
)
 
# Agente 3: escreve relatório
redator = LlmAgent(
    name="redator_relatorio",
    model="gemini-2.0-flash",
    description="Escreve o relatório final.",
    instruction="Escreva um relatório profissional com as sugestões.",
    output_key="relatorio",
)
 
# Pipeline: analisa → sugere → redige
pipeline = SequentialAgent(
    name="pipeline_code_review",
    sub_agents=[analisador, sugeridor, redator],
)

Por que usar Google ADK?

• Otimizado para Gemini , integração nativa com os melhores modelos do Google
• Multi-agente nativo , SequentialAgent, ParallelAgent sem código extra
• Vertex AI , deploy com um comando
• A2A Protocol , comunicação entre agentes de frameworks diferentes
• Interface web , debugging visual incluído

6. Comparativo: Qual Usar?

Quando Usar Cada Um?

Use Pydantic AI quando:

• Você já usa Pydantic ou FastAPI
• Precisa de saída estruturada validada
• Quer um agente simples e tipado
• Está construindo uma API que consome o agente

Use LangChain quando:

• Precisa de RAG (recuperação de documentos)
• Quer o maior ecossistema de integrações
• Está construindo pipelines complexos com múltiplas etapas
• Precisa de tracing e monitoramento (LangSmith)

Use Agno quando:

• Performance é prioridade
• Quer algo simples e direto sem abstrações pesadas
• Precisa de multi-modal (texto + imagem + áudio)
• Quer um runtime de produção pronto (AgentOS)

Use Google ADK quando:

• Seu projeto já usa Google Cloud ou Vertex AI
• Quer multi-agente nativo sem configurar grafos
• Prefere ter uma interface web de debugging
• Quer usar o protocolo A2A para comunicação entre agentes

7. Considerações Finais

Não existe um framework "melhor" , cada um resolve um problema diferente. A escolha depende do seu contexto:

• Começando do zero? → Comece com Pydantic AI ou Agno (mais simples)
• Precisa de RAG? → LangChain tem o melhor ecossistema para isso
• Usa Google Cloud? → Google ADK é a escolha natural
• Precisa de performance? → Agno é o mais rápido

O mais importante é entender o problema que você está resolvendo antes de escolher o framework. Muitas vezes, um agente simples com chamadas diretas à API do LLM já resolve, não precisa de framework para tudo. Essa filosofia de simplicidade também se conecta com princípios de modularização de código — nem toda funcionalidade precisa de uma nova camada de abstração. E se você quer descobrir quais ferramentas de IA estão transformando a produtividade dos desenvolvedores em 2026, confira nosso guia completo.