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
Build Multimodal Search for 3D Assets with Tripo and Zilliz Cloud
Generate 3D assets with Tripo, then search them by text, image, and metadata with multimodal embeddings and Zilliz Cloud.
Zilliz Cloud Introduces Advanced BYOC-I Solution for Ultimate Enterprise Data Sovereignty
Explore Zilliz Cloud BYOC-I, the solution that balances AI innovation with data control, enabling secure deployments in finance, healthcare, and education sectors.
How to Build RAG with Milvus, QwQ-32B and Ollama
Hands-on tutorial on how to create a streamlined, powerful RAG pipeline that balances efficiency, accuracy, and scalability using the QwQ-32B and Milvus.