LangChain: Framework für LLM-Anwendungen

Was dieser Artikel über LangChain behandelt

• Was LangChain ist und wofür Du es nutzen kannst.
• Die zentralen Begriffe: Chain, Prompt Template, Retriever, Agent und mehr.
• Warum ein Framework der reinen API oftmals vorzuziehen ist.
• Installation und ein erstes laufendes Beispiel mit Ollama.
• Wie RAG und Agenten mit LangChain funktionieren.
• Typische Fehler und Stolpersteine beim Einstieg.

Einleitung: LangChain verständlich erklärt

LangChain ist ein Open-Source-Framework für Python und JavaScript, mit dem Du Anwendungen auf Basis von Large Language Models aufbauen kannst. Es bietet vorgefertigte Bausteine, die Du zu einer Chain zusammensetzen kannst. Eine Chain ist ein durchlaufbares Ablauf aus Prompt, Modellaufruf und Antwortverarbeitung.

Viele wiederkehrende Aufgaben sind bereits gelöst: das Einlesen von PDFs, die Suche in einem Vector Store, der Aufruf einer Suchmaschine oder das Umwandeln der Modellantwort in eine saubere Struktur. Du musst also weniger Klebe-Code schreiben und kannst Dich auf die eigene Logik konzentrieren.

LangGraph, das auf LangChain aufbaut, behandeln wir in einem eigenen Artikel unter LangGraph, damit wir nicht zweimal denselben Inhalt durchgehen.

Warum brauche ich LangChain?

Stell Dir vor, Du möchtest ein lokales LLM mit einem PDF und einer Websuche verbinden. Ohne Framework kombinierst Du mehrere Bibliotheken mit unterschiedlichen APIs. LangChain nimmt Dir viel dieses Klebe-Codes ab. Du lädst ein PDF mit einem Document Loader, splittest es in Chunks, speicherst diese in einem Vector Store und bindest die Ergebnisse in eine Chain ein. Für die Websuche wählst Du ein passendes Tool aus dem Paket.

Außerdem ist LangChain portabel. Viele Komponenten funktionieren sowohl mit Cloud-APIs als auch mit lokalen Modellen. Wenn Du bei Ollama startest und später ein anderes Modell ausprobieren willst, änderst Du oft nur eine Zeile.

LangChain kurz erklärt

Im Kern bietet LangChain folgende Komponenten:

• Models: Abstraktionen für Chat Models, LLMs und Embeddings.
• Prompt Templates: Vorlagen, die Eingaben in ein konsistentes Format bringen.
• Document Loaders: Module, die Dateiformate in Text umwandeln.
• Text Splitters: Hilfsmittel, um lange Texte in Chunks zu zerlegen.
• Vector Stores: Datenbanken für semantische Suche.
• Retrievers: Komponenten, die relevante Dokumente aus einem Vector Store holen.
• Output Parser: Werkzeuge, um Modellantworten in feste Strukturen zu pressen.
• Chains: Verknüpfte Schritte, die wie eine Pipeline ausgeführt werden.
• Agents: Komponenten, die selbstständig entscheiden, welche Tools sie verwenden.
• Memory: Möglichkeiten, Kontext über mehrere Nachrichten hinweg zu speichern.

Der neueste Stil heißt LCEL, das LangChain Expression Language. Damit verkettest Du Komponenten mit dem Pipe-Operator |, fast wie bei Unix-Pipes.

Für wen ist LangChain gedacht?

LangChain richtet sich an Entwickler, die Sprachmodelle in Anwendungen einbauen wollen. Du solltest mit Python oder JavaScript vertraut sein und nicht vor pip oder npm zurückschrecken. Vorkenntnisse in RAG oder Agenten erleichtern den Einstieg, sind aber kein Muss. Wenn Du lieber visuell arbeitest, ist LangFlow passender. Für komplexe Zustandsgraphen lohnt sich LangGraph.

Wichtige Begriffe rund um LangChain

