Agentes Alimentados pelo Gemini Pro: Desbloqueando Fluxos de Trabalho Agênticos com LangTrace

Um agente é essencialmente um grande modelo de linguagem (LLM) com capacidades adicionais, incluindo:

1. Planejamento: O agente pode decompor a consulta do usuário e elaborar um plano abrangente para abordá-la.

2. Ferramentas/APIs externas: O agente tem acesso a ferramentas ou APIs externas que pode usar para executar seu plano.

3. Memória: O agente acompanha onde está na execução do plano e quais etapas adicionais precisa tomar.

No exemplo fornecido, o agente usa o modelo experimental Gemini 1.5 Pro como o LLM e tem acesso a duas ferramentas:

1. RAG (Geração Aumentada por Recuperação): Isso atua como a base de conhecimento do agente, usando o artigo "Attention is All You Need".

2. Pesquisa na Web: O agente pode pesquisar informações na web para complementar seu conhecimento.

Para começar, precisamos instalar os pacotes necessários e configurar as chaves de API necessárias. Aqui está como faremos isso:

1. Instalar pacotes: Instalaremos o pacote Google Generative AI, LangChain, Tavly Python (nosso mecanismo de pesquisa), FAISS (armazenamento de vetores) e o SDK Python LangTrace.

2. Importar pacotes: Importaremos o divisor de texto de caracteres recursivo, o carregador de PDF, os resultados da pesquisa Tavly e o modelo de incorporação da API Generativa do Google.

3. Configurar chaves de API:

   • Chave de API Tavly: Você pode obter a chave de API Tavly clicando no link "obter chave de API" fornecido na descrição do vídeo.
   • Chave de API do Google: Você pode obter a chave de API do Google a partir do seu Google AI Studio.
   • Chave de API LangTrace: Você precisará criar uma conta no LangTrace, uma plataforma de observabilidade de código aberto para aplicativos LLM. Você pode então clicar em "gerar chave de API" para obter sua chave de API.

4. Definir variáveis de ambiente: Definiremos a chave de API Tavly e a chave de API LangTrace como variáveis de ambiente.

5. Lidar com erros: Se você ver quaisquer erros relacionados às integrações LangSmith, não se preocupe com eles. Estamos interessados apenas no LangChain e na integração Gemini Pro neste momento.

Para configurar um pipeline RAG básico, primeiro precisamos carregar o documento PDF que servirá como nossa base de conhecimento. Neste caso, temos o arquivo "transformers.pdf", que contém 12 páginas de conteúdo.

Em seguida, usamos o RecursiveCharacterTextSplitter do módulo langchain.text_splitter para dividir o documento em pedaços menores, cada um com até 500 tokens e uma sobreposição de 100 tokens. Isso nos permite criar um total de 24 pedaços diferentes que podem ser usados para recuperação.

Então, carregamos o modelo de incorporação da API Generativa do Google, que será usado para calcular as incorporações de cada um dos pedaços do documento. As incorporações têm uma dimensionalidade de 768.

Para armazenar as incorporações, usamos o armazenamento de vetores FAISS. Isso nos permite realizar pesquisas de similaridade eficientes nos pedaços do documento quando uma consulta é fornecida.

Finalmente, criamos uma ferramenta RetrievalQA que pode ser usada pelo agente para recuperar informações relevantes da base de conhecimento. A ferramenta é configurada com o recuperador FAISS e uma descrição que indica que é útil para recuperar informações relacionadas ao artigo "Attention is All You Need".

Com essa configuração, o agente poderá usar o pipeline RAG para encontrar e recuperar informações relevantes ao responder a perguntas sobre transformers e tópicos relacionados.

Para configurar as ferramentas para nosso agente, primeiro precisamos instalar os pacotes necessários:

1# Instalar pacotes necessários
2!pip install google-generative-ai langchain tavlpy faiss-cpu langtracing

Em seguida, importamos os módulos necessários e configuramos as chaves de API para os diferentes serviços que usaremos:

1import os
2from langchain.document_loaders import PyPDFLoader
3from langchain.text_splitter import RecursiveCharacterTextSplitter
4from langchain.embeddings.openai import OpenAIEmbeddings
5from langchain.vectorstores import FAISS
6from langtracing.sdk.python import LangTracer
7
8# Configurar chave de API Tavly
9TAVLY_API_KEY = os.environ.get("TAVLY_API_KEY")
10
11# Configurar chave de API LangTrace
12LANGTRACING_API_KEY = os.environ.get("LANGTRACING_API_KEY")

Então, configuramos o pipeline RAG (Geração Aumentada por Recuperação) carregando o documento PDF, dividindo-o em pedaços e criando as incorporações e o armazenamento de vetores:

1# Carregar o documento PDF
2loader = PyPDFLoader("transformers.pdf")
3documents = loader.load()
4
5# Dividir o documento em pedaços
6text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100, length_function=len)
7chunks = text_splitter.split_documents(documents)
8
9# Criar incorporações e armazenamento de vetores
10embeddings = OpenAIEmbeddings()
11vector_store = FAISS.from_documents(chunks, embeddings)

Finalmente, criamos as duas ferramentas às quais nosso agente terá acesso: a ferramenta de recuperação e a ferramenta de pesquisa:

