Tool-Using Agents: o motor invisível por trás dos copilotos de IA

Todo mundo quer um copiloto com Inteligência Artificial, mas poucos entendem o que está por trás deles. Eles parecem mágicos, entendem nossos comandos, consultam ferramentas e tomam decisões. No entanto, essa fluidez sobrenatural, nada mais é do que o resultado de uma arquitetura clara e pragmática:

Tool-Using Agents.

Neste artigo, você vai entender como eles funcionam, por que são tão poderosos, e também como o protocolo MCP (Model Context Protocol) deu a esses agentes ainda mais poderes e autonomia.

Por que os copilotos parecem mágica?

Nos últimos anos, assistimos a criação de produtos como o GitHub Copilot, Notion AI, Replit Ghostwriter e o Microsoft 365 Copilot, que popularizaram bastante o conceito de copilotos de IA.

A proposta deles é simples: você digita uma intenção e algo acontece.

Só que entre o "digitei"e o "aconteceu", há um processo bastante sofisticado:

• O modelo entende sua intenção;
• Decide qual ação ou ferramenta usar;
• Executa operações externas (APIs, busca por documentos, planilhas, código, acessa bancos de dados);
• E retorna o resultado, muitas vezes com explicações adicionais.

O que permite esse nível de autonomia e flexibilidade?

São os **Tool-Using Agents —**agentes capazes de usar ferramentas como parte de seu raciocínio.

Tool-Using Agents: o que são e como funcionam

Um Tool-Using Agent, ou Agente com capacidade de utilizar ferramentas, é um modelo de linguagem (LLM) que:

• Recebe uma tarefa do usuário;
• Decide qual ferramenta é apropriada;
• Executa essa ferramenta (via API, código, etc.);
• Integra os resultados ao raciocínio para continuar ou concluir.

Estes agentes são coordenados por abstrações como o LangChain, que permitem conectar o modelo a um conjunto de ferramentas como:

• Calculadoras;
• Navegadores web;
• Sistemas de arquivos;
• SQL e bancos de dados;
• APIs REST e automações.

O agente também pode usar loops de pensamento, planejando múltiplas etapas antes de responder.

Exemplo: “Crie um resumo executivo das vendas da semana passada”.

• Etapa 1: Buscar dados via SQLTool;
• Etapa 2: Usar Python REPL para calcular variações;
• Etapa 3: Gerar o resumo via LLM;
• Etapa 4: Escrever a resposta ao usuário.

A arquitetura típica de um copiloto com Tool-Using Agent

O agente é quem toma decisões, executa ferramentas, interpreta resultados e responde.

Mas para isso tudo aí em cima funcionar bem, o agente precisa ter acesso ao contexto certo — e é aí que o MCP entra em cena.

Onde entra o MCP (Model Context Protocol)?

O Model Context Protocol (MCP) não cria agentes, mas dá mais poderes a eles.

Antes, os Tool-Using Agents dependiam de integrações específicas e contexto adicionado ao prompt de sistema. Agora, com o MCP, eles podem consultar sistemas externos de forma padronizada, segura, dinâmica e de acordo com sua demanda.

O que é o MCP?

• Um protocolo aberto, desenvolvido inicialmente pela Anthropic, para que modelos possam consultar ferramentas e dados externos de forma estruturada.
• Utiliza JSON-RPC como base de comunicação.
• Define como um modelo pode descobrir, consultar e executar funções de sistemas externos.
• Permite acesso granular a informações como perfil do usuário, permissões, documentos, histórico, etc.

O MCP é como um conector universal para os agentes, como um “USB-C do contexto”.

Como isso melhora os Tool-Using Agents?

• Eles ganham acesso a sistemas compatíveis com o MCP, sem precisar de integrações customizadas.
• Reduz a complexidade e o risco de vazamento de contexto sensível.
• Permite governança, logging e rastreamento de decisões tomadas com base em dados externos.

MCP não substitui o agente. Ele fortalece o seu ecossistema.

Construindo seu próprio copiloto com Tool-Using Agent e MCP (opcional)

A parte mais legal de como essa arquitetura foi projetada, é que você não precisa começar com todas as partes do quebra-cabeças, você pode construir pecinha por pecinha.

Comece com:

• Um agente com LangChain ou outro framework;
• 3 ou 4 ferramentas úteis ao seu fluxo (ex: SQL, arquivo, automação);
• Logging e fallback simples;
• Uma interface CLI ou Streamlit.

E depois:

• Adicione suporte ao MCP para acessar dados e ferramentas externas de forma segura e transparente;
• Estruture o seu contexto com gateways (perfil, histórico, tarefa, permissões);
• Exponha suas próprias APIs internas como servidores MCP.

O que diferencia copilotos bons de copilotos confiáveis?

Copilotos de IA não são aplicações mágicas, são sistemas compostos por:

• Um agente que pensa;
• Ferramentas que agem;
• E um protocolo que estrutura o acesso ao mundo externo.

Você pode projetar o seu com propósito, clareza e objetividade, sem esperar que as grandes plataformas resolvam tudo por você.

Comece pequeno. De forma arquitetada, auditável e intencional. Use os Tool-Using agents pra começar e, quando fizer sentido, dê a eles os superpoderes do MCP!

Anexo Técnico: plano de implementação

Como extensão deste artigo, desenvolvi, junto com meu estagiário 😅, um projeto que contém o boilerplate necessário para você iniciar o desenvolvimento do seu próprio Tool-Using agent. O código completo pode ser encontrado no repositório do GitHub.

Estrutura Inicial (sem MCP)

copilot/
├── agents/
│ └── main_agent.py
├── tools/
│ ├── sql_tool.py
│ ├── file_tool.py
│ ├── python_tool.py
│ └── zapier_tool.py
├── core/
│ └── router.py
├── interface/
│ └── cli.py
├── logs/
│ └── execution.jsonl
└── main.py

Extensão com MCP (opcional)

copilot/
├── mcp/
│ ├── client.py
│ ├── context_gateways/
│ │ ├── user_profile.py
│ │ ├── history.py
│ │ └── permissions.py
│ └── mcp_config.yaml

Exemplos de comandos

“Crie uma planilha com as tarefas da semana.”
“Liste os arquivos mais recentes da pasta marketing.”
“Envie um alerta ao time de vendas se o volume cair.”

Até o próximo artigo! 😉