Comment créer un agent RAG LangChain avec reporting
L’un des aspects les plus importants du passage d’AI Agents en production avec vos applications de génération augmentée par récupération est de surveiller ce qu’ils font sous la surface. De nombreux outils de surveillance, tels qu’Arize, TruEra et Portkey, sont disponibles sur le marché. Dans cet exemple, nous créons un AI Agent avec LangChain, Milvus et OpenAI. Ensuite, nous utilisons Portkey pour surveiller notre utilisation des tokens, le nombre de tokens et la latence des requêtes. Retrouvez le code des AI Agents Cookbooks dans ce dépôt GitHub.
Introduction à la stack technologique
Avant d’entrer dans le code, couvrons brièvement les éléments de cette stack technologique. Dans ce tutoriel, nous utilisons quatre technologies principales : LangChain pour orchestrer votre application de génération augmentée par récupération, Milvus comme notre base de données vectorielle pour stocker et envoyer des informations pertinentes à l’un de vos grands modèles de langage (LLM) préférés, Portkey pour les systèmes de surveillance, et OpenAI pour notre LLM.
LangChain
LangChain est le framework d’orchestration de LLM open source le plus populaire en mai 2024. C’est l’un des nombreux frameworks du marché pour la génération augmentée par récupération. La spécialité de LangChain est le chaînage. Il est particulièrement adapté à l’assemblage des entrées (ou données pertinentes) et des sorties des grands modèles de langage (LLMs) et d’autres fonctions associées. Vous pouvez en savoir plus sur la différence entre les trois frameworks populaires dans cet article sur LangChain vs. LlamaIndex vs. Haystack.
Milvus
Milvus est la base de données vectorielle open source la plus populaire et la seule distribuée, souvent utilisée pour stocker vos multiples sources de données lors de la création d’applications de génération augmentée par récupération. Milvus effectue particulièrement bien la recherche de similarité vectorielle en termes d’évolutivité, de flexibilité et de fonctionnalités prêtes pour l’entreprise par rapport aux autres bases de données vectorielles. Pour ce tutoriel, nous exécuterons Milvus via Docker Compose.
Portkey
Portkey proposait le LLM Gateway open source le plus populaire en mai 2024. C’est l’une des nombreuses solutions de surveillance pour les applications LLM. Portkey fournit une surveillance en acheminant les appels via sa passerelle. Il surveille le coût, le nombre de tokens et la latence de vos appels. Portkey vous permet également de configurer des outils auxiliaires comme un cache sémantique, similaire à GPTCache.
OpenAI
OpenAI a attiré l’attention du grand public sur les LLMs via ChatGPT. Depuis, ils ont publié plusieurs versions différentes de GPT et encouragé de nombreux concurrents, tels que Mistral, Meta AI et d’autres, à entrer sur le marché.
Création de l’agent RAG LangChain
Maintenant que nous connaissons les principales technologies avec lesquelles nous travaillons, construisons notre agent LangChain de génération augmentée par récupération (RAG). Vous pouvez exécuter les lignes ci-dessous dans une cellule de notebook Python, ou vous pouvez les exécuter directement dans le terminal sans le ! au début. Nous avons besoin de cinq bibliothèques obligatoires et d’une sixième facultative.
Les cinq bibliothèques obligatoires sont :
pymilvuspour les actions Milvuslangchainpour LangChainlangchain-communitypour les intégrations de la communauté, y compris l’intégration Milvus + LangChainlangchain-openaipour la bibliothèque OpenAI + LangChainunstructuredpour aider à charger les données
La sixième bibliothèque facultative est langchainhub. Nous utilisons cette bibliothèque pour accéder aux prompts d’agent depuis le hub LangChain, afin de ne pas avoir à les écrire nous-mêmes. La deuxième commande, `docker compose up—d', exécute le fichier Docker Compose pour lancer Milvus.
! pip install --upgrade --quiet pymilvus langchain langchain-community langchainhub langchain-openai unstructured
! docker-compose up -d
Configuration
La première partie de la création de notre Agent RAG est simple. Tout ce que nous faisons ici consiste à charger nos variables d’environnement et à effectuer un ensemble d’importations. Les deux variables d’environnement dont nous aurons besoin sont une clé API Portkey et une clé API OpenAI. Nous pouvons nous passer de la clé Portkey si nous l’hébergeons localement.
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"]
Je vais diviser les importations en deux sections : celles liées à LangChain et celles liées à Portkey. Nous avons besoin de neuf importations depuis LangChain. Nous avons besoin de :
- DirectoryLoader pour charger des données depuis un répertoire spécifié
- RecursiveCharacterTextSplitter pour diviser le texte de nos documents
- Milvus, pour se connecter à Milvus
- OpenAIEmbeddings pour créer des vecteurs d’embedding
hubest le hub LangChain depuis lequel nous récupérons les promptscreate_retriever_toolpour créer un outil capable de récupérer des données- ChatOpenAI pour utiliser GPT comme endpoint de chat
- AgentExecutor pour exécuter un agent
Et
create_openai_tools_agentpour créer un agent à partir d’outils et de l’endpoint OpenAI
Nous avons besoin de trois importations pour gérer Portkey : l’URL de la passerelle Portkey, une fonction pour créer des en-têtes, et la bibliothèque UUID pour suivre chaque exécution.
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
Importer des documents dans Milvus
La première étape de la création d’un agent RAG consiste à envoyer vos sources de données, dans ce cas des documents, vers Milvus. D’abord, nous définissons notre séparateur de texte. Pour cet exemple, nous définissons une taille de bloc et un chevauchement de blocs. Ces deux concepts sont ce que nous utilisons pour diviser un énorme document en blocs de taille raisonnable. Le chevauchement aide à prendre en compte la récupération d’informations contextuelles et la continuité.
Une fois que nous avons un séparateur de texte prêt, nous chargeons le répertoire et le divisons en documents LangChain à l’aide du séparateur de texte. Ensuite, nous définissons notre fonction d’embedding, dans ce cas en utilisant le modèle de langage OpenAIEmbeddings. Maintenant, avec le document et la fonction d’embeddings prêts, nous nous connectons à Milvus et chargeons les blocs avec la fonction OpenAI embeddings.
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"})
Créer un outil de récupération pour RAG
La première étape de la création de RAG consiste à importer vos documents dans une base de données vectorielle comme Milvus. Lors de l’utilisation d’un framework comme LangChain, l’étape suivante est le composant de récupération d’informations, qui consiste à transformer les sources de données de la base de données vectorielle en un « retriever ». Cet objet prend automatiquement une chaîne, la vectorise et recherche dans la base de données vectorielle des réponses pertinentes.
Puisque nous construisons un Agent IA, nous devons transformer notre retriever en outil. La création d’un outil de récupération dans LangChain nécessite trois paramètres : le modèle de retriever lui-même, le nom de l’outil et une description de sa fonction.
Maintenant, nous créons une liste d’outils et ajoutons cet outil de récupération. Cette étape devient importante plus tard.
retriever = db.as_retriever()
tool = create_retriever_tool(
retriever,
"search_cities",
"Searches and returns excerpts from Wikipedia entries of many cities.",
)
tools = [tool]
Configurer l’Agent RAG
Nous commençons à configurer l’agent RAG en récupérant le prompt. Nous pouvons créer un prompt ou l’extraire directement du hub LangChain, où Harrison Chase dispose d’un prompt prêt pour un agent construit sur OpenAI. La dernière chose que nous devons créer avant de récupérer le LLM est nos en-têtes Portkey.
Nous utilisons Portkey ici pour surveiller notre utilisation et vérifier les détails internes de nos appels LLM, tels que la latence, le nombre de tokens utilisés et le coût. Pour nos en-têtes Portkey, nous avons besoin de quatre choses : la clé API Portkey, un UUID, le nom du fournisseur LLM (OpenAI) et une configuration Portkey. Le fichier de configuration peut être n’importe quelle configuration ; vous pouvez créer une configuration par défaut pour le tableau de bord utilisateur.
Ensuite, nous instancions notre LLM via ChatOpenAI. Nous avons besoin de quatre paramètres : la clé API OpenAI, l’URL de la passerelle Portkey, les en-têtes Portkey et la température du LLM. Une fois tout cela prêt, nous pouvons créer l’agent en utilisant create_openai_tools_agent. Nous n’avons besoin que de trois paramètres pour créer l’agent : le LLM, la liste des outils et le 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)
Essayer l’agent RAG
La dernière étape consiste à créer une fonction pour exécuter des tâches pour notre agent, puis notre agent est enfin prêt pour le terrain. C’est un nom étrange quand on y pense. Quoi qu’il en soit, la fonction qui peut exécuter notre workflow agentique prend deux paramètres : l’agent outil et les outils eux-mêmes.
agent_executor = AgentExecutor(agent=agent, tools=tools)
Notre agent étant prêt à s’exécuter, nous pouvons l’invoquer avec une entrée. Pour cet exemple, nous lui demandons de nous donner la superficie de San Francisco.
result = agent_executor.invoke(
{
"input": "What is the size of San Francisco?"
}
)
L’agent peut récupérer des informations à partir des documents créés sur la page Wikipedia de San Francisco. Il nous indique que la superficie de San Francisco est de 46,9 miles carrés ou 121 kilomètres carrés.
Pour vérifier notre surveillance et voir comment se comporte notre agent RAG LangChain, nous pouvons simplement consulter le tableau de bord Portkey. Nous pouvons voir que cette question particulière posée à l’agent RAG nous a coûté 0,1191 centime, a pris 787 ms et a utilisé 769 tokens.
Résumé de la création d’un agent RAG LangChain
Ce tutoriel nous a appris à créer un agent IA qui fait du RAG en utilisant LangChain. En plus de l’agent IA, nous pouvons surveiller le coût, la latence et l’utilisation des tokens de notre agent à l’aide d’une passerelle. La passerelle que nous avons choisie pour ce tutoriel particulier est Portkey.
Il y avait cinq étapes pour créer, utiliser et surveiller cet agent RAG LangChain. Tout d’abord, nous avons dû passer par l’étape la plus ennuyeuse : la configuration. Après avoir effectué notre configuration de base, nous avons importé nos connaissances externes (documents) dans Milvus afin d’effectuer une recherche sémantique pour une récupération efficace. Ensuite, nous avons transformé notre objet LangChain Milvus en récupérateur, puis ce récupérateur en outil de récupération.
Si nous nous étions arrêtés à la phase de récupération, nous aurions eu la base d’un RAG standard. La création de l’outil nous permet de construire un agent par-dessus. Une fois l’outil prêt, nous avons défini un LLM routé via une passerelle (Portkey) et lui avons donné accès aux outils. Ensuite, nous avons posé une question à notre agent RAG et obtenu une réponse. Cette exécution nous a donné un aperçu de la manière dont l’agent a exécuté le LLM et des détails des réponses, du coût, de la latence et de l’utilisation des tokens.
Plus de ressources Langchain
Continuer à lire
Zilliz Cloud Launches in AWS Australia, Expanding Global Reach to Australia and Neighboring Markets
We're thrilled to announce that Zilliz Cloud is now available in the AWS Sydney, Australia region (ap-southeast-2).
AI Agents Are Quietly Transforming E-Commerce — Here’s How
Discover how AI agents transform e-commerce with autonomous decision-making, enhanced product discovery, and vector search capabilities for today's retailers.
Vector Databases vs. Document Databases
Use a vector database for similarity search and AI-powered applications; use a document database for flexible schema and JSON-like data storage.