Entwicklung intelligenter RAG-Anwendungen mit LangServe, LangGraph und Milvus
Dieser Blogbeitrag ist eine Fortsetzung meines vorherigen Artikels über Local Agentic RAG with LangGraph and Llama 3.
In diesem Blogbeitrag werden wir erkunden, wie man Anwendungen mit LangServe und LangGraph erstellt, zwei leistungsstarken Tools aus dem LangChain-Ökosystem. Wir werden außerdem Milvus als Vektordatenbank verwenden. Wir zeigen Ihnen, wie Sie eine FastAPI-Anwendung einrichten, LangServe und LangGraph konfigurieren und Milvus für effizienten Datenabruf nutzen.
Folgen Sie dem Video-Tutorial
Was Sie lernen werden
Einrichtung einer FastAPI-Anwendung mit LangServe und LangGraph.
Integration von Milvus für Vektorspeicherung und -abruf.
Aufbau eines LLM-Agenten mit LangGraph
Voraussetzungen
Bevor wir beginnen, stellen Sie sicher, dass Sie die folgenden Abhängigkeiten installiert haben:
Python 3.9+
Docker
Grundkenntnisse in FastAPI und Docker
Einführung in LangServe & Milvus
LangServe ist eine Erweiterung von FastAPI, die darauf ausgelegt ist, die Erstellung dynamischer und leistungsstarker Endpunkte zu vereinfachen, die LangChain nutzen. Sie ermöglicht es Ihnen, komplexe Verarbeitungsworkflows zu definieren, die als API-Endpunkte bereitgestellt werden können.
LangGraph — Eine Erweiterung von Langchain, die darauf abzielt, robuste und zustandsbehaftete Multi-Akteur-Anwendungen mit LLMs zu erstellen, indem Schritte als Kanten und Knoten in einem Graphen modelliert werden.
Milvus ist eine leistungsstarke Open-Source-Vektordatenbank, die für Skalierung entwickelt wurde. Milvus Lite, die leichtgewichtige und lokale Version von Milvus, kann auf Ihrem persönlichen Gerät ausgeführt werden, ohne dass Docker oder Kubernetes erforderlich sind.
Erstellung von Tool-Calling-Agenten mit LangGraph
In unserem vorherigen Blogbeitrag haben wir besprochen, wie LangGraph die Fähigkeiten von Sprachmodellen durch Tool-Calling erheblich verbessern kann. Hier werden wir demonstrieren, wie man solche Agenten mit LangServe erstellt und sie mithilfe von Docker auf verschiedenen Infrastrukturen bereitstellt.
Einführung in Agentic RAG
Agenten können Sprachmodelle in leistungsstarke Reasoning-Engines verwandeln, die Aktionen bestimmen, ausführen und die Ergebnisse bewerten. Dieser Prozess ist als Agentic RAG (Retrieval Augmented Generation) bekannt. Agenten können:
Websuchen durchführen
E-Mails durchsuchen
Selbstreflexion oder Selbstbewertung abgerufener Dokumente durchführen
Benutzerdefinierte Funktionen ausführen
Und mehr …
Einrichtung
LangGraph: Eine Erweiterung von LangChain zur Erstellung zustandsbehafteter Anwendungen mit LLMs, wobei Graphen zur Modellierung von Schritten und Entscheidungen verwendet werden.
Ollama & Llama 3: Ollama ermöglicht es, Open-Source-Sprachmodelle wie Llama 3 lokal auszuführen, was Offline-Nutzung und größere Kontrolle ermöglicht.
Milvus Lite: Eine lokale Version von Milvus für effiziente Vektorspeicherung und -abruf, geeignet für die Ausführung auf persönlichen Geräten.
Verwendung von LangServe und Milvus
LangServe ermöglicht es Ihnen, komplexe Verarbeitungsworkflows als API-Endpunkte bereitzustellen. Wir zeigen hier ein Beispiel für die Funktion analyze_text; dabei fügen wir unserer FastAPI-App den Endpunkt /analyze hinzu, wodurch es möglich wird, ihn abzufragen.
- Definieren Sie Ihre FastAPI-Anwendung:
import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel
from langchain_core.runnables import RunnableLambda
from langserve import add_routes
# Define Pydantic model for request body
class QuestionRequest(BaseModel):
question: str
fastapi_app = FastAPI()
# Define LangServe route for text analysis
@fastapi_app.post("/analyze")
async def analyze_text(request: QuestionRequest):
# Simulate text analysis (replace with your actual LangServe logic)
entities = ["entity1", "entity2"]
processed_data = f"Processed entities: {entities}"
return {"entities": entities, "processed_data": processed_data}
add_routes(fastapi_app, RunnableLambda(analyze_text))
if __name__ == "__main__":
uvicorn.run(fastapi_app, host="0.0.0.0", port=5001)
- Integrieren Sie LangGraph für das Workflow-Management:
Verwenden Sie LangGraph, um einen benutzerdefinierten, Llama3-gestützten RAG-Agenten zu erstellen, der verschiedene Aufgaben bewältigen kann, z. B. das Weiterleiten von Benutzeranfragen an die am besten geeignete Retrieval-Methode oder die Durchführung von Selbstkorrekturen zur Verbesserung der Antwortqualität. Schauen Sie sich gerne unseren Blog über LangGraph an, um zu sehen, wie Sie das umsetzen können.
- Nutzen Sie Milvus für effizientes Daten-Retrieval:
Integrieren Sie Milvus, um Vektordaten effizient zu speichern und abzurufen. Dieser Schritt ermöglicht einen schnellen Zugriff auf relevante Informationen und verbessert die Leistung Ihrer Anwendung.
from langchain_core.documents import Document
def load_and_split_documents(urls: list[str]) -> list[Document]:
docs = [WebBaseLoader(url).load() for url in urls]
docs_list = [item for sublist in docs for item in sublist]
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(chunk_size=250, chunk_overlap=0)
return text_splitter.split_documents(docs_list)
def add_documents_to_milvus(doc_splits: list[Document], embedding_model: Embeddings, connection_args: Any):
vectorstore = Milvus.from_documents(documents=doc_splits, collection_name="rag_milvus", embedding=embedding_model, connection_args=connection_args)
return vectorstore.as_retriever()
urls = [
"https://lilianweng.github.io/posts/2023-06-23-agent/",
"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/",
"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/",
]
doc_splits = load_and_split_documents(urls)
embedding_model = HuggingFaceEmbeddings()
connection_args = {"uri": "./milvus_rag.db"}
retriever = add_documents_to_milvus(doc_splits, embedding_model, connection_args)
#Function that the Agent will call when needed.
def retrieve(state: Dict[str, Any]) -> Dict[str, Any]:
print("---RETRIEVE---")
question = state["question"]
documents = retriever.invoke(question)
return {"documents": [doc.page_content for doc in documents], "question": question}
Schauen Sie sich gerne den Code auf meinem GitHub an.
Fazit
In diesem Blogbeitrag haben wir gezeigt, wie man ein RAG-System mit Agenten unter Verwendung von LangServe, LangGraph, Llama 3 und Milvus erstellt. Diese Agenten erweitern die Fähigkeiten von LLMs, indem sie Planung, Gedächtnis und Tool-Nutzung einbeziehen, was zu robusteren und informativeren Antworten führt. Durch die Integration von LangServe können Sie diese ausgefeilten Workflows als API-Endpunkte bereitstellen, wodurch das Erstellen und Bereitstellen intelligenter Anwendungen einfacher wird.
Wenn Ihnen dieser Blogbeitrag gefallen hat, geben Sie uns gerne einen Stern auf Github und treten Sie unserem Discord bei, um Ihre Erfahrungen mit der Community zu teilen.
Weiterlesen
Announcing VDBBench 1.0: Open-Source VectorDB Benchmarking with Your Real-World Production Workloads
Discover VDBBench 1.0, an open-source tool for benchmarking vector databases with real-world production data, streaming ingestion, and concurrent workloads.
Balancing Precision and Performance: How Zilliz Cloud's New Parameters Help You Optimize Vector Search
Optimize vector search with Zilliz Cloud’s level and recall features to tune accuracy, balance performance, and power AI applications.
Selecting the Right ETL Tools for Unstructured Data to Prepare for AI
Learn the right ETL tools for unstructured data to power AI. Explore key challenges, tool comparisons, and integrations with Milvus for vector search.