# Comparaison des frameworks RAG

Choisissez le bon framework Retrieval-Augmented Generation (RAG) pour votre projet sur les serveurs GPU Clore.ai.

{% hint style="info" %}
**RAG (Retrieval-Augmented Generation)** permet aux LLM de répondre à des questions en utilisant vos propres documents. Ce guide compare les quatre principaux frameworks : LangChain, LlamaIndex, Haystack et RAGFlow — en couvrant les fonctionnalités, les performances et quand utiliser chacun.
{% endhint %}

***

## Matrice de décision rapide

|                            | LangChain                  | LlamaIndex         | Haystack               | RAGFlow          |
| -------------------------- | -------------------------- | ------------------ | ---------------------- | ---------------- |
| **Meilleur pour**          | Applications LLM générales | Q\&R sur documents | Recherche d'entreprise | RAG auto-hébergé |
| **Courbe d'apprentissage** | Moyen                      | Faible-Moyenne     | Moyenne-Élevée         | Faible           |
| **Flexibilité**            | Très élevée                | Élevée             | Élevée                 | Moyen            |
| **Interface intégrée**     | Non                        | Non                | Non                    | Oui              |
| **Étoiles GitHub**         | 90K+                       | 35K+               | 15K+                   | 12K+             |
| **Langue**                 | Python                     | Python             | Python                 | Python           |
| **Licence**                | MIT                        | MIT                | Apache 2.0             | Apache 2.0       |

***

## Aperçu

### LangChain

LangChain est le framework d'orchestration de LLM le plus populaire. Il fournit une interface unifiée pour les chaînes, les agents, la mémoire et les pipelines RAG.

**Philosophie**: Tout est une chaîne de composants composables.

```python
from langchain.chains import RetrievalQA
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI

# Construire un pipeline RAG en 5 lignes
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(docs, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
chain = RetrievalQA.from_chain_type(llm=OpenAI(), retriever=retriever)
result = chain.run("Quelle est la capitale de la France ?")
```

### LlamaIndex

LlamaIndex (anciennement GPT Index) est conçu spécifiquement pour l'indexation et la récupération de documents. Il excelle à connecter les LLM à diverses sources de données.

**Philosophie**: Indexer d'abord, interroger intelligemment.

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Charger et indexer des documents
documents = SimpleDirectoryReader("data/").load_data()
index = VectorStoreIndex.from_documents(documents)

# Requête
query_engine = index.as_query_engine()
response = query_engine.query("Résumez les principales conclusions")
print(response)
```

### Haystack

Haystack (par deepset) est un framework NLP de niveau entreprise axé sur la recherche et les pipelines Q\&R. Il possède une architecture par composants avec un constructeur de pipeline visuel.

**Philosophie**: Pipelines modulaires avec fiabilité d'entreprise.

```python
from haystack.nodes import DensePassageRetriever, FARMReader
from haystack.pipelines import ExtractiveQAPipeline

retriever = DensePassageRetriever(document_store=document_store)
reader = FARMReader(model_name_or_path="deepset/roberta-base-squad2")
pipeline = ExtractiveQAPipeline(reader, retriever)
result = pipeline.run(query="Qu'est-ce que l'apprentissage automatique ?", params={"Retriever": {"top_k": 10}})
```

### RAGFlow

RAGFlow est un moteur RAG open-source avec une interface web intégrée, un parsing de documents et une gestion de base de connaissances. Il est conçu pour être déployé comme solution complète.

**Philosophie**: Système RAG prêt à l'emploi, aucun codage requis.

```yaml
# RAGFlow est déployé via Docker Compose
# Configuration via l'interface web à localhost:80
version : "3"
services:
  ragflow :
    image : infiniflow/ragflow:latest
    ports:
      - "80:80"
    volumes:
      - ./ragflow-data:/ragflow/data
