Creación de aplicaciones RAG inteligentes con LangServe, LangGraph y Milvus
Esta publicación de blog es una continuación de mi artículo anterior sobre RAG agéntico local con LangGraph y Llama 3.
En esta publicación de blog, exploraremos cómo crear aplicaciones usando LangServe y LangGraph, dos potentes herramientas del ecosistema de LangChain. También usaremos Milvus como base de datos vectorial. Te mostraremos cómo configurar una aplicación FastAPI, configurar LangServe y LangGraph, y usar Milvus para una recuperación de datos eficiente.
Sigue el videotutorial
Lo que aprenderás
Configurar una aplicación FastAPI con LangServe y LangGraph.
Integrar Milvus para el almacenamiento y la recuperación de vectores.
Crear un agente LLM con LangGraph
Requisitos previos
Antes de empezar, asegúrate de tener instaladas las siguientes dependencias:
Python 3.9+
Docker
Conocimientos básicos de FastAPI y Docker
Introducción a LangServe y Milvus
LangServe es una extensión de FastAPI diseñada para agilizar la creación de endpoints dinámicos y potentes que utilizan LangChain. Te permite definir flujos de trabajo de procesamiento complejos que pueden exponerse como endpoints de API.
LangGraph — Una extensión de Langchain orientada a crear aplicaciones multiagente robustas y con estado con LLMs, modelando los pasos como aristas y nodos en un grafo.
Milvus es una base de datos vectorial de código abierto de alto rendimiento creada para escalar. Milvus Lite, la versión ligera y local de Milvus, puede ejecutarse en tu dispositivo personal sin necesidad de Docker ni Kubernetes.
Creación de agentes con llamada a herramientas con LangGraph
En nuestra publicación de blog anterior, analizamos cómo LangGraph puede mejorar significativamente las capacidades de los modelos de lenguaje al habilitar la llamada a herramientas. Aquí, demostraremos cómo crear tales agentes con LangServe y desplegarlos en diversas infraestructuras usando Docker.
Introducción al RAG agéntico
Los agentes pueden transformar los modelos de lenguaje en potentes motores de razonamiento que determinan acciones, las ejecutan y evalúan los resultados. Este proceso se conoce como RAG agéntico (generación aumentada por recuperación). Los agentes pueden:
Realizar búsquedas web
Navegar por correos electrónicos
Realizar autorreflexión o autoevaluación sobre documentos recuperados
Ejecutar funciones personalizadas definidas por el usuario
Y más…
Configuración inicial
LangGraph: Una extensión de LangChain para crear aplicaciones con estado con LLMs, usando grafos para modelar pasos y decisiones.
Ollama y Llama 3: Ollama permite ejecutar localmente modelos de lenguaje de código abierto como Llama 3, lo que permite el uso sin conexión y un mayor control.
Milvus Lite: Una versión local de Milvus para el almacenamiento y la recuperación eficiente de vectores, adecuada para ejecutarse en dispositivos personales.
Uso de LangServe y Milvus
LangServe te permite exponer flujos de trabajo de procesamiento complejos como endpoints de API. Mostramos un ejemplo para la función analyze_text; aquí, añadimos el endpoint /analyze a nuestra aplicación FastAPI, lo que hace posible consultarlo.
- Define tu aplicación 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 para la gestión de flujos de trabajo:
Usa LangGraph para crear un agente RAG personalizado impulsado por Llama3 que pueda gestionar varias tareas, como dirigir las consultas de los usuarios al método de recuperación más adecuado o realizar autocorrección para mejorar la calidad de las respuestas. No dudes en consultar nuestro blog sobre LangGraph para ver cómo puedes hacerlo.
- Utiliza Milvus para una recuperación de datos eficiente:
Integra Milvus para almacenar y recuperar datos vectoriales de manera eficiente. Este paso permitirá un acceso rápido a información relevante y mejorará el rendimiento de tu aplicación.
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}
No dudes en consultar el código en mi GitHub.
Conclusión
En esta publicación del blog, hemos mostrado cómo crear un sistema RAG usando agentes con LangServe, LangGraph, Llama 3 y Milvus. Estos agentes mejoran las capacidades de los LLM al incorporar planificación, memoria y uso de herramientas, lo que conduce a respuestas más sólidas e informativas. Al integrar LangServe, puedes exponer estos flujos de trabajo sofisticados como endpoints de API, lo que facilita la creación y el despliegue de aplicaciones inteligentes.
Si disfrutaste esta publicación del blog, considera darnos una estrella en Github y unirte a nuestro Discord para compartir tus experiencias con la comunidad.
Sigue leyendo
Why We Built Vector Lakebase: Rethinking Unstructured Data Architecture for AI
Vector Lakebase: a unified, lake-native data foundation for AI workloads — and an answer to what happens after vector databases succeed.
How to Calculate the Total Cost of Your RAG-Based Solutions
In this guide, we’ll break down the main components of RAG costs and show you how to calculate these expenses using the Zilliz RAG Cost Calculator,
How AI Is Transforming Information Retrieval and What’s Next for You
This blog will summarize the monumental changes AI brought to Information Retrieval (IR) in 2024.