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
My Wife Wanted Dior. I Spent $600 on Claude Code to Vibe-Code a 2M-Line Database Instead.
Write tests, not code reviews. How a test-first workflow with 6 parallel Claude Code sessions turns a 2M-line C++ codebase into a daily shipping pipeline.
Zilliz Cloud Introduces Advanced BYOC-I Solution for Ultimate Enterprise Data Sovereignty
Explore Zilliz Cloud BYOC-I, the solution that balances AI innovation with data control, enabling secure deployments in finance, healthcare, and education sectors.
Selecting the Right ETL Tools for Unstructured Data to Prepare for AI
Learn the right ETL tools for unstructured data to power AI. Explore key challenges, tool comparisons, and integrations with Milvus for vector search.