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
Introducing Loon: A New Storage Engine for Vector Data That Never Stops Changing
Loon is a new storage engine for Milvus 3.0 and Zilliz Vector Lakebase, built to manage evolving vector datasets with ColumnGroups, row ID alignment, and Manifests.
Vector Lakebase: End the AI Data Silo
Learn how Vector Lakebase unifies vector search, data lakes, and AI data operations so teams can serve RAG and agents without copy-and-sync pipelines.
Introducing Functions and Model Inference on Zilliz Cloud: Automatic Embedding and Reranking with Hosted Models
Zilliz Cloud Functions auto-generate embeddings via OpenAI, Voyage AI, Cohere, or Zilliz Hosted Models. Built-in reranking — just insert text and search.