Ir al contenido principal
Español— Elegir un idioma
Menú

Marcos de trabajo RAG: LangChain, LlamaIndex, Haystack

Lección 18 de 18 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Más allá de RAG desde cero
  2. LangChain con Mistral
  3. LlamaIndex con Mistral
  4. Haystack con Mistral
  5. ¿Cuál elegir?
  6. Próximos pasos
  7. Puntos clave
  8. Pon a prueba tus conocimientos

Más allá de RAG desde cero

Has construido una canalización RAG completa en Python puro, y ese era el camino correcto: ahora sabes qué hace cada línea, dónde se ocultan los errores de alineación y por qué un fragmento mal segmentado arruina una respuesta. En producción, también puedes confiar en marcos de trabajo especializados que se encargan de la infraestructura básica y añaden funciones avanzadas. Los tres principales —LangChain, LlamaIndex y Haystack— son compatibles con Mistral AI, y la elección entre ellos depende menos de la calidad que del tipo de aplicación que quieras desarrollar.

LangChain con Mistral

LangChain es el marco de trabajo más popular para aplicaciones de LLM. Su principal fortaleza es la amplitud de su ecosistema de integraciones, complementado por el módulo LangGraph para flujos de control avanzados. La instalación incluye el núcleo, el conector de Mistral, las integraciones de la comunidad y FAISS.

pip install langchain langchain-mistralai langchain-community faiss-cpu

El RAG mínimo cabe en unas treinta líneas, y lo importante es ver qué ha desaparecido en comparación con tu implementación manual. El procesamiento por lotes, los reintentos, la conversión a float32 y la alineación entre vectores y metadatos: todo esto lo absorbe FAISS.from_texts. El RecursiveCharacterTextSplitter sustituye a tus funciones de fragmentación con los mismos parámetros que antes: 1500 caracteres y 200 de solapamiento. La cadena final se escribe con el operador de tubería, que compone los pasos de izquierda a derecha: el recuperador alimenta el contexto, RunnablePassthrough hace circular la pregunta tal cual, el prompt los ensambla, el modelo genera y el analizador extrae la cadena.

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 de Mistral
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)

# Segmentación e indexación
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Crear el almacén vectorial
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# Cadena RAG
prompt = ChatPromptTemplate.from_template(
    """Contexto: {context}

Pregunta: {question}

Responde basándote en el contexto."""
)

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# Uso
answer = rag_chain.invoke("¿Cómo funciona FAISS?")
print(answer)

LangGraph para RAG correctivo, propio y adaptativo

La cadena lineal anterior funciona para un RAG estándar, pero no puede crear bucles ni ramificaciones; sin embargo, eso es exactamente lo que hacen las arquitecturas de las tres lecciones anteriores. LangGraph aborda esta necesidad definiendo flujos de control como grafos. El GraphState tipificado actúa como memoria compartida: cada nodo lo recibe, lee lo que necesita y devuelve los campos que actualiza. Reconocerás tus propias funciones detrás de retrieve_node, grade_node y generate_node, reutilizando grade_document tal cual.

El mecanismo realmente nuevo es add_conditional_edges. Donde tu clase de Python encadenaba sentencias if, el grafo declara una función de decisión —aquí route_after_grade— y la tabla de destinos posibles. Esta separación entre la lógica de negocio de los nodos y la topología del flujo hace que la canalización sea legible de un vistazo y modificable sin tocar el código de los pasos. Una vez compilado, el grafo se invoca como una función simple.

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):
    """Nodo de recuperación."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Nodo de evaluación de documentos."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Usar el LLM para evaluar la relevancia
        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):
    """Nodo de generación."""
    question = state["question"]
    docs = state["documents"]
    context = "\n\n".join([d.page_content for d in docs])
    generation = llm.invoke(f"Contexto: {context}\n\nPregunta: {question}")
    return {"generation": generation.content}

def route_after_grade(state):
    """Decisión condicional tras la evaluación."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Construir el grafo
workflow = StateGraph(GraphState)

# Añadir nodos
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Definir el flujo
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()

# Ejecutar
result = app.invoke({"question": "¿Cómo funciona RAG?"})
print(result["generation"])

LlamaIndex con Mistral

LlamaIndex lleva la abstracción un paso más allá porque está optimizado específicamente para RAG y la gestión de documentos estructurados.

pip install llama-index llama-index-llms-mistralai llama-index-embeddings-mistralai

La configuración se realiza mediante un objeto global Settings que establece el modelo de generación y el de incrustación de una vez por todas. SimpleDirectoryReader carga un directorio completo adivinando los formatos, y VectorStoreIndex.from_documents encadena la fragmentación y la codificación sin que tengas que parametrizarlas. La ganancia en concisión es real, pero mide lo que implica: la estrategia de división, que ahora sabes que determina la calidad de la recuperación, la elige el sistema por ti. Es cómodo para empezar, pero será el primer ajuste que debas retomar el día que las respuestas decepcionen. Ten en cuenta que response.source_nodes conserva los metadatos, de ahí la trazabilidad que implementaste 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

