English 中文 العربية 日本語 Português

AI: Agente de IA

Última atualização: 2026-08-26

1. O Que Você Aprenderá

Nº. Conteúdo
❶ A Diferença entre um Agente e um Chatbot Comum
❷ Modo ReAct (Raciocínio + Ação)
❸ Chamada de Função
❹ Planejamento e Memória do Agente
❺ Implementando um Agente Simples em Python

2. A História

Bob queria que a IA o ajudasse a "verificar o preço mais recente das ações da Apple e analisar se vale a pena investir." Um ChatGPT padrão responderia apenas: "Não consigo me conectar à internet. Até a data de corte dos meus dados de treinamento..."—a informação está desatualizada e é completamente inútil.

Alice construiu um agente de IA usando o framework Agent. Quando feita a mesma pergunta, o agente decide por si mesmo:

  1. Abrir a Ferramenta de Busca → Descobrir que o preço atual da AAPL é $195,27, com uma razão P/L de 31,2
  2. Abrir a Ferramenta de Cálculo → Calcular o retorno anualizado esperado em aproximadamente 6,8%
  3. Com base nos resultados acima → Gerar recomendações de investimento

Bob exclamou: "Isso não é simplesmente a IA pensando e trabalhando sozinha?"

A diferença principal: Um chatbot apenas "conversa", enquanto um agente "age."

3. O Que É um Agente de IA?

(1) Definição de um Agente

Agente de IA = LLM + Ferramentas + Memória + Planejamento

Componente Função Analogia
LLM (Modelo de Linguagem Grande) Compreensão, Raciocínio, Tomada de Decisão Cérebro
Ferramentas Executar ações (pesquisar, calcular, executar código, etc.) Mãos
Memória Salva histórico de conversas e conhecimento de longo prazo Caderno de Anotações
Planejamento Decompõe tarefas e esboça etapas Agenda

Um chatbot típico depende exclusivamente de um LLM, como um consultor que "só consegue falar, mas não agir". Um agente, entretanto, equipado com ferramentas, memória e capacidades de planejamento, é como um assistente que pode pesquisar informações na web, realizar cálculos e redigir relatórios de forma independente.

(2) Chatbot vs Agente vs Workflow

Dimensão Chatbot Agente Workflow
Método de Tomada de Decisão Sem decisão; responde diretamente O LLM decide o próximo passo por conta própria Processo predefinido pelo humano
Uso de Ferramentas Nenhuma Seleção e Invocação Dinâmicas Invocação de Nós Fixos
Flexibilidade Baixa Alta Média
Controlabilidade Alta Média Alta
Cenários Típicos Perguntas e Respostas, Conversas Informais Pesquisa, Análise, Exploração Independente Fluxos de Trabalho, Processos de Aprovação

4. Modelo ReAct — Raciocínio + Ação

(1) O Conceito Central do ReAct

ReAct (Raciocínio + Ação) é o modelo de tomada de decisão mais clássico para agentes:

  1. Observação: Receber a entrada do usuário ou os resultados retornados pela ferramenta
  2. Pensamento: O LLM analisa a situação atual e decide sobre o próximo passo
  3. Ação: Chamar uma ferramenta para executar uma operação
  4. Repetir este processo até chegar à resposta final.

(2) Explicação de Cada Etapa no ReAct

Etapa Descrição Exemplo
Observação Receber Entrada/Resultados da Ferramenta "Pergunta do Usuário: Qual é o preço mais recente das ações da Apple?"
Pensamento Raciocínio do LLM: O que devo fazer agora? "Preciso usar uma ferramenta de busca para consultar os preços das ações"
Ação Executar Chamada de Ferramenta search_stock("AAPL")
Observação Resultados da Ferramenta "AAPL = $195.27"
Pensamento Continuar raciocinando "Agora que temos o preço das ações, podemos calcular a relação preço-lucro (P/L)"
Ação Chamar a próxima ferramenta calculate_pe(195.27, 6.26)
... Repetir até chegar à resposta final ...
Resposta Final Produzir a resposta final "O AAPL está atualmente a $195.27, com uma relação P/L de 31.2..."

(3) Fluxograma ReAct

