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
The AWS Outage Was a Wake-Up Call for Vector Database Cross-Region Disaster Recovery
Zilliz Cloud Had the Answer Before the Crisis. Zilliz Cloud is the world's first vector database with native cross-region disaster recovery.
How to Install and Run OpenClaw (Previously Clawdbot/Moltbot) on Mac
Turn your Mac into an AI gateway for WhatsApp, Telegram, Discord, iMessage, and more — in under 5 minutes.
Zilliz Cloud Update: Smarter Autoscaling for Cost Savings, Stronger Compliance with Audit Logs, and More
What's new in Zilliz Cloud? Smarter autoscaling with scale-down, audit logs GA, enhanced SSO, and Milvus 2.6 in Private Preview.