# Configuración global
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")

# Cargar documentos
documents = SimpleDirectoryReader("./data/").load_data()

# Crear el índice (fragmentación + incrustación automáticas)
index = VectorStoreIndex.from_documents(documents)

# Crear el motor de consultas
query_engine = index.as_query_engine(similarity_top_k=3)

# Hacer una pregunta
response = query_engine.query("¿Cuáles son los pasos de RAG?")
print(response)
print(f"\nFuentes: {[n.metadata for n in response.source_nodes]}")

Haystack con Mistral

Haystack, desarrollado por deepset, adopta una tercera filosofía: la de canalizaciones modulares, donde cada componente tiene nombre, se añade y luego se conecta explícitamente a sus vecinos.

pip install haystack-ai mistral-haystack

La siguiente canalización de indexación ilustra bien este enfoque. Se declaran tres componentes —el divisor, el codificador mediante MistralDocumentEmbedder y el escritor hacia el almacén de documentos— y luego se enlazan mediante llamadas connect que hacen visible el flujo de datos en el código. Esta verbosidad, que puede parecer innecesaria en un caso simple, se convierte en una ventaja tan pronto como la canalización se ramifica o necesitas sustituir un enlace sin tocar los demás. Observa también la distinción entre MistralDocumentEmbedder y MistralTextEmbedder: el primero codifica documentos en tiempo de indexación, el segundo codificará consultas en tiempo de interrogación, una separación que evita el error clásico de tratar ambos casos de la misma manera.

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

# Almacén de documentos
doc_store = InMemoryDocumentStore()

# Canalización de indexación
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")

¿Cuál elegir?

Cada marco de trabajo tiene sus puntos fuertes, y la siguiente tabla resume la compensación.

Marco de trabajoPrincipal fortalezaPunto fuerte
LangChainEcosistema más rico, LangGraph para flujos de control complejosAgentes y RAG avanzado
LlamaIndexEl más sencillo para RAG, gestión nativa de documentos estructuradosInicio rápido, principiantes
HaystackEnfoque de canalización modular, sólido en evaluaciónDespliegue en producción

Próximos pasos

Ya tienes todas las bases para construir sistemas RAG con Mistral AI. Sabes cómo codificar texto con mistral-embed y sus 1024 dimensiones, codificar código con codestral-embed y sus dimensiones configurables hasta 3072, construir un RAG desde cero sobre FAISS y la API de Mistral, y luego reforzarlo con arquitecturas Correctivas, Propias y Adaptativas. Esta última lección añade la vía de los marcos de trabajo: LangChain, LlamaIndex y Haystack.

Para ir más allá, explora los libros de cocina oficiales de Mistral AI, así como los cuadernos de cada marco de trabajo, que siguen la evolución de la API más de cerca que cualquier curso. RAG es un campo en rápida evolución: las técnicas de fragmentación, recuperación y verificación mejoran constantemente, y es precisamente porque has escrito cada paso a mano como podrás evaluar la siguiente que aparezca.

Puntos clave

  • LangChain + LangGraph es la elección principal para flujos de control RAG avanzados
  • LlamaIndex es el más sencillo para RAG estándar con Mistral
  • Haystack destaca en modularidad y evaluación de canalizaciones
  • Los tres marcos de trabajo admiten nativamente mistral-embed y mistral-large
  • Empieza con RAG desde cero para entender, luego migra a un marco de trabajo para producción

Pon a prueba tus conocimientos

Incrustaciones, RAG y variantes avanzadas: el gran examen final.

1. ¿Cuáles son los dos modelos de incrustación de Mistral y para qué sirven?

Respuesta: mistral-embed para texto general, codestral-embed para código; cada uno proyecta su dominio en un espacio donde se mide la similitud semántica.

2. ¿Qué pasos componen la canalización RAG del curso?

Respuesta: Preparar datos (fragmentación), crear incrustaciones, almacenarlas en un almacén vectorial (FAISS) y luego recuperación + generación: la pregunta encuentra sus pasajes y el modelo responde basándose en ellos.

3. ¿Qué corrige el RAG correctivo?

Respuesta: Recuperaciones deficientes: evalúa la relevancia de los pasajes recuperados y activa una corrección (nueva búsqueda, reformulación) antes de generar, en lugar de responder sobre ruido.

4. Self-RAG y Adaptive RAG: ¿cuál es la idea común?

Respuesta: Hacer que la canalización sea reflexiva: decidir cuándo recuperar, criticar sus propias salidas, adaptar la estrategia a la pregunta; RAG deja de ser una tubería fija.

5. ¿Qué aportan LangChain, LlamaIndex o Haystack?

Respuesta: Herramientas: componentes listos para ingestión, índices, cadenas y evaluación; útiles para la velocidad, siempre que entiendas qué ensamblan (algo que este curso te ha enseñado).

Ahora sabes cómo construir un RAG a mano y encomendarlo a un marco de trabajo con pleno conocimiento de causa; ese es el orden correcto.