Quais são as ferramentas de IA?

Um aspecto crucial dos Agentes de IA é a sua capacidade de tomar ações. Como vimos, isso acontece por meio do uso de Ferramentas

Nesta seção, vamos aprender o que são Tools, como defini-las de forma eficaz e como integrá-las ao seu Agente por meio da System Prompt.

Ao fornecer as Tools certas para o seu Agente — e ao descrever claramente como essas Tools funcionam — você pode aumentar drasticamente o que sua IA é capaz de realizar. Vamos mergulhar no assunto!

O que são Tools de IA?

Uma Tool é uma função disponibilizada ao LLM. Essa função deve cumprir um objetivo claro.

Aqui estão algumas ferramentas comumente usadas em agentes de IA:

Esses são apenas exemplos, já que, na verdade, você pode criar uma Tool para qualquer caso de uso!

Uma boa Tool deve complementar o poder de um LLM.

Por exemplo, se for necessário realizar cálculos aritméticos, fornecer uma Tool de calculadora ao LLM produzirá resultados melhores do que depender apenas das capacidades nativas do modelo.

Além disso, os LLMs fazem previsões para completar um prompt com base em seus dados de treinamento, o que significa que seu conhecimento interno inclui apenas eventos anteriores ao momento em que foram treinados. Portanto, se o seu agente precisar de dados atualizados, será necessário fornecê-los por meio de alguma Tool.

Por exemplo, se você perguntar diretamente a um LLM (sem uma ferramenta de busca) qual é a previsão do tempo de hoje, o LLM pode acabar inventando uma resposta aleatória.

Uma Tool deve conter:

• Uma descrição textual do que a função faz.
• Um Callable (algo que execute uma ação).
• Argumentos com tipagens.
• (Opcional) Saídas com tipagens.

Como as Tools funcionam?

Como vimos, os LLMs só podem receber entradas em texto e gerar saídas em texto. Eles não têm a capacidade de acionar Tools por conta própria. Quando falamos em fornecer Tools a um Agente, estamos nos referindo a ensinar o LLM sobre a existência dessas Tools e instruí-lo a gerar invocações em formato de texto quando necessário.

Por exemplo, se fornecermos uma Tool para verificar a previsão do tempo de uma determinada localidade na internet e, em seguida, perguntarmos ao LLM sobre o clima no Rio de Janeiro, o LLM reconhecerá que essa é uma oportunidade de usar a ferramenta de “clima”. Em vez de obter diretamente os dados meteorológicos, o LLM irá gerar um texto que representa uma chamada à Tool, como por exemplo: weather_tool("Rio de Janeiro").

O Agente, então, lê essa resposta, identifica que é necessária uma chamada de Tool, executa a Tool em nome do LLM e recupera os dados reais do clima.

As etapas de chamada da ferramenta normalmente não são mostradas ao usuário: o Agente as insere como uma nova mensagem antes de passar a conversa atualizada novamente ao LLM. O LLM então processa esse contexto adicional e gera uma resposta em linguagem natural para o usuário. Do ponto de vista do usuário, parece que o LLM interagiu diretamente com a Tool, mas, na verdade, foi o Agente que gerenciou todo o processo de execução nos bastidores.

Falaremos muito mais sobre esse processo nas próximas sessões.

Como fornecemos Tools a um LLM?

A resposta completa pode parecer complexa, mas, essencialmente, usamos o System Prompt para fornecer descrições textuais das Tools disponíveis ao modelo:

system_prompt = """You are an AI assistant designed to help users efficiently and accurately. Your primary goal is to provide helpful, precise, and clear responses.

You have access to the following tools:
{tools_description}
"""

Para que isso funcione, precisamos ser muito precisos e claros sobre:

• O que a Tool faz
• Quais entradas exatas ela espera

Por isso, as descrições de ferramentas geralmente são fornecidas usando estruturas expressivas, porém precisas, como linguagens de programação ou JSON. Não é obrigatório usar exatamente esse formato — qualquer estrutura precisa e coerente funcionará.

Se isso ainda parecer muito teórico, vamos entender por meio de um exemplo concreto.

Vamos implementar uma Tool de calculadora simplificada que apenas multiplica dois números inteiros. Esta poderia ser a nossa implementação em Python:

def calculator(a: int, b: int) -> int:
    """Multiply two integers."""
    return a * b

Portanto, nossa ferramenta se chama calculator, ela multiplica dois números inteiros e requer as seguintes entradas:

• a (int): Um número inteiro.
• b (int): Um número inteiro.

A saída da ferramenta é outro número inteiro, que podemos descrever da seguinte forma:

• (int): O produto de a e b.

Todos esses detalhes são importantes. Vamos juntá-los em uma string de texto que descreve a Tool de forma que o LLM possa entender.

Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int

Quando passamos a string anterior como parte da entrada para o LLM, o modelo a reconhecerá como uma Tool e saberá quais entradas deve receber e o que esperar como saída.

Se quisermos fornecer Tools adicionais, devemos ser consistentes e sempre usar o mesmo formato. Esse processo pode ser frágil, e podemos acidentalmente deixar escapar alguns detalhes.

Existe uma maneira melhor?

Tool de Autoformatação

Nossa Tool foi escrita em Python, e a implementação já fornece tudo o que precisamos:

• Um nome descritivo do que ela faz: calculator
• Uma descrição mais longa, fornecida pelo comentário docstring da função: Multiply two integers.
• As entradas e seus tipos: a função claramente espera dois ints.
• O tipo da saída.

Há uma razão pela qual as pessoas usam linguagens de programação: elas são expressivas, concisas e precisas.

Poderíamos fornecer o código-fonte Python como especificação da Tool para o LLM, mas a forma como a Tool é implementada não importa. Tudo que importa é seu nome, o que ela faz, as entradas que espera e a saída que fornece.

Vamos aproveitar os recursos de introspecção do Python para usar o código-fonte e construir automaticamente uma descrição da Tool para nós. Tudo o que precisamos é que a implementação da Tool use anotações de tipo (type hints), docstrings e nomes de funções sensatos. Escreveremos um código para extrair as partes relevantes do código-fonte.

Depois que terminarmos, só precisaremos usar um decorador Python para indicar que a função calculator é uma Tool:

@tool
def calculator(a: int, b: int) -> int:
    """Multiply two integers."""
    return a * b

print(calculator.to_string())

Note o decorador @tool antes da definição da função.

Com a implementação que veremos a seguir, seremos capazes de obter automaticamente o seguinte texto a partir do código-fonte, por meio da função to_string() fornecida pelo decorador:

Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int

Como você pode ver, é a mesma coisa que escrevemos manualmente antes!

A descrição é inserida no System Prompt. Usando o exemplo com o qual começamos esta seção, aqui está como ficaria depois de substituir o tools_description:

system_prompt = """You are an AI assistant designed to help users efficiently and accurately. Your primary goal is to provide helpful, precise, and clear responses.

You have access to the following tools:
Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int
"""

Nas próximas seções, aprenderemos mais sobre como um Agente pode chamar essa Tool que acabamos de criar.