So erstellen Sie einen LangChain-RAG-Agenten mit Reporting
Einer der wichtigsten Aspekte beim Überführen von AI Agents in die Produktion mit Ihren Retrieval-Augmented-Generation-Anwendungen ist die Überwachung dessen, was sie unter der Oberfläche tun. Viele Monitoring-Tools wie Arize, TruEra und Portkey sind auf dem Markt verfügbar. In diesem Beispiel erstellen wir einen AI Agent mit LangChain, Milvus und OpenAI. Anschließend verwenden wir Portkey, um unsere Token-Nutzung, Token-Anzahl und Anfrage-Latenz zu überwachen. Den Code für AI Agents Cookbooks finden Sie in diesem GitHub-Repo.
Einführung in den Tech-Stack
Bevor wir in den Code einsteigen, behandeln wir kurz die Bestandteile dieses Tech-Stacks. In diesem Tutorial verwenden wir vier zentrale Technologien: LangChain zur Orchestrierung Ihrer Retrieval-Augmented-Generation-App, Milvus als unsere Vektordatenbank, um relevante Informationen zu speichern und an eines Ihrer bevorzugten Large Language Models (LLM) zu senden, Portkey für Monitoring-Systeme und OpenAI für unser LLM.
LangChain
LangChain ist Stand Mai 2024 das beliebteste Open-Source-LLM-Orchestrierungsframework. Es ist eines von vielen Frameworks auf dem Markt für Retrieval Augmented Generation. Die Spezialität von LangChain ist das Verketten. Es eignet sich besonders zum Zusammenstellen von Eingaben (oder relevanten Daten) und Ausgaben großer Sprachmodelle (LLMs) und anderer verwandter Funktionen. Mehr über den Unterschied zwischen den drei beliebten Frameworks erfahren Sie in diesem Artikel über LangChain vs. LlamaIndex vs. Haystack.
Milvus
Milvus ist die beliebteste Open-Source- und einzige verteilte Vektordatenbank, die häufig verwendet wird, um Ihre verschiedenen Datenquellen beim Erstellen von Retrieval-Augmented-Generation-Anwendungen zu speichern. Milvus führt Vektor-Ähnlichkeitssuche im Hinblick auf Skalierbarkeit, Flexibilität und unternehmensreife Funktionen im Vergleich zu anderen Vektordatenbanken besonders gut aus. Für dieses Tutorial führen wir Milvus über Docker Compose aus.
Portkey
Portkey verfügte im Mai 2024 über das beliebteste Open-Source-LLM Gateway. Es ist eine von vielen Monitoring-Lösungen für LLM-Anwendungen. Portkey stellt Monitoring bereit, indem es Aufrufe durch sein Gateway leitet. Es überwacht die Kosten, die Token-Anzahl und die Latenz Ihrer Aufrufe. Portkey ermöglicht Ihnen außerdem, zusätzliche Tools wie einen semantischen Cache zu konfigurieren, ähnlich wie GPTCache.
OpenAI
OpenAI hat LLMs über ChatGPT ins Bewusstsein der breiten Öffentlichkeit gerückt. Seitdem haben sie mehrere verschiedene Versionen von GPT veröffentlicht und viele Wettbewerber wie Mistral, Meta AI und andere dazu angeregt, in den Markt einzutreten.
Aufbau des LangChain-RAG-Agenten
Da wir nun die wichtigsten Technologien kennen, mit denen wir arbeiten, bauen wir unseren LangChain Retrieval Augmented Generation (RAG) Agent. Sie können die folgenden Zeilen in einer Python-Notebook-Zelle ausführen, oder Sie können sie direkt im Terminal ohne das ! am Anfang ausführen. Wir benötigen fünf erforderliche Bibliotheken und eine optionale sechste.
Die fünf erforderlichen Bibliotheken sind:
pymilvusfür Milvus-Aktionenlangchainfür LangChainlangchain-communityfür die Community-Integrationen, einschließlich der Milvus- + LangChain-Integrationlangchain-openaifür die OpenAI- + LangChain-Bibliothekunstructuredzur Unterstützung beim Laden der Daten
Die sechste optionale Bibliothek ist langchainhub. Wir verwenden diese Bibliothek, um auf die Agent-Prompts aus dem LangChain Hub zuzugreifen, damit wir sie nicht selbst schreiben müssen. Der zweite Befehl, `docker compose up—d', führt die Docker-Compose-Datei aus, um Milvus zu starten.
! pip install --upgrade --quiet pymilvus langchain langchain-community langchainhub langchain-openai unstructured
! docker-compose up -d
Einrichtung
Der erste Teil beim Aufbau unseres RAG-Agenten ist einfach. Alles, was wir hier tun, ist, unsere Umgebungsvariablen zu laden und eine Reihe von Imports durchzuführen. Die zwei Umgebungsvariablen, die wir benötigen, sind ein Portkey-API-Schlüssel und ein OpenAI-API-Schlüssel. Auf den Portkey-Schlüssel können wir verzichten, wenn wir ihn lokal hosten.
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"]
Ich werde die Imports in zwei Abschnitte aufteilen: LangChain-bezogen und Portkey-bezogen. Wir benötigen neun Imports von LangChain. Wir brauchen:
- DirectoryLoader, um Daten aus einem angegebenen Verzeichnis zu laden
- RecursiveCharacterTextSplitter, um den Text in unseren Dokumenten aufzuteilen
- Milvus, um eine Verbindung zu Milvus herzustellen
- OpenAIEmbeddings, um Embedding-Vektoren zu erstellen
hubist der LangChain-Hub, aus dem wir die Prompts beziehencreate_retriever_toolzum Erstellen eines Tools, das Daten abrufen kann- ChatOpenAI, um GPT als Chat-Endpunkt zu verwenden
- AgentExecutor, um einen Agenten auszuführen
Und
create_openai_tools_agent, um aus Tools und dem OpenAI-Endpunkt einen Agenten zu erstellen
Wir benötigen drei Imports, um Portkey zu verwalten: die Portkey-Gateway-URL, eine Funktion zum Erstellen von Headern und die UUID-Bibliothek, um jeden Lauf zu verfolgen.
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
Dokumente in Milvus übertragen
Der erste Schritt beim Erstellen eines RAG-Agenten besteht darin, Ihre Datenquellen, in diesem Fall Dokumente, an Milvus zu senden. Zuerst definieren wir unseren Text-Splitter. Für dieses Beispiel definieren wir eine Chunk-Größe und eine Chunk-Überlappung. Diese beiden Konzepte verwenden wir, um ein riesiges Dokument in angemessen große Chunks aufzuteilen. Die Überlappung hilft dabei, kontextbezogene Informationsabfrage und Kontinuität zu berücksichtigen.
Sobald wir einen Text-Splitter bereit haben, laden wir das Verzeichnis und teilen es mithilfe des Text-Splitters in LangChain-Dokumente auf. Als Nächstes definieren wir unsere Embedding-Funktion, in diesem Fall unter Verwendung des Sprachmodells OpenAIEmbeddings. Nun, da Dokumente und Embedding-Funktion bereit sind, verbinden wir uns mit Milvus und laden die Chunks mit der Funktion für 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"})
Ein Retriever-Tool für RAG erstellen
Schritt eins beim Aufbau von RAG besteht darin, Ihre Dokumente in eine Vektordatenbank wie Milvus zu bringen. Wenn man ein Framework wie LangChain verwendet, ist der nächste Schritt die Komponente zur Informationsabfrage, die darin besteht, die Datenquellen der Vektordatenbank in einen „Retriever“ umzuwandeln. Dieses Objekt nimmt automatisch einen String, vektorisiert ihn und durchsucht die Vektordatenbank nach relevanten Antworten.
Da wir einen KI-Agenten erstellen, müssen wir unseren Retriever in ein Tool umwandeln. Das Erstellen eines Retriever-Tools in LangChain erfordert drei Parameter: das Retriever-Modell selbst, den Namen des Tools und eine Beschreibung seiner Funktion.
Nun erstellen wir eine Liste von Tools und fügen dieses Retriever-Tool hinzu. Dieser Schritt wird später wichtig.
retriever = db.as_retriever()
tool = create_retriever_tool(
retriever,
"search_cities",
"Searches and returns excerpts from Wikipedia entries of many cities.",
)
tools = [tool]
Einrichten des RAG-Agenten
Wir beginnen mit der Einrichtung des RAG-Agenten, indem wir den Prompt abrufen. Wir können einen Prompt erstellen oder ihn direkt aus dem LangChain Hub ziehen, wo Harrison Chase einen Prompt für einen auf OpenAI aufgebauten Agenten bereitgestellt hat. Das Letzte, was wir erstellen müssen, bevor wir das LLM abrufen, sind unsere Portkey-Header.
Wir verwenden Portkey hier, um unsere Nutzung zu überwachen und interne Details unserer LLM-Aufrufe zu prüfen, wie etwa Latenz, Anzahl der verwendeten Token und Kosten. Für unsere Portkey-Header benötigen wir vier Dinge: den Portkey API Key, eine UUID, den Namen des LLM-Anbieters (OpenAI) und eine Portkey-Konfiguration. Die Konfigurationsdatei kann eine beliebige Konfiguration sein; du kannst eine Standardkonfiguration für das Benutzer-Dashboard erstellen.
Als Nächstes instanziieren wir unser LLM über ChatOpenAI. Wir benötigen vier Parameter: den OpenAI API Key, die Portkey-Gateway-URL, die Portkey-Header und die Temperatur des LLM. Wenn all dies bereit ist, können wir den Agenten mit create_openai_tools_agent erstellen. Wir benötigen nur drei Parameter, um den Agenten zu erstellen: das LLM, die Tool-Liste und den 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)
Den RAG-Agenten ausprobieren
Der letzte Schritt besteht darin, eine Funktion zu erstellen, die Aufgaben für unseren Agenten ausführt, und dann ist unser Agent endlich bereit für den Einsatz. Es ist ein seltsamer Name, wenn man darüber nachdenkt. Jedenfalls nimmt die Funktion, die unseren agentischen Workflow ausführen kann, zwei Parameter entgegen: den Tool-Agenten und die Tools selbst.
agent_executor = AgentExecutor(agent=agent, tools=tools)
Da unser Agent nun bereit zur Ausführung ist, können wir ihn mit einer Eingabe aufrufen. Für dieses Beispiel bitten wir ihn, uns die Größe von San Francisco zu nennen.
result = agent_executor.invoke(
{
"input": "What is the size of San Francisco?"
}
)
Der Agent kann Informationen aus den Dokumenten abrufen, die auf der Wikipedia-Seite von San Francisco erstellt wurden. Er teilt uns mit, dass die Größe von San Francisco 46,9 Quadratmeilen oder 121 Quadratkilometer beträgt.
Um unser Monitoring zu prüfen und zu sehen, wie unser LangChain RAG Agent abschneidet, können wir einfach das Dashboard von Portkey aufrufen. Wir sehen, dass diese spezielle Frage an den RAG-Agenten uns 0,1191 Cent gekostet hat, 787 ms dauerte und 769 Token verwendet hat.
Zusammenfassung zum Erstellen eines LangChain RAG Agent
In diesem Tutorial haben wir gelernt, wie man einen AI Agent erstellt, der RAG mit LangChain durchführt. Zusätzlich zum AI Agent können wir die Kosten, Latenz und Token-Nutzung unseres Agenten mithilfe eines Gateways überwachen. Das Gateway, das wir für dieses spezielle Tutorial ausgewählt haben, ist Portkey.
Es gab fünf Schritte beim Erstellen, Verwenden und Überwachen dieses LangChain RAG Agent. Zuerst mussten wir den langweiligsten Schritt durchlaufen – die Einrichtung. Nachdem unsere grundlegende Einrichtung abgeschlossen war, importierten wir unser externes Wissen (Dokumente) in Milvus, um semantische Suche für effizientes Retrieval durchzuführen. Dann verwandelten wir unser LangChain Milvus-Objekt in einen Retriever und diesen Retriever in ein Retriever-Tool.
Wenn wir bei der Retrieval-Phase aufgehört hätten, hätten wir die Grundlage für Standard-RAG gehabt. Das Erstellen des Tools ermöglicht es uns, darauf einen Agenten aufzubauen. Nachdem das Tool bereit war, definierten wir ein LLM, das über ein Gateway (Portkey) geroutet wird, und gaben ihm Zugriff auf die Tools. Als Nächstes stellten wir unserem RAG Agent eine Frage und erhielten eine Antwort. Dieser Durchlauf gab uns Einblick darin, wie der Agent das LLM ausführte, sowie in die Details der Antworten, die Kosten, die Latenz und die Token-Nutzung.
Weitere Langchain-Ressourcen
Weiterlesen
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.
Milvus 2.6.x Now Generally Available on Zilliz Cloud, Making Vector Search Faster, Smarter, and More Cost-Efficient for Production AI
Milvus 2.6.x is now GA on Zilliz Cloud, delivering faster vector search, smarter hybrid queries, and lower costs for production RAG and AI applications.
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.