# Vergleich von RAG-Frameworks

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

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

***

## Schnelle Entscheidungsübersicht

|                    | LangChain                  | LlamaIndex      | Haystack         | RAGFlow         |
| ------------------ | -------------------------- | --------------- | ---------------- | --------------- |
| **Am besten für**  | Allgemeine LLM-Anwendungen | Dokumenten Q\&A | Enterprise-Suche | Self-hosted RAG |
| **Lernkurve**      | Mittel                     | Niedrig–Mittel  | Mittel–Hoch      | Niedrig         |
| **Flexibilität**   | Sehr hoch                  | Hoch            | Hoch             | Mittel          |
| **Integrierte UI** | Nein                       | Nein            | Nein             | Ja              |
| **GitHub-Sterne**  | 90K+                       | 35K+            | 15K+             | 12K+            |
| **Sprache**        | Python                     | Python          | Python           | Python          |
| **Lizenz**         | MIT                        | MIT             | Apache 2.0       | Apache 2.0      |

***

## Übersicht

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

# Erstelle eine RAG-Pipeline in 5 Zeilen
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 (früher GPT Index) ist speziell für Dokumentindizierung und -retrieval entwickelt. Es ist hervorragend darin, LLMs mit vielfältigen Datenquellen zu verbinden.

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

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

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

# Abfragen
query_engine = index.as_query_engine()
response = query_engine.query("Summarize the main findings")
print(response)
```

### Haystack

Haystack (von deepset) ist ein unternehmensgerechtes NLP-Framework, das sich auf Such- und Q\&A-Pipelines konzentriert. Es hat eine komponentenbasierte Architektur mit visuellem Pipeline-Builder.

**Philosophie**: Modulare Pipelines mit Unternehmenszuverlä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="What is machine learning?", params={"Retriever": {"top_k": 10}})
```

### RAGFlow

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

**Philosophie**: Sofort einsatzbereites RAG-System, keine Programmierung erforderlich.

```yaml
# RAGFlow wird via Docker Compose bereitgestellt
# Konfiguration über 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 Vector Stores | 50+       | 30+        | 20+       | Integriert |
| Dokumenten-Loader               | 100+      | 50+        | 30+       | Integriert |
| Hybride Suche                   | ✅         | ✅          | ✅         | ✅          |
| Re-Ranking                      | ✅         | ✅          | ✅         | ✅          |
| Multimodal                      | ✅         | ✅          | Teilweise | ✅          |
| Streaming                       | ✅         | ✅          | ✅         | ✅          |
| Async-Unterstützung             | ✅         | ✅          | ✅         | ✅          |
| Agents                          | ✅         | ✅          | ✅         | ❌          |

### Integrations-Ökosystem

| Integrationsart | LangChain                                       | LlamaIndex                              | Haystack                             | RAGFlow                    |
| --------------- | ----------------------------------------------- | --------------------------------------- | ------------------------------------ | -------------------------- |
| LLM-Anbieter    | 50+                                             | 30+                                     | 20+                                  | 10+                        |
| Vector DBs      | Chroma, Pinecone, Weaviate, Qdrant, 40+ weitere | Chroma, Pinecone, Weaviate, 25+ weitere | Weaviate, Elasticsearch, 15+ weitere | Integrierte 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 |
| --------------------------------------- | --------- | ----------------- | --------- | ------- |
| Query-Zerlegung                         | ✅         | ✅                 | ✅         | ✅       |
| HyDE (Hypothetical Document Embeddings) | ✅         | ✅                 | ❌         | ❌       |
| Multi-Hop-Retrieval                     | ✅         | ✅                 | Teilweise | ✅       |
| Kontextuelle Kompression                | ✅         | ✅                 | ✅         | ✅       |
| Self-RAG                                | ✅         | ✅                 | ❌         | ❌       |
| GraphRAG                                | ✅         | ✅ (PropertyGraph) | ❌         | ✅       |
| Zitationsverfolgung                     | Teilweise | ✅                 | Teilweise | ✅       |

***

## Leistungs-Benchmarks

### Retrieval-Genauigkeit (RAG-Bench, 2024)

{% hint style="info" %}
Benchmarks variieren stark je nach Datensatz und Konfiguration. Dies sind ungefähre Werte 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%          |

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

### Indexierungsgeschwindigkeit (10K Dokumente, \~1KB jeweils)

| 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 text-embedding-ada-002-Äquivalent (1536 dims)*

### Query-Latenz (P50/P99, mit vorgefertigtem Index)

| Framework  | P50    | P99   | Hinweise                |
| ---------- | ------ | ----- | ----------------------- |
| LangChain  | 450 ms | 1,2 s | Kein Re-Ranking         |
| LlamaIndex | 400 ms | 1,0 s | Kein Re-Ranking         |
| Haystack   | 500 ms | 1,5 s | Mit Pipeline-Overhead   |
| RAGFlow    | 600 ms | 2,0 s | Enthält UI/API-Overhead |

***

## LangChain: Detaillierter Einblick

### Stärken

✅ **Größtes Ökosystem** — 50+ Integrationen, große Community\
✅ **Agents und Tools** — baue autonome KI-Agenten\
✅ **LangSmith** — ausgezeichnete Observability und Debugging\
✅ **LCEL** — LangChain Expression Language zum Komponieren von Chains\
✅ **Memory-Systeme** — Gesprächsverlauf, Entity-Memory

### Schwächen

❌ **Komplexität** — kann für einfache Aufgaben überentwickelt sein\
❌ **Häufige Breaking Changes** — Migrationen v0.1 vs v0.2 vs v0.3\
❌ **Große Abhängigkeiten** — große Installationsgröße\
❌ **Abstraktions-Leckage** — manchmal schwerer 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: Fortgeschrittenes 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

# Setup
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"
)

# Erstelle Chain mit Quellenangabe
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": "What are the main risks?"})
print(result["answer"])
print("Sources:", result["sources"])
```