100% 
graph TB
    A[Entrada do Usuário] --> B[Observação]
    B --> C[Pensamento]
    C --> D{Necessita Ação?}
    D -- Sim --> E[Ação / Chamada de Ferramenta]
    E --> F[Resultado da Ferramenta]
    F --> B
    D -- Não --> G[Resposta Final]
    G --> H[Usuário]

5. Function Calling

(1) O que é Function Calling?

O Function Calling é uma capacidade oferecida por modelos como o OpenAI: você informa ao modelo "quais ferramentas estão disponíveis" e, ao responder, o modelo pode optar por chamar uma ferramenta específica em vez de fornecer diretamente uma resposta baseada em texto.

Diferença Chave: O modelo não executa o código diretamente; em vez disso, ele emite uma solicitação estruturada de invocação de ferramenta (nome da função + argumentos), que seu código é responsável por executar.

(2) Comparação dos Tipos de Ferramentas

Tipo de Ferramenta Propósito API Típica Exemplo
Busca Obter Informações em Tempo Real SerpAPI / Tavily get_stock_price("AAPL")
Calculadora Operações Matemáticas Python eval / Wolfram calculate("31.2 / 6.26")
Execução de Código Executar Programa Python REPL / Docker run_code("print(2**10)")
Chamada de API Integração com Serviços Externos HTTP / SDK send_email(to, subject)

▶ Exemplo: Definindo uma função utilitária (Dificuldade: ⭐)

PYTHON 
import json

def get_weather(city: str) -> str:
    """Get current weather for a city."""
    weather_data = {
        "Beijing": '{"temp": 22, "condition": "Sunny"}',
        "Tokyo": '{"temp": 18, "condition": "Cloudy"}',
        "New York": '{"temp": 15, "condition": "Rainy"}',
    }
    return weather_data.get(city, '{"temp": null, "condition": "Unknown"}')

tool_definition = {
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a given city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name, e.g. Beijing, Tokyo"
                }
            },
            "required": ["city"]
        }
    }
}

print(get_weather("Beijing"))
TEXT 📖 Somente leitura 
{"temp": 22, "condition": "Sunny"}

▶ Exemplo: Chamando uma Função OpenAI (Dificuldade: ⭐⭐)

PYTHON 
from openai import OpenAI

client = OpenAI()

tools = [tool_definition]

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "What is the weather in Beijing?"}
    ],
    tools=tools,
    tool_choice="auto"
)

message = response.choices[0].message

if message.tool_calls:
    tool_call = message.tool_calls[0]
    func_name = tool_call.function.name
    func_args = json.loads(tool_call.function.arguments)

    print(f"Model wants to call: {func_name}")
    print(f"Arguments: {func_args}")

    result = get_weather(**func_args)
    print(f"Tool result: {result}")
TEXT 📖 Somente leitura 
Model wants to call: get_weather
Arguments: {'city': 'Beijing'}
Tool result: {"temp": 22, "condition": "Sunny"}

6. Planejamento e Memória do Agente

(1) Planejamento

Tarefas complexas devem ser concluídas passo a passo. As capacidades de planejamento de um agente são refletidas em:

(2) Memória

Tipo Descrição Implementação
Memória de curto prazo Contexto da conversa atual Histórico da conversa (lista)
Memória de longo prazo Conhecimento entre sessões Bancos de dados vetoriais / Armazenamento em arquivos
Memória de trabalho Resultados intermediários da tarefa atual Área de rascunho / Variáveis

A memória de curto prazo é simplesmente o histórico da conversa — passar todas as mensagens anteriores junto com cada chamada ao LLM. A memória de longo prazo requer um mecanismo de armazenamento adicional.

7. Implementando um Agente Simples em Python

▶ Exemplo: Loop do Agente (Implementado com um loop while) (Dificuldade: ⭐⭐)

PYTHON 
import json
from openai import OpenAI

client = OpenAI()

def get_weather(city: str) -> str:
    """Obtém o clima atual para uma cidade."""
    data = {
        "Beijing": '{"temp": 22, "condition": "Ensolarado"}',
        "Tokyo": '{"temp": 18, "condition": "Nublado"}',
    }
    return data.get(city, '{"temp": null, "condition": "Desconhecido"}')

available_tools = {
    "get_weather": get_weather,
}

tool_schemas = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Obtém o clima atual para uma cidade dada",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "Nome da cidade"}
            },
            "required": ["city"]
        }
    }
}]

