Agent Capabilities: Understanding Tool Use (Function Calling)

1. O Que é "Tool Use"? A Ponte Para o Mundo Real

Um Large Language Model (LLM), em sua essência, é um motor de raciocínio e geração de texto. Ele não pode, por si só, consultar um banco de dados ou chamar uma API. A ideia de "uso de ferramentas" é uma inovação que permite ao LLM instruir seu aplicativo a executar essas ações.

Em vez de gerar uma resposta em linguagem natural, o LLM é treinado para produzir uma saída estruturada, geralmente em formato JSON, que descreve uma função a ser chamada e os argumentos a serem passados.

Para uma introdução formal, vamos explorar o que a Microsoft chama de "Tool Use Design Pattern".

A principal conclusão é esta: o LLM não executa a ferramenta; ele gera uma solicitação para que seu aplicativo a execute. Pense no LLM como um cérebro que decide qual ação tomar, e no seu código de backend como as "mãos" que executam essa ação.

2. Por Que Essa Separação? Princípios de System Design

Dado seu background em engenharia de software e backend, você pode estar se perguntando por que o LLM simplesmente não executa a função diretamente. A resposta está em princípios sólidos de design de sistemas, que garantem robustez, segurança e escalabilidade.

O vídeo a seguir explica de forma excelente as razões por trás dessa arquitetura de delegação.

Como o vídeo destaca, manter o LLM stateless e focado em raciocínio, enquanto delega a execução para seu aplicativo, cria um sistema mais seguro e gerenciável. Seu aplicativo é o lugar certo para lidar com autenticação de API, gerenciamento de segredos, lógica de repetição (retries) e tratamento de erros de rede — tarefas para as quais um LLM não foi projetado.

3. A Mecânica do Function Calling

Agora que entendemos o "o quê" e o "porquê", vamos mergulhar no "como". O processo de ponta a ponta envolve várias etapas coordenadas entre seu aplicativo e o LLM. O vídeo a seguir oferece um guia prático e detalhado sobre como isso funciona, usando a API da OpenAI como exemplo, que estabeleceu o padrão para essa funcionalidade.

Para resumir o processo que você acabou de ver:

1. Definição da Ferramenta: Você define uma lista de ferramentas disponíveis, cada uma com um nome, uma descrição clara de sua finalidade e o esquema de seus parâmetros (ex: get_jira_ticket(ticket_id: string)).
2. Primeira Chamada ao LLM: Você envia o prompt do usuário e a lista de definições de ferramentas para o LLM.
3. Resposta do LLM (Tool Call): O LLM analisa o prompt, decide que uma ação é necessária e responde com um objeto tool_calls, contendo o nome da função a ser chamada e os argumentos extraídos do prompt.
4. Execução da Ferramenta: Seu aplicativo recebe essa resposta, identifica a função solicitada (get_jira_ticket) e a executa com os argumentos fornecidos ("JIRA-123").
5. Segunda Chamada ao LLM: Você envia o histórico da conversa, incluindo a tool_call original e o resultado da execução da ferramenta, de volta para o LLM.
6. Resposta Final: O LLM usa o resultado da ferramenta para formular uma resposta final e coesa para o usuário (ex: "O ticket JIRA-123 é sobre...").

4. Conectando ao Seu Objetivo: As Ferramentas do Seu Agente

Este conceito é o cerne do seu projeto. O seu agente de código será um orquestrador de ferramentas. No seu caso, algumas das ferramentas que você precisará definir são:

• Ferramentas Jira: get_ticket_details(ticket_id), add_comment(ticket_id, comment), change_ticket_status(ticket_id, status).
• Ferramentas Google Drive: search_documents(query), read_document(file_id).
• Ferramentas GitHub: create_branch(repo, branch_name), get_file_content(repo, file_path), commit_changes(repo, branch, commit_message, files), create_pull_request(...).
• Ferramentas de Banco de Dados: generate_mariadb_migration(schema_change_description).

É exatamente assim que os agentes do Atlassian Rovo funcionam: eles são um motor de raciocínio cercado por um conjunto de ferramentas especializadas.

5. Além do Básico: Frameworks e Desafios de Produção

Construir esse ciclo do zero é instrutivo, mas em um cenário de produção, você usará frameworks que abstraem grande parte da complexidade.

• Frameworks de Orquestração: Ferramentas como LangChain (mencionada no final do vídeo de Adam Lucek) e Semantic Kernel padronizam a criação e o uso de ferramentas. Dado seu background em C#/.NET, o Semantic Kernel da Microsoft é particularmente relevante, pois foi projetado para se integrar nativamente ao ecossistema .NET.

• O "Execution Gap": Saber qual ferramenta chamar é apenas metade da batalha. O artigo a seguir destaca os desafios do mundo real na camada de execução — os problemas que você, como desenvolvedor, terá que resolver.

Os pontos sobre autenticação, tratamento de erros e governança são cruciais. Ao construir seu agente, você não estará apenas lidando com a lógica do LLM, mas também construindo uma aplicação de backend robusta e segura que gerencia as interações com essas APIs críticas.

Conclusão

Nesta lição, desmistificamos a fase "Act" do ciclo de um agente. Você aprendeu que a "mágica" de um agente que interage com o mundo real não é mágica, mas sim um padrão de design de software bem definido chamado tool use ou function calling.

Principais Pontos:

• Tool Use Estende Capacidades: É o mecanismo que permite a um LLM ir além da geração de texto e interagir com sistemas externos (APIs, bancos de dados, arquivos).
• Separação de Responsabilidades: O LLM decide qual ferramenta usar e com quais argumentos, mas seu aplicativo executa a ferramenta. Este design promove segurança, robustez e manutenibilidade.
• O Ciclo de Function Calling: Envolve definir ferramentas com esquemas, permitir que o LLM escolha uma ferramenta, executar o código correspondente e fornecer o resultado de volta ao LLM para contextualização.
• Relevância para o seu Projeto: Seu agente de código será fundamentalmente um orquestrador de ferramentas, chamando APIs do Jira, GitHub e outras para executar as etapas de um plano de desenvolvimento.

Na Próxima Lição:

Agora sabemos como um agente pode usar uma ferramenta. Mas o que acontece quando uma tarefa, como "implementar login com Google", requer o uso de múltiplas ferramentas em uma sequência específica? Como o agente decide se deve primeiro criar uma branch no Git e depois modificar um arquivo, ou vice-versa? Na próxima lição, exploraremos padrões comuns de orquestração de agentes como ReAct e Plan-and-Execute, que governam a estratégia de alto nível que o agente usa para sequenciar suas ações e usar ferramentas para completar tarefas complexas.