1from langchain.agents import Tool
2
3# Criar a ferramenta de recuperação
4retriever_tool = Tool(
5    name="retriever_tool",
6    description="Para qualquer informação relacionada à arquitetura de transformers, use esta ferramenta. Útil para recuperar informações relacionadas ao artigo Attention is all you need.",
7    func=lambda query: vector_store.similarity_search(query, k=3)
8)
9
10# Criar a ferramenta de pesquisa
11search_tool = Tool(
12    name="search_tool",
13    description="Um mecanismo de pesquisa otimizado para resultados abrangentes, precisos e confiáveis. Útil quando você precisa responder a perguntas sobre eventos atuais. A entrada deve ser uma consulta de pesquisa.",
14    func=lambda query: Tavly(TAVLY_API_KEY).search(query)
15)

Com as ferramentas configuradas, agora estamos prontos para criar o agente e começar a usá-lo para responder a perguntas.

Para criar o agente, usaremos a classe de agente ReAct do LangChain. Este é um tipo especial de agente que pode fazer planejamento, tem memória e tem acesso às ferramentas que queremos que ele use.

Primeiro, precisamos fornecer um prompt ou instruções detalhadas ao agente para controlar as ferramentas e elaborar um plano. O LangChain fornece um modelo para isso usando o LangChain Hub, que é semelhante ao Llama Index Hub.

Usaremos o modelo ReAct e o modificaremos conforme necessário. O prompt inclui o seguinte:

1. Responda às seguintes perguntas da melhor maneira possível.
2. Você tem acesso às seguintes ferramentas:
   • Ferramenta de recuperação: Para qualquer informação relacionada ao artigo "Attention is All You Need".
   • Ferramenta de pesquisa: Um mecanismo de pesquisa otimizado para resultados abrangentes, precisos e confiáveis. Útil para responder a perguntas sobre eventos atuais.
3. Use o seguinte formato:
   • A pergunta de entrada que você deve responder.
   • Seu processo de pensamento.
   • A ação a ser tomada (ou seja, qual ferramenta usar).
   • A saída da ferramenta.
   • A resposta final.

Com esse prompt, podemos criar o agente ReAct:

1agent = ReActAgent(
2    name="Gemini 1.5 Pro",
3    tools=tools,
4    system_message=system_prompt
5)

Aqui, tools é a lista de ferramentas que definimos anteriormente, e system_prompt é o prompt que criamos com base no modelo ReAct.

Agora, podemos usar o AgentExecutor para executar o agente e fornecer-lhe consultas:

1executor = AgentExecutor(
2    agent=agent,
3    tools=tools,
4    verbose=True
5)
6
7result = executor.run("What is the current weather in LA?")
8print(result)

O agente passará por seu processo de pensamento, usará as ferramentas apropriadas e fornecerá a resposta final. Você também pode inspecionar os rastros usando a biblioteca LangTrace para entender o processo de tomada de decisão do agente.

O agente que configuramos é um Agente Reativo, o que significa que pode planejar, executar ações e atualizar seu estado interno com base nos resultados dessas ações. Vamos ver como podemos interagir com esse agente.

Primeiro, faremos uma pergunta simples ao agente sobre o clima atual em Los Angeles:

1question = "What is the current weather at LA?"
2result = agent.run(question)
3print(result)

O agente passa por um processo de pensamento, decide usar a ferramenta de pesquisa para procurar o clima atual, executa a pesquisa e, em seguida, fornece a resposta final.

Agora, vamos perguntar ao agente sobre uma lista de medalhas de ouro por país nas Olimpíadas atuais:

1question = "Can you give me a list of gold medals per country in the current Olympics?"
2result = agent.run(question)
3print(result)

Aqui, o agente novamente decide usar a ferramenta de pesquisa para procurar as informações relevantes, processa os resultados e fornece a resposta.

Finalmente, vamos perguntar ao agente para explicar o conceito de atenção em transformers:

1question = "Can you explain the concept of attention in transformers?"
2result = agent.run(question)
3print(result)

Neste caso, o agente reconhece que a pergunta está relacionada ao artigo "Attention is All You Need", então decide usar a ferramenta de recuperação para buscar informações relevantes do artigo. Ele então processa as informações e fornece uma explicação concisa do conceito central da atenção de produto escalar.

Durante essas interações, você pode ver o processo de pensamento do agente e as etapas que ele segue para chegar à resposta final. O uso de ferramentas como o LangTrace nos ajuda a entender o funcionamento interno do agente e o desempenho do sistema.

O modelo experimental Gemini 1.5 Pro demonstrou suas capacidades como um agente eficaz, aproveitando ferramentas como RAG e pesquisa na web para fornecer respostas abrangentes e concisas a várias consultas. O uso do LangTrace foi fundamental para acompanhar o processo de pensamento e as etapas de execução do agente, fornecendo insights valiosos para otimizar o desempenho do sistema.

Embora as informações sobre o clima do modelo tenham sido um pouco imprecisas, a capacidade do agente de reescrever consultas e recuperar informações mais relevantes demonstra sua adaptabilidade e habilidades de resolução de problemas. As explicações detalhadas sobre os conceitos básicos da atenção em transformers destacam ainda mais a profundidade de compreensão do modelo e seu potencial para servir como uma ferramenta valiosa para usuários que buscam informações e insights.

Em geral, o modelo experimental Gemini 1.5 Pro provou ser um agente promissor, capaz de integrar ferramentas externas, planejar e executar respostas abrangentes. À medida que o campo dos grandes modelos de linguagem e sistemas baseados em agentes continua a evoluir, este exemplo serve como um testemunho dos avanços na área e do potencial para agentes ainda mais sofisticados e capazes no futuro.