> 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-de/vergleiche/rag-frameworks-comparison.md).

# Vergleich von RAG-Frameworks

Wählen Sie das passende Retrieval-Augmented-Generation-(RAG)-Framework für Ihr Projekt auf Clore.ai GPU-Servern.

{% hint style="info" %}
**RAG (Retrieval-Augmented Generation)** ermöglicht es LLMs, Fragen mithilfe Ihrer eigenen Dokumente zu beantworten. Dieser Leitfaden vergleicht die vier führenden Frameworks: LangChain, LlamaIndex, Haystack und RAGFlow — und behandelt Funktionen, Leistung und wann man welches verwendet.
{% endhint %}

***

## Schnelle Entscheidungsübersicht

|                                    | LangChain                  | LlamaIndex                       | Haystack         | RAGFlow               |
| ---------------------------------- | -------------------------- | -------------------------------- | ---------------- | --------------------- |
| **Am besten für**                  | Allgemeine LLM-Anwendungen | Dokumenten-Fragen und -Antworten | Enterprise-Suche | Selbst gehostetes RAG |
| **Lernkurve**                      | Mittel                     | Niedrig-Mittel                   | Mittel-Hoch      | Niedrig               |
| **Flexibilität**                   | Sehr hoch                  | Hoch                             | Hoch             | Mittel                |
| **Integrierte Benutzeroberfläche** | Nein                       | Nein                             | Nein             | Ja                    |
| **GitHub-Stars**                   | 90.000+                    | 35.000+                          | 15K+             | 12K+                  |
| **Sprache**                        | Python                     | Python                           | Python           | Python                |
| **Lizenz**                         | MIT                        | MIT                              | Apache 2.0       | Apache 2.0            |

***

## Überblick

### LangChain

LangChain ist das beliebteste Orchestrierungs-Framework für LLMs. Es bietet eine einheitliche Schnittstelle für Chains, Agents, Memory und RAG-Pipelines.

**Philosophie**: Alles ist eine Kette aus zusammensetzbaren Komponenten.

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

# RAG-Pipeline in 5 Zeilen erstellen
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("What is the capital of France?")
```

### LlamaIndex

LlamaIndex (ehemals GPT Index) wurde speziell für Dokumentenindizierung und -abruf entwickelt. Es ist besonders gut darin, LLMs mit unterschiedlichen Datenquellen zu verbinden.

**Philosophie**: Erst indizieren, dann intelligent abfragen.

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

# Dokumente laden und indizieren
documents = SimpleDirectoryReader("data/").load_data()
index = VectorStoreIndex.from_documents(documents)

# Abfrage
query_engine = index.as_query_engine()
response = query_engine.query("Fassen Sie die wichtigsten Erkenntnisse zusammen")
print(response)
```

### Haystack

Haystack (von deepset) ist ein NLP-Framework für Unternehmen mit Schwerpunkt auf Such- und Q\&A-Pipelines. Es verfügt über eine komponentenbasierte Architektur mit visuellem Pipeline-Builder.

**Philosophie**: Modulare Pipelines mit unternehmensweiter Zuverlässigkeit.

```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="Was ist maschinelles Lernen?", params={"Retriever": {"top_k": 10}})
```

### RAGFlow

RAGFlow ist eine Open-Source-RAG-Engine mit integrierter Web-UI, Dokumentenanalyse und Wissensdatenbankverwaltung. Sie ist darauf ausgelegt, als Komplettlösung bereitgestellt zu werden.

**Philosophie**: RAG-System sofort einsatzbereit, keine Programmierung erforderlich.

```yaml
# RAGFlow wird über Docker Compose bereitgestellt
# Konfiguration über die Web-UI unter localhost:80
version: "3"
services:
  ragflow:
    image: infiniflow/ragflow:latest
    ports:
      - "80:80"
    volumes:
      - ./ragflow-data:/ragflow/data
```

***

## Funktionsvergleich

### Kernfunktionen von RAG

| Funktion                         | LangChain | LlamaIndex | Haystack  | RAGFlow    |
| -------------------------------- | --------- | ---------- | --------- | ---------- |
| Unterstützung für Vektorspeicher | 50+       | 30+        | 20+       | Integriert |
| Dokumenten-Loader                | 100+      | 50+        | 30+       | Integriert |
| Hybridsuche                      | ✅         | ✅          | ✅         | ✅          |
| Re-Ranking                       | ✅         | ✅          | ✅         | ✅          |
| Multimodal                       | ✅         | ✅          | Teilweise | ✅          |
| Streaming                        | ✅         | ✅          | ✅         | ✅          |
| Asynchrone Unterstützung         | ✅         | ✅          | ✅         | ✅          |
| Agenten                          | ✅         | ✅          | ✅         | ❌          |