Begriff	Bedeutung
Chain	Eine zusammenhängende Abfolge von Schritten, meist Prompt, Modell und Parser.
Prompt Template	Eine Vorlage, die Eingaben in ein konsistentes Format für das Modell bringt.
Retriever	Eine Komponente, die passende Dokumente aus einem Vector Store zurückgibt.
Document Loader	Ein Modul, das PDFs, Textdateien oder Webseiten in Dokumente umwandelt.
Output Parser	Hilft, die Modellausgabe in eine gewünschte Struktur wie Listen oder Objekte zu wandeln.
Agent	Ein Mechanismus, der selbst entscheidet, welche Tools und Schritte nötig sind.
Tool	Eine Funktion, die ein Agent oder eine Chain aufrufen kann, etwa eine Websuche.
Memory	Speicher für vergangene Nachrichten oder Zwischenergebnisse.
Callback	Ein Hook, mit dem Du Ereignisse während der Ausführung loggen kannst.
LCEL	LangChain Expression Language, die Pipe-Notation für das Verketten von Komponenten.

LangChain vs. reine API

Für ein einfaches Prompt-Antwort-Spiel ist die direkte API oft schneller. Sobald Du aber mehrere Schritte kombinierst, stoßt Du an folgende Punkte:

• Wiederholungen: Prompt-Formate, Retry-Logik und Fehlerbehandlung musst Du selbst implementieren.
• Formatwechsel: Jeder Modellanbieter hat ein anderes Nachrichtenformat. LangChain gleicht diese Unterschiede aus.
• Datenintegration: PDFs, Webseiten und Vektorspeicher anzuschließen erzeugt viel Kleinkram.
• Wartbarkeit: Eine Chain aus vorgefertigten Komponenten ist leichter zu lesen und anzupassen.

LangChain ist kein Muss, aber ein sinnvolles Hilfsmittel, sobald Deine Anwendung über reine Prompts hinauswächst.

Installation

Für die meisten Beispiele reichen folgende Befehle:

pip install langchain langchain-community langchain-ollama

Für PDFs ergänzt Du:

pip install pypdf

Für Chroma als Vektorspeicher:

pip install chromadb

Für JavaScript:

npm install langchain

Verwende Python 3.9 oder neuer. Ollama muss installiert sein und mindestens ein Modell bereitliegen. Mehr dazu im Artikel Ollama.

Erstes Beispiel

Ein einfacher Einstieg ist eine Chain aus Prompt Template, Modell und Output Parser:

from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

model = ChatOllama(model="llama3.2")

prompt = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein freundlicher Assistent, der kurz und klar antwortet."),
    ("human", "Erkläre mir {thema} in drei Sätzen."),
])

parser = StrOutputParser()

chain = prompt | model | parser

antwort = chain.invoke({"thema": "LangChain"})
print(antwort)

Das Prompt Template nimmt die Variable thema entgegen, das Modell antwortet, und der Parser liefert den reinen Text.

RAG mit LangChain

RAG, also Retrieval-Augmented Generation, ist ein häufiger Anwendungsfall. Der Ablauf ist:

1. Lade Dokumente mit einem Document Loader.
2. Teile sie in kleine Chunks.
3. Berechne Embeddings und speichere sie in einem Vector Store.
4. Hole beim Anfragen die passendsten Chunks ab.
5. Führe die gefundenen Chunks und die Nutzerfrage in einer Chain zusammen.

Ein minimales Beispiel mit Ollama, einem PDF und Chroma:

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_ollama import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_ollama import ChatOllama
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_retrieval_chain
from langchain_core.prompts import ChatPromptTemplate

loader = PyPDFLoader("dokument.pdf")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)

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

retriever = vectorstore.as_retriever()

model = ChatOllama(model="llama3.2")

prompt = ChatPromptTemplate.from_messages([
    ("system", "Beantworte die Frage ausschließlich anhand des bereitgestellten Kontexts."),
    ("human", "Kontext: {context}\n\nFrage: {input}"),
])

combine_chain = create_stuff_documents_chain(model, prompt)
rag_chain = create_retrieval_chain(retriever, combine_chain)

