Creare applicazioni RAG intelligenti con LangServe, LangGraph e Milvus

Jun 25, 20244 min read

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

  1. LangGraph: Un'estensione di LangChain per creare applicazioni stateful con LLM, usando grafi per modellare passaggi e decisioni.

  2. Ollama & Llama 3: Ollama consente di eseguire localmente modelli linguistici open-source come Llama 3, permettendo l'uso offline e un maggiore controllo.

  3. 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.

  1. 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)
  1. 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.

  1. 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.

Aggiornato il Jul 09, 2026