Créer des applications RAG intelligentes avec LangServe, LangGraph et Milvus
Cet article de blog fait suite à mon précédent article sur Local Agentic RAG with LangGraph and Llama 3.
Dans cet article de blog, nous allons explorer comment créer des applications à l’aide de LangServe et LangGraph, deux outils puissants de l’écosystème LangChain. Nous utiliserons également Milvus comme base de données vectorielle. Nous vous montrerons comment configurer une application FastAPI, configurer LangServe et LangGraph, et utiliser Milvus pour une récupération efficace des données.
Suivez le tutoriel vidéo
Ce que vous apprendrez
Configurer une application FastAPI avec LangServe et LangGraph.
Intégrer Milvus pour le stockage et la récupération vectoriels.
Créer un agent LLM avec LangGraph
Prérequis
Avant de commencer, assurez-vous d’avoir installé les dépendances suivantes :
Python 3.9+
Docker
Connaissances de base de FastAPI et Docker
Introduction à LangServe et Milvus
LangServe est une extension de FastAPI conçue pour simplifier la création d’endpoints dynamiques et puissants qui utilisent LangChain. Elle vous permet de définir des workflows de traitement complexes pouvant être exposés sous forme d’endpoints d’API.
LangGraph — Une extension de Langchain destinée à créer des applications multi-acteurs robustes et avec état avec des LLM, en modélisant les étapes sous forme d’arêtes et de nœuds dans un graphe.
Milvus est une base de données vectorielle open source haute performance conçue pour passer à l’échelle. Milvus Lite, la version légère et locale de Milvus, peut être exécutée sur votre appareil personnel sans avoir besoin de Docker ou Kubernetes.
Créer des agents avec appel d’outils avec LangGraph
Dans notre précédent article de blog, nous avons expliqué comment LangGraph peut améliorer considérablement les capacités des modèles de langage en permettant l’appel d’outils. Ici, nous montrerons comment créer de tels agents avec LangServe et les déployer sur diverses infrastructures à l’aide de Docker.
Introduction à Agentic RAG
Les agents peuvent transformer les modèles de langage en puissants moteurs de raisonnement qui déterminent des actions, les exécutent et évaluent les résultats. Ce processus est connu sous le nom d’Agentic RAG (Retrieval Augmented Generation). Les agents peuvent :
Effectuer des recherches web
Parcourir des e-mails
Mener une auto-réflexion ou une auto-évaluation sur les documents récupérés
Exécuter des fonctions personnalisées définies par l’utilisateur
Et plus encore…
Mise en place
LangGraph : Une extension de LangChain pour créer des applications avec état avec des LLM, en utilisant des graphes pour modéliser les étapes et les décisions.
Ollama & Llama 3 : Ollama permet d’exécuter localement des modèles de langage open source comme Llama 3, permettant une utilisation hors ligne et un meilleur contrôle.
Milvus Lite : Une version locale de Milvus pour un stockage et une récupération vectoriels efficaces, adaptée à l’exécution sur des appareils personnels.
Utiliser LangServe et Milvus
LangServe vous permet d’exposer des workflows de traitement complexes sous forme de points de terminaison d’API. Nous montrons ici un exemple pour la fonction analyze_text ; nous ajoutons le point de terminaison /analyze à notre application FastAPI, ce qui permet de l’interroger.
- Définissez votre application FastAPI :
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)
- Intégrez LangGraph pour la gestion des workflows :
Utilisez LangGraph pour créer un agent RAG personnalisé propulsé par Llama3, capable de gérer diverses tâches, telles que l’orientation des requêtes des utilisateurs vers la méthode de récupération la plus appropriée ou l’exécution d’une autocorrection pour améliorer la qualité des réponses. N’hésitez pas à consulter notre blog sur LangGraph pour voir comment vous pouvez procéder.
- Utilisez Milvus pour une récupération efficace des données :
Intégrez Milvus pour stocker et récupérer efficacement les données vectorielles. Cette étape permettra un accès rapide aux informations pertinentes et améliorera les performances de votre application.
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}
N’hésitez pas à consulter le code sur mon GitHub.
Conclusion
Dans cet article de blog, nous avons montré comment créer un système RAG utilisant des agents avec LangServe, LangGraph, Llama 3 et Milvus. Ces agents améliorent les capacités des LLM en intégrant la planification, la mémoire et l’utilisation d’outils, ce qui conduit à des réponses plus robustes et plus informatives. En intégrant LangServe, vous pouvez exposer ces workflows sophistiqués sous forme de points de terminaison d’API, ce qui facilite la création et le déploiement d’applications intelligentes.
Si vous avez apprécié cet article de blog, envisagez de nous attribuer une étoile sur Github et de rejoindre notre Discord pour partager vos expériences avec la communauté.
Continuer à lire
VDBBench Adds Cost-Aware Benchmarking for Vector Databases
Compare Zilliz Cloud, Pinecone, and turbopuffer with VDBBench cost-aware vector database benchmarks across latency, freshness, multitenancy, and cold starts.
How Zilliz Ended Up at the Center of NVIDIA’s Unstructured Data Story at GTC 2026
If unstructured data is the context of AI, then the ceiling of AI applications will be set not just by models, but by how mature the infrastructure for unstructured data becomes.
What is the K-Nearest Neighbors (KNN) Algorithm in Machine Learning?
KNN is a supervised machine learning technique and algorithm for classification and regression. This post is the ultimate guide to KNN.