> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/comparaisons/rag-frameworks-comparison.md).

# Comparaison des frameworks RAG

Choisissez le bon framework de génération augmentée par récupération (RAG) pour votre projet sur les serveurs GPU de Clore.ai.

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

***

## Matrice de décision rapide

|                                    | LangChain                     | LlamaIndex                       | Haystack               | RAGFlow          |
| ---------------------------------- | ----------------------------- | -------------------------------- | ---------------------- | ---------------- |
| **Idéal pour**                     | Applications générales de LLM | Questions-réponses 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é                            | Élevé                  | Moyen            |
| **Interface utilisateur intégrée** | Non                           | Non                              | Non                    | Oui              |
| **Étoiles GitHub**                 | 90 k+                         | 35 k+                            | 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 spécialement conçu pour l’indexation et la récupération de documents. Il excelle à connecter les LLM à diverses sources de données.

**Philosophie**: Indexez d’abord, interrogez intelligemment.

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

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

# Interroger
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 les pipelines de recherche et de questions-réponses. Il dispose d’une architecture basée sur des composants avec un constructeur visuel de pipelines.

**Philosophie**: Pipelines modulaires avec une fiabilité de niveau 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, l’analyse de documents et la gestion d’une base de connaissances. Il est conçu pour être déployé comme une 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 sur 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 |
| ------------------------------------- | --------- | ---------- | -------- | ------- |
| Prise en charge du stockage vectoriel | 50+       | 30+        | 20+      | Intégré |
| Chargeurs de documents                | 100+      | 50+        | 30+      | Intégré |
| Recherche hybride                     | ✅         | ✅          | ✅        | ✅       |
| Réordonnancement                      | ✅         | ✅          | ✅        | ✅       |
| Multi-modal                           | ✅         | ✅          | Partiel  | ✅       |
| Flux continu                          | ✅         | ✅          | ✅        | ✅       |
| Prise en charge asynchrone            | ✅         | ✅          | ✅        | ✅       |
| Agents                                | ✅         | ✅          | ✅        | ❌       |

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

| Type d’intégration            | LangChain                                      | LlamaIndex                             | Haystack                            | RAGFlow                    |
| ----------------------------- | ---------------------------------------------- | -------------------------------------- | ----------------------------------- | -------------------------- |
| Fournisseurs de 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, DB, 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 des requêtes                   | ✅         | ✅                 | ✅        | ✅       |
| HyDE (embeddings de documents hypothétiques) | ✅         | ✅                 | ❌        | ❌       |
| Récupération multi-sauts                     | ✅         | ✅                 | Partiel  | ✅       |
| Compression contextuelle                     | ✅         | ✅                 | ✅        | ✅       |
| Self-RAG                                     | ✅         | ✅                 | ❌        | ❌       |
| GraphRAG                                     | ✅         | ✅ (PropertyGraph) | ❌        | ✅       |
| Suivi des citations                          | Partiel   | ✅                 | Partiel  | ✅       |

***

## Benchmarks de performance

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

{% hint style="info" %}
Les benchmarks varient fortement selon le jeu de données et la configuration. Il s’agit de valeurs approximatives issues 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 segments*

### Vitesse d’indexation (10 000 documents, \~1 Ko 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 dimensions)*

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

| Framework  | P50    | P99   | Remarques                              |
| ---------- | ------ | ----- | -------------------------------------- |
| LangChain  | 450 ms | 1.2s  | Sans réordonnancement                  |
| LlamaIndex | 400 ms | 1.0s  | Sans réordonnancement                  |
| Haystack   | 500 ms | 1.5s  | Avec la surcharge du pipeline          |
| RAGFlow    | 600 ms | 2,0 s | Inclut la surcharge de l’interface/API |

***

## LangChain : plongée approfondie

### Points forts

✅ **Le plus grand écosystème** — 50+ intégrations, immense communauté\
✅ **Agents et outils** — créez 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 des conversations, mémoire d’entités

### Faiblesses

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

### Cas d’utilisation idéaux

* 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 les documents avec des 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 : plongée approfondie

### Points forts

✅ **Conception centrée sur les documents** — idéal pour l’indexation de documents complexes\
✅ **Types d’index** — vecteur, graphe de connaissances, SQL, mots-clés\
✅ **Moteur de sous-questions** — décompose automatiquement les requêtes complexes\
✅ **Sorties structurées** — intégration Pydantic\
✅ **Moteur de requêtes routeur** — dirige intelligemment vers le bon index