```

***

## Comparaison des fonctionnalités

### Fonctionnalités RAG principales

| Fonctionnalité                  | LangChain | LlamaIndex | Haystack | RAGFlow |
| ------------------------------- | --------- | ---------- | -------- | ------- |
| Support des magasins vectoriels | 50+       | 30+        | 20+      | Intégré |
| Chargeurs de documents          | 100+      | 50+        | 30+      | Intégré |
| Recherche hybride               | ✅         | ✅          | ✅        | ✅       |
| Réordonnancement (re-ranking)   | ✅         | ✅          | ✅        | ✅       |
| Multi-modal                     | ✅         | ✅          | Partiel  | ✅       |
| Streaming                       | ✅         | ✅          | ✅        | ✅       |
| Support asynchrone              | ✅         | ✅          | ✅        | ✅       |
| Agents                          | ✅         | ✅          | ✅        | ❌       |

### Écosystème d'intégration

| Type d'intégration            | LangChain                                      | LlamaIndex                             | Haystack                            | RAGFlow                    |
| ----------------------------- | ---------------------------------------------- | -------------------------------------- | ----------------------------------- | -------------------------- |
| Fournisseurs LLM              | 50+                                            | 30+                                    | 20+                                 | 10+                        |
| Bases de données vectorielles | Chroma, Pinecone, Weaviate, Qdrant, 40+ autres | Chroma, Pinecone, Weaviate, 25+ autres | Weaviate, Elasticsearch, 15+ autres | InfiniFlow intégré         |
| Types de documents            | PDF, Web, CSV, JSON, 80+                       | PDF, Web, CSV, BD, 40+                 | PDF, TXT, HTML, 20+                 | PDF, Word, Excel, PPT, Web |
| Stockage cloud                | S3, GCS, Azure                                 | S3, GCS, Azure                         | S3, GCS                             | S3                         |

### Fonctionnalités RAG avancées

| Fonctionnalité                          | LangChain | LlamaIndex        | Haystack | RAGFlow |
| --------------------------------------- | --------- | ----------------- | -------- | ------- |
| Décomposition de requêtes               | ✅         | ✅                 | ✅        | ✅       |
| HyDE (Hypothetical Document Embeddings) | ✅         | ✅                 | ❌        | ❌       |
| Récupération multi-sauts (multi-hop)    | ✅         | ✅                 | Partiel  | ✅       |
| Compression contextuelle                | ✅         | ✅                 | ✅        | ✅       |
| Self-RAG                                | ✅         | ✅                 | ❌        | ❌       |
| GraphRAG                                | ✅         | ✅ (PropertyGraph) | ❌        | ✅       |
| Suivi des citations                     | Partiel   | ✅                 | Partiel  | ✅       |

***

## Benchmarks de performance

### Précision de récupération (RAG-Bench, 2024)

{% hint style="info" %}
Les benchmarks varient considérablement selon le jeu de données et la configuration. Ce sont des chiffres approximatifs issus de benchmarks communautaires.
{% endhint %}

| Framework            | HotpotQA (F1) | Natural Questions (EM) | TriviaQA (Acc) |
| -------------------- | ------------- | ---------------------- | -------------- |
| LangChain (RAG)      | \~68%         | \~42%                  | \~72%          |
| LlamaIndex (RAG)     | \~71%         | \~45%                  | \~74%          |
| Haystack (RAG)       | \~69%         | \~43%                  | \~71%          |
| RAGFlow (par défaut) | \~65%         | \~40%                  | \~68%          |

*Les résultats dépendent fortement du LLM choisi, du modèle d'embeddings et de la taille des chunks*

### Vitesse d'indexation (10K documents, \~1KB chacun)

| Framework  | CPU uniquement | Embeddings GPU |
| ---------- | -------------- | -------------- |
| LangChain  | \~120 s        | \~18 s         |
| LlamaIndex | \~110 s        | \~15 s         |
| Haystack   | \~130 s        | \~20 s         |
| RAGFlow    | \~150 s        | \~25 s         |

*Avec l'équivalent de text-embedding-ada-002 (1536 dims)*

### Latence de requête (P50/P99, avec index pré-construit)

| Framework  | P50    | P99   | Remarques                  |
| ---------- | ------ | ----- | -------------------------- |
| LangChain  | 450 ms | 1,2 s | Pas de re-ranking          |
| LlamaIndex | 400 ms | 1,0 s | Pas de re-ranking          |
| Haystack   | 500 ms | 1,5 s | Avec surcharge du pipeline |
| RAGFlow    | 600 ms | 2,0 s | Inclut la surcharge UI/API |

***

## LangChain : Analyse approfondie

### Forces

✅ **Écosystème le plus vaste** — 50+ intégrations, communauté massive\
✅ **Agents et outils** — construire des agents IA autonomes\
✅ **LangSmith** — excellente observabilité et débogage\
✅ **LCEL** — LangChain Expression Language pour composer des chaînes\
✅ **Systèmes de mémoire** — historique de conversation, mémoire d'entités

### Faiblesses

❌ **Complexité** — peut être sur-conçu pour des tâches simples\
❌ **Changements fréquents cassants** — migrations v0.1 vs v0.2 vs v0.3\
❌ **Dépendance lourde** — taille d'installation importante\
❌ **Fuite d'abstraction** — parfois plus difficile à déboguer

### Meilleurs cas d'utilisation

* Pipelines LLM multi-étapes avec logique complexe
* Agents IA qui utilisent des outils (recherche web, exécution de code, API)
* Applications nécessitant une mémoire de conversation
* Projets nécessitant une flexibilité maximale

### Exemple : RAG avancé avec sources

```python
from langchain.chains import RetrievalQAWithSourcesChain
from langchain_community.vectorstores import Chroma
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Configuration
llm = ChatOpenAI(model="gpt-4", temperature=0)
embeddings = OpenAIEmbeddings()

