Creare applicazioni RAG intelligenti con LangServe, LangGraph e Milvus
Questo post del blog è un seguito del mio articolo precedente su Local Agentic RAG with LangGraph and Llama 3.
In questo post del blog, esploreremo come creare applicazioni usando LangServe e LangGraph, due potenti strumenti dell'ecosistema LangChain. Useremo anche Milvus come Vector Database. Ti mostreremo come configurare un'applicazione FastAPI, configurare LangServe e LangGraph e usare Milvus per un recupero dei dati efficiente.
Segui il video tutorial
Cosa imparerai
Configurazione di un'applicazione FastAPI con LangServe e LangGraph.
Integrazione di Milvus per l'archiviazione e il recupero di vettori.
Creazione di un agente LLM con LangGraph
Prerequisiti
Prima di iniziare, assicurati di avere installate le seguenti dipendenze:
Python 3.9+
Docker
Conoscenza di base di FastAPI e Docker
Introduzione a LangServe e Milvus
LangServe è un'estensione di FastAPI progettata per semplificare la creazione di endpoint dinamici e potenti che utilizzano LangChain. Ti consente di definire workflow di elaborazione complessi che possono essere esposti come endpoint API.
LangGraph — Un'estensione di Langchain mirata alla creazione di applicazioni multi-attore robuste e stateful con LLM, modellando i passaggi come archi e nodi in un grafo.
Milvus è un database vettoriale open-source ad alte prestazioni, progettato per la scalabilità. Milvus Lite, la versione leggera e locale di Milvus, può essere eseguita sul tuo dispositivo personale senza bisogno di Docker o Kubernetes.
Creare agenti con tool-calling con LangGraph
Nel nostro post del blog precedente, abbiamo discusso di come LangGraph possa migliorare significativamente le capacità dei modelli linguistici abilitando il tool-calling. Qui dimostreremo come creare tali agenti con LangServe e distribuirli su varie infrastrutture usando Docker.
Introduzione ad Agentic RAG
Gli agenti possono trasformare i modelli linguistici in potenti motori di ragionamento che determinano azioni, le eseguono e valutano i risultati. Questo processo è noto come Agentic RAG (Retrieval Augmented Generation). Gli agenti possono:
Eseguire ricerche sul web
Sfogliare email
Condurre auto-riflessione o autovalutazione sui documenti recuperati
Eseguire funzioni personalizzate definite dall'utente
E altro ancora…
Configurazione
LangGraph: Un'estensione di LangChain per creare applicazioni stateful con LLM, usando grafi per modellare passaggi e decisioni.
Ollama & Llama 3: Ollama consente di eseguire localmente modelli linguistici open-source come Llama 3, permettendo l'uso offline e un maggiore controllo.
Milvus Lite: Una versione locale di Milvus per l'archiviazione e il recupero efficienti di vettori, adatta all'esecuzione su dispositivi personali.
Usare LangServe e Milvus
LangServe ti consente di esporre workflow di elaborazione complessi come endpoint API. Mostriamo un esempio per la funzione analyze_text: qui aggiungiamo l'endpoint /analyze alla nostra app FastAPI, il che rende possibile interrogarlo.
- Definisci la tua applicazione 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)
- Integra LangGraph per la gestione del workflow:
Usa LangGraph per creare un agente RAG personalizzato basato su Llama3 in grado di gestire varie attività, come l'instradamento delle query degli utenti al metodo di retrieval più adatto o l'esecuzione di autocorrezione per migliorare la qualità delle risposte. Sentiti libero di consultare il nostro blog su LangGraph per vedere come puoi farlo.
- Utilizza Milvus per un recupero dei dati efficiente:
Integra Milvus per archiviare e recuperare dati vettoriali in modo efficiente. Questo passaggio consentirà un accesso rapido alle informazioni pertinenti e migliorerà le prestazioni della tua applicazione.
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}
Sentiti libero di consultare il codice sul mio GitHub.
Conclusione
In questo post del blog, abbiamo mostrato come creare un sistema RAG usando agenti con LangServe, LangGraph, Llama 3 e Milvus. Questi agenti migliorano le capacità degli LLM incorporando pianificazione, memoria e uso di strumenti, portando a risposte più solide e informative. Integrando LangServe, puoi esporre questi workflow sofisticati come endpoint API, rendendo più semplice la creazione e il deployment di applicazioni intelligenti.
Se questo post del blog ti è piaciuto, considera di lasciarci una stella su Github e di unirti al nostro Discord per condividere le tue esperienze con la community.
Continua a leggere
Introducing Customer-Managed Encryption Keys (CMEK) on Zilliz Cloud
We're announcing the general availability of Customer-Managed Encryption Keys (CMEK) on Zilliz Cloud.
Zilliz Cloud Audit Logs Goes GA: Security, Compliance, and Transparency at Scale
Zilliz Cloud Audit Logs are now GA, giving enterprises real-time visibility, compliance-ready trails, and stronger security across AWS, GCP, and Azure.
Legal Document Analysis: Harnessing Zilliz Cloud's Semantic Search and RAG for Legal Insights
Enhance legal document analysis with Zilliz Cloud’s Semantic Search and RAG. Improve accuracy, efficiency, and scalability for contracts, case law, and compliance.