Was ist LangChain und warum sollten Sie es lernen?
Künstliche Intelligenz revolutioniert die Softwareentwicklung, und LangChain steht an vorderster Front dieser Revolution. Wenn Sie nach einem umfassenden LangChain Tutorial suchen, das Sie von den Grundlagen bis zur produktionsreifen KI-Anwendung führt, sind Sie hier genau richtig. Dieses LangChain Tutorial zeigt Ihnen Schritt für Schritt, wie Sie leistungsstarke KI-Apps mit Python entwickeln und dabei die Fähigkeiten moderner Large Language Models (LLMs) voll ausschöpfen.
LangChain ist ein Open-Source-Framework, das die Entwicklung von Anwendungen mit Large Language Models (LLMs) wie GPT-4, Claude oder Llama drastisch vereinfacht. Es bietet modulare Bausteine für Prompt-Management, Chains, Agents, Memory und Integration mit externen Datenquellen – alles, was Sie brauchen, um intelligente, kontextbewusste Anwendungen zu erstellen.
Warum LangChain?
- Modularität: Wiederverwendbare Komponenten für schnelle Entwicklung
- LLM-Agnostisch: Unterstützt OpenAI, Anthropic, Hugging Face, lokale Modelle und mehr
- Production-Ready: Integrierte Fehlerbehandlung, Caching und Monitoring
- Riesiges Ökosystem: Hunderte von Integrationen (Datenbanken, APIs, Tools)
- RAG-Unterstützung: Retrieval-Augmented Generation out-of-the-box
- Agents: Autonome KI-Systeme, die Tools nutzen und Probleme lösen können
Voraussetzungen für dieses LangChain Tutorial
Um diesem Tutorial folgen zu können, benötigen Sie:
- Python 3.9+: Installiert und lauffähig
- pip oder Poetry: Package Manager für Python
- API-Keys: OpenAI, Anthropic oder andere LLM-Provider (kostenlose Testversionen verfügbar)
- Code-Editor: VS Code, PyCharm oder ähnliches
- Grundkenntnisse Python: Funktionen, Klassen, async/await
- Optional: Git für Version Control
Geschätzte Bearbeitungszeit
- Schnelldurchlauf: 2-3 Stunden
- Mit Praxisprojekt: 6-8 Stunden
- Vollständige Vertiefung: 2-3 Tage
Schritt 1: Installation und Setup
Beginnen wir mit einer sauberen Python-Umgebung:
Virtuelle Umgebung erstellen
1
2
3
4
5
6
7
8
9
10
11
12
| # Projekt-Verzeichnis erstellen
mkdir langchain-tutorial
cd langchain-tutorial
# Virtuelle Umgebung erstellen
python3 -m venv venv
# Aktivieren (Linux/Mac)
source venv/bin/activate
# Aktivieren (Windows)
venv\Scripts\activate |
LangChain installieren
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| # Basis-Installation
pip install langchain
# Mit OpenAI-Unterstützung
pip install langchain-openai
# Mit Community-Integrationen
pip install langchain-community
# Für Vektordatenbanken
pip install chromadb
# Für Document Loading
pip install pypdf unstructured
# Alle abhängigkeiten auf einmal
pip install langchain langchain-openai langchain-community chromadb pypdf python-dotenv |
Requirements.txt erstellen
1
2
3
4
5
6
7
| langchain==0.1.0
langchain-openai==0.0.5
langchain-community==0.0.16
chromadb==0.4.22
pypdf==4.0.1
python-dotenv==1.0.0
openai==1.10.0 |
Schritt 2: API-Keys sicher konfigurieren
Sicherheit first! Speichern Sie API-Keys niemals direkt im Code.
.env-Datei erstellen
1
2
3
4
| # .env
OPENAI_API_KEY=sk-proj-...
ANTHROPIC_API_KEY=sk-ant-...
HUGGINGFACE_API_KEY=hf_... |
Keys laden und verwenden
1
2
3
4
5
6
7
8
9
10
11
12
| from dotenv import load_dotenv
import os
# .env-Datei laden
load_dotenv()
# Keys abrufen
openai_key = os.getenv("OPENAI_API_KEY")
# Sicherstellen, dass Key vorhanden ist
if not openai_key:
raise ValueError("OPENAI_API_KEY nicht gefunden!") |
.gitignore anlegen
1
2
3
4
5
6
| # .gitignore
.env
venv/
__pycache__/
*.pyc
.DS_Store |
Schritt 3: Erstes LLM-Setup – “Hello World”
Lassen Sie uns Ihr erstes LLM-Programm schreiben:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
# Environment laden
load_dotenv()
# LLM initialisieren
llm = ChatOpenAI(
model="gpt-4",
temperature=0.7,
max_tokens=500
)
# Erste Abfrage
response = llm.invoke("Erkläre LangChain in einem Satz.")
print(response.content) |
Alternative LLM-Provider
1
2
3
4
5
6
7
8
9
10
11
| # Anthropic Claude
from langchain_anthropic import ChatAnthropic
llm = ChatAnthropic(model="claude-3-sonnet-20240229")
# Hugging Face
from langchain_community.llms import HuggingFaceHub
llm = HuggingFaceHub(repo_id="google/flan-t5-xxl")
# Lokales Modell (Ollama)
from langchain_community.llms import Ollama
llm = Ollama(model="llama2") |
Schritt 4: Prompt Templates – Strukturierte Eingaben
Prompt Templates ermöglichen wiederverwendbare, parametrisierte Prompts:
Einfaches Template
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| from langchain.prompts import PromptTemplate
# Template definieren
template = """
Du bist ein hilfreicher Assistent für {fachgebiet}.
Beantworte die folgende Frage auf Deutsch:
Frage: {frage}
Antwort:
"""
prompt = PromptTemplate(
input_variables=["fachgebiet", "frage"],
template=template
)
# Template befüllen
formatted_prompt = prompt.format(
fachgebiet="Python-Programmierung",
frage="Was sind Decorators?"
)
# An LLM senden
response = llm.invoke(formatted_prompt)
print(response.content) |
Chat-Prompt-Template
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| from langchain.prompts import ChatPromptTemplate
chat_prompt = ChatPromptTemplate.from_messages([
("system", "Du bist ein Experte für {expertise}. Antworte präzise und hilfreich."),
("human", "{user_input}")
])
# Verwenden
messages = chat_prompt.format_messages(
expertise="Machine Learning",
user_input="Erkläre Overfitting."
)
response = llm.invoke(messages)
print(response.content) |
Schritt 5: Chains – Verkettung von Operationen
Chains kombinieren mehrere Schritte zu einem Workflow:
Einfache LLMChain
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| from langchain.chains import LLMChain
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
llm = ChatOpenAI(model="gpt-4")
prompt = PromptTemplate(
input_variables=["produkt"],
template="Schreibe einen Marketing-Slogan für {produkt}."
)
chain = LLMChain(llm=llm, prompt=prompt)
# Chain ausführen
result = chain.run(produkt="KI-gestützte Projektmanagement-Software")
print(result) |
Sequential Chain – Mehrstufige Verarbeitung
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| from langchain.chains import SimpleSequentialChain
# Chain 1: Idee generieren
chain1 = LLMChain(
llm=llm,
prompt=PromptTemplate(
input_variables=["thema"],
template="Generiere eine innovative Geschäftsidee für: {thema}"
)
)
# Chain 2: Idee bewerten
chain2 = LLMChain(
llm=llm,
prompt=PromptTemplate(
input_variables=["idee"],
template="Bewerte diese Geschäftsidee auf Machbarkeit (1-10): {idee}"
)
)
# Chains verketten
sequential_chain = SimpleSequentialChain(chains=[chain1, chain2])
# Ausführen
result = sequential_chain.run("Nachhaltige Mobilität")
print(result) |
Schritt 6: Document Loading – Daten einlesen
LangChain kann Dokumente aus verschiedenen Quellen laden:
PDF laden
1
2
3
4
5
6
7
| from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader("dokument.pdf")
pages = loader.load_and_split()
print(f"Anzahl Seiten: {len(pages)}")
print(f"Erste Seite: {pages[0].page_content[:500]}") |
Website laden
1
2
3
4
5
6
| from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://beispiel.de/artikel")
docs = loader.load()
print(docs[0].page_content[:1000]) |
Mehrere Dateien laden
1
2
3
4
5
6
7
8
9
10
11
| from langchain_community.document_loaders import DirectoryLoader
from langchain_community.document_loaders import TextLoader
loader = DirectoryLoader(
'./daten/',
glob="**/*.txt",
loader_cls=TextLoader
)
documents = loader.load()
print(f"Geladene Dokumente: {len(documents)}") |
Schritt 7: RAG mit Vector Stores – Semantische Suche
Retrieval-Augmented Generation (RAG) ermöglicht es, LLMs mit eigenen Daten zu erweitern:
Texte in Vektordatenbank speichern
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
# Dokumente in Chunks aufteilen
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200
)
chunks = text_splitter.split_documents(documents)
# Embeddings erstellen
embeddings = OpenAIEmbeddings()
# Vektordatenbank erstellen
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=embeddings,
persist_directory="./chroma_db"
)
print(f"Chunks gespeichert: {len(chunks)}") |
Semantische Suche durchführen
1
2
3
4
5
6
7
| # Ähnliche Dokumente finden
query = "Wie funktioniert Machine Learning?"
docs = vectorstore.similarity_search(query, k=3)
for i, doc in enumerate(docs):
print(f"\n--- Dokument {i+1} ---")
print(doc.page_content[:300]) |
RAG-Chain erstellen
1
2
3
4
5
6
7
8
9
10
11
| from langchain.chains import RetrievalQA
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)
# Frage stellen
antwort = qa_chain.run("Was sind die Hauptvorteile von LangChain?")
print(antwort) |
Schritt 8: Agents mit Tools – Autonome KI
Agents können selbstständig Tools nutzen, um Probleme zu lösen:
Tools definieren
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| from langchain.agents import Tool
from langchain_community.utilities import GoogleSearchAPIWrapper
import datetime
# Tool 1: Websuche
search = GoogleSearchAPIWrapper()
search_tool = Tool(
name="Websuche",
func=search.run,
description="Nützlich für aktuelle Informationen aus dem Internet."
)
# Tool 2: Rechner
def rechner(eingabe: str) -> str:
try:
return str(eval(eingabe))
except:
return "Fehler bei der Berechnung"
rechner_tool = Tool(
name="Rechner",
func=rechner,
description="Führt mathematische Berechnungen durch. Eingabe: Python-Ausdruck"
)
# Tool 3: Datum
def datum_tool(eingabe: str) -> str:
return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
datum = Tool(
name="Datum",
func=datum_tool,
description="Gibt das aktuelle Datum und Uhrzeit zurück."
)
tools = [search_tool, rechner_tool, datum] |
Agent initialisieren
1
2
3
4
5
6
7
8
9
10
11
12
| from langchain.agents import initialize_agent, AgentType
agent = initialize_agent(
tools=tools,
llm=llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True # Zeigt Denkprozess
)
# Agent ausführen
antwort = agent.run("Wie spät ist es und was ist 1234 * 5678?")
print(antwort) |
Schritt 9: Memory – Konversationsgeschichte
Memory ermöglicht es, den Kontext über mehrere Interaktionen hinweg zu behalten:
Conversation Buffer Memory
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
memory = ConversationBufferMemory()
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=True
)
# Mehrere Nachrichten
print(conversation.predict(input="Hallo, ich bin Max."))
print(conversation.predict(input="Was ist mein Name?"))
print(conversation.predict(input="Erzähl mir einen Witz.")) |
Summary Memory – Für lange Konversationen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| from langchain.memory import ConversationSummaryMemory
summary_memory = ConversationSummaryMemory(llm=llm)
conversation = ConversationChain(
llm=llm,
memory=summary_memory,
verbose=True
)
# Längere Konversation
for i in range(5):
response = conversation.predict(input=f"Nachricht {i+1}: Erzähl mir etwas Interessantes.")
print(response) |
Schritt 10: Deployment – Production Ready
FastAPI-Server erstellen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| from fastapi import FastAPI
from pydantic import BaseModel
from langchain_openai import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
app = FastAPI()
# LLM und Memory initialisieren
llm = ChatOpenAI(model="gpt-4")
memory = ConversationBufferMemory()
conversation = ConversationChain(llm=llm, memory=memory)
class Query(BaseModel):
message: str
@app.post("/chat")
async def chat(query: Query):
response = conversation.predict(input=query.message)
return {"response": response}
# Server starten: uvicorn main:app --reload |
Docker-Container
1
2
3
4
5
6
7
8
9
10
11
| # Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"] |
Environment Variables für Production
1
2
3
4
5
6
7
8
9
| import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model=os.getenv("LLM_MODEL", "gpt-4"),
temperature=float(os.getenv("LLM_TEMPERATURE", "0.7")),
max_tokens=int(os.getenv("LLM_MAX_TOKENS", "1000")),
request_timeout=int(os.getenv("LLM_TIMEOUT", "30"))
) |
Praxisprojekt: RAG-Chatbot für Dokumentation
Jetzt bauen wir ein komplettes Projekt: Einen Chatbot, der Ihre Dokumentation kennt.
1. Projekt-Struktur
1
2
3
4
5
6
7
| rag-chatbot/
├── main.py
├── requirements.txt
├── .env
├── data/
│ └── docs/ # Ihre Dokumentation hier
└── chroma_db/ # Wird automatisch erstellt |
2. Vollständiger Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
| import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
load_dotenv()
class RAGChatbot:
def __init__(self, docs_path="./data/docs", db_path="./chroma_db"):
self.llm = ChatOpenAI(model="gpt-4", temperature=0.7)
self.embeddings = OpenAIEmbeddings()
self.docs_path = docs_path
self.db_path = db_path
self.vectorstore = None
self.chain = None
def load_documents(self):
"""Dokumente laden und in Chunks aufteilen"""
loader = DirectoryLoader(
self.docs_path,
glob="**/*.txt",
loader_cls=TextLoader
)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200
)
chunks = text_splitter.split_documents(documents)
print(f"✅ {len(documents)} Dokumente geladen, {len(chunks)} Chunks erstellt")
return chunks
def create_vectorstore(self, chunks):
"""Vektordatenbank erstellen"""
self.vectorstore = Chroma.from_documents(
documents=chunks,
embedding=self.embeddings,
persist_directory=self.db_path
)
print(f"✅ Vektordatenbank erstellt")
def setup_chain(self):
"""RAG-Chain mit Memory konfigurieren"""
memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True,
output_key="answer"
)
self.chain = ConversationalRetrievalChain.from_llm(
llm=self.llm,
retriever=self.vectorstore.as_retriever(search_kwargs={"k": 3}),
memory=memory,
return_source_documents=True
)
print("✅ RAG-Chain konfiguriert")
def initialize(self):
"""Komplettes Setup"""
# Prüfen, ob DB existiert
if os.path.exists(self.db_path):
print("⚡ Lade bestehende Vektordatenbank...")
self.vectorstore = Chroma(
persist_directory=self.db_path,
embedding_function=self.embeddings
)
else:
print("📚 Erstelle neue Vektordatenbank...")
chunks = self.load_documents()
self.create_vectorstore(chunks)
self.setup_chain()
print("🚀 Chatbot bereit!\n")
def chat(self, question):
"""Frage stellen"""
result = self.chain({"question": question})
answer = result["answer"]
sources = result.get("source_documents", [])
print(f"\n🤖 Antwort: {answer}\n")
if sources:
print("📄 Quellen:")
for i, doc in enumerate(sources[:2], 1):
print(f" {i}. {doc.metadata.get('source', 'Unbekannt')}")
return answer
# Hauptprogramm
if __name__ == "__main__":
chatbot = RAGChatbot()
chatbot.initialize()
# Interaktive Chat-Schleife
print("💬 Stellen Sie Ihre Fragen (oder 'exit' zum Beenden):\n")
while True:
frage = input("Sie: ")
if frage.lower() in ["exit", "quit", "bye"]:
print("👋 Auf Wiedersehen!")
break
if frage.strip():
chatbot.chat(frage) |
3. Testen
1
2
3
4
5
6
7
| # Dokumentation in data/docs/ ablegen, dann:
python main.py
# Beispiel-Fragen:
# - "Wie installiere ich das System?"
# - "Welche Features gibt es?"
# - "Gibt es ein Tutorial?" |
Fehlerbehebung: Häufige Probleme
Problem 1: “RateLimitError” von OpenAI
Lösung: Retry-Logic implementieren:
1
2
3
4
5
6
7
| from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="gpt-4",
max_retries=3,
request_timeout=60
) |
Problem 2: Vektordatenbank zu groß
Lösung: Chunk-Size reduzieren oder Filter verwenden:
1
2
3
4
5
6
| retriever = vectorstore.as_retriever(
search_kwargs={
"k": 3,
"filter": {"source": "important_docs"}
}
) |
Problem 3: Memory wächst zu stark
Lösung: ConversationSummaryMemory oder Token-Limit:
1
2
3
4
5
6
| from langchain.memory import ConversationTokenBufferMemory
memory = ConversationTokenBufferMemory(
llm=llm,
max_token_limit=2000
) |
Best Practices für Production
1. Caching implementieren
1
2
3
4
| from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache
set_llm_cache(InMemoryCache()) |
2. Error Handling
1
2
3
4
5
6
7
| from langchain.schema import HumanMessage
try:
response = llm.invoke([HumanMessage(content=prompt)])
except Exception as e:
print(f"LLM-Fehler: {e}")
# Fallback-Logik |
3. Monitoring
1
2
3
4
5
6
| from langchain.callbacks import get_openai_callback
with get_openai_callback() as cb:
result = chain.run(query)
print(f"Kosten: ${cb.total_cost}")
print(f"Tokens: {cb.total_tokens}") |
4. Streaming für bessere UX
1
2
3
4
5
6
| from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
llm = ChatOpenAI(
streaming=True,
callbacks=[StreamingStdOutCallbackHandler()]
) |
Weiterführende Ressourcen
- Offizielle Dokumentation: python.langchain.com
- GitHub: github.com/langchain-ai/langchain
- Discord Community: discord.gg/langchain
- Cookbook: github.com/langchain-ai/langchain/tree/master/cookbook
- YouTube-Kanal: LangChain Official
Fazit: Ihr Weg zur KI-App-Entwicklung mit LangChain
Herzlichen Glückwunsch! Sie haben nun ein umfassendes LangChain Tutorial durchlaufen und alle wesentlichen Konzepte kennengelernt – von der Installation über Prompt-Engineering und RAG bis hin zu autonomen Agents und Production Deployment.
Die wichtigsten Erkenntnisse aus diesem LangChain Tutorial:
- Modularität ist King: Nutzen Sie wiederverwendbare Komponenten (Chains, Tools, Memory)
- RAG erweitert LLMs: Integrieren Sie eigene Daten für präzisere Antworten
- Agents sind mächtig: Lassen Sie KI selbstständig Tools nutzen
- Production braucht Planung: Error Handling, Monitoring, Caching sind essentiell
- Sicherheit geht vor: API-Keys schützen, Input validieren
Nächste Schritte
- Eigenes Projekt starten: Wenden Sie das Gelernte auf einen echten Use Case an
- Community beitreten: Tauschen Sie sich mit anderen Entwicklern aus
- Erweiterte Konzepte: LangSmith für Debugging, LangServe für Deployment
- Alternative Modelle testen: Probieren Sie Claude, Llama, Mistral
- Performance optimieren: Prompt-Engineering, Caching, Model-Selection
LangChain entwickelt sich rasant weiter – bleiben Sie am Ball, experimentieren Sie und bauen Sie die KI-Anwendungen der Zukunft! Mit diesem Tutorial haben Sie das Fundament gelegt, um professionelle, skalierbare LLM-Applikationen zu entwickeln.
Haben Sie Fragen zu diesem LangChain Tutorial? Hinterlassen Sie einen Kommentar oder kontaktieren Sie unsere KI-Experten für individuelle Unterstützung bei Ihrem Projekt!
- Über den Autor
- Aktuelle Beiträge
Mark ist IT-Administrator beim EDV-Dienstleister Biteno GmbH und schreibt außerdem für die Redaktion von Text-Center.