# Indexer des documents avec métadonnées
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

vectorstore = Chroma.from_documents(
    chunks, 
    embeddings,
    persist_directory="./chroma_db"
)

# Construire la chaîne avec attribution des sources
chain = RetrievalQAWithSourcesChain.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
    return_source_documents=True
)

result = chain({"question": "Quels sont les principaux risques ?"})
print(result["answer"])
print("Sources :", result["sources"])
```

***

## LlamaIndex : Analyse approfondie

### Forces

✅ **Conception axée sur le document** — meilleur pour l'indexation de documents complexes\
✅ **Types d'index** — Vector, Knowledge Graph, SQL, Keyword\
✅ **Moteur de sous-questions** — décompose automatiquement les requêtes complexes\
✅ **Sorties structurées** — intégration Pydantic\
✅ **Moteur de routage de requêtes** — achemine intelligemment vers le bon index

### Faiblesses

❌ **Moins axé sur les agents** que LangChain\
❌ **Écosystème plus petit** que LangChain\
❌ **Documentation** peut être incohérent

### Meilleurs cas d'utilisation

* Systèmes Q\&R sur documents (PDF, rapports, wikis)
* Raisonnement complexe multi-documents
* Construction de graphes de connaissances
* Ponts données→LLM (bases de données, API)

### Exemple : moteur de requête multi-documents

```python
from llama_index.core import (
    VectorStoreIndex, 
    SimpleDirectoryReader,
    StorageContext,
    Settings
)
from llama_index.core.query_engine import RouterQueryEngine
from llama_index.core.tools import QueryEngineTool
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# Configurer globalement
Settings.llm = OpenAI(model="gpt-4")
Settings.embed_model = OpenAIEmbedding()

# Créer des index séparés pour différents ensembles de documents
annual_reports = SimpleDirectoryReader("./annual_reports").load_data()
tech_docs = SimpleDirectoryReader("./tech_docs").load_data()

index_reports = VectorStoreIndex.from_documents(annual_reports)
index_tech = VectorStoreIndex.from_documents(tech_docs)

# Construire un routeur qui sélectionne le bon index
tools = [
    QueryEngineTool.from_defaults(
        query_engine=index_reports.as_query_engine(),
        description="Rapports financiers annuels et métriques commerciales"
    ),
    QueryEngineTool.from_defaults(
        query_engine=index_tech.as_query_engine(),
        description="Documentation technique et références d'API"
    )
]

