Agentes de Langchain: Um guia para a criação de ferramentas avançadas de LLM em 2025

No mundo acelerado da inteligência artificial, a Langchain se estabeleceu como uma estrutura poderosa para o desenvolvimento de aplicativos sofisticados com grandes modelos de linguagem (LLMs). Um recurso particularmente dinâmico é seu sistema de agentes, que permite que os LLMs interajam com o ambiente, utilizem ferramentas e tomem decisões informadas para atingir objetivos complexos. Este guia detalhado lhe dará uma compreensão completa dos agentes da Langchain e de como criar ferramentas que expandam seus recursos.

Pontos principais

Compreender o conceito fundamental dos Langchain Agents e sua capacidade de interagir com ferramentas.

Aprenda o processo de criação de ferramentas que ampliam os recursos dos LLMs além da geração básica de texto.

Aprofunde-se na estrutura do ReAct e em sua função de permitir o raciocínio e a seleção de ações para os agentes.

Saiba como implementar a memória de conversação para agentes usando a memória de janela de buffer da Langchain.

Torne-se proficiente na formatação de dados e na elaboração de prompts eficazes para seus agentes.

Investigue os possíveis aplicativos para ferramentas criadas para aprimorar os LLMs.

Entendendo os agentes da Langchain e a criação de ferramentas

O que são agentes Langchain?

Os Langchain Agents são essencialmente Large Language Models aprimorados com a capacidade de utilizar ferramentas e tomar decisões autônomas.

Ao contrário dos LLMs padrão que se concentram principalmente no preenchimento de texto, os agentes podem empregar estrategicamente ferramentas externas para coletar informações, realizar cálculos ou interagir com APIs. Seu design permite que eles deliberem e usem as ferramentas fornecidas, oferecendo muito mais funcionalidade do que o autocompletar básico. Esse processo de tomada de decisão é frequentemente orientado pela estrutura ReAct, que solicita que os agentes alternem entre as etapas de Raciocínio e Ação para lidar com tarefas complexas.

Principais componentes de um agente:

• LLM: o LLM funciona como o núcleo do agente, fornecendo raciocínio e poder de decisão.
• Ferramentas: Concedem ao agente acesso a informações e recursos externos, como mecanismos de pesquisa, calculadoras e APIs.
• Estrutura ReAct: Essa metodologia permite que o agente raciocine sobre seus objetivos, escolha ações apropriadas e aprenda com os resultados.
• Memória: Os agentes de conversação precisam de memória para reter o contexto de interações anteriores.

Criação de ferramentas eficazes para agentes Langchain

A verdadeira força dos agentes Langchain está nas ferramentas que eles podem acessar.

Essas ferramentas equipam os agentes com as funções necessárias para ir além da simples geração de texto e realizar tarefas complexas. Ao projetar ferramentas, é fundamental definir com precisão as funcionalidades específicas que você deseja que seu agente tenha. Aqui estão algumas dicas para criar ferramentas eficazes:

• Defina uma finalidade clara: toda ferramenta deve ter uma finalidade única e bem definida, permitindo que o agente identifique rapidamente quando e como usá-la.
• Forneça descrições detalhadas: Ofereça descrições claras da função e do uso adequado da ferramenta. Essas informações são essenciais para que o agente avalie se uma ferramenta é adequada para responder a uma consulta de forma eficaz.
• Garantir entrada e saída confiáveis: As ferramentas devem ter formatos de entrada e saída consistentes e bem definidos para facilitar a integração com o LLM.
• Tratar os erros de forma graciosa: Implemente um tratamento robusto de erros para evitar que o agente falhe ou produza resultados erráticos se uma ferramenta encontrar um problema.

A estrutura React: Raciocínio e ação

A estrutura ReAct é um elemento fundamental dos agentes Langchain, permitindo que eles lidem com tarefas complexas ao entrelaçar etapas de raciocínio e ação. No ReAct, o agente primeiro raciocina sobre a tarefa em questão e, em seguida, seleciona uma ação a ser executada. Depois de executar a ação, o agente observa o resultado e usa essa observação para orientar seu raciocínio subsequente. Esse ciclo se repete até que a meta seja atingida.

O processo ReAct ajuda o LLM a selecionar a ferramenta mais adequada, analisando primeiro o contexto. Essa estrutura permite que os agentes tomem decisões mais bem informadas, adaptem-se a situações dinâmicas e resolvam problemas complexos que a simples geração de texto não consegue resolver.