def run_agent(user_query: str, max_steps: int = 5) -> str:
    messages = [{"role": "user", "content": user_query}]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tool_schemas,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)

        if not msg.tool_calls:
            return msg.content

        for tool_call in msg.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)

            print(f"[Passo {step+1}] Chamando {func_name}({func_args})")

            result = available_tools[func_name](**func_args)

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "O agente atingiu o número máximo de etapas sem uma resposta final."

answer = run_agent("Qual é o clima em Beijing e Tokyo?")
print(answer)
TEXT 📖 Somente leitura 
[Passo 1] Chamando get_weather({'city': 'Beijing'})
[Passo 2] Chamando get_weather({'city': 'Tokyo'})
O clima em Beijing é de 22°C e Ensolarado, enquanto Tokyo está com 18°C e Nublado.

▶ Exemplo: Agente Multi-Ferramenta (Busca + Calculadora) (Dificuldade: ⭐⭐⭐)

PYTHON 
import json
from openai import OpenAI

client = OpenAI()

def search_web(query: str) -> str:
    """Simula uma busca na web."""
    mock_results = {
        "receita Tesla 2024": "Receita total da Tesla em 2024: US$ 97,69 bilhões",
        "receita Tesla 2023": "Receita total da Tesla em 2023: US$ 96,77 bilhões",
        "preço ação AAPL": "Preço atual da AAPL: US$ 195,27, relação P/L: 31,2",
    }
    for key, val in mock_results.items():
        if key.lower() in query.lower():
            return val
    return "Nenhum resultado encontrado para: " + query

def calculate(expression: str) -> str:
    """Avalia uma expressão matemática de forma segura."""
    allowed = set("0123456789+-*/.() ")
    if all(c in allowed for c in expression):
        try:
            result = eval(expression)
            return str(result)
        except Exception as e:
            return f"Erro no cálculo: {e}"
    return "Expressão inválida"

available_tools = {
    "search_web": search_web,
    "calculate": calculate,
}

tool_schemas = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Pesquisa na web por informações",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Consulta de pesquisa"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Avalia uma expressão matemática",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "Expressão matemática para avaliar"}
                },
                "required": ["expression"]
            }
        }
    }
]

def run_multi_tool_agent(user_query: str, max_steps: int = 10) -> str:
    messages = [{"role": "user", "content": user_query}]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tool_schemas,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)

        if not msg.tool_calls:
            return msg.content

        for tool_call in msg.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)

            print(f"[Passo {step+1}] {func_name}({func_args})")

            result = available_tools[func_name](**func_args)
            print(f"  -> {result}")

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "O agente atingiu o número máximo de etapas."

answer = run_multi_tool_agent("Qual foi a receita da Tesla em 2024 e quanto ela cresceu em relação ao ano anterior?")
print(f"\nResposta Final:\n{answer}")
TEXT 📖 Somente leitura 
[Passo 1] search_web({'query': 'receita Tesla 2024'})
  -> Receita total da Tesla em 2024: US$ 97,69 bilhões
[Passo 2] search_web({'query': 'receita Tesla 2023'})
  -> Receita total da Tesla em 2023: US$ 96,77 bilhões
[Passo 3] calculate({'expression': '(97.69 - 96.77) / 96.77 * 100'})
  -> 0.9508080206700424

Resposta Final:
A receita da Tesla em 2024 foi de US$ 97,69 bilhões, contra US$ 96,77 bilhões em 2023.
Isso representa um crescimento interanual de aproximadamente 0,95%.

▶ Exemplo: Agente com Memória (Dificuldade: ⭐⭐⭐)

PYTHON 
import json
from openai import OpenAI

client = OpenAI()

class MemoryAgent:
    def __init__(self, system_prompt: str = "Você é um assistente prestativo."):
        self.system_prompt = system_prompt
        self.short_term_memory: list = []
        self.long_term_memory: list = []

    def add_to_long_term(self, fact: str):
        self.long_term_memory.append(fact)
        print(f"[Memória Salva] {fact}")

    def get_context(self) -> list:
        context = [{"role": "system", "content": self.system_prompt}]
        if self.long_term_memory:
            mem_str = "\n".join(f"- {m}" for m in self.long_term_memory)
            context.append({
                "role": "system",
                "content": f"Memória de longo prazo:\n{mem_str}"
            })
        context.extend(self.short_term_memory)
        return context

    def chat(self, user_input: str) -> str:
        self.short_term_memory.append({"role": "user", "content": user_input})

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=self.get_context()
        )
        reply = response.choices[0].message.content
        self.short_term_memory.append({"role": "assistant", "content": reply})
        return reply

    def remember(self, fact: str):
        self.add_to_long_term(fact)

