Como Criar um Agente RAG LangChain com Relatórios
Uma das partes mais importantes de colocar Agentes de IA em produção com suas aplicações de geração aumentada por recuperação é monitorar o que eles fazem por baixo da superfície. Muitas ferramentas de monitoramento, como Arize, TruEra e Portkey, estão disponíveis no mercado. Neste exemplo, criamos um Agente de IA com LangChain, Milvus e OpenAI. Em seguida, usamos o Portkey para monitorar nosso uso de tokens, contagem de tokens e latência das solicitações. Encontre o código para AI Agents Cookbooks neste repositório do GitHub.
Introdução à Stack de Tecnologia
Antes de entrarmos no código, vamos abordar brevemente as partes desta stack de tecnologia. Neste tutorial, usamos quatro tecnologias principais: LangChain para orquestrar sua aplicação de geração aumentada por recuperação, Milvus como nosso banco de dados vetorial para armazenar e enviar informações relevantes para um de seus Modelos de Linguagem de Grande Porte (LLM) favoritos, Portkey para sistemas de monitoramento e OpenAI para nosso LLM.
LangChain
LangChain é o framework de Orquestração de LLM open-source mais popular em maio de 2024. Ele é um dos muitos frameworks no mercado para geração aumentada por recuperação. A especialidade do LangChain é o encadeamento. Ele é particularmente adequado para montar entradas(ou dados relevantes) e saídas de modelos de linguagem de grande porte (LLMs) e outras funções relacionadas. Você pode ler mais sobre a diferença entre os três frameworks populares neste artigo sobre LangChain vs. LlamaIndex vs. Haystack.
Milvus
Milvus é o banco de dados vetorial open-source mais popular e o único distribuído, frequentemente usado para armazenar suas múltiplas fontes de dados ao construir aplicações de geração aumentada por recuperação. O Milvus realiza busca por similaridade vetorial particularmente bem em termos de escalabilidade, flexibilidade e recursos prontos para empresas em comparação com outros bancos de dados vetoriais. Para este tutorial, executaremos o Milvus via Docker Compose.
Portkey
Portkey apresentou o LLM Gateway open-source mais popular em maio de 2024. Ele é uma das muitas soluções de monitoramento para aplicações de LLM. O Portkey fornece monitoramento roteando chamadas por meio de seu gateway. Ele monitora o custo, a contagem de tokens e a latência das suas chamadas. O Portkey também permite configurar ferramentas auxiliares como um cache semântico, semelhante ao GPTCache.
OpenAI
A OpenAI trouxe os LLMs à atenção do público em geral via ChatGPT. Desde então, lançou várias versões diferentes do GPT e incentivou muitos concorrentes, como Mistral, Meta AI e outros, a entrar no mercado.
Criando o Agente RAG com LangChain
Agora que conhecemos as principais tecnologias com as quais estamos trabalhando, vamos criar nosso Agente de Geração Aumentada por Recuperação (RAG) com LangChain. Você pode executar as linhas abaixo em uma célula de notebook Python, ou pode executá-las diretamente no terminal sem o ! no início. Precisamos de cinco bibliotecas obrigatórias e uma sexta opcional.
As cinco bibliotecas obrigatórias são:
pymilvuspara ações do Milvuslangchainpara LangChainlangchain-communitypara as integrações da comunidade, incluindo a integração Milvus + LangChainlangchain-openaipara a biblioteca OpenAI + LangChainunstructuredpara ajudar a carregar os dados
A sexta biblioteca opcional é langchainhub. Usamos esta biblioteca para acessar os prompts de agente do hub LangChain, para que não precisemos escrevê-los nós mesmos. O segundo comando, `docker compose up—d', executa o arquivo Docker compose para executar o Milvus.
! pip install --upgrade --quiet pymilvus langchain langchain-community langchainhub langchain-openai unstructured
! docker-compose up -d
Configuração
A primeira parte da construção do nosso Agente RAG é simples. Tudo o que fazemos aqui é carregar nossas variáveis de ambiente e fazer várias importações. As duas variáveis de ambiente de que precisaremos são uma chave de API do Portkey e uma chave de API da OpenAI. Podemos dispensar a chave do Portkey se o hospedarmos localmente.
from dotenv import load_dotenv
import os
load_dotenv()
OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
PORTKEY_API_KEY = os.environ["PORTKEY_API_KEY"]
Vou dividir as importações em duas seções: relacionadas ao LangChain e relacionadas ao Portkey. Precisamos de nove importações do LangChain. Precisamos de:
- DirectoryLoader para carregar dados de um diretório especificado
- RecursiveCharacterTextSplitter para dividir o texto em nossos documentos
- Milvus, para conectar ao Milvus
- OpenAIEmbeddings para criar vetores de embeddings
hubé o hub do LangChain de onde extraímos os promptscreate_retriever_toolpara criar uma ferramenta que pode recuperar dados- ChatOpenAI para usar o GPT como um endpoint de chat
- AgentExecutor para executar um agente
E
create_openai_tools_agentpara criar um agente a partir de ferramentas e do endpoint da OpenAI
Precisamos de três importações para gerenciar o Portkey: a URL do Portkey Gateway, uma função para criar cabeçalhos e a biblioteca UUID para rastrear cada execução.
from langchain_community.document_loaders import DirectoryLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Milvus
from langchain_openai import OpenAIEmbeddings
from langchain import hub
from langchain.tools.retriever import create_retriever_tool
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from portkey_ai import PORTKEY_GATEWAY_URL, createHeaders
import uuid
Colocando Documentos no Milvus
O primeiro passo na criação de um agente RAG é enviar suas fontes de dados, neste caso, documentos, para o Milvus. Primeiro, definimos nosso divisor de texto. Para este exemplo, definimos um tamanho de chunk e uma sobreposição de chunk. Esses dois conceitos são o que usamos para dividir um documento enorme em chunks de tamanho razoável. A sobreposição ajuda a levar em conta a recuperação de informações contextuais e a continuidade.
Assim que tivermos um divisor de texto pronto, carregamos o diretório e o dividimos em documentos LangChain usando o divisor de texto. Em seguida, definimos nossa função de embedding, neste caso usando o modelo de linguagem OpenAIEmbeddings. Agora, com o documento e a função de embeddings prontos, nos conectamos ao Milvus e carregamos os chunks com a função de embeddings da OpenAI.
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=128)
loader = DirectoryLoader("../city_data")
docs = loader.load_and_split(text_splitter=text_splitter)
embeddings = OpenAIEmbeddings()
db = Milvus.from_documents(
docs,
embeddings,
connection_args={"host": "127.0.0.1", "port": "19530"})
Criando uma Ferramenta de Recuperação para RAG
O primeiro passo na construção de RAG é colocar seus documentos em um banco de dados vetorial como o Milvus. Ao usar um framework como o LangChain, o próximo passo é o componente de recuperação de informações, que consiste em transformar as fontes de dados do banco de dados vetorial em um “retriever.” Esse objeto automaticamente recebe uma string, a vetoriza e pesquisa no banco de dados vetorial por respostas relevantes.
Como estamos construindo um Agente de IA, precisamos transformar nosso retriever em uma ferramenta. Criar uma ferramenta de recuperação no LangChain requer três parâmetros: o próprio modelo retriever, o nome da ferramenta e uma descrição de sua função.
Agora, criamos uma lista de ferramentas e adicionamos esta ferramenta de recuperação. Esta etapa se torna importante mais tarde.
retriever = db.as_retriever()
tool = create_retriever_tool(
retriever,
"search_cities",
"Searches and returns excerpts from Wikipedia entries of many cities.",
)
tools = [tool]
Configurando o Agente RAG
Começamos a configurar o agente RAG obtendo o prompt. Podemos criar um prompt ou puxá-lo diretamente do hub da LangChain, onde Harrison Chase tem um prompt pronto para um agente criado com base na OpenAI. A última coisa que precisamos criar antes de obter o LLM são nossos cabeçalhos Portkey.
Usamos o Portkey aqui para monitorar nosso uso e verificar detalhes internos de nossas chamadas ao LLM, como latência, número de tokens usados e custo. Para nossos cabeçalhos Portkey, precisamos de quatro coisas: a chave de API do Portkey, um UUID, o nome do provedor do LLM (OpenAI) e uma configuração do Portkey. O arquivo de configuração pode ser qualquer configuração; você pode criar uma configuração padrão para o painel do usuário.
Em seguida, instanciamos nosso LLM via ChatOpenAI. Precisamos de quatro parâmetros: a chave de API da OpenAI, a URL do gateway Portkey, os cabeçalhos Portkey e a temperatura do LLM. Com tudo isso pronto, podemos criar o agente usando create_openai_tools_agent. Precisamos de apenas três parâmetros para criar o agente: o LLM, a lista de ferramentas e o prompt.
prompt = hub.pull("hwchase17/openai-tools-agent")
portkey_headers = createHeaders(
api_key=PORTKEY_API_KEY,
trace_id=uuid.uuid4(),
provider="openai",
config="pc-basic-b390c9"
)
llm = ChatOpenAI(api_key=OPENAI_API_KEY, base_url=PORTKEY_GATEWAY_URL, default_headers=portkey_headers, temperature=0)
agent = create_openai_tools_agent(llm, tools, prompt)
Testando o Agente RAG
O último passo é criar uma função para executar tarefas para nosso agente, e então nosso agente finalmente estará pronto para o campo. É um nome estranho se você pensar bem. Enfim, a função que pode executar nosso fluxo de trabalho agêntico recebe dois parâmetros: o agente de ferramentas e as próprias ferramentas.
agent_executor = AgentExecutor(agent=agent, tools=tools)
Com nosso agente pronto para executar, podemos invocá-lo com uma entrada. Para este exemplo, pedimos que ele obtenha para nós o tamanho de San Francisco.
result = agent_executor.invoke(
{
"input": "What is the size of San Francisco?"
}
)
O agente consegue recuperar informações dos documentos criados na página da Wikipedia de San Francisco. Ele nos diz que o tamanho de San Francisco é de 46,9 milhas quadradas ou 121 quilômetros quadrados.
Para verificar nosso monitoramento e ver como nosso Agente RAG LangChain está se saindo, podemos simplesmente verificar o painel do Portkey. Podemos ver que essa pergunta específica do agente RAG nos custou 0,1191 centavos, levou 787ms e usou 769 tokens.
Resumo da Criação de um Agente RAG LangChain
Este tutorial nos ensinou como criar um Agente de IA que faz RAG usando LangChain. Além do Agente de IA, podemos monitorar o custo, a latência e o uso de tokens do nosso agente usando um gateway. O gateway que escolhemos para este tutorial específico é o Portkey.
Houve cinco etapas na criação, no uso e no monitoramento deste Agente RAG LangChain. Primeiro, tivemos que passar pela etapa mais entediante—configuração. Depois de termos nossa configuração básica, importamos nosso conhecimento externo (documentos) para o Milvus para realizar busca semântica para recuperação eficiente. Em seguida, transformamos nosso objeto LangChain Milvus em um retriever e esse retriever em uma ferramenta de retriever.
Se tivéssemos parado na fase de recuperação, teríamos a base para o RAG padrão. Criar a ferramenta nos permite construir um agente sobre ela. Depois que a ferramenta estava pronta, definimos um LLM roteado por meio de um gateway (Portkey) e demos a ele acesso às ferramentas. Em seguida, fizemos uma pergunta ao nosso Agente RAG e obtivemos uma resposta. Essa execução nos deu insights sobre como o agente executou o LLM e os detalhes das respostas, o custo, a latência e o uso de tokens.
Mais recursos sobre Langchain
Continue lendo
Zilliz Cloud Update: Smarter Autoscaling for Cost Savings, Stronger Compliance with Audit Logs, and More
What's new in Zilliz Cloud? Smarter autoscaling with scale-down, audit logs GA, enhanced SSO, and Milvus 2.6 in Private Preview.
1 Table = 1000 Words? Foundation Models for Tabular Data
TableGPT2 automates tabular data insights, overcoming schema variability, while Milvus accelerates vector search for efficient, scalable decision-making.
DeepSeek-VL2: Mixture-of-Experts Vision-Language Models for Advanced Multimodal Understanding
Explore DeepSeek-VL2, the open-source MoE vision-language model. Discover its architecture, efficient training pipeline, and top-tier performance.