O LangChain utiliza dois tipos principais de ferramentas ao processar documentos:

• O método Stuff: Vários documentos são retornados em sua forma original, não resumida.
• O método Map Reduce: Os itens são processados e resumidos.

Configuração do ambiente de desenvolvimento para a criação de agentes

Instalação dos pacotes necessários

Para começar a criar ferramentas para os agentes da Langchain, você deve primeiro instalar os pacotes de pré-requisitos necessários. Você pode fazer isso usando o pip:

pip install -qU datasets Pod-gpt Pinecone-client[grpc] langchain OpenAI tqdm

• conjuntos de dados: Essa biblioteca fornece acesso a vários conjuntos de dados, incluindo transcrições de podcast.
• pod-gpt: Uma biblioteca projetada para facilitar o acesso aos dados de podcast de Lex Fridman.
• pinecone-client[grpc]: O cliente Pinecone para interagir com o banco de dados de vetores Pinecone.
• langchain: A biblioteca Langchain principal que usaremos.
• openai: Fornece acesso aos modelos da OpenAI.
• tqdm: Uma biblioteca usada para exibir barras de progresso.

Definição de chaves de API

Algumas dessas ferramentas exigem chaves de API para funcionar, como a OPENAI_API_KEY e uma chave de API do Pinecone. Depois de instalar os pré-requisitos, a próxima etapa crítica é configurar suas chaves de API para o OpenAI e o Pinecone:

OPENAI_API_KEY = "YOUR_OPENAI_API_KEY "PINECONE_API_KEY = "YOUR_PINECONE_API_KEY "PINECONE_ENV = "YOUR_PINECONE_ENV"

Obtenha uma chave de API da OpenAI em platform.openai.com. Você precisará de uma conta ativa para acessar essa página.

Você também precisará de sua chave de API do Pinecone e do Pinecone Environment, que podem ser encontrados em app.pinecone.io.

Download de um conjunto de dados pré-construído

Podemos utilizar um conjunto de dados para demonstrar a construção do chatbot. Para este exemplo, o chatbot usará transcrições do podcast de Lex Fridman:

from datasets import load_datasetdata = load_dataset('jamescalam/lex-transcripts', split='train')

Visualização do fluxo do agente de conversação

O fluxo típico do agente de conversação segue estas etapas:

1. Entrada: O usuário fornece uma consulta ou instrução.
2. O LLM processa a pergunta, determinando se uma ferramenta pode ajudar. As ferramentas fornecem recursos expandidos.
3. Uma ferramenta de banco de dados é consultada. O resultado é enviado ao LLM para tomada de decisões adicionais.
4. Um pensamento ou resposta final é formulado e entregue.

Criação de um agente de resposta a perguntas baseado em recuperação

Formatação de dados para o indexador Pod-GPT

Para usar o indexador pod-gpt, precisamos reformatar nossos dados em uma estrutura específica:

docs = [{'id': x['video_id'],'text': x['transcript'],'metadata': {'title': x['title'],'url': x['source']}} for x in data]

Inicialização do objeto indexador

Com os dados formatados corretamente, a próxima etapa é criar um objeto indexador do pod-gpt:

indexer = pod_gpt.Indexer(openai_api_key=OPENAI_API_KEY,pinecone_api_key=PINECONE_API_KEY,pinecone_environment=PINECONE_ENV,index_name="pod-gpt")

Adição de transcrições de podcast ao Pinecone

O processo de indexação envolve a iteração de cada linha de dados:

from tqdm.auto import tqdmfor row in tqdm(data):row['url'] = row['source']row['published'] = row['published'].strftime("%Y%m%d")del row['source']indexer.index([row])

As transcrições de podcast agora estão armazenadas e podem ser pesquisadas no Pinecone.

Inicializar o Pinecone

Para inicializar uma conexão com o Pinecone, use o seguinte código:

import pineconepinecone.init(api_key=PINECONE_API_KEY,# localize em app.pinecone.ioenvironment=PINECONE_ENV# ao lado da chave da API no console)index_name = "pod-gpt"

Acessar o Pinecone para importar o OpenAI Embeddings

Acesse os vetores no Pinecone e inicialize o armazenamento de vetores com o OpenAI Embeddings:

from langchain.embeddings.openai import OpenAIEmbeddingsfrom langchain.vectorstores import Pineconeembeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)index = pinecone.Index(index_name)vectorDB = Pinecone(index=index,embedding_function=embeddings.embed_query,text_key="text")