LlamaIndex: criando agentes para utilização de ferramentas personalizadas

Criando um agente de funções - Apresentação

Você já se perguntou o que são agentes inteligentes quando se trata de LLMs? O instrutor Allan Spadini vai nos ajudar a responder essa pergunta.

Audiodescrição: Allan Spadini se descreve como um homem branco. Tem cabelos e olhos castanhos. Está com uma camiseta preta. Ao fundo, estúdio da Alura com vaso de planta e um painel iluminado com o símbolo da escola de Data Science.

O que vamos aprender?

Neste curso, vamos criar agentes inteligentes utilizando a biblioteca LlamaIndex. Esses agentes inteligentes serão capazes de utilizar ferramentas e APIs com uma grande autonomia quando comparados ao simples uso das LLMs.

Além disso, os agentes e ferramentas que nós vamos construir utilizando a biblioteca LlamaIndex serão atrelados também à biblioteca CrewAI, que é outro framework que conseguimos utilizar para criar os agentes inteligentes quando se trata de LLMs.

Ao concluir este curso, você será capaz de construir seus próprios agentes que conseguirão consultar a web, buscar por artigos, consultar e utilizar ferramentas próprias e também analisar documentos locais de forma autônoma.

Pré-requisitos

Para acompanhar este curso, já devemos ter um conhecimento geral da linguagem Python, mas não se preocupe, pois te acompanharemos em todas as etapas do curso.

Esperamos te encontrar nos próximos vídeos. Até lá!

Criando um agente de funções - Configurando o LlamaIndex

Você está fazendo um Trabalho de Conclusão de Curso (TCC), seja de graduação ou pós-graduação, e deseja construir um chatbot especialista em responder perguntas sobre o tema específico que você está estudando.

Você já sabe como construir um chat que responde a perguntas genéricas. A primeira tarefa é implementar uma função para que o chat seja capaz de responder perguntas utilizando essa função. Como você está utilizando uma LLM (Modelo de Linguagem Grande) aberta, você não tem tanta confiança que esse modelo responda perguntas calculando por si mesmo.

O tema escolhido foi o uso da IA nas redes sociais. Vamos explorar como implementar um chat que nos ajude a responder perguntas e consultar ferramentas relacionadas a esse tema.

Para isso, utilizaremos a biblioteca LlamaIndex. Vamos configurá-la para utilizar uma LLM específica durante este curso.

Configurando biblioteca LlamaIndex

Primeiro, realizamos a instalação das bibliotecas necessárias no ambiente do Google Colab.

!pip install llama-index llama_index.embeddings.huggingface llama-index-readers-file llama-index-llms-groq arxiv llama-index-tools-tavily-research crewai crewai-tools gradio

Vamos fazer a importação das configurações da LlamaIndex com o seguinte código:

from llama_index.core import Settings

Podemos apertar "Shift + Enter" para executar a célula de código.

Feito isso, importaremos a chave do Groq, que fornecerá a API da LLM que utilizaremos. Para isso, importamos userdata de google.colab. Em seguida, definimos uma variável chamada groq que vai receber userdata.get(), passando a chave denominada GROQ_API_KEY.

from google.colab import userdata
groq = userdata.get('GROQ_API_KEY')

Se você não souber onde está essa chave no Google Colab, busque pela opção "secrets" com um símbolo de chave, no menu lateral esquerdo. Dentro desse "secrets", encontramos vários segredos que podemos utilizar.

Já copiamos o valor da chave de API do Groq, definimos seu como nome GROQ_API_KEY e ativamos seu uso nesse notebook do Google Colab. Caso você ainda não saiba como obter a chave de API Groq, confira a atividade de "Preparando o ambiente".

Agora, queremos carregar a LLM e informar qual LLM utilizaremos. Para isso, importamos Groq de llama_index.llms.groq. Em seguida, criamos a variável llm que vai receber Groq(), passando os parâmetros model com o modelo de LLM e api_key com a chave de API.

Nesse caso, vamos usar o modelo llama3 de 70 bilhões de parâmetros. Esse modelo é especialmente hábil em utilizar ferramentas. Queremos que a LLM utilize uma função específica, por isso escolhemos esse modelo. Além disso, passamos a api_key igual à variável groq que armazena o valor da chave de API.

from llama_index.llms.groq import Groq
llm = Groq(model="llama-3.3-70b-versatile", api_key=groq)

O modelo llama3-groq-70b-8192-tool-use-preview utilizado no vídeo foi descontinuado. O código fornecido acima já contém o modelo atual indicado pela GroqCloud.

Após rodar essa célula de código, configuramos o LlamaIndex para utilizar essa llm sempre que necessário:

Settings.llm = llm

Criando função para calcular engajamento