antwort = rag_chain.invoke({"input": "Was steht im Dokument zum Thema Kosten?"})
print(antwort["answer"])

Das Muster kannst Du auf verschiedene Dateitypen, Embedding-Modelle und Vector Stores übertragen. Mehr Hintergrund findest Du in Lokales RAG und RAG Grundlagen.

Agenten mit LangChain

Agenten entscheiden selbst, welche Tools sie aufrufen. Ein einfaches ReAct-Beispiel:

from langchain_ollama import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub

model = ChatOllama(model="llama3.2")
tools = [DuckDuckGoSearchRun()]

prompt = hub.pull("hwchase17/react")

agent = create_react_agent(model, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

antwort = agent_executor.invoke({"input": "Wie ist das Wetter heute in Berlin?"})
print(antwort["output"])

Nicht jedes Modell beherrscht Tool-Calling zuverlässig. Qwen, Mistral oder Command R eignen sich hier oft besser als sehr kleine Varianten. Mehr dazu in Tool-Calling und Was ist ein KI-Agent.

LangChain und Ollama

LangChain spricht Ollama über die Klassen ChatOllama, Ollama und OllamaEmbeddings an:

• ChatOllama: Für Chat Prompts mit Rollen wie system, human und ai.
• Ollama: Für Text-Completion-Modelle.
• OllamaEmbeddings: Für lokale Embeddings in RAG-Projekten.

Beispiel für ChatOllama:

from langchain_ollama import ChatOllama

model = ChatOllama(
    model="llama3.2",
    temperature=0.7,
    base_url="http://localhost:11434"
)

antwort = model.invoke("Erkläre LangChain in einem Satz.")
print(antwort.content)

Achte darauf, dass Ollama läuft und das gewählte Modell bereits verfügbar ist. Mehr zur API gibt es im Artikel Ollama API.

LangChain vs. LangGraph vs. LangFlow

Aspekt	LangChain	LangGraph	LangFlow
Ebene	Framework für Chains und Integrationen.	Auf LangChain aufbauende Graphen-Engine.	Visueller Editor für LangChain-Abläufe.
Code	Python oder JavaScript.	Python oder JavaScript.	No-Code bis Low-Code.
Starke	Schnelle Prototypen, RAG, Tool-Calling.	Zustandsbasierte Workflows, Schleifen, Multi-Agent.	Übersichtliche visuelle Pipelines.
Steuerfluss	Linear oder bedingt über Chains.	Als Graph mit Knoten und Kanten.	Über verbundene Bausteine.
Lernkurve	Moderat.	Etwas höher.	Niedrig, wenn man keine Programmierung mag.
Ideal für	Erste Projekte und etablierte Pipelines.	Komplexe Entscheidungsbäume.	Experimentieren und Demonstrieren.

LangGraph behandeln wir gesondert, da es eigene Konzepte wie State, Nodes und Conditional Edges einführt. LangFlow eignet sich, um Abläufe ohne tiefen Code-Einstieg zu verstehen. LangChain bleibt der gemeinsame Boden für beide.

Typische Stolpersteine bei LangChain

• Falsche Modellklasse verwenden: Ollama und ChatOllama sind nicht austauschbar. Für Chat-Prompts brauchst Du ChatOllama.
• Token-Limit ignorieren: Lange Chains mit viel Kontext können das Kontextfenster sprengen.
• Output Parser falsch wählen: JsonOutputParser scheitert, wenn das Modell kein valides JSON liefert. StrOutputParser ist für den Start sicherer.
• Retriever liefert schlechte Treffer: RAG hängt stark von Chunking, Embedding-Modell und Top-k-Parametern ab.
• Agenten mit schwachem Modell: Kleine Modelle verstehen Tool-Calling oft nicht zuverlässig.
• Versionskonfusion: Alte Tutorials greifen auf veraltete Import-Pfade wie langchain.chat_models zurück.
• Fehlende Fehlerbehandlung: API-Aufrufe können fehlschlagen. Setze von Anfang an try-except-Blöcke oder Retries ein.
• Zu viele Abhängigkeiten: Installiere nur die Integrationen, die Du tatsächlich nutzt.

Hardware, Kosten und Sicherheit bei LangChain

LangChain selbst ist kostenlos und Open Source. Kosten entstehen durch Modelle und Infrastruktur. Lokal zahlst Du für Hardware und Strom, nicht pro Aufruf. Cloud-APIs kosten pro Token, laufen aber auf schwächerer Hardware.

Für den lokalen Betrieb gilt: Je größer das Modell, desto mehr RAM oder VRAM brauchst Du. Ein 7B-Modell läuft dank Quantisierung oft auf 8 GB VRAM, größere Varianten fordern deutlich mehr. RAG erzeugt zusätzliche Last durch Embeddings und Vektorspeicher, bleibt aber vergleichsweise günstig.

Sicherheit ist wichtig, sobald Agenten Websuchen oder Dateien lesen dürfen. Prüfe Berechtigungen und Sandboxing, bevor Du ein Deployment öffentlich zugänglich machst.

Weiterführende Links und Infos zu LangChain

• Entwicklungs-Tools Übersicht für verwandte Frameworks.
• LangGraph für komplexe zustandsbasierte Abläufe.
• LangFlow für den visuellen Ansatz.
• Was ist ein KI-Agent für das Agentenkonzept.
• Tool-Calling für externe Funktionen.
• Lokales RAG und RAG Grundlagen für datenbasierte Anwendungen.
• Ollama und Ollama API für den lokalen Modellbetrieb.

FAQ: LangChain - Typische Fragen

Ist LangChain kostenlos?

Ja. Das Framework selbst ist Open Source. Kosten entstehen nur durch Modelle, Hosting oder Zusatzdienste.

Brauche ich Python-Kenntnisse?

Ja für die meisten Anleitungen. Es gibt auch eine JavaScript-Version, aber der Python-Stack ist am weitesten verbreitet.

Kann ich LangChain vollständig lokal betreiben?

Ja. Mit Ollama, lokalen Modellen und lokalen Vektorspeichern wie Chroma oder FAISS ist das möglich.

Was ist der Unterschied zwischen LangChain und LlamaIndex?

LangChain deckt Chains, Tools und Agenten ab. LlamaIndex fokussiert sich stärker auf RAG und den Umgang mit eigenen Daten.

Welches Modell eignet sich für LangChain am besten?

Für einfache Chains reichen kleine Modelle wie Llama 3.2. Für RAG und Agenten greifst Du zu stärkeren Varianten wie Mistral, Qwen oder Command R.

Wie lerne ich am besten?

Baue ein erstes Chain-Beispiel, erweitere um RAG und probiere dann Agenten aus. BotServ.de bietet passende Einstiegsartikel.

Warum gibt es so viele langchain-*-Pakete?

LangChain wurde aufgeteilt, um Abhängigkeiten sauber zu halten. langchain ist der Kern, langchain-community enthält Integrationen, langchain-ollama bindet Ollama an.

Was ist LCEL?

LCEL steht für LangChain Expression Language. Damit verkettest Du Komponenten mit dem Pipe-Operator.

Kann ich LangChain mit meinem eigenen Fine-Tuned-Modell nutzen?

Ja, solange das Modell über eine kompatible Schnittstelle erreichbar ist.

Gibt es Alternativen zu LangChain?

Ja. Neben LlamaIndex, LangGraph und LangFlow sind CrewAI, Haystack oder eigene Implementierungen Optionen.

Wie stabil ist die API?

LangChain entwickelt sich schnell. Achte darauf, dass Tutorials zur installierten Version passen, um veraltete Importe zu vermeiden.

Quellen und weiterführende Literatur

• LangChain Documentation: https://python.langchain.com/
• LangChain JS/TS Documentation: https://js.langchain.com/
• LangChain GitHub Repository: https://github.com/langchain-ai/langchain
• Ollama LangChain-Integration: https://python.langchain.com/docs/integrations/chat/ollama/
• LangGraph: https://langchain-ai.github.io/langgraph/
• LangFlow: https://www.langflow.org/