Criando Aplicações RAG Inteligentes com LangServe, LangGraph e Milvus
Este post do blog é uma continuação do meu artigo anterior sobre Local Agentic RAG com LangGraph e Llama 3.
Neste post do blog, vamos explorar como criar aplicações usando LangServe e LangGraph, duas ferramentas poderosas do ecossistema LangChain. Também usaremos Milvus como o Banco de Dados Vetorial. Mostraremos como configurar uma aplicação FastAPI, configurar LangServe e LangGraph e usar Milvus para recuperação eficiente de dados.
Acompanhe com o tutorial em vídeo
O Que Você Vai Aprender
Configurar uma aplicação FastAPI com LangServe e LangGraph.
Integrar Milvus para armazenamento e recuperação de vetores.
Criar um Agente LLM com LangGraph
Pré-requisitos
Antes de começarmos, certifique-se de ter as seguintes dependências instaladas:
Python 3.9+
Docker
Conhecimento básico de FastAPI e Docker
Introdução ao LangServe e Milvus
LangServe é uma extensão do FastAPI projetada para simplificar a criação de endpoints dinâmicos e poderosos que utilizam LangChain. Ela permite definir fluxos de trabalho de processamento complexos que podem ser expostos como endpoints de API.
LangGraph — Uma extensão do Langchain voltada para a criação de aplicações multiator robustas e com estado usando LLMs, modelando etapas como arestas e nós em um grafo.
Milvus é um banco de dados vetorial de código aberto de alto desempenho criado para escala. Milvus Lite, a versão leve e local do Milvus, pode ser executado no seu dispositivo pessoal sem a necessidade de Docker ou Kubernetes.
Criando Agentes com Chamada de Ferramentas com LangGraph
Em nosso post anterior do blog, discutimos como o LangGraph pode aprimorar significativamente as capacidades dos modelos de linguagem ao permitir chamadas de ferramentas. Aqui, demonstraremos como criar esses agentes com LangServe e implantá-los em várias infraestruturas usando Docker.
Introdução ao RAG Agêntico
Agentes podem transformar modelos de linguagem em mecanismos de raciocínio poderosos que determinam ações, executam-nas e avaliam os resultados. Esse processo é conhecido como RAG Agêntico (Geração Aumentada por Recuperação). Agentes podem:
Realizar pesquisas na web
Navegar por e-mails
Conduzir autorreflexão ou autoavaliação em documentos recuperados
Executar funções personalizadas definidas pelo usuário
E mais…
Configurando Tudo
LangGraph: Uma extensão do LangChain para criar aplicações com estado usando LLMs, utilizando grafos para modelar etapas e decisões.
Ollama e Llama 3: Ollama permite executar modelos de linguagem de código aberto como Llama 3 localmente, possibilitando uso offline e maior controle.
Milvus Lite: Uma versão local do Milvus para armazenamento e recuperação eficientes de vetores, adequada para execução em dispositivos pessoais.
Usando LangServe e Milvus
O LangServe permite expor fluxos de trabalho de processamento complexos como endpoints de API. Mostramos um exemplo para a função analyze_text; aqui, adicionamos o endpoint /analyze ao nosso app FastAPI, o que torna possível consultá-lo.
- Defina sua aplicação 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)
- Integre o LangGraph para gerenciamento de fluxos de trabalho:
Use o LangGraph para criar um agente RAG personalizado com Llama3 que possa lidar com várias tarefas, como encaminhar consultas de usuários para o método de recuperação mais adequado ou realizar autocorreção para melhorar a qualidade das respostas. Fique à vontade para conferir nosso blog sobre LangGraph para ver como você pode fazer isso.
- Utilize o Milvus para recuperação eficiente de dados:
Integre o Milvus para armazenar e recuperar dados vetoriais com eficiência. Esta etapa permitirá acesso rápido a informações relevantes e melhorará o desempenho da sua aplicação.
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}
Fique à vontade para conferir o código no meu GitHub.
Conclusão
Neste post do blog, mostramos como criar um sistema RAG usando agentes com LangServe, LangGraph, Llama 3 e Milvus. Esses agentes aprimoram as capacidades dos LLMs incorporando planejamento, memória e uso de ferramentas, levando a respostas mais robustas e informativas. Ao integrar o LangServe, você pode expor esses fluxos de trabalho sofisticados como endpoints de API, facilitando a criação e a implantação de aplicações inteligentes.
Se você gostou deste post do blog, considere nos dar uma estrela no Github e entrar no nosso Discord para compartilhar suas experiências com a comunidade.
Continue lendo
Stop Building AI Data Infra for the Wrong Stage
Learn how AI data infrastructure should evolve from prototype to enterprise scale, and when Vector Lakebase becomes the right architecture for AI apps.
Balancing Precision and Performance: How Zilliz Cloud's New Parameters Help You Optimize Vector Search
Optimize vector search with Zilliz Cloud’s level and recall features to tune accuracy, balance performance, and power AI applications.
Milvus WebUI: A Visual Management Tool for Your Vector Database
Explore Milvus WebUI to monitor, manage, and optimize your vector database with real-time insights, performance tracking, and system health monitoring.