Modelos de linguagem sabem conversar — mas, sozinhos, não consultam seu banco de dados, não leem o índice de documentos da empresa nem disparam ações no mundo real. É aí que entram os agentes de IA e o tool calling (também chamado de function calling). Neste guia você entende o conceito a fundo, vê o ciclo de execução passo a passo, um exemplo de código e as boas práticas para colocar um agente em produção com segurança.

O que é um agente de IA?

Um agente é um modelo de linguagem que decide e AGE: ele interpreta um objetivo, escolhe ferramentas, executa passos e usa o resultado para chegar à resposta final. Diferente de um chatbot simples — que apenas prevê o próximo texto —, o agente opera em um laço (loop) de raciocínio e ação, encadeando várias chamadas até cumprir a tarefa.

Na prática, o que transforma um “modelo que responde” em um “agente que resolve” são três ingredientes:

• Objetivo: uma instrução clara do que precisa ser alcançado.
• Ferramentas: funções, APIs ou fontes de dados que o modelo pode acionar.
• Loop de controle: a lógica que executa as chamadas, devolve os resultados ao modelo e repete até haver uma resposta final.

O que é tool calling (function calling)?

Tool calling é a capacidade do modelo de solicitar a chamada de funções ou APIs externas que você registrou. Você descreve cada ferramenta — nome, descrição, parâmetros e tipos — e o modelo decide quando e como usá-la, devolvendo um JSON estruturado com os argumentos. Um ponto essencial de segurança: o modelo apenas pede a execução; quem roda a função é o seu código, com as suas validações e permissões.

Exemplos de ferramentas comuns:

• buscarDocumentos(consulta) — consulta um índice vetorial (RAG) com os manuais da empresa.
• consultarPedido(id) — lê o status de um pedido em um sistema interno.
• criarChamado(assunto, descricao) — abre um ticket de suporte.
• enviarEmail(destinatario, corpo) — dispara uma notificação.

Como funciona, na prática: o ciclo do agente

1. O usuário faz um pedido (ex.: “qual o status do pedido 123?”).
2. O modelo percebe que precisa de dados externos e chama a ferramenta consultarPedido(123), retornando os argumentos em JSON.
3. Seu código executa a função de verdade (consulta o banco/API) e devolve o resultado ao modelo.
4. O modelo avalia o resultado. Se precisar de mais dados, chama outra ferramenta — e o laço se repete.
5. Quando tem tudo o que precisa, o modelo escreve a resposta final em linguagem natural, ancorada nos dados reais.

Anatomia de uma ferramenta

Cada ferramenta é descrita por um schema que o modelo lê para decidir se e como chamá-la. Quanto mais claros o nome, a descrição e os parâmetros, melhor a decisão do modelo. Um exemplo de definição (formato JSON de function calling):

{
  "name": "consultarPedido",
  "description": "Consulta o status atual de um pedido pelo seu identificador.",
  "parameters": {
    "type": "object",
    "properties": {
      "id": {
        "type": "integer",
        "description": "Identificador numerico do pedido, ex.: 123"
      }
    },
    "required": ["id"]
  }
}

No seu código, você intercepta a decisão do modelo, executa a função correspondente e devolve o resultado. Em pseudocódigo Python:

resposta = client.responses.create(model="gpt-5", input=mensagens, tools=ferramentas)

for chamada in resposta.tool_calls:
    if chamada.name == "consultarPedido":
        args = json.loads(chamada.arguments)
        resultado = consultar_pedido(args["id"])   # sua funcao real
        mensagens.append(tool_result(chamada.id, resultado))

# devolve os resultados ao modelo para a resposta final
final = client.responses.create(model="gpt-5", input=mensagens, tools=ferramentas)
print(final.output_text)

Exemplo: assistente de suporte com uma ferramenta de busca (RAG)

1. Crie o agente no Azure AI Foundry (Agent Service) e escolha um modelo — hoje há opções melhores que o GPT-4 para agentes: GPT-4.1, GPT-5 ou os modelos de raciocínio o3/o4-mini.
2. Registre uma tool de retrieval que consulta um índice vetorial (RAG) construído a partir dos manuais e FAQs da empresa.
3. Defina a instrução (system prompt): “responda dúvidas de produto usando a ferramenta de busca; cite a fonte; se não encontrar, diga que não sabe em vez de inventar.”
4. Teste: a cada pergunta, o agente decide chamar a busca, recebe os trechos relevantes e responde ancorado neles (grounding).
5. Adicione governança: content filters, avaliação de groundedness, Managed Identity e logging das chamadas de ferramenta.

