Criando Aplicações RAG Inteligentes com LangServe, LangGraph e Milvus

Jun 25, 20244 min read

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

  1. LangGraph: Uma extensão do LangChain para criar aplicações com estado usando LLMs, utilizando grafos para modelar etapas e decisões.

  2. Ollama e Llama 3: Ollama permite executar modelos de linguagem de código aberto como Llama 3 localmente, possibilitando uso offline e maior controle.

  3. 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.

  1. 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)
  1. 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.

  1. 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.

Atualizado em Jul 09, 2026