agent = MemoryAgent(system_prompt="Você é um assistente de pesquisa.")

r1 = agent.chat("Meu nome é Bob e trabalho na Apple Inc.")
print(f"Agente: {r1}")

agent.remember("Nome do usuário: Bob, trabalha na Apple Inc.")

r2 = agent.chat("Qual é o meu nome e onde eu trabalho?")
print(f"Agente: {r2}")
TEXT 📖 Somente leitura 
Agente: Prazer em conhecê-lo, Bob! Como posso ajudá-lo hoje?
[Memória Salva] Nome do usuário: Bob, trabalha na Apple Inc.
Agente: Seu nome é Bob e você trabalha na Apple Inc.

8. Frameworks de Agentes

(1) Comparação de Frameworks de Agentes

Framework Funcionalidades Cenários Adequados Linguagem
LangChain / LangGraph Ecossistema rico, comunidade grande, flexível mas complexo Desenvolvimento de agentes de propósito geral Python / JS
OpenAI Assistants API Hospedado oficialmente, fácil de usar, caixa preta Prototipagem rápida, ecossistema OpenAI REST / Python
AutoGen (Microsoft) Colaboração multiagente, conversacional Discussão e colaboração entre múltiplos agentes Python
CrewAI Representação de papéis, Colaboração em Equipe Simulação de fluxos de trabalho em equipe Python

(2) Como Escolher

9. Exemplo Abrangente: Agente Assistente de Pesquisa

▶ Exemplo: Construindo um "Agente Assistente de Pesquisa" (Dificuldade: ⭐⭐⭐)

PYTHON 
import json
from openai import OpenAI

client = OpenAI()

# --- Definições de Ferramentas ---

def search_web(query: str) -> str:
    """Simula uma pesquisa na web para informações em tempo real."""
    mock_db = {
        "Tesla 2024 revenue": "Receita total da Tesla em 2024: US$97,69 bilhões, lucro líquido: US$7,09 bilhões",
        "Tesla 2023 revenue": "Receita total da Tesla em 2023: US$96,77 bilhões, lucro líquido: US$14,99 bilhões",
        "Tesla stock price": "Preço atual da TSLA: US$352,00, valor de mercado: US$1,13 trilhão",
    }
    for key, val in mock_db.items():
        if key.lower() in query.lower():
            return val
    return f"Nenhum resultado específico para: {query}"

def calculate(expression: str) -> str:
    """Avalia uma expressão matemática."""
    allowed = set("0123456789+-*/.() ")
    if all(c in allowed for c in expression):
        try:
            return str(eval(expression))
        except Exception as e:
            return f"Erro: {e}"
    return "Expressão inválida"

def run_code(code: str) -> str:
    """Executa código Python e retorna a saída."""
    import io
    import contextlib
    output = io.StringIO()
    try:
        with contextlib.redirect_stdout(output):
            exec(code, {"__builtins__": {}})
        return output.getvalue() or "Código executado sem saída."
    except Exception as e:
        return f"Erro de execução: {e}"

# --- Configuração do Agente ---

available_tools = {
    "search_web": search_web,
    "calculate": calculate,
    "run_code": run_code,
}

tool_schemas = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Pesquisa na web informações em tempo real como preços de ações, receita, notícias",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Consulta de pesquisa"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Avalia uma expressão matemática, ex: (100-90)/90*100",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "Expressão matemática"}
                },
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_code",
            "description": "Executa código Python para análise complexa, gráficos ou processamento de dados",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {"type": "string", "description": "Código Python a executar"}
                },
                "required": ["code"]
            }
        }
    }
]

SYSTEM_PROMPT = """Você é um agente assistente de pesquisa. Ao responder perguntas:
1. Use search_web para encontrar dados em tempo real
2. Use calculate para operações matemáticas
3. Use run_code para análise complexa
Sempre mostre seu raciocínio passo a passo."""