Padrões de arquitetura de agentes

• Agente único com ferramentas: o mais comum. Um modelo, um conjunto pequeno de tools. Ideal para 80% dos casos.
• RAG + agente: a ferramenta de busca alimenta o modelo com conhecimento atualizado, reduzindo alucinação.
• Multiagente (orquestração): um agente “orquestrador” delega subtarefas a agentes especialistas. Poderoso, mas adiciona latência e complexidade — use só quando um agente único não der conta.
• Human-in-the-loop: ações sensíveis (pagamentos, exclusões, e-mails externos) passam por confirmação humana antes de executar.

Tratamento de erros e limites

• Timeouts e retries: ferramentas externas falham. Trate exceções e devolva ao modelo uma mensagem de erro clara para ele decidir o próximo passo.
• Limite de iterações: defina um número máximo de chamadas por tarefa para evitar loops infinitos e custo descontrolado.
• Validação de argumentos: nunca confie cegamente no JSON gerado — valide tipos e faixas antes de executar.
• Idempotência: em ações que alteram estado, garanta que uma repetição acidental não cause efeito duplicado.

Boas práticas

• Descreva bem as ferramentas: o modelo só usa bem o que entende. Nomes, descrições e parâmetros claros importam mais do que parece.
• Menos é mais: comece com 1–2 ferramentas. Excesso confunde o agente e piora a escolha.
• Valide as saídas: nunca execute ações sensíveis sem checagem ou confirmação.
• Ancore as respostas: peça que o agente cite as fontes recuperadas e admita quando não souber.
• Observe e avalie: logue as chamadas de ferramenta para depurar, medir e melhorar continuamente.
• Cuide de custo e latência: cada iteração é uma chamada ao modelo. Menos passos e ferramentas mais objetivas reduzem tempo e gasto.

Dica de modelo Para agentes que encadeiam várias ferramentas, os modelos de raciocínio (o3/o4-mini) e o GPT-4.1/GPT-5 decidem melhor quando e qual tool chamar do que o GPT-4 original — erram menos na sequência de passos e sabem parar quando já têm a resposta.

Quando usar um agente (e quando não usar)

Use um agente quando a tarefa exige consultar dados dinâmicos, executar ações ou encadear vários passos — como suporte que consulta pedidos, assistentes que abrem chamados ou fluxos que combinam busca e cálculo. Evite o agente quando uma simples resposta de texto ou um RAG direto (busca + resposta, sem ações) já resolve: adicionar ferramentas e loops sem necessidade só aumenta custo, latência e superfície de erro.

Perguntas frequentes (FAQ)

Qual a diferença entre um chatbot e um agente de IA?

Um chatbot responde texto; um agente decide e age — chama ferramentas, consulta dados e executa passos até cumprir um objetivo.

Tool calling é o mesmo que function calling?

Sim. São dois nomes para o mesmo conceito: o modelo solicita, em formato estruturado, a chamada de uma função/API que você registrou. “Tool calling” é o termo mais atual e abrangente.

Tool calling é seguro?

Sim, se você validar as saídas e nunca executar ações sensíveis sem confirmação. O modelo apenas solicita a chamada; quem executa é o seu código, com as suas regras e permissões.

Qual a diferença entre um agente e um RAG?

RAG é uma técnica de recuperar contexto para responder melhor. O agente é o orquestrador que pode usar RAG como uma de suas ferramentas — além de executar ações. Muitos agentes usam RAG por baixo.

Quantas ferramentas um agente deve ter?

Comece com uma ou duas. Excesso de ferramentas confunde o modelo e piora a escolha. Adicione mais conforme a necessidade real.

Preciso de um modelo caro para começar?

Não. Você pode prototipar com modelos menores (como o4-mini) e evoluir para GPT-4.1/GPT-5 conforme a complexidade da orquestração aumentar.

Conclusão

Agentes + tool calling transformam o modelo de “quem só fala” em “quem resolve”. É a ponte entre a IA generativa e os seus sistemas reais — e a base dos assistentes corporativos modernos. Comece pequeno, com uma ou duas ferramentas bem descritas, adicione governança e evolua a partir de casos reais.

👉 Demonstro agentes na prática nos vídeos do canal.