### Integrations-Ökosystem

| Integrationstyp    | LangChain                                       | LlamaIndex                              | Haystack                             | RAGFlow                    |
| ------------------ | ----------------------------------------------- | --------------------------------------- | ------------------------------------ | -------------------------- |
| LLM-Anbieter       | 50+                                             | 30+                                     | 20+                                  | 10+                        |
| Vektor-Datenbanken | Chroma, Pinecone, Weaviate, Qdrant, 40+ weitere | Chroma, Pinecone, Weaviate, 25+ weitere | Weaviate, Elasticsearch, 15+ weitere | Integriertes InfiniFlow    |
| Dokumenttypen      | PDF, Web, CSV, JSON, 80+                        | PDF, Web, CSV, DB, 40+                  | PDF, TXT, HTML, 20+                  | PDF, Word, Excel, PPT, Web |
| Cloud-Speicher     | S3, GCS, Azure                                  | S3, GCS, Azure                          | S3, GCS                              | S3                         |

### Erweiterte RAG-Funktionen

| Funktion                                 | LangChain | LlamaIndex        | Haystack  | RAGFlow |
| ---------------------------------------- | --------- | ----------------- | --------- | ------- |
| Zerlegung von Abfragen                   | ✅         | ✅                 | ✅         | ✅       |
| HyDE (Hypothetische Dokument-Embeddings) | ✅         | ✅                 | ❌         | ❌       |
| Mehrstufige Abrufsuche                   | ✅         | ✅                 | Teilweise | ✅       |
| Kontextuelle Komprimierung               | ✅         | ✅                 | ✅         | ✅       |
| Self-RAG                                 | ✅         | ✅                 | ❌         | ❌       |
| GraphRAG                                 | ✅         | ✅ (PropertyGraph) | ❌         | ✅       |
| Quellenverfolgung                        | Teilweise | ✅                 | Teilweise | ✅       |

***

## Leistungsbenchmarks

### Abrufgenauigkeit (RAG-Bench, 2024)

{% hint style="info" %}
Die Benchmarks variieren je nach Datensatz und Konfiguration erheblich. Dies sind Näherungswerte aus Community-Benchmarks.
{% 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 (Standard) | \~65%         | \~40%                  | \~68%          |

*Die Ergebnisse hängen stark vom gewählten LLM, Embedding-Modell und Chunk-Größe ab*

### Indexierungsgeschwindigkeit (10.000 Dokumente, je \~1 KB)

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

*Mit einem Äquivalent zu text-embedding-ada-002 (1536 Dimensionen)*

### Abfragelatenz (P50/P99, mit vorab erstellt Index)

| Framework  | P50    | P99   | Hinweise                    |
| ---------- | ------ | ----- | --------------------------- |
| LangChain  | 450 ms | 1.2s  | Kein Re-Ranking             |
| LlamaIndex | 400 ms | 1.0s  | Kein Re-Ranking             |
| Haystack   | 500 ms | 1.5s  | Mit Pipeline-Overhead       |
| RAGFlow    | 600 ms | 2,0 s | Beinhaltet UI-/API-Overhead |

***

## LangChain: Tiefenanalyse

### Stärken

✅ **Größtes Ökosystem** — 50+ Integrationen, riesige Community\
✅ **Agenten und Tools** — autonome KI-Agenten erstellen\
✅ **LangSmith** — hervorragende Beobachtbarkeit und Fehlersuche\
✅ **LCEL** — LangChain Expression Language zum Zusammensetzen von Chains\
✅ **Speichersysteme** — Gesprächsverlauf, Entitätsspeicher

### Schwächen

❌ **Komplexität** — kann für einfache Aufgaben überdimensioniert sein\
❌ **Häufige Breaking Changes** — Migrationen von v0.1 zu v0.2 zu v0.3\
❌ **Schwere Abhängigkeit** — große Installationsgröße\
❌ **Abstraktionsleck** — manchmal schwieriger zu debuggen

### Beste Anwendungsfälle

* Mehrstufige LLM-Pipelines mit komplexer Logik
* KI-Agenten, die Tools nutzen (Websuche, Codeausführung, APIs)
* Anwendungen, die Gesprächsspeicher benötigen
* Projekte, die maximale Flexibilität benötigen

### Beispiel: Erweiterte RAG mit Quellen

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

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

# Dokumente mit Metadaten indizieren
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

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

# Chain mit Quellenzuordnung erstellen
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": "Was sind die wichtigsten Risiken?"})
print(result["answer"])
print("Quellen:", result["sources"])
```

***

## LlamaIndex: Tiefenanalyse

### Stärken

✅ **Dokument-zuerst-Design** — am besten für komplexe Dokumentenindizierung\
✅ **Indextypen** — Vektor, Wissensgraph, SQL, Schlüsselwort\
✅ **Unterfragen-Engine** — zerlegt komplexe Abfragen automatisch\
✅ **Strukturierte Ausgaben** — Pydantic-Integration\
✅ **Router-Abfrage-Engine** — leitet intelligent zum richtigen Index weiter

### Schwächen

❌ **Weniger auf Agenten fokussiert** als LangChain\
❌ **Kleineres Ökosystem** als LangChain\
❌ **Dokumentation** kann uneinheitlich sein

### Beste Anwendungsfälle

* Dokumenten-Q\&A-Systeme (PDFs, Berichte, Wikis)
* Komplexes Schlussfolgern über mehrere Dokumente
* Aufbau von Wissensgraphen
* Daten-zu-LLM-Brücken (Datenbanken, APIs)

### Beispiel: Mehrdokumenten-Abfrage-Engine

```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

# Global konfigurieren
Settings.llm = OpenAI(model="gpt-4")
Settings.embed_model = OpenAIEmbedding()

# Separate Indizes für unterschiedliche Dokumentensammlungen erstellen
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)

