Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Frameworks RAG: LangChain, LlamaIndex, Haystack

Aula 18 de 18 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Para Além do RAG Feito à Medida
  2. LangChain com Mistral
  3. LlamaIndex com Mistral
  4. Haystack com Mistral
  5. Qual Escolher
  6. Próximos Passos
  7. Pontos-chave
  8. Teste os Seus Conhecimentos

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.

FrameworkPonto Forte PrincipalCaso de Uso Ideal
LangChainEcossistema mais rico, LangGraph para fluxos de controlo complexosAgentes e RAG avançado
LlamaIndexMais simples para RAG, gestão nativa de documentos estruturadosInício rápido, iniciantes
HaystackAbordagem de pipeline modular, forte em avaliaçãoImplementaçã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.