Cómo crear un agente RAG de LangChain con generación de informes
Una de las partes más importantes de llevar Agentes de IA a producción con tus aplicaciones de generación aumentada por recuperación es monitorear lo que hacen por debajo de la superficie. Hay muchas herramientas de monitoreo disponibles en el mercado, como Arize, TruEra y Portkey. En este ejemplo, creamos un Agente de IA con LangChain, Milvus y OpenAI. Luego, usamos Portkey para monitorear nuestro uso de tokens, recuento de tokens y latencia de solicitudes. Encuentra el código de AI Agents Cookbooks en este repositorio de GitHub.
Introducción al stack tecnológico
Antes de entrar en el código, cubramos brevemente las piezas de este stack tecnológico. En este tutorial, usamos cuatro piezas principales de tecnología: LangChain para orquestar tu aplicación de generación aumentada por recuperación, Milvus como nuestra base de datos vectorial para almacenar y enviar información relevante a uno de tus Modelos de Lenguaje Grandes (LLM) favoritos, Portkey para sistemas de monitoreo y OpenAI para nuestro LLM.
LangChain
LangChain es el framework de orquestación de LLM de código abierto más popular a mayo de 2024. Es uno de los muchos frameworks del mercado para la generación aumentada por recuperación. La especialidad de LangChain es el encadenamiento. Es particularmente adecuado para ensamblar entradas (o datos relevantes) y salidas de modelos de lenguaje grandes (LLMs) y otras funciones relacionadas. Puedes leer más sobre la diferencia entre los tres frameworks populares en este artículo sobre LangChain vs. LlamaIndex vs. Haystack.
Milvus
Milvus es la base de datos vectorial distribuida de código abierto más popular y la única que a menudo se usa para almacenar tus múltiples fuentes de datos al crear aplicaciones de generación aumentada por recuperación. Milvus realiza búsquedas de similitud vectorial particularmente bien en términos de escalabilidad, flexibilidad y características listas para empresas en comparación con otras bases de datos vectoriales. Para este tutorial, ejecutaremos Milvus mediante Docker Compose.
Portkey
Portkey presentó el LLM Gateway de código abierto más popular en mayo de 2024. Es una de las muchas soluciones de monitoreo para aplicaciones LLM. Portkey proporciona monitoreo enrutando llamadas a través de su gateway. Monitorea el costo, el recuento de tokens y la latencia de tus llamadas. Portkey también te permite configurar herramientas auxiliares como una caché semántica, similar a GPTCache.
OpenAI
OpenAI llevó los LLMs a la atención del público general mediante ChatGPT. Desde entonces, ha lanzado varias versiones diferentes de GPT y ha alentado a muchos competidores, como Mistral, Meta AI y otros, a entrar en el mercado.
Creación del agente RAG de LangChain
Ahora que conocemos las principales tecnologías con las que estamos trabajando, construyamos nuestro Agente de generación aumentada por recuperación (RAG) de LangChain. Puedes ejecutar las líneas de abajo en una celda de un notebook de Python, o puedes ejecutarlas directamente en la terminal sin el ! al principio. Necesitamos cinco bibliotecas requeridas y una sexta opcional.
Las cinco bibliotecas requeridas son:
pymilvuspara acciones de Milvuslangchainpara LangChainlangchain-communitypara las integraciones de la comunidad, incluida la integración Milvus + LangChainlangchain-openaipara la biblioteca OpenAI + LangChainunstructuredpara ayudar a cargar los datos
La sexta biblioteca opcional es langchainhub. Usamos esta biblioteca para acceder a los prompts del agente desde LangChain hub, así no tenemos que escribirlos nosotros mismos. El segundo comando, `docker compose up—d', ejecuta el archivo de Docker compose para ejecutar Milvus.
! pip install --upgrade --quiet pymilvus langchain langchain-community langchainhub langchain-openai unstructured
! docker-compose up -d
Configuración
La primera parte de construir nuestro agente RAG es sencilla. Todo lo que hacemos aquí es cargar nuestras variables de entorno y realizar un montón de importaciones. Las dos variables de entorno que necesitaremos son una clave API de Portkey y una clave API de OpenAI. Podemos prescindir de la clave de Portkey si lo alojamos 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"]
Dividiré las importaciones en dos secciones: relacionadas con LangChain y relacionadas con Portkey. Necesitamos nueve importaciones de LangChain. Necesitamos:
- DirectoryLoader para cargar datos desde un directorio especificado
- RecursiveCharacterTextSplitter para dividir el texto en nuestros documentos
- Milvus, para conectarnos a Milvus
- OpenAIEmbeddings para crear vectores de embeddings
hubes el hub de LangChain desde el que obtenemos los promptscreate_retriever_toolpara crear una herramienta que pueda recuperar datos- ChatOpenAI para usar GPT como endpoint de chat
- AgentExecutor para ejecutar un agente
Y
create_openai_tools_agentpara crear un agente a partir de herramientas y el endpoint de OpenAI
Necesitamos tres importaciones para gestionar Portkey: la URL de Portkey Gateway, una función para crear encabezados y la biblioteca UUID para rastrear cada ejecución.
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
Introducir documentos en Milvus
El primer paso para crear un agente RAG es enviar tus fuentes de datos, en este caso, documentos a Milvus. Primero, definimos nuestro divisor de texto. Para este ejemplo, definimos un tamaño de fragmento y una superposición de fragmentos. Estos dos conceptos son lo que usamos para dividir un documento enorme en fragmentos de tamaño razonable. La superposición ayuda a tener en cuenta la recuperación de información contextual y la continuidad.
Una vez que tenemos listo un divisor de texto, cargamos el directorio y lo dividimos en documentos de LangChain usando el divisor de texto. A continuación, definimos nuestra función de embeddings, en este caso usando el modelo de lenguaje OpenAIEmbeddings. Ahora, con el documento y la función de embeddings listos, nos conectamos a Milvus y cargamos los fragmentos con la función de embeddings de 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"})
Crear una herramienta de recuperación para RAG
El primer paso para construir RAG es introducir tus documentos en una base de datos vectorial como Milvus. Al usar un framework como LangChain, el siguiente paso es el componente de recuperación de información, que consiste en convertir las fuentes de datos de la base de datos vectorial en un “retriever”. Este objeto toma automáticamente una cadena, la vectoriza y busca en la base de datos vectorial respuestas relevantes.
Dado que estamos construyendo un agente de IA, debemos convertir nuestro retriever en una herramienta. Crear una herramienta de retriever en LangChain requiere tres parámetros: el propio modelo retriever, el nombre de la herramienta y una descripción de su función.
Ahora, creamos una lista de herramientas y añadimos esta herramienta de retriever. Este paso cobra importancia más adelante.
retriever = db.as_retriever()
tool = create_retriever_tool(
retriever,
"search_cities",
"Searches and returns excerpts from Wikipedia entries of many cities.",
)
tools = [tool]
Configurar el agente RAG
Comenzamos a configurar el agente RAG obteniendo el prompt. Podemos crear un prompt o extraerlo directamente del hub de LangChain, donde Harrison Chase tiene un prompt listo para un agente construido sobre OpenAI. Lo último que debemos crear antes de obtener el LLM son nuestros encabezados de Portkey.
Usamos Portkey aquí para monitorear nuestro uso y revisar detalles internos de nuestras llamadas al LLM, como la latencia, el número de tokens utilizados y el costo. Para nuestros encabezados de Portkey, necesitamos cuatro cosas: la clave API de Portkey, un UUID, el nombre del proveedor del LLM (OpenAI) y una configuración de Portkey. El archivo de configuración puede ser cualquier configuración; puedes crear una configuración predeterminada para el panel de usuario.
A continuación, instanciamos nuestro LLM mediante ChatOpenAI. Necesitamos cuatro parámetros: la clave API de OpenAI, la URL de gateway de Portkey, los encabezados de Portkey y la temperatura del LLM. Con todo esto listo, podemos crear el agente usando create_openai_tools_agent. Solo necesitamos tres parámetros para crear el agente: el LLM, la lista de herramientas y el 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)
Probando el agente RAG
El último paso es crear una función para ejecutar tareas para nuestro agente, y entonces nuestro agente finalmente estará listo para salir al campo. Es un nombre extraño si lo piensas. En fin, la función que puede ejecutar nuestro flujo de trabajo agéntico toma dos parámetros: el agente de herramientas y las propias herramientas.
agent_executor = AgentExecutor(agent=agent, tools=tools)
Con nuestro agente listo para ejecutarse, podemos invocarlo con una entrada. Para este ejemplo, le pedimos que nos obtenga el tamaño de San Francisco.
result = agent_executor.invoke(
{
"input": "What is the size of San Francisco?"
}
)
El agente puede recuperar información de los documentos creados en la página de Wikipedia de San Francisco. Nos dice que el tamaño de San Francisco es de 46,9 millas cuadradas o 121 kilómetros cuadrados.
Para revisar nuestro monitoreo y ver cómo está funcionando nuestro agente RAG de LangChain, podemos simplemente consultar el panel de Portkey. Podemos ver que esta pregunta concreta del agente RAG nos costó 0,1191 centavos, tardó 787 ms y usó 769 tokens.
Resumen de la construcción de un agente RAG de LangChain
Este tutorial nos enseñó cómo construir un agente de IA que hace RAG usando LangChain. Además del agente de IA, podemos monitorear el costo, la latencia y el uso de tokens de nuestro agente usando un gateway. El gateway que elegimos para este tutorial en particular es Portkey.
Hubo cinco pasos para construir, usar y monitorear este agente RAG de LangChain. Primero, tuvimos que pasar por el paso más aburrido: la configuración. Después de tener nuestra configuración básica, importamos nuestro conocimiento externo (documentos) a Milvus para realizar búsqueda semántica y lograr una recuperación eficiente. Luego, convertimos nuestro objeto LangChain Milvus en un recuperador y ese recuperador en una herramienta de recuperación.
Si nos hubiéramos detenido en la fase de recuperación, habríamos tenido la base para un RAG estándar. Crear la herramienta nos permite construir un agente encima de ella. Una vez que la herramienta estuvo lista, definimos un LLM enrutado a través de un gateway (Portkey) y le dimos acceso a las herramientas. Después, le hicimos una pregunta a nuestro agente RAG y obtuvimos una respuesta. Esa ejecución nos dio información sobre cómo el agente ejecutó el LLM y los detalles de las respuestas, el costo, la latencia y el uso de tokens.
Más recursos de Langchain
Sigue leyendo
The AWS Outage Was a Wake-Up Call for Vector Database Cross-Region Disaster Recovery
Zilliz Cloud Had the Answer Before the Crisis. Zilliz Cloud is the world's first vector database with native cross-region disaster recovery.
Zilliz Cloud BYOC Now Available Across AWS, GCP, and Azure
Zilliz Cloud BYOC is now generally available on all three major clouds. Deploy fully managed vector search in your own AWS, GCP, or Azure account — your data never leaves your VPC.
Milvus WebUI: A Visual Management Tool for Your Vector Database
Explore Milvus WebUI to monitor, manage, and optimize your vector database with real-time insights, performance tracking, and system health monitoring.