Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Framework RAG: LangChain, LlamaIndex, Haystack

Lezione 18 di 18 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Oltre il RAG fatto in casa
  2. LangChain con Mistral
  3. LlamaIndex con Mistral
  4. Haystack con Mistral
  5. Quale Scegliere
  6. Prossimi Passi
  7. Punti chiave
  8. Metti alla Prova le Tue Conoscenze

Oltre il RAG fatto in casa

Hai costruito una pipeline RAG completa in puro Python, ed era la strada giusta: ora sai cosa fa ogni riga, dove si nascondono gli errori di allineamento e perché un chunk tagliato male rovina una risposta. In produzione, puoi però affidarti a framework specializzati che gestiscono la parte infrastrutturale e aggiungono funzionalità avanzate. I tre principali—LangChain, LlamaIndex e Haystack—sono tutti compatibili con Mistral AI, e la scelta tra loro dipende meno dalla qualità che dal tipo di applicazione che vuoi realizzare.

LangChain con Mistral

LangChain è il framework più popolare per le applicazioni LLM. Il suo punto di forza principale è l’ampiezza del suo ecosistema di integrazioni, completato dal modulo LangGraph per i flussi di controllo avanzati. L’installazione include il core, il connettore Mistral, le integrazioni della community e FAISS.

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

Il RAG minimale sta poi in una trentina di righe, e l’obiettivo è vedere cosa è scomparso rispetto alla tua implementazione manuale. Batching, retry, conversione in float32, allineamento tra vettori e metadati: tutto questo viene assorbito da FAISS.from_texts. Il RecursiveCharacterTextSplitter sostituisce le tue funzioni di chunking con gli stessi parametri di prima, 1500 caratteri e 200 di sovrapposizione. La catena finale è scritta con l’operatore pipe, che compone i passaggi da sinistra a destra: il retriever fornisce il contesto, RunnablePassthrough fa circolare la domanda così com’è, il prompt li assembla, il modello genera e il parser estrae la stringa.

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

# Modelli Mistral
embeddings = MistralAIEmbeddings(model="mistral-embed")
llm = ChatMistralAI(model="mistral-large-latest", temperature=0.1)

# Suddivisione e indicizzazione
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1500,
    chunk_overlap=200,
)
chunks = splitter.split_text(document_text)

# Creazione del vector store
vectorstore = FAISS.from_texts(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# Catena RAG
prompt = ChatPromptTemplate.from_template(
    """Context: {context}

Question: {question}

Answer based on the context."""
)

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

# Utilizzo
answer = rag_chain.invoke("How does FAISS work?")
print(answer)

LangGraph per RAG Correttivo, Self e Adattivo

La catena lineare sopra funziona per il RAG standard, ma non può creare loop o diramazioni—eppure è esattamente ciò che fanno le architetture delle ultime tre lezioni. LangGraph risponde a questa esigenza definendo i flussi di controllo come grafi. Il GraphState tipizzato agisce come memoria condivisa: ogni nodo lo riceve, legge ciò che gli serve e restituisce i campi che aggiorna. Riconoscerai le tue funzioni dietro retrieve_node, grade_node e generate_node, con grade_document riutilizzato così com’è.

Il meccanismo veramente nuovo è add_conditional_edges. Dove la tua classe Python incatenava istruzioni if, il grafo dichiara una funzione di decisione—qui route_after_grade—e la tabella delle possibili destinazioni. Questa separazione tra la logica di business dei nodi e la topologia del flusso rende la pipeline leggibile a colpo d’occhio e modificabile senza toccare il codice dei singoli passaggi. Una volta compilato, il grafo viene invocato come una semplice funzione.

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 di retrieval."""
    question = state["question"]
    docs = retriever.get_relevant_documents(question)
    return {"documents": docs, "question": question}

def grade_node(state):
    """Nodo di valutazione documenti."""
    question = state["question"]
    docs = state["documents"]
    relevant = []
    web_needed = False

    for doc in docs:
        # Usa l'LLM per valutare la rilevanza
        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 di generazione."""
    question = state["question"]
    docs = state["documents"]
    context = "\n\n".join([d.page_content for d in docs])
    generation = llm.invoke(f"Context: {context}\n\nQuestion: {question}")
    return {"generation": generation.content}

def route_after_grade(state):
    """Decisione condizionale dopo la valutazione."""
    if state["web_search_needed"]:
        return "web_search"
    return "generate"

# Costruzione del grafo
workflow = StateGraph(GraphState)

# Aggiunta dei nodi
workflow.add_node("retrieve", retrieve_node)
workflow.add_node("grade", grade_node)
workflow.add_node("generate", generate_node)

# Definizione del flusso
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)

# Compilazione
app = workflow.compile()

# Esecuzione
result = app.invoke({"question": "How does RAG work?"})
print(result["generation"])

LlamaIndex con Mistral

LlamaIndex spinge l’astrazione oltre, perché è ottimizzato specificamente per il RAG e la gestione strutturata dei documenti.

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

La configurazione avviene tramite un oggetto globale Settings che imposta una volta per tutte il modello di generazione e quello di embedding. SimpleDirectoryReader carica un’intera directory indovinando i formati, e VectorStoreIndex.from_documents incatena chunking e codifica senza che tu debba parametrizzarli. Il guadagno in concisione è reale, ma misura cosa implica: la strategia di suddivisione, che ora sai determinare la qualità del retrieval, qui viene scelta per te. È comodo per iniziare, ed è la prima impostazione che dovrai riprendere in mano il giorno in cui le risposte deluderanno. Nota che response.source_nodes preserva i metadati, da qui la tracciabilità che hai implementato 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

