LangChain-Architektur und zentrale Abstraktionen
Sie verstehen das Komponentenmodell von LangChain, einschließlich LLMs, ChatModels, PromptTemplates, OutputParsers und Runnables, und wie diese zu Pipelines kombiniert werden.
LangChain-Architektur und zentrale Abstraktionen ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was LangChain tatsächlich ist
LangChain ist ein Framework zum Erstellen von Anwendungen, die von Sprachmodellen unterstützt werden. Statt rohe API-Aufrufe und Glue-Code selbst zu schreiben, stellt LangChain wiederverwendbare Komponenten bereit, die sich zu Pipelines verbinden lassen. Über eine einheitliche Schnittstelle werden mehrere LLM-Anbieter unterstützt (OpenAI, Anthropic, Cohere und lokale Modelle), sodass ein Anbieterwechsel nur minimale Codeänderungen erfordert.
Überblick über das Komponentenmodell
LangChain organisiert seine Bausteine in verschiedene Komponentenkategorien. LLMs und ChatModels kapseln Modellanbieter. PromptTemplates verwalten die dynamische Erstellung von Prompts. OutputParsers wandeln den rohen Modelltext in strukturierte Python-Objekte um. Runnables sind die universelle Schnittstelle, die alle Komponenten zu frei kombinierbaren Pipelines verbindet.
LLMs und ChatModels im Vergleich
LangChain unterscheidet zwischen zwei Modellschnittstellen. LLM nimmt einen String-Prompt entgegen und gibt eine String-Vervollständigung zurück – den älteren Stil der Textvervollständigung. ChatModel nimmt eine Liste von Nachrichten (System, Human, AI) entgegen und gibt ein Nachrichtenobjekt zurück. Moderne Modelle von OpenAI, Anthropic und Gemini sind allesamt ChatModels. Für neue Anwendungen sollten Sie ChatModel bevorzugen.
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
llm = ChatOpenAI(model='gpt-4o-mini')
response = llm.invoke([
SystemMessage(content='You are a helpful assistant.'),
HumanMessage(content='What is LangChain?')
])
print(response.content)PromptTemplates: Dynamische Prompts
Mit PromptTemplate können Sie einen Prompt mit Platzhaltervariablen definieren, die zur Laufzeit gefüllt werden. ChatPromptTemplate erfüllt denselben Zweck für chatbasierte Prompts mit mehreren Nachrichten. Templates trennen die Prompt-Struktur von den Laufzeitwerten und machen Prompts dadurch wiederverwendbar, testbar und einfach per Versionsverwaltung zu verwalten.
from langchain_core.prompts import ChatPromptTemplate
template = ChatPromptTemplate.from_messages([
('system', 'You are an expert in {domain}.'),
('human', 'Explain {concept} in simple terms.')
])
# Fill in variables at runtime
messages = template.invoke({'domain': 'machine learning', 'concept': 'embeddings'})
print(messages)OutputParsers: Modell-Output strukturieren
OutputParsers wandeln die rohe String-Ausgabe eines Modells in strukturierte Python-Typen um. StrOutputParser extrahiert lediglich den Inhalts-String. JsonOutputParser parst JSON. PydanticOutputParser validiert anhand eines Pydantic-Schemas. Parser erzeugen außerdem Formatierungsanweisungen, die Sie in Prompts einfügen können, um das Modell zum erwarteten Format anzuleiten.
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from pydantic import BaseModel
class MovieReview(BaseModel):
title: str
rating: int
summary: str
parser = JsonOutputParser(pydantic_object=MovieReview)
# parser.get_format_instructions() returns JSON schema instructions
print(parser.get_format_instructions()[:200])Die Runnable-Schnittstelle
Jede LangChain-Komponente implementiert die Schnittstelle Runnable, die drei zentrale Methoden definiert: invoke() für synchrone Einzelaufrufe, stream() für das Streaming einzelner Tokens und batch() für die parallele Verarbeitung mehrerer Eingaben. Da jede Komponente ein Runnable ist, können alle Komponenten mithilfe des Pipe-Operators einheitlich kombiniert werden.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model='gpt-4o-mini')
# Single call
result = llm.invoke('What is 2+2?')
# Streaming tokens
for chunk in llm.stream('Tell me a joke.'):
print(chunk.content, end='', flush=True)
# Batch processing
results = llm.batch(['What is Paris?', 'What is Rome?'])Kombinieren mit dem Pipe-Operator
Der Pipe-Operator (|) ist syntaktischer Zucker zum Erstellen von RunnableSequence-Objekten. Wenn Sie prompt | llm | parser schreiben, erstellt LangChain eine Kette, in der die Ausgabe jedes Schritts in die Eingabe des nächsten fließt. Dies bildet den Kern von LCEL – der LangChain Expression Language – und ersetzt die früheren, ausführlicheren Chain-Klassen.
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_template('Summarize this in one sentence: {text}')
llm = ChatOpenAI(model='gpt-4o-mini')
parser = StrOutputParser()
# Chain composed with pipe operator
chain = prompt | llm | parser
result = chain.invoke({'text': 'LangChain is a framework for LLM applications...'})
print(result)Dokument-Loader und Text-Splitter
Für RAG-Anwendungen stellt LangChain Document Loaders bereit, die Dateien in verschiedenen Formaten (PDF, Word, HTML, CSV) einlesen und eine Liste von Document-Objekten mit den Feldern page_content und metadata zurückgeben. Text Splitters teilen anschließend lange Dokumente in kleinere Chunks auf, die sich für Embedding und Retrieval eignen.
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
loader = PyPDFLoader('report.pdf')
docs = loader.load() # List of Document objects
splitter = RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=50
)
chunks = splitter.split_documents(docs)
print(f'Split {len(docs)} pages into {len(chunks)} chunks')Vector Stores als Runnables
LangChain kapselt Vektordatenbanken (Chroma, Pinecone, pgvector) als VectorStore-Objekte, die eine Methode similarity_search() bereitstellen. Sie können jeden VectorStore mit .as_retriever() in ein Retriever-Runnable umwandeln und dadurch in LCEL-Ketten einsetzen. Der Retriever nimmt einen Abfragestring entgegen und gibt die k relevantesten Dokumente zurück.
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)
# Convert to Retriever Runnable
retriever = vectorstore.as_retriever(
search_type='similarity',
search_kwargs={'k': 5}
)
results = retriever.invoke('How does LangChain work?')
for doc in results:
print(doc.page_content[:100])Callbacks und Observability
Mit dem Callback-System von LangChain können Sie sich in jedes Ereignis bei der Ausführung einer Kette einklinken: wenn ein LLM startet, wenn Tokens gestreamt werden, wenn eine Kette beendet wird oder wenn ein Tool aufgerufen wird. Zu den integrierten Callbacks gehört StdOutCallbackHandler für die Protokollierung in der Konsole. Drittanbieterintegrationen wie LangSmith werden über Umgebungsvariablen automatisch eingebunden und erfassen vollständige Ausführungs-Traces ohne Codeänderungen.
from langchain.callbacks import StdOutCallbackHandler
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model='gpt-4o-mini',
callbacks=[StdOutCallbackHandler()]
)
# Now every call logs input/output automatically
# Or enable LangSmith tracing globally:
import os
os.environ['LANGCHAIN_TRACING_V2'] = 'true'
os.environ['LANGCHAIN_API_KEY'] = 'your-key'Speicher und Zustand in Ketten
Standardmäßig sind LangChain-Ketten zustandslos – jede Ausführung ist unabhängig. Um ein Gesprächsgedächtnis hinzuzufügen, umschließen Sie eine Kette mit einer Speicherkomponente, die den Gesprächsverlauf speichert und einfügt. RunnableWithMessageHistory ist die native LCEL-Möglichkeit, Speicher hinzuzufügen. Dabei wird eine Funktion get_session_history übergeben, die den Verlauf anhand der Sitzungs-ID lädt.
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory
store = {} # session_id -> ChatMessageHistory
def get_session_history(session_id: str):
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]
with_history = RunnableWithMessageHistory(chain, get_session_history)
response = with_history.invoke(
{'input': 'Hi, my name is Alice'},
config={'configurable': {'session_id': 'user-1'}}
)Kurzer Wissenstest
Testen Sie Ihr Verständnis der LangChain-Architektur und der zentralen Abstraktionen.
Lektionsrückblick
In dieser Lektion haben Sie gelernt: LangChains Komponentenmodell organisiert LLMs, PromptTemplates, OutputParsers und Retriever als Runnables mit einer einheitlichen Schnittstelle, der Pipe-Operator (|) kombiniert Runnables über LCEL zu sequenziellen Ketten, und Callbacks ermöglichen Observability in jedem Schritt, ohne die Geschäftslogik zu verändern. Als Nächstes untersuchen wir das Erstellen von Ketten mit LCEL im Detail.
Häufig gestellte Fragen
Ist die Lektion „LangChain-Architektur und zentrale Abstraktionen“ kostenlos?
Ja — der vollständige Text von „LangChain-Architektur und zentrale Abstraktionen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „LangChain-Architektur und zentrale Abstraktionen“?
Sie verstehen das Komponentenmodell von LangChain, einschließlich LLMs, ChatModels, PromptTemplates, OutputParsers und Runnables, und wie diese zu Pipelines kombiniert werden. Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Engineering Academy zu starten?
Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „LangChain-Architektur und zentrale Abstraktionen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?
Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- LangChain-Architektur und zentrale Abstraktionen
- Mit LCEL Chains erstellen
- Verzweigte und parallele Chains
- Ausgaben in LangChain streamen