def research_agent(user_query: str, max_steps: int = 10) -> str:
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": user_query}
    ]

    for step in range(max_steps):
        print(f"\n--- Passo {step + 1} ---")

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tool_schemas,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)

        if msg.content:
            print(f"Pensamento: {msg.content[:200]}")

        if not msg.tool_calls:
            return msg.content

        for tool_call in msg.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)

            print(f"Ação: {func_name}({json.dumps(func_args)})")

            result = available_tools[func_name](**func_args)
            print(f"Observação: {result[:200]}")

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return "O agente atingiu o número máximo de passos."

# --- Executar o Agente ---

answer = research_agent(
    "Qual foi a receita da Tesla em 2024? Quanto cresceu em relação ao ano anterior? "
    "Calcule a taxa de crescimento como uma porcentagem."
)
print(f"\n{'='*50}\nResposta Final:\n{answer}")
TEXT 📖 Somente leitura 
--- Passo 1 ---
Pensamento: Preciso encontrar a receita da Tesla em 2024 e 2023 primeiro.
Ação: search_web({"query": "Tesla 2024 revenue"})
Observação: Receita total da Tesla em 2024: US$97,69 bilhões, lucro líquido: US$7,09 bilhões

--- Passo 2 ---
Ação: search_web({"query": "Tesla 2023 revenue"})
Observação: Receita total da Tesla em 2023: US$96,77 bilhões, lucro líquido: US$14,99 bilhões

--- Passo 3 ---
Ação: calculate({"expression": "(97.69 - 96.77) / 96.77 * 100"})
Observação: 0.9508080206700424

==================================================
Resposta Final:
A receita total da Tesla em 2024 foi de US$97,69 bilhões, comparado a US$96,77 bilhões em 2023.
A taxa de crescimento ano a ano é de aproximadamente 0,95%.

❓ Perguntas Frequentes

Q: Qual é a diferença entre um agente e um script de automação? R: Scripts de automação executam de acordo com regras fixas e não pensam por conta própria. Agentes tomam decisões dinâmicas baseadas em LLMs—eles podem ajustar suas estratégias ao encontrar situações inesperadas, em vez de reportar um erro e parar.

Q: Um agente pode sair do controle? R: É possível, mas você pode mitigar isso limitando as ferramentas disponíveis, definindo um limite de max_steps, adicionando uma etapa de aprovação com humano no circuito e validando as entradas das ferramentas.

Q: Qual é a diferença entre Function Calling e uma chamada de API regular? R: Com uma chamada de API regular, você escreve código para determinar quando chamar qual API. Com Function Calling, o LLM decide qual função chamar e quais parâmetros passar; seu código é responsável apenas por executar a função e retornar o resultado.

Q: Quando você deve usar um agente em vez de escrever código diretamente? R: Use um agente quando as etapas de uma tarefa são incertas e precisam ser ajustadas dinamicamente com base em resultados intermediários. Se o processo é fixo e as etapas estão claras, escrever código diretamente é mais confiável e eficiente.

Q: Quanta capacidade computacional um Agente requer? R: O principal custo de um Agente está nas chamadas de LLM—cada etapa ReAct requer uma chamada de API. Tarefas simples levam de 2 a 3 etapas, enquanto tarefas complexas podem levar 10 ou mais. Usar modelos menores, como o gpt-4o-mini, pode reduzir significativamente os custos.

📖 Resumo

📝 Exercícios

  1. Básico (⭐): Defina duas ferramentas personalizadas (como get_population e get_gdp), escreva as definições das ferramentas no formato JSON Schema para Function Calling e registre-as no dicionário available_tools.

  2. Avançado (⭐⭐): Implemente um loop de agente com ferramenta única: Defina uma ferramenta chamada get_exchange_rate. Quando o usuário digitar "Quanto é 100 USD em CNY?", o agente deve chamar a ferramenta automaticamente e retornar o resultado.

  3. Desafio (⭐⭐⭐): Faça o Agente responder uma pergunta que exija tanto busca quanto cálculo: por exemplo, "Qual é a população de Tóquio? Se cada pessoa precisa de 2 kg de água por dia, quantas toneladas métricas de água Tóquio precisa por dia?" O Agente deve decidir sozinho primeiro buscar os dados da população e então usar uma ferramenta de cálculo para chegar à resposta.

Web-Tutorial.com

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

100%