LangChain vs LlamaIndex — Framework-Vergleich

LangChain und LlamaIndex sind die zwei wichtigsten Frameworks für LLM-Anwendungsentwicklung. Aber welches ist das richtige für Ihr Projekt?

Die Philosophien

LangChain

"Alles ist eine Chain." LangChain ist ein general-purpose Framework für LLM-Anwendungen — von einfachen Prompts bis zu komplexen Agenten. Größtes Ökosystem, meisten Integrationen.

LlamaIndex

"Alles ist Daten." LlamaIndex ist spezialisiert auf Datenanbindung an LLMs — RAG, Dokumentenverarbeitung, strukturierte Daten. Fokus auf Retrieval und Indexierung.

Feature-Vergleich

| Feature | LangChain | LlamaIndex |
|---------|-----------|------------|
| RAG-Pipelines | ✅ | ✅ (Spezialität) |
| Multi-Agent Systems | ✅ (LangGraph) | ✅ (Workflows) |
| Vector-Store Integration | 80+ | 60+ |
| LLM-Provider | 70+ | 50+ |
| Document Loaders | 100+ | 160+ (Spezialität) |
| Output Parsers | 30+ | 15+ |
| Memory/History | ✅ | ✅ |
| Streaming | ✅ | ✅ |
| Tool-Calling Agent | ✅ (LangGraph) | ✅ |
| Structured Output | ✅ | ✅ |
| Evaluation | LangSmith | LlamaDebug |

RAG-Fähigkeiten

| Aspekt | LangChain | LlamaIndex |
|--------|-----------|------------|
| Basic RAG | ✅ | ✅ |
| Multi-Query Retrieval | ✅ | ✅ |
| Hybrid Retrieval (BM25 + Vector) | ✅ | ✅ (besser integriert) |
| Re-Ranking | ✅ (via Module) | ✅ (eingebaut) |
| Query Transformation | ✅ | ✅ (Spezialität) |
| Document Chunking | ✅ (Standard) | ✅ (Semantic Chunking, Sentence Window) |
| Query Engine | ❌ | ✅ (vorgefertigte Engines) |
| Structured Data (SQL) | ✅ | ✅ (besser) |

Sieger RAG: LlamaIndex — tiefere RAG-Funktionen, bessere Document Loader, mehr Retrieval-Strategien.

Agent-Fähigkeiten

| Aspekt | LangChain | LlamaIndex |
|--------|-----------|------------|
| ReAct Agent | ✅ | ✅ |
| Multi-Agent Orchestration | ✅ (LangGraph) | ✅ (Workflows) |
| Tool Integration | ✅ (sehr viele) | ✅ |
| Custom Tools | ✅ | ✅ |
| State Management | ✅ (LangGraph) | ✅ (Context) |
| Human-in-the-Loop | ✅ (LangGraph) | ✅ |
| Complex Workflows | ✅ (LangGraph) | ✅ |

Sieger Agent: LangChain (LangGraph) — mächtigere Multi-Agent-Systeme und komplexere Workflows.

Code-Vergleich: Einfache RAG

LangChain

``python
from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

Load

docs = PyPDFLoader("doc.pdf").load()
chunks = RecursiveCharacterTextSplitter().split_documents(docs)

Index

vs = Chroma.from_documents(chunks, OllamaEmbeddings(model="nomic-embed-text"))

Chain

prompt = ChatPromptTemplate.from_template("Answer: {context}\n\nQ: {question}")
llm = ChatOllama(model="llama3.1")
chain = ({"context": vs.as_retriever(), "question": RunnablePassthrough()}
| prompt | llm)

print(chain.invoke("Was steht im Dokument?"))
`

LlamaIndex


`python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Config

Settings.llm = Ollama(model="llama3.1")
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text")

Load + Index (in einem Schritt)

docs = SimpleDirectoryReader(input_files=["doc.pdf"]).load_data()
index = VectorStoreIndex.from_documents(docs)

Query

query_engine = index.as_query_engine(similarity_top_k=5)
print(query_engine.query("Was steht im Dokument?"))
`

Erkenntnis: LlamaIndex benötigt weniger Code für einfaches RAG. LangChain ist modularer.

LangGraph (LangChain-Erweiterung)

LangGraph ist das mächtigste Tool für komplexe AI-Agenten:

`python
from langgraph.graph import StateGraph, END

graph = StateGraph(AgentState)
graph.add_node("researcher", research_agent)
graph.add_node("writer", writing_agent)
graph.add_node("reviewer", review_agent)
graph.add_edge("researcher", "writer")
graph.add_conditional_edges("writer", should_revise, {
True: "reviewer", False: END
})
graph.add_edge("reviewer", "writer")

app = graph.compile()
`

LlamaIndex bietet ähnliche Funktionalität mit Workflows, aber LangGraph ist ausgereifter.

Lernkurve

| Aspekt | LangChain | LlamaIndex |
|--------|-----------|------------|
| Erste Schritte | Mittel | Einfach |
| Basic RAG | ~50 Zeilen | ~15 Zeilen |
| Komplexe Apps | Steile Kurve | Mittlere Kurve |
| Dokumentation | Sehr umfangreich (manchmal verwirrend) | Sehr gut strukturiert |
| Community | Größter Discord | Aktiver Discord |

Wann welches Framework?

LangChain — wenn Sie:

Komplexe Multi-Agent-Systeme bauen

Viele verschiedene Tools integrieren wollen

LangSmith für Monitoring/Tracing nutzen möchten

Allgemeinere LLM-Anwendungen bauen (nicht nur RAG)

Maximale Flexibilität brauchen

LlamaIndex — wenn Sie:

RAG-Anwendungen bauen (Hauptanwendung)

Effiziente Dokumentenverarbeitung brauchen

Strukturierte Daten (SQL, APIs) an LLMs anbinden

Weniger Code schreiben wollen

Spezialisierte Query-Engines brauchen (Sub-Question, Router, etc.)

Beide kombinieren

Ja! LlamaIndex kann als Document Loader in LangChain verwendet werden. LangChain-Tools in LlamaIndex-Agenten:

`python
from llama_index.core import VectorStoreIndex
from langchain.tools import Tool

index = VectorStoreIndex.from_documents(docs)
query_engine = index.as_query_engine()

langchain_tool = Tool(
name="DocumentQuery",
description="Frag deine Dokumente",
func=lambda q: str(query_engine.query(q))
)
`

FAQ

Welches ist beliebter?

LangChain hat mehr GitHub-Stars (90.000+ vs 35.000+), aber LlamaIndex wächst schneller im RAG-Bereich.

Welches ist schneller in Produktion?

Beide sind Production-Ready. LlamaIndex hat mit LlamaDeploy` eine einfachere Deployment-Lösung. LangChain mit LangServe ebenfalls gut.

Brauche ich überhaupt ein Framework?

Für einfache API-Aufrufe: nein. Für RAG, Agenten oder komplexe Workflows: ja. Ein Framework spart Wochen an Entwicklungszeit.

Fazit

Für RAG und Datenanbindung: LlamaIndex — bessere Document Loader, Query Engines und weniger Code.

Für komplexe Agenten-Systeme: LangChain (mit LangGraph) — mächtiger, flexibler, größeres Ökosystem.

Für die meisten Projekte: Starten Sie mit LlamaIndex für RAG und greifen Sie auf LangChain zurück, wenn Sie Agenten oder komplexere Workflows brauchen.