### Faiblesses

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

### Cas d’utilisation idéaux

* Systèmes de Q\&R documentaire (PDF, rapports, wikis)
* Raisonnement complexe sur plusieurs documents
* Construction de graphes de connaissances
* Passerelles de données vers le 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

# Configuration globale
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 indicateurs commerciaux"
    ),
    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 : plongée approfondie

### Points forts

✅ **De niveau entreprise** — fiabilité de production\
✅ **Constructeur de pipeline visuel** — Haystack Studio\
✅ **Outil d’annotation** — interface de labellisation intégrée\
✅ **NLP puissant** — Q\&R 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 les architectures innovantes

### Cas d’utilisation idéaux

* Recherche documentaire d’entreprise et Q\&R
* Projets nécessitant des pistes d’audit et de l’observabilité
* Équipes souhaitant une conception visuelle des pipelines
* 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": "apprentissage profond"}, 
                       "embedding_retriever": {"query": "apprentissage profond"}})
```

***

## RAGFlow : plongée approfondie

### Points forts

✅ **Déploiement sans code** — interface complète incluse\
✅ **Analyse avancée des documents** — tableaux, images, graphiques\
✅ **Gestion de la 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 sur le code\
❌ **Exigences élevées en ressources** (Elasticsearch + Infinity DB)\
❌ **Prise en charge limitée des LLM** par rapport à LangChain\
❌ **Projet plus récent** — communauté plus petite

### Cas d’utilisation idéaux

* Non-développeurs ayant besoin de RAG sans coder
* Équipes souhaitant un produit complet de base de connaissances
* Wikis internes d’entreprise et recherche documentaire
* 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 quoi

### 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
* Vous construisez des pipelines complexes à plusieurs étapes
* Vous intégrez de nombreux LLM et sources de données différents
* Votre équipe est à l’aise avec Python

### Choisissez LlamaIndex si :

* Le cas d’utilisation principal est la Q\&R documentaire
* Vous travaillez avec des structures de documents complexes (tableaux, contenu imbriqué)
* Vous avez besoin de graphes de connaissances ou de routage multi-index
* Vous voulez une ingestion de documents de premier ordre
* Développer sur des données structurées (bases de données, API)

### Choisissez Haystack si :

* Environnement d'entreprise avec des exigences de conformité
* Besoin d'outils visuels de création de pipelines
* Développer au-dessus d'Elasticsearch
* Vous voulez une QA extractive (pas seulement générative)
* L'équipe a besoin d'une observabilité du pipeline 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 est prioritaire sur la personnalisation
* Construire une base de connaissances interne
* Ne pas vouloir écrire de code Python

***

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

| Framework  | RAM minimale  | VRAM minimale    | GPU recommandé |
| ---------- | ------------- | ---------------- | -------------- |
| LangChain  | 8 Go          | 8 Go (LLM local) | RTX 3080       |
| LlamaIndex | 8 Go          | 8 Go (LLM local) | RTX 3080       |
| Haystack   | 16 Go         | 8 Go (LLM local) | RTX 3090       |
| RAGFlow    | 32 Go (RAM !) | 16 Go            | 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 bénéficie aussi de 16 Go de RAM ou plus.
{% endhint %}

***

## Liens utiles

* [Documentation LangChain](https://python.langchain.com)
* [Documentation LlamaIndex](https://docs.llamaindex.ai)
* [Documentation Haystack](https://docs.haystack.deepset.ai)
* [GitHub de RAGFlow](https://github.com/infiniflow/ragflow)
* [Article de synthèse sur le RAG (arxiv)](https://arxiv.org/abs/2312.10997)

***

## Recommandation récapitulative

```
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 votre équipe et des contraintes de déploiement. En cas de doute, commencez par **LlamaIndex** pour les cas d'utilisation riches en documents ou **LangChain** si vous avez besoin de l'écosystème le plus vaste possible.

***

## Recommandations GPU Clore.ai

| Cas d’utilisation  | GPU recommandé   | Coût estimé sur Clore.ai                  |
| ------------------ | ---------------- | ----------------------------------------- |
| Développement/Test | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h                         |
| Production         | RTX 4090 (24 Go) | 0,14–0,42 $/gpu/h                         |
| Grande échelle     | A100 80 Go       | [bare metal](https://clore.ai/bare-metal) |

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.