router = RouterQueryEngine.from_defaults(query_engine_tools=tools)
response = router.query("Quelle a été la croissance du chiffre d'affaires l'année dernière ?")
```

***

## Haystack : Analyse approfondie

### Forces

✅ **De niveau entreprise** — fiabilité en production\
✅ **Constructeur de pipeline visuel** — Haystack Studio\
✅ **Outil d'annotation** — UI d'étiquetage intégrée\
✅ **NLP puissant** — QA extractive, résumé\
✅ **deepset Cloud** — option de déploiement gérée

### Faiblesses

❌ **Courbe d'apprentissage plus raide** que les concurrents\
❌ **Communauté plus petite** que LangChain/LlamaIndex\
❌ **Moins flexible** pour des architectures nouvelles

### Meilleurs cas d'utilisation

* Recherche de documents d'entreprise et Q\&R
* Projets nécessitant des pistes d'audit et de l'observabilité
* Équipes souhaitant une conception de pipeline visuelle
* Déploiements en production avec exigences SLA

### Exemple : Pipeline de recherche hybride

```python
from haystack import Pipeline
from haystack.components.retrievers import InMemoryBM25Retriever, InMemoryEmbeddingRetriever
from haystack.components.joiners import DocumentJoiner
from haystack.components.rankers import MetaFieldRanker
from haystack.components.generators import OpenAIGenerator
from haystack.components.builders import RAGPromptBuilder

# Construire un pipeline de recherche hybride
pipeline = Pipeline()
pipeline.add_component("bm25_retriever", InMemoryBM25Retriever(document_store=store, top_k=10))
pipeline.add_component("embedding_retriever", InMemoryEmbeddingRetriever(document_store=store, top_k=10))
pipeline.add_component("joiner", DocumentJoiner(join_mode="reciprocal_rank_fusion"))
pipeline.add_component("ranker", MetaFieldRanker(meta_field="score"))
pipeline.add_component("prompt_builder", RAGPromptBuilder())
pipeline.add_component("llm", OpenAIGenerator(model="gpt-4"))