# Router erstellen, der den richtigen Index auswählt
tools = [
    QueryEngineTool.from_defaults(
        query_engine=index_reports.as_query_engine(),
        description="Jahresfinanzberichte und Geschäftskennzahlen"
    ),
    QueryEngineTool.from_defaults(
        query_engine=index_tech.as_query_engine(),
        description="Technische Dokumentation und API-Referenzen"
    )
]

router = RouterQueryEngine.from_defaults(query_engine_tools=tools)
response = router.query("Wie hoch war das Umsatzwachstum im letzten Jahr?")
```

***

## Haystack: Tiefenanalyse

### Stärken

✅ **Für Unternehmen geeignet** — produktionsreife Zuverlässigkeit\
✅ **Visueller Pipeline-Builder** — Haystack Studio\
✅ **Annotationswerkzeug** — integrierte Beschriftungsoberfläche\
✅ **Starkes NLP** — extraktive QA, Zusammenfassung\
✅ **deepset Cloud** — verwaltete Bereitstellungsoption

### Schwächen

❌ **Steilere Lernkurve** als bei der Konkurrenz\
❌ **Kleinere Community** als bei LangChain/LlamaIndex\
❌ **Weniger flexibel** für neuartige Architekturen

### Beste Anwendungsfälle

* Unternehmensdokumentensuche und Q\&A
* Projekte, die Audit-Trails und Beobachtbarkeit benötigen
* Teams, die visuelles Pipeline-Design wünschen
* Produktionsbereitstellungen mit SLA-Anforderungen

### Beispiel: Hybride Suchpipeline

```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

# Hybride Suchpipeline erstellen
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"))

# Komponenten verbinden
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: Tiefenanalyse

### Stärken

✅ **Bereitstellung ohne Code** — vollständige UI enthalten\
✅ **Erweitertes Dokumenten-Parsing** — Tabellen, Bilder, Diagramme\
✅ **Wissensdatenbankverwaltung** — visuelle Oberfläche\
✅ **API enthalten** — REST-API direkt integriert\
✅ **Agentisches RAG** — integrierte Agenten

### Schwächen

❌ **Weniger anpassbar** als code-first-Frameworks\
❌ **Hoher Ressourcenbedarf** (Elasticsearch + Infinity DB)\
❌ **Eingeschränkte LLM-Unterstützung** im Vergleich zu LangChain\
❌ **Neueres Projekt** — kleinere Community

### Beste Anwendungsfälle

* Nicht-Entwickler, die RAG ohne Programmierung benötigen
* Teams, die ein vollständiges Wissensdatenbank-Produkt möchten
* Interne Unternehmens-Wikis und Dokumentensuche
* Schnelles Prototyping von RAG-Anwendungen

### Bereitstellung auf Clore.ai

```yaml
# docker-compose.yml für 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
# Web-UI unter http://<server-ip>:80 aufrufen
```

***

## Wann welches Modell verwenden

### Wählen Sie LangChain, wenn:

* Sie KI-Agenten mit Tools erstellen (Websuche, Codeausführung, APIs)
* maximale Flexibilität des Ökosystems benötigt wird
* komplexe mehrstufige Pipelines erstellt werden
* mit vielen verschiedenen LLMs und Datenquellen integriert werden soll
* das Team mit Python vertraut ist

### Wählen Sie LlamaIndex, wenn:

* der Hauptanwendungsfall Dokumenten-Q\&A ist
* mit komplexen Dokumentenstrukturen (Tabellen, verschachtelte Inhalte) gearbeitet wird
* Wissensgraphen oder Multi-Index-Routing benötigt werden
* erstklassige Dokumentenaufnahme möchten
* Auf strukturierten Daten aufbauen (Datenbanken, APIs)

### Wähle Haystack, wenn:

* Unternehmensumgebung mit Compliance-Anforderungen
* Benötigen visuelle Tools zum Erstellen von Pipelines
* Auf Elasticsearch aufbauen
* Extraktive (nicht nur generative) QA wünschen
* Das Team benötigt Observability für NLP-Pipelines

### Wähle RAGFlow, wenn:

* Ein nicht-technisches Team benötigt Self-Service-RAG
* Ein fertiges Produkt statt eines Frameworks wünschen
* Schnelle Bereitstellung hat Vorrang vor Anpassbarkeit
* Eine interne Wissensdatenbank aufbauen
* Möchten keinen Python-Code schreiben

***

## Ausführung auf Clore.ai: Ressourcenanforderungen

| Framework  | Min. RAM     | Min. VRAM          | Empfohlene GPU |
| ---------- | ------------ | ------------------ | -------------- |
| LangChain  | 8 GB         | 8 GB (lokales LLM) | RTX 3080       |
| LlamaIndex | 8 GB         | 8 GB (lokales LLM) | RTX 3080       |
| Haystack   | 16 GB        | 8 GB (lokales LLM) | RTX 3090       |
| RAGFlow    | 32 GB (RAM!) | 16 GB              | A6000 / A100   |

{% hint style="warning" %}
**RAGFlow benötigt mehr RAM**: Es führt Elasticsearch + InfinityDB + die Anwendung selbst aus. Plane mindestens 32 GB Systemspeicher ein. Haystack mit Elasticsearch profitiert ebenfalls von 16 GB+ RAM.
{% endhint %}

***

## Nützliche Links

* [LangChain-Dokumentation](https://python.langchain.com)
* [LlamaIndex-Dokumentation](https://docs.llamaindex.ai)
* [Haystack-Dokumentation](https://docs.haystack.deepset.ai)
* [RAGFlow-GitHub](https://github.com/infiniflow/ragflow)
* [RAG-Umfragepapier (arXiv)](https://arxiv.org/abs/2312.10997)

***

## Zusammenfassende Empfehlung

```
Einfache Dokumenten-Q&A          → LlamaIndex
Komplexe KI-Agenten            → LangChain
Enterprise-Suche            → Haystack
No-Code-RAG-Produkt          → RAGFlow
Maximale Flexibilität          → LangChain
Bestes Dokumentenverständnis  → LlamaIndex
```

Alle vier Frameworks sind ausgezeichnete Optionen — die richtige hängt von deinen spezifischen Anforderungen, den Fähigkeiten des Teams und den Bereitstellungsbeschränkungen ab. Im Zweifel beginne mit **LlamaIndex** für dokumentenlastige Anwendungsfälle oder **LangChain** wenn du das größtmögliche Ökosystem benötigst.

***

## GPU-Empfehlungen für Clore.ai

| Anwendungsfall     | Empfohlene GPU   | Geschätzte Kosten bei Clore.ai            |
| ------------------ | ---------------- | ----------------------------------------- |
| Entwicklung/Testen | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde                    |
| Produktion         | RTX 4090 (24 GB) | 0,14–0,42 $/GPU/Stunde                    |
| Großflächig        | A100 80GB        | [Bare Metal](https://clore.ai/bare-metal) |

> 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

# 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-de/vergleiche/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.