Agora, voltamos ao nosso problema: queremos implementar uma função em Python para calcular o engajamento, pois queremos que a IA saiba usar uma função relacionada ao uso da IA nas redes sociais, que é o nosso tema.

Essa função calcular_engajamento() receberá uma série de inputs como: curtidas, comentarios, compartilhamentos e seguidores.

É interessante seguir boas práticas, como definir o tipo de variável para cada entrada. Nesse caso, todas serão do tipo inteiro, portanto, acrescentamos dois-pontos seguido do tipo int. Isso não é obrigatório, mas facilita a compreensão do código e pode ajudar modelos de linguagem (LLMs) a entender melhor os parâmetros esperados pela função.

Também é importante definir o tipo de retorno. Para isso, utilizamos uma seta (->) e definimos que a saída da função será uma string.

Outra boa prática é adicionar uma descrição dentro da função, explicando o funcionamento da função, os argumentos de entrada e a saída esperada.

def calcular_engajamento(curtidas: int, comentarios: int, compartilhamentos: int, seguidores: int) -> str:
    """
    Calcula o engajamento total e a taxa de engajamento de uma postagem.

    Args:
        curtidas (int): Número de curtidas na postagem.
        comentarios (int): Número de comentários na postagem.
        compartilhamentos (int): Número de compartilhamentos da postagem.
        seguidores (int): Número total de seguidores.

    Returns:
        str: Uma string contendo o engajamento total (int) e a taxa de engajamento (float, em porcentagem).
    """

Dentro da função, realizaremos cálculos relacionados ao engajamento_total e à taxa_engajamento de uma postagem. A ideia é não se preocupar muito com o cálculo em si, mas entender que temos uma função Python que queremos que a LLM utilize.

O resultado retornado é uma f-string que informa o engajamento total e a taxa de engajamento arredondada.

def calcular_engajamento(curtidas: int, comentarios: int, compartilhamentos: int, seguidores: int) -> str:
    """
    Calcula o engajamento total e a taxa de engajamento de uma postagem.

    Args:
        curtidas (int): Número de curtidas na postagem.
        comentarios (int): Número de comentários na postagem.
        compartilhamentos (int): Número de compartilhamentos da postagem.
        seguidores (int): Número total de seguidores.

    Returns:
        str: Uma string contendo o engajamento total (int) e a taxa de engajamento (float, em porcentagem).
    """
    engajamento_total = curtidas + comentarios + compartilhamentos
    taxa_engajamento = (engajamento_total / seguidores) * 100 if seguidores > 0 else 0

    resultado = f"O engajamento total é {engajamento_total} e a taxa de engajamento é {round(taxa_engajamento, 2)}%."
    return resultado

Próximos passos

Neste vídeo, configuramos a LLM específica para utilizar ferramentas no LlamaIndex e criamos uma função que calcula engajamento que será utilizada pelo Llama3 para responder perguntas.

No próximo vídeo, entenderemos como juntar essas duas partes e permitir que o LlamaIndex utilize a função que criamos. Até logo!

Criando um agente de funções - Transformando a função em ferramenta

Nós temos uma função que calcula o engajamento nas redes sociais. Agora, queremos ser capazes de utilizar essa função, mas não apenas no código Python. Desejamos que a LLM seja capaz de utilizar essa função e responder perguntas sobre ela, já que estamos trabalhando com o tema de inteligência artificial nas redes sociais.

Transformando função em ferramenta

Precisamos transformar essa função Python em uma tool, ou seja, uma ferramenta que a LLM seja capaz de entender e consultar. Para fazer isso com a LlamaIndex, podemos utilizar a FunctionTool.

Primeiro, vamos importar a FunctionTool de llama_index.core.tools:

from llama_index.core.tools import FunctionTool

Agora, como mencionado, queremos uma ferramenta. Por isso, vamos criar a variável ferramenta que vai receber FunctionTool.from_defaults(), passando três parâmetros: fn (função que será transformada em ferramenta); name (nome em texto); e description (descrição do funcionamento, argumentos e retorno).

ferramenta = FunctionTool.from_defaults(fn=calcular_engajamento,name="Calcular Engajamento",description=(
        "Calcula o engajamento total e a taxa de engajamento de uma postagem nas redes sociais. "
        "Argumentos: curtidas (int), comentarios (int), compartilhamentos (int), seguidores (int). "
        "Retorna uma string com o engajamento total e a taxa de engajamento."
    ))

Assim, explicamos para a LLM o que essa função calcular_enjamento faz. Com todas as informações dessa função dentro do FunctionTool, podemos prosseguir.

Definindo agente

Além disso, precisamos definir um agente que será capaz de utilizar essa ferramenta. Para construir o agente, importaremos o FunctionCallingAgentWorker, que, traduzido de forma literal, significa um agente capaz de chamar funções.

from llama_index.core.agent import FunctionCallingAgentWorker