# Connecter les composants
pipeline.connect("bm25_retriever", "joiner.documents")
pipeline.connect("embedding_retriever", "joiner.documents")
pipeline.connect("joiner", "ranker")
pipeline.connect("ranker", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

result = pipeline.run({"bm25_retriever": {"query": "deep learning"}, 
                       "embedding_retriever": {"query": "deep learning"}})
```

***

## RAGFlow : Analyse approfondie

### Forces

✅ **Déploiement sans code** — UI complète incluse\
✅ **Parsing avancé de documents** — tables, images, graphiques\
✅ **Gestion de base de connaissances** — interface visuelle\
✅ **API incluse** — API REST prête à l'emploi\
✅ **RAG agentique** — agents intégrés

### Faiblesses

❌ **Moins personnalisable** que les frameworks axés code\
❌ **Exigence de ressources lourde** (Elasticsearch + Infinity DB)\
❌ **Support LLM limité** par rapport à LangChain\
❌ **Projet plus récent** — communauté plus petite

### Meilleurs cas d'utilisation

* Non-développeurs ayant besoin de RAG sans coder
* Équipes voulant un produit complet de base de connaissances
* Wikis internes d'entreprise et recherche dans la documentation
* Prototypage rapide d'applications RAG

### Déploiement sur Clore.ai

```yaml
# docker-compose.yml pour RAGFlow
version : "3"
services:
  ragflow :
    image : infiniflow/ragflow:v0.12.0
    container_name : ragflow
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./ragflow-logs:/ragflow/logs
      - ./ragflow-data:/ragflow/data
    depends_on:
      - elasticsearch
      - infinity

  elasticsearch :
    image : elasticsearch:8.11.3
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
      - xpack.security.enabled=false
    volumes:
      - es_data:/usr/share/elasticsearch/data

  infinity :
    image : infiniflow/infinity:v0.3.0
    volumes:
      - infinity_data:/var/infinity

volumes:
  es_data :
  infinity_data :
```

```bash
docker compose up -d
# Accéder à l'interface web à http://<server-ip>:80
```

***

## Quand utiliser lequel

### Choisissez LangChain si :

* Vous construisez des agents IA avec des outils (recherche web, exécution de code, API)
* Vous avez besoin d'une flexibilité maximale de l'écosystème
* Construction de pipelines multi-étapes complexes
* Intégration avec de nombreux LLM et sources de données différents
* L'équipe est à l'aise avec Python

### Choisissez LlamaIndex si :

* Le cas d'utilisation principal est la Q\&R sur documents
* Travaillez avec des structures de documents complexes (tables, contenu imbriqué)
* Vous avez besoin de graphes de connaissances ou de routage multi-index
* Vous voulez l'ingestion de documents de premier ordre
* Construction sur des données structurées (bases de données, API)

### Choisissez Haystack si :

* Environnement d'entreprise avec exigences de conformité
* Vous avez besoin d'outils de construction de pipeline visuels
* Construction sur Elasticsearch
* Vous voulez du QA extractif (pas seulement génératif)
* L'équipe a besoin d'observabilité des pipelines NLP

### Choisissez RAGFlow si :

* Une équipe non technique a besoin d'un RAG en libre-service
* Vous voulez un produit complet, pas un framework
* Le déploiement rapide prime sur la personnalisation
* Construction d'une base de connaissances interne
* Vous ne voulez pas écrire de code Python

***

## Exécution sur Clore.ai : Exigences en ressources

| Framework  | RAM min       | VRAM min.        | GPU recommandé |
| ---------- | ------------- | ---------------- | -------------- |
| LangChain  | 8 Go          | 8 Go (LLM local) | RTX 3080       |
| LlamaIndex | 8 Go          | 8 Go (LLM local) | RTX 3080       |
| Haystack   | 16GB          | 8 Go (LLM local) | RTX 3090       |
| RAGFlow    | 32 Go (RAM !) | 16GB             | A6000 / A100   |

{% hint style="warning" %}
**RAGFlow nécessite plus de RAM**: Il exécute Elasticsearch + InfinityDB + l'application elle-même. Prévoyez au moins 32 Go de RAM système. Haystack avec Elasticsearch profite également de 16 Go+ de RAM.
{% endhint %}

***

## Liens utiles

* [Docs LangChain](https://python.langchain.com)
* [Docs LlamaIndex](https://docs.llamaindex.ai)
* [Docs Haystack](https://docs.haystack.deepset.ai)
* [RAGFlow GitHub](https://github.com/infiniflow/ragflow)
* [Article d'enquête RAG (arxiv)](https://arxiv.org/abs/2312.10997)

***

## Recommandation résumée

```
Q&R simple sur documents → LlamaIndex
Agents IA complexes → LangChain
Recherche d'entreprise → Haystack
Produit RAG sans code → RAGFlow
Flexibilité maximale → LangChain
Meilleure compréhension des documents → LlamaIndex
```

Les quatre frameworks sont d'excellents choix — le bon dépend de vos besoins spécifiques, des compétences de l'équipe et des contraintes de déploiement. En cas de doute, commencez par **LlamaIndex** pour les cas d'utilisation axés sur les documents ou **LangChain** si vous avez besoin de l'écosystème le plus large possible.

***

## Recommandations GPU Clore.ai

| Cas d’utilisation  | GPU recommandé  | Coût estimé sur Clore.ai |
| ------------------ | --------------- | ------------------------ |
| Développement/Test | RTX 3090 (24GB) | \~$0.12/gpu/hr           |
| Production         | RTX 4090 (24GB) | \~$0.70/gpu/hr           |
| Grande échelle     | A100 80GB       | \~$1.20/gpu/hr           |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/comparaisons/rag-frameworks-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.