Frameworks RAG: LangChain, LlamaIndex, Haystack
Nesta página
Para Além do RAG Feito à Medida
Construiu um pipeline RAG completo em Python puro, e esse foi o caminho correto: agora sabe o que cada linha faz, onde se escondem os erros de alinhamento e por que um fragmento mal dividido arruína uma resposta. Em produção, pode também contar com frameworks especializados que tratam da infraestrutura e adicionam funcionalidades avançadas. Os três principais — LangChain, LlamaIndex e Haystack — são todos compatíveis com a Mistral AI, e a escolha entre eles depende menos da qualidade do que do tipo de aplicação que visa desenvolver.
LangChain com Mistral
O LangChain é o framework mais popular para aplicações de LLM. A sua principal força reside na amplitude do seu ecossistema de integrações, complementado pelo módulo LangGraph para fluxos de controlo avançados. A instalação inclui o núcleo, o conetor Mistral, integrações da comunidade e o FAISS.
pip install langchain langchain-mistralai langchain-community faiss-cpu
O RAG mínimo cabe então em cerca de trinta linhas, e o objetivo é observar o que desapareceu em comparação com a sua implementação manual. O processamento em lote, as novas tentativas, a conversão para float32, o alinhamento entre vetores e metadados: tudo isto é absorvido pelo FAISS.from_texts. O RecursiveCharacterTextSplitter substitui as suas funções de fragmentação com os mesmos parâmetros de antes, 1500 caracteres e 200 de sobreposição. A cadeia final é escrita com o operador pipe, que compõe os passos da esquerda para a direita: o recuperador alimenta o contexto, o RunnablePassthrough faz circular a pergunta tal como está, o prompt reúne-os, o modelo gera e o analisador extrai a cadeia de caracteres.
from langchain_mistralai import ChatMistralAI, MistralAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
# Modelos Mistral
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)
# Divisão e indexação
splitter = RecursiveCharacterTextSplitter(
chunk_size=1500,
chunk_overlap=200,
)
chunks = splitter.split_text(document_text)
# Criar a loja vetorial
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
# Cadeia RAG
prompt = ChatPromptTemplate.from_template(
"""Contexto: {context}
Pergunta: {question}
Responda com base no contexto."""
)
rag_chain = (
{"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# Utilização
answer = rag_chain.invoke("Como funciona o FAISS?")
print(answer)
LangGraph para RAG Corretivo, Automático e Adaptativo
A cadeia linear acima funciona para um RAG padrão, mas não permite loops nem ramificações — no entanto, é exatamente isso que as arquiteturas das últimas três lições fazem. O LangGraph responde a esta necessidade definindo fluxos de controlo como grafos. O GraphState tipificado atua como memória partilhada: cada nó recebe-o, lê o que precisa e devolve os campos que atualizou. Reconhecerá as suas próprias funções por detrás de retrieve_node, grade_node e generate_node, com grade_document reutilizado tal como está.
O mecanismo verdadeiramente novo é o add_conditional_edges. Onde a sua classe Python encadeava instruções if, o grafo declara uma função de decisão — aqui route_after_grade — e a tabela de destinos possíveis. Esta separação entre a lógica de negócio dos nós e a topologia do fluxo torna o pipeline legível à primeira vista e modificável sem tocar no código dos passos. Uma vez compilado, o grafo é invocado como uma função simples.
from langgraph.graph import StateGraph, END
from typing import TypedDict
class GraphState(TypedDict):
question: str
documents: list
generation: str
web_search_needed: bool
def retrieve_node(state):
"""Nó de recuperação."""
question = state["question"]
docs = retriever.get_relevant_documents(question)
return {"documents": docs, "question": question}
def grade_node(state):
"""Nó de avaliação de documentos."""
question = state["question"]
docs = state["documents"]
relevant = []
web_needed = False
for doc in docs:
# Usar o LLM para avaliar a relevância
grade = grade_document(question, doc.page_content)
if grade:
relevant.append(doc)
else:
web_needed = True
return {"documents": relevant, "web_search_needed": web_needed}
def generate_node(state):
"""Nó de geração."""
question = state["question"]
docs = state["documents"]
context = "\n\n".join([d.page_content for d in docs])
generation = llm.invoke(f"Contexto: {context}\n\nPergunta: {question}")
return {"generation": generation.content}
def route_after_grade(state):
"""Decisão condicional após a avaliação."""
if state["web_search_needed"]:
return "web_search"
return "generate"
# Construir o grafo
workflow = StateGraph(GraphState)
# Adicionar nós
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)
# Definir o fluxo
workflow.set_entry_point("retrieve")
workflow.add_edge("retrieve", "grade")
workflow.add_conditional_edges("grade", route_after_grade, {
"generate": "generate",
"web_search": "web_search",
})
workflow.add_edge("generate", END)
# Compilar
app = workflow.compile()
# Executar
result = app.invoke({"question": "Como funciona o RAG?"})
print(result["generation"])
LlamaIndex com Mistral
O LlamaIndex leva a abstração mais longe, pois é otimizado especificamente para RAG e gestão de documentos estruturados.
pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai
A configuração ocorre através de um objeto global Settings que define o modelo de geração e o modelo de incorporação de uma vez por todas. O SimpleDirectoryReader carrega um diretório inteiro adivinhando os formatos, e o VectorStoreIndex.from_documents encadeia a fragmentação e a codificação sem que tenha de as parametrizar. O ganho em concisão é real, mas avalie o que isso implica: a estratégia de divisão, que agora sabe determinar a qualidade da recuperação, é aqui escolhida por si. É confortável para começar, e será a primeira definição que terá de retomar no dia em que as respostas dececionarem. Note que response.source_nodes preserva os metadados, daí a rastreabilidade que implementou manualmente.
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.mistralai import MistralAI
from llama_index.embeddings.mistralai import MistralAIEmbedding
from llama_index.core import Settings
# Configuração global
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")
# Carregar documentos
documents = SimpleDirectoryReader("./data/").load_data()
# Criar o índice (fragmentação + incorporação automáticas)
index = VectorStoreIndex.from_documents(documents)
# Criar o motor de consulta
query_engine = index.as_query_engine(similarity_top_k=3)
# Fazer uma pergunta
response = query_engine.query("Quais são as etapas do RAG?")
print(response)
print(f"\nFontes: {[n.metadata for n in response.source_nodes]}")
Haystack com Mistral
O Haystack, desenvolvido pela deepset, adota uma terceira filosofia: a de pipelines modulares, onde cada componente é nomeado, adicionado e depois explicitamente ligado aos seus vizinhos.
pip install haystack-ai mistral-haystack
O pipeline de indexação abaixo ilustra bem esta abordagem. Três componentes são declarados — o divisor, o codificador via MistralDocumentEmbedder e o escritor para a loja de documentos — e depois ligados por chamadas connect que tornam o fluxo de dados visível no código. Esta verbosidade, que pode parecer desnecessária num caso simples, torna-se um ativo assim que o pipeline se ramifica ou precisa de substituir uma ligação sem tocar nas outras. Note também a distinção entre MistralDocumentEmbedder e MistralTextEmbedder: o primeiro codifica documentos no momento da indexação, o segundo codificará consultas no momento da interrogação, uma separação que previne o erro clássico de tratar ambos da mesma forma.
from haystack import Pipeline
from haystack.components.writers import DocumentWriter
from haystack.components.preprocessors import DocumentSplitter
from haystack_integrations.components.embedders.mistral import (
MistralDocumentEmbedder,
MistralTextEmbedder,
)
from haystack_integrations.components.generators.mistral import MistralChatGenerator
from haystack.document_stores.in_memory import InMemoryDocumentStore
# Loja de documentos
doc_store = InMemoryDocumentStore()
# Pipeline de indexação
indexing_pipeline = Pipeline()
indexing_pipeline.add_component("splitter", DocumentSplitter(
split_by="passage", split_length=5
))
indexing_pipeline.add_component("embedder", MistralDocumentEmbedder(
model="mistral-embed"
))
indexing_pipeline.add_component("writer", DocumentWriter(
document_store=doc_store
))
indexing_pipeline.connect("splitter", "embedder")
indexing_pipeline.connect("embedder", "writer")
Qual Escolher
Cada framework tem os seus pontos fortes, e a tabela abaixo resume o compromisso.
| Framework | Ponto Forte Principal | Caso de Uso Ideal |
|---|---|---|
| LangChain | Ecossistema mais rico, LangGraph para fluxos de controlo complexos | Agentes e RAG avançado |
| LlamaIndex | Mais simples para RAG, gestão nativa de documentos estruturados | Início rápido, iniciantes |
| Haystack | Abordagem de pipeline modular, forte em avaliação | Implementação em produção |
Próximos Passos
Tem agora todas as bases para construir sistemas RAG com a Mistral AI. Sabe como codificar texto com o mistral-embed e as suas 1024 dimensões, codificar código com o codestral-embed e as suas dimensões configuráveis até 3072, construir um RAG do zero no FAISS e na API da Mistral, e depois reforçá-lo com arquiteturas Corretivas, Automáticas e Adaptativas. Esta última lição adiciona o caminho dos frameworks: LangChain, LlamaIndex e Haystack.
Para ir mais longe, explore os cookbooks oficiais da Mistral AI, bem como os notebooks de cada framework, que acompanham a evolução da API mais de perto do que qualquer curso. O RAG é um campo em rápida evolução: as técnicas de fragmentação, recuperação e verificação melhoram constantemente, e é precisamente porque escreveu cada passo à mão que será capaz de avaliar o próximo que surgir.
Pontos-chave
- LangChain + LangGraph é a escolha principal para fluxos de controlo RAG avançados
- LlamaIndex é o mais simples para RAG padrão com Mistral
- Haystack destaca-se na modularidade e avaliação de pipelines
- Os três frameworks suportam nativamente o mistral-embed e o mistral-large
- Comece com RAG feito à medida para compreender, depois migre para um framework para produção
Teste os Seus Conhecimentos
Incorporações, RAG e variantes avançadas: o grande exame final.
1. Quais são os dois modelos de incorporação da Mistral e para que servem?
Resposta: mistral-embed para texto geral, codestral-embed para código — cada um projeta o seu domínio num espaço onde a similaridade semântica é medida.
2. Que etapas compõem o pipeline RAG do curso?
Resposta: Preparar dados (fragmentação), criar incorporações, armazená-las numa loja vetorial (FAISS), depois recuperação + geração: a pergunta encontra os seus trechos, o modelo responde com base neles.
3. O que corrige o RAG Corretivo?
Resposta: Recuperações pobres: avalia a relevância dos trechos recuperados e aciona uma correção (nova pesquisa, reformulação) antes de gerar — em vez de responder com base em ruído.
4. Self-RAG e RAG Adaptativo: qual é a ideia comum?
Resposta: Tornar o pipeline reflexivo: decidir quando recuperar, criticar as suas próprias saídas, adaptar a estratégia à pergunta — o RAG deixa de ser um tubo fixo.
5. O que trazem o LangChain, o LlamaIndex ou o Haystack?
Resposta: Ferramentas: componentes prontos para ingestão, índices, cadeias e avaliação — úteis para velocidade, desde que compreenda o que montam (o que este curso lhe ensinou).
Sabe agora como construir um RAG à mão e confiá-lo a um framework com total consciência — essa é a ordem correta.