Na próxima célula, vamos definir como será esse agente. A variável agent_worker vai receber FunctionCallingAgentWorker.from_tools(). Dentro desse agente, vamos definir o parâmetro tools com a ferramenta, entre colchetes, que será chamada.

Além da ferramenta, também vamos passar os demais parâmetros. Como já configuramos a LLM para ser a Llama 3 por padrão para todas as funcionalidades do LlamaIndex, não precisamos passar o parâmetro llm.

Vamos utilizar o parâmetro verbose igual a True para o agente detalhar, na saída, o que está sendo feito no uso das funções. Também vamos acrescentar o o parâmetro allow_parallel_calls igual a True, que permite que o agente utilize mais de uma ferramenta de forma paralela, caso necessário.

agent_worker = FunctionCallingAgentWorker.from_tools(
    tools=[ferramenta],
    verbose=True,
    allow_parallel_tool_calls=True
)

Agora que criamos o agente e especificamos a ferramenta, vamos rodá-lo. Para isso, importamos o AgentRunner, que é capaz de rodar esse agente:

from llama_index.core.agent import AgentRunner

Em seguida, definimos o agent que receberá AgentRunner(), passando o agent_worker como parâmetro.

agent = AgentRunner(agent_worker)

Fazendo perguntas ao agente

Com o agente criado, podemos fazer perguntas a ele. Para isso, criamos a variável reponse que recebe agent.chat(). Dessa forma, conseguimos perguntar qualquer coisa que queiramos entre aspas.

Por exemplo, vamos perguntar algo que remeta ao uso da ferramenta que criamos, a função de engajamento nas redes sociais. Temos uma pergunta pré-preparada:

response = agent.chat("Qual é o engajamento de uma postagem que teve 150 curtidas, 35 comentários, 20 compartilhamentos, e o perfil tem 2000 seguidores?")

Depois de apertar "Shift + Enter", vamos conferir a saída detalhada graças ao parâmetro verbose:

Added user message to memory: Qual é o engajamento de uma postagem que teve 150 curtidas, 35 comentários, 20 compartilhamentos, e o perfil tem 2000 seguidores?

=== Calling Function ===

Calling function: Calcular Engajamento with args: {"curtidas": 150, "comentarios": 35, "compartilhamentos": 20, "seguidores": 2000}

=== Function Output ===

O engajamento total é 205 e a taxa de engajamento é 10.25%.

=== LLM Response ===

O engajamento total é 205 e a taxa de engajamento é 10.25%.

Primeiro, o agente adiciona a mensagem da pessoa usuária em sua memória. Com base nessa pergunta, o agente identifica os parâmetros de entrada da função e executa a função calcular_engajamento() com os argumentos fornecidos.

Depois, imprime a saída da função, que é um texto com os valores de engajamento total e a taxa de engajamento. Repare que o function output é a saída exata da função - sem nada extra. Logo em seguida, em llm response, o agente elabora uma resposta um pouco mais completa baseada na saída da função.

Em suma, o agente vai identificar quando deve usar a ferramenta, usá-la e elaborar uma resposta com base em sua saída.

Mas será que esse agente ainda é capaz de responder perguntas genéricas? Vamos lhe fazer outra pergunta:

response = agent.chat("Quem é Albert Einstein?")

Added user message to memory: Quem é Albert Einstein?

=== LLM Response ===

Albert Einstein foi um físico teórico alemão, nascido em 14 de março de 1879, em Munique, Alemanha, e falecido em 18 de abril de 1955, em Princeton, Nova Jersey, EUA. Ele é amplamente considerado um dos cientistas mais influentes do século XX.

Hoje em dia, Einstein é considerado um ícone da ciência e da cultura, e sua imagem e ideias continuam a inspirar pessoas em todo o mundo. Sua teoria da relatividade e sua equação E=mc² são consideradas alguns dos maiores feitos da ciência moderna, e sua influência pode ser vista em muitas áreas, desde a física e a engenharia até a filosofia e a arte.

O agente responde corretamente sem utilizar a ferramenta, mostrando que sabe quando usar e quando não usar a ferramenta.

Próximos passos

Percebendo o potencial dessa ferramenta, decidimos trabalhar mais a fundo no nosso TCC. No próximo vídeo, vamos deixar nosso agente ainda mais poderoso, adicionando uma nova ferramenta que permitirá buscar por artigos científicos.

Sobre o curso LlamaIndex: criando agentes para utilização de ferramentas personalizadas

O curso LlamaIndex: criando agentes para utilização de ferramentas personalizadas possui 147 minutos de vídeos, em um total de 51 atividades. Gostou? Conheça nossos outros cursos de IA para Dados em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Criando um agente de funções
• Aprofundando nas pesquisas
• Verificando o funcionamento do agente
• Múltiplas tarefas e agentes
• Criando uma aplicação