# Configurazione globale
Settings.llm = MistralAI(model="mistral-large-latest", temperature=0.1)
Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")

# Caricamento documenti
documents = SimpleDirectoryReader("./data/").load_data()

# Creazione dell'indice (chunking + embedding automatici)
index = VectorStoreIndex.from_documents(documents)

# Creazione del motore di query
query_engine = index.as_query_engine(similarity_top_k=3)

# Poni una domanda
response = query_engine.query("What are the steps of RAG?")
print(response)
print(f"\nSources: {[n.metadata for n in response.source_nodes]}")

Haystack con Mistral

Haystack, sviluppato da deepset, adotta una terza filosofia: quella delle pipeline modulari, dove ogni componente viene nominato, aggiunto e poi esplicitamente connesso ai suoi vicini.

pip install haystack-ai mistral-haystack

La pipeline di indicizzazione qui sotto illustra bene questo approccio. Tre componenti sono dichiarati—lo splitter, l’encoder tramite MistralDocumentEmbedder e lo scrittore nello store dei documenti—poi collegati da chiamate connect che rendono visibile il flusso dei dati nel codice. Questa verbosità, che può sembrare inutile in un caso semplice, diventa un asset non appena la pipeline si dirama o hai bisogno di sostituire un collegamento senza toccare gli altri. Nota anche la distinzione tra MistralDocumentEmbedder e MistralTextEmbedder: il primo codifica i documenti al momento dell’indicizzazione, il secondo codificherà le query al momento dell’interrogazione, una separazione che previene il classico errore di trattare entrambi allo stesso modo.

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

# Document store
doc_store = InMemoryDocumentStore()

# Pipeline di indicizzazione
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")

Quale Scegliere

Ogni framework ha i suoi punti di forza, e la tabella seguente riassume il compromesso.

FrameworkPunto di Forza PrincipaleCaso d’Uso Ideale
LangChainEcosistema più ricco, LangGraph per flussi di controllo complessiAgenti e RAG avanzato
LlamaIndexIl più semplice per il RAG, gestione nativa di documenti strutturatiAvvio rapido, principianti
HaystackApproccio a pipeline modulare, forte sulla valutazioneDeployment in produzione

Prossimi Passi

Ora hai tutte le basi per costruire sistemi RAG con Mistral AI. Sai come codificare testo con mistral-embed e le sue 1024 dimensioni, codificare codice con codestral-embed e le sue dimensioni configurabili fino a 3072, costruire un RAG da zero su FAISS e l’API Mistral, per poi rafforzarlo con architetture Correttive, Self e Adattive. Questa lezione finale aggiunge il percorso tramite framework: LangChain, LlamaIndex e Haystack.

Per andare oltre, esplora i cookbook ufficiali di Mistral AI così come i notebook per ogni framework, che tengono il passo con l’evoluzione delle API più da vicino di qualsiasi corso. Il RAG è un campo in rapida evoluzione: le tecniche di chunking, retrieval e verifica migliorano costantemente, ed è proprio perché hai scritto ogni passaggio a mano che sarai in grado di valutare il prossimo che apparirà.

Punti chiave

  • LangChain + LangGraph è la scelta primaria per i flussi di controllo RAG avanzati
  • LlamaIndex è il più semplice per il RAG standard con Mistral
  • Haystack eccelle nella modularità e nella valutazione delle pipeline
  • Tutti e tre i framework supportano nativamente mistral-embed e mistral-large
  • Inizia con il RAG fatto in casa per capire, poi migra su un framework per la produzione

Metti alla Prova le Tue Conoscenze

Embedding, RAG e varianti avanzate: il grande esame finale.

1. Quali sono i due modelli di embedding di Mistral e a cosa servono?

Risposta: mistral-embed per il testo generico, codestral-embed per il codice—ciascuno proietta il proprio dominio in uno spazio dove viene misurata la similarità semantica.

2. Quali passaggi compongono la pipeline RAG del corso?

Risposta: Preparazione dati (chunking), creazione embedding, memorizzazione in un vector store (FAISS), poi retrieval + generazione: la domanda trova i suoi passaggi, il modello risponde basandosi su di essi.

3. Cosa risolve il RAG Correttivo?

Risposta: I retrieval scadenti: valuta la rilevanza dei passaggi recuperati e attiva una correzione (nuova ricerca, riformulazione) prima di generare—invece di rispondere sul rumore.

4. Self-RAG e RAG Adattivo: qual è l'idea comune?

Risposta: Rendere la pipeline riflessiva: decidere quando recuperare, criticare i propri output, adattare la strategia alla domanda—il RAG smette di essere un tubo fisso.

5. Cosa portano LangChain, LlamaIndex o Haystack?

Risposta: Strumentazione: componenti pronti per ingestione, indici, catene e valutazione—utili per la velocità, a patto di capire cosa assemblano (cosa che questo corso ti ha insegnato).

Ora sai come costruire un RAG a mano e affidarlo a un framework con piena consapevolezza—questo è l’ordine giusto.