***

## LlamaIndex: Detaillierter Einblick

### Stärken

✅ **Dokumenten-zentriertes Design** — am besten für komplexe Dokumentindizierung\
✅ **Index-Typen** — Vektor, Wissensgraph, SQL, Keyword\
✅ **Sub-Question-Engine** — zerlegt automatisch komplexe Anfragen\
✅ **Strukturierte Ausgaben** — Pydantic-Integration\
✅ **Router Query Engine** — leitet intelligent an den richtigen Index weiter

### Schwächen

❌ **Weniger agenten-fokussiert** als LangChain\
❌ **Kleineres Ökosystem** als LangChain\
❌ **Dokumentation** kann inkonsistent sein

### Beste Anwendungsfälle

* Dokumenten Q\&A-Systeme (PDFs, Berichte, Wikis)
* Komplexes Multi-Dokumenten-Reasoning
* Erstellung von Wissensgraphen
* Brücken von Daten zu LLMs (Datenbanken, APIs)

### Beispiel: Multi-Dokument Query 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()

# Erstelle separate Indizes für verschiedene Dokumentenmengen
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)

# Baue Router, der den richtigen Index auswählt
tools = [
    QueryEngineTool.from_defaults(
        query_engine=index_reports.as_query_engine(),
        description="Jährliche Finanzberichte 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("What was the revenue growth last year?")
```

***

## Haystack: Detaillierter Einblick

### Stärken

✅ **Enterprise-geeignet** — Produktionszuverlässigkeit\
✅ **Visueller Pipeline-Builder** — Haystack Studio\
✅ **Annotierungstool** — integrierte Labeling-UI\
✅ **Starkes NLP** — Extraktive QA, Zusammenfassung\
✅ **deepset Cloud** — verwaltete Bereitstellungsoption

### Schwächen

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

### Beste Anwendungsfälle

* Enterprise-Dokumentensuche und Q\&A
* Projekte, die Prüfpfade und Observability benötigen
* Teams, die visuelles Pipeline-Design möchten
* Produktive Bereitstellungen mit SLA-Anforderungen

### Beispiel: Hybrid Search Pipeline

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

# Erstelle hybride Such-Pipeline
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"))

# Verbinde Komponenten
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: Detaillierter Einblick

### Stärken

✅ **Zero-Code-Bereitstellung** — vollständige UI enthalten\
✅ **Fortgeschrittenes Dokumentenparsing** — Tabellen, Bilder, Diagramme\
✅ **Wissensdatenbankverwaltung** — visuelle Oberfläche\
✅ **API enthalten** — REST-API sofort einsatzbereit\
✅ **Agentisches RAG** — integrierte Agents

### Schwächen

❌ **Weniger anpassbar** als Code-first-Frameworks\
❌ **Hoher Ressourcenbedarf** (Elasticsearch + Infinity DB)\
❌ **Begrenzte 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 komplettes Wissensdatenbank-Produkt wollen
* Interne Enterprise-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
# Greifen Sie auf die Web-UI zu unter http://<server-ip>:80
```

***

## Wann welches verwenden

### Wählen Sie LangChain, wenn:

* Sie KI-Agenten mit Tools bauen (Websuche, Codeausführung, APIs)
* Maximale Ökosystem-Flexibilität benötigt wird
* Sie komplexe mehrstufige Pipelines bauen
* Integration mit vielen verschiedenen LLMs und Datenquellen erforderlich ist
* Das Team mit Python vertraut ist

### Wählen Sie LlamaIndex, wenn:

* Der primäre Anwendungsfall Dokumenten-Q\&A ist
* Sie mit komplexen Dokumentstrukturen arbeiten (Tabellen, verschachtelte Inhalte)
* Wissensgraphen oder Multi-Index-Routing benötigt werden
* Sie bestmögliche Dokumentenaufnahme wünschen
* Sie über strukturierte Daten aufbauen (Datenbanken, APIs)

### Wählen Sie Haystack, wenn:

* Unternehmensumgebung mit Compliance-Anforderungen vorliegt
* Sie visuelle Pipeline-Building-Tools benötigen
* Sie auf Elasticsearch aufbauen
* Sie extraktive (nicht nur generative) QA wollen
* Das Team Observability für NLP-Pipelines braucht

### Wählen Sie RAGFlow, wenn:

* Ein nicht-technisches Team Self-Service-RAG braucht
* Sie ein komplettes Produkt, kein Framework, möchten
* Schnelle Bereitstellung wichtiger ist als Anpassung
* Sie eine interne Wissensdatenbank aufbauen
* Sie keinen Python-Code schreiben möchten

***

## Ausführung auf Clore.ai: Ressourcenanforderungen

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

{% hint style="warning" %}
**RAGFlow benötigt mehr RAM**: Es läuft Elasticsearch + InfinityDB + die Anwendung selbst. Planen Sie mindestens 32 GB System-RAM ein. Haystack mit Elasticsearch profitiert ebenfalls von 16 GB+ RAM.
{% endhint %}

***

## Nützliche Links

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

***

## Zusammenfassende Empfehlung

```
Einfaches Dokumenten-Q&A     → LlamaIndex
Komplexe KI-Agenten          → LangChain
Enterprise-Suche             → Haystack
No-Code RAG-Produkt          → RAGFlow
Maximale Flexibilität        → LangChain
Beste Dokumentenerkennung    → LlamaIndex
```

Alle vier Frameworks sind ausgezeichnete Optionen — das richtige hängt von Ihren spezifischen Anforderungen, den Fähigkeiten des Teams und den Bereitstellungsbeschränkungen ab. Im Zweifelsfall beginnen Sie mit **LlamaIndex** für dokumentenlastige Anwendungsfälle oder **LangChain** wenn Sie das breitestmögliche Ökosystem benötigen.

***

## Clore.ai GPU-Empfehlungen

| Anwendungsfall    | Empfohlene GPU  | Geschätzte Kosten auf Clore.ai |
| ----------------- | --------------- | ------------------------------ |
| Entwicklung/Tests | RTX 3090 (24GB) | \~$0.12/gpu/hr                 |
| Produktion        | RTX 4090 (24GB) | \~$0.70/gpu/hr                 |
| Großmaßstab       | A100 80GB       | \~$1.20/gpu/hr                 |

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