# LangChain für Data Scientists 2026: LLMs, Agents und Interview-Fragen

> LangChain 0.3 für Data Science beherrschen: LCEL-Chains, RAG-Muster, ReAct-Agents und Memory-Systeme. Inklusive Interview-Fragen und Produktions-Deployment-Strategien.

- Published: 2026-07-22
- Updated: 2026-07-22
- Author: SharpSkill
- Tags: langchain, llm, data-science, agents, rag, interview
- Reading time: 12 min

---

LangChain 0.3 hat sich als De-facto-Framework für die Entwicklung LLM-gestützter Anwendungen in produktiven Data-Science-Workflows etabliert. Dieses Tutorial behandelt die zentralen Abstraktionen, Agent-Architekturen und Retrieval-Muster, mit denen Data Scientists sowohl in realen Projekten als auch in technischen Interviews konfrontiert werden.

> **LangChain im Jahr 2026**
>
> LangChain Expression Language (LCEL) ermöglicht deklarative Chain-Komposition mit Streaming, Parallelisierung und Fallbacks. Die LCEL-Syntax sollte vor dem Einstieg in Agents beherrscht werden – die meisten Interview-Fragen setzen Vertrautheit mit Pipe-Operatoren und Runnables voraus.

## Verständnis der LangChain-Kernkomponenten

LangChain organisiert die LLM-Orchestrierung in vier primäre Abstraktionen: Models, Prompts, Chains und Agents. Jede Abstraktion baut auf der vorherigen auf und schafft ein komponierbares System für komplexe KI-Workflows.

Die Model-Schicht umhüllt verschiedene LLM-Anbieter (OpenAI, Anthropic, lokale Modelle) hinter einer einheitlichen Schnittstelle. Diese Abstraktion ermöglicht den Wechsel zwischen Anbietern ohne Änderung der Anwendungslogik – entscheidend für Kostenoptimierung und Anbieterflexibilität.

```python
# langchain_setup.py
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, SystemMessage

# Initialize with specific model and temperature
openai_model = ChatOpenAI(
    model="gpt-4o",
    temperature=0.1,  # Lower temperature for deterministic outputs
    max_tokens=2048
)

# Anthropic model with same interface
anthropic_model = ChatAnthropic(
    model="claude-sonnet-4-20250514",
    temperature=0.1
)

# Both models accept identical message format
messages = [
    SystemMessage(content="You are a data science expert."),
    HumanMessage(content="Explain gradient boosting in one sentence.")
]

# Swap models without changing message structure
response = openai_model.invoke(messages)
```

Die einheitliche Schnittstelle bedeutet, dass Datenpipelines basierend auf Kosten-, Latenz- oder Leistungsanforderungen zwischen Anbietern wechseln können.

## Chains mit LCEL-Pipe-Syntax erstellen

LangChain Expression Language ersetzt die veraltete `LLMChain`-Klasse durch eine flexiblere Pipe-basierte Syntax. LCEL-Chains sind Runnables, die standardmäßig Streaming, Batching und asynchrone Ausführung unterstützen.

```python
# lcel_chain.py
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from pydantic import BaseModel, Field

# Define structured output schema
class DataInsight(BaseModel):
    metric: str = Field(description="The metric being analyzed")
    trend: str = Field(description="Upward, downward, or stable")
    confidence: float = Field(description="Confidence score 0-1")

# Create prompt template with variables
prompt = ChatPromptTemplate.from_messages([
    ("system", "Analyze the following data and extract insights."),
    ("human", "Dataset: {dataset_description}\nFocus on: {metric}")
])

# LCEL chain with pipe operator
model = ChatOpenAI(model="gpt-4o", temperature=0)
parser = JsonOutputParser(pydantic_object=DataInsight)

chain = prompt | model | parser  # Pipe syntax composes runnables

# Invoke with input dictionary
result = chain.invoke({
    "dataset_description": "Monthly sales data showing 15% increase",
    "metric": "revenue growth"
})
# Returns: DataInsight(metric='revenue growth', trend='upward', confidence=0.85)
```

LCEL-Chains handhaben automatisch die Typkonvertierung zwischen Komponenten. Das Prompt-Template gibt einen `PromptValue` aus, den das Modell in eine Antwort umwandelt, die der Parser in das Pydantic-Schema strukturiert.

## Retrieval-Augmented Generation für Datenanwendungen

[RAG-Muster](/blog/data-science/rag-retrieval-augmented-generation-llm-data-science-interview-2026) verbessern LLM-Antworten mit domänenspezifischem Kontext, der aus Vektordatenbanken abgerufen wird. Für Data-Science-Anwendungen ermöglicht RAG die Abfrage von Dokumentation, früheren Analysen oder Domänenwissensbasen.

```python
# rag_pipeline.py
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_chroma import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

# Initialize embeddings and vector store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma(
    collection_name="data_docs",
    embedding_function=embeddings,
    persist_directory="./chroma_db"
)

# Create retriever with relevance threshold
retriever = vectorstore.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={"score_threshold": 0.7, "k": 4}
)

# RAG prompt with context injection
rag_prompt = ChatPromptTemplate.from_messages([
    ("system", """Answer based on the provided context only.
Context: {context}
If the context doesn't contain relevant information, say so."""),
    ("human", "{question}")
])

# Format documents into context string
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# RAG chain with parallel retrieval
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | ChatOpenAI(model="gpt-4o", temperature=0)
)

# Query with automatic retrieval
answer = rag_chain.invoke("What normalization method works best for skewed distributions?")
```

Der `RunnablePassthrough` bewahrt die ursprüngliche Frage, während der Retriever parallel den Kontext abruft. Dieses Muster skaliert auf Produktions-Workloads mit minimalem Latenz-Overhead.

## ReAct-Agents für Datenaufgaben implementieren

Agents erweitern Chains um Tool-Calling-Fähigkeiten und Reasoning-Schleifen. Das ReAct-Muster (Reasoning + Acting) verschachtelt Denk- und Handlungsschritte, wodurch Agents mehrstufige Probleme lösen können.

```python
# react_agent.py
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
import pandas as pd
import numpy as np

# Define data analysis tools
@tool
def calculate_statistics(data: str, column: str) -> str:
    """Calculate descriptive statistics for a column in CSV data."""
    df = pd.read_csv(pd.io.common.StringIO(data))
    stats = df[column].describe()
    return stats.to_string()

@tool
def detect_outliers(data: str, column: str, method: str = "iqr") -> str:
    """Detect outliers using IQR or Z-score method."""
    df = pd.read_csv(pd.io.common.StringIO(data))
    values = df[column]
    
    if method == "iqr":
        q1, q3 = values.quantile([0.25, 0.75])
        iqr = q3 - q1
        outliers = values[(values < q1 - 1.5 * iqr) | (values > q3 + 1.5 * iqr)]
    else:  # z-score
        z_scores = np.abs((values - values.mean()) / values.std())
        outliers = values[z_scores > 3]
    
    return f"Found {len(outliers)} outliers: {outliers.tolist()[:10]}"

@tool
def correlation_analysis(data: str, col1: str, col2: str) -> str:
    """Calculate Pearson correlation between two columns."""
    df = pd.read_csv(pd.io.common.StringIO(data))
    corr = df[col1].corr(df[col2])
    return f"Correlation between {col1} and {col2}: {corr:.4f}"

# Create ReAct agent with tools
model = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [calculate_statistics, detect_outliers, correlation_analysis]

agent = create_react_agent(
    model=model,
    tools=tools,
    state_modifier="You are a data analyst. Use tools to analyze data step by step."
)

# Agent reasons about which tools to use
result = agent.invoke({
    "messages": [("human", "Analyze the sales column for outliers and basic stats")]
})
```

Der `@tool`-Decorator registriert Funktionen als Agent-Tools mit automatischer Schema-Generierung aus Type-Hints und Docstrings. Der Agent entscheidet basierend auf den Aufgabenanforderungen, wann jedes Tool aufgerufen wird.

## Memory-Muster für konversationelle Analytik

Langlaufende Datenanalysesitzungen erfordern Konversations-Memory, um den Kontext über Interaktionen hinweg aufrechtzuerhalten. LangChain bietet mehrere Memory-Strategien, die für verschiedene Anwendungsfälle optimiert sind.

```python
# memory_patterns.py
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# Initialize model and prompt with history placeholder
model = ChatOpenAI(model="gpt-4o", temperature=0.1)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a data science assistant helping with analysis."),
    MessagesPlaceholder(variable_name="history"),  # Inject conversation history
    ("human", "{input}")
])

chain = prompt | model

# Session-based message store
message_stores = {}

def get_session_history(session_id: str):
    if session_id not in message_stores:
        message_stores[session_id] = InMemoryChatMessageHistory()
    return message_stores[session_id]

# Wrap chain with message history
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history"
)

# Conversation maintains context across invocations
config = {"configurable": {"session_id": "analysis_session_1"}}

response1 = chain_with_history.invoke(
    {"input": "I'm analyzing customer churn data with 50k rows"},
    config=config
)
# Later in the same session
response2 = chain_with_history.invoke(
    {"input": "What sampling strategy should I use for this dataset size?"},
    config=config
)  # Agent remembers the 50k rows context
```

Produktions-Deployments ersetzen typischerweise `InMemoryChatMessageHistory` durch Redis- oder PostgreSQL-gestützte Speicher für Persistenz über Server-Neustarts hinweg.

## LangChain-Interview-Fragen und Antworten

Technische Interviews für ML-Engineering- und Data-Science-Positionen beinhalten zunehmend LangChain-Fragen. Diese bewerten typischerweise das Verständnis von Kernabstraktionen, Produktionsüberlegungen und Debugging-Strategien.

> **Häufige Interview-Themen**
>
> Interviewer konzentrieren sich auf drei Bereiche: Chain-Kompositionsmuster, RAG-Optimierungstechniken und Agent-Zuverlässigkeitsstrategien. Erwarten Sie, eine Retrieval-Pipeline auf dem Whiteboard zu entwerfen oder ein Halluzinationsszenario zu debuggen.

**F: Erklären Sie den Unterschied zwischen Chains und Agents in LangChain.**

Chains führen eine vorbestimmte Sequenz von Operationen aus – Prompt zu Modell zu Parser – ohne Laufzeitentscheidungen. Agents fügen eine Reasoning-Schleife hinzu, die dynamisch Tools basierend auf Zwischenergebnissen auswählt. Chains eignen sich für strukturierte Workflows wie Datentransformations-Pipelines; Agents handhaben offene Aufgaben, die adaptive Tool-Auswahl erfordern.

**F: Wie reduzieren Sie Halluzinationen in einer RAG-Anwendung?**

Mehrere Strategien wirken zusammen: Erhöhung der Retrieval-Präzision mit Hybrid-Suche (Kombination aus Dense- und Sparse-Retrievern), Hinzufügen von Relevanz-Scoring zum Filtern von Chunks mit niedriger Konfidenz, Einbeziehung von Quellenattribution in Prompts, Implementierung von Antwortverifikation gegen abgerufenen Kontext und Verwendung niedrigerer Temperature-Einstellungen für faktische Abfragen. Die [Feature-Engineering-Muster](/technologies/data-science/interview-questions/feature-engineering) für Embedding-Qualität beeinflussen ebenfalls die Retrieval-Genauigkeit.

**F: Was sind Runnables und warum verwendet LangChain sie?**

Runnables sind die Basisabstraktion, die das `Runnable`-Protokoll mit `invoke`, `stream`, `batch` und `ainvoke`-Methoden implementiert. Jede Komponente – Prompts, Modelle, Parser, Retriever – ist ein Runnable. Diese Einheitlichkeit ermöglicht Komposition mit dem Pipe-Operator, wobei Ausgabetypen automatisch zu Eingabeerwartungen passen. Runnables bieten auch integrierte Parallelisierung, Retry-Logik und Streaming ohne zusätzlichen Code.

**F: Wie würden Sie Streaming-Antworten für eine Chat-Oberfläche implementieren?**

```python
# streaming_example.py
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template("Explain {concept} in detail")
model = ChatOpenAI(model="gpt-4o", streaming=True)

chain = prompt | model

# Stream yields chunks as they arrive
for chunk in chain.stream({"concept": "backpropagation"}):
    print(chunk.content, end="", flush=True)
```

Die `stream`-Methode liefert `AIMessageChunk`-Objekte mit partiellen Antworten. Für Webanwendungen werden diese Chunks typischerweise in Server-Sent Events oder WebSocket-Verbindungen eingespeist.

**F: Beschreiben Sie Strategien zum Testen von LangChain-Anwendungen.**

Das Testen von LLM-Anwendungen erfordert mehrere Ansätze: Unit-Tests mit gemockten Modellantworten für deterministisches Chain-Verhalten, Integrationstests mit echten Modellen für Prompt-Effektivität, Evaluierungsdatensätze mit erwarteten Ausgaben zur Regressionserkennung und Tracing-Tools wie [LangSmith](https://smith.langchain.com/) für Produktions-Debugging. Die Model-Schicht sollte während der CI gemockt werden, um API-Kosten und Flakiness zu vermeiden.

## Überlegungen zum Produktions-Deployment

Das Deployment von LangChain-Anwendungen erfordert Aufmerksamkeit für Latenz, Kosten und Zuverlässigkeit über das hinaus, was Entwicklungsumgebungen offenbaren.

> **Token-Kostenmanagement**
>
> Produktions-RAG-Anwendungen können erhebliche Token-Kosten verursachen. Implementieren Sie Token-Zählung-Middleware, setzen Sie Budget-Alerts und erwägen Sie Caching-Strategien für wiederholte Abfragen. Eine einzelne Agent-Schleife mit mehreren Tool-Aufrufen kann Tausende von Tokens pro Anfrage verbrauchen.

Caching reduziert sowohl Latenz als auch Kosten für wiederholte Abfragen. Die Caching-Schicht von LangChain speichert Modellantworten, die nach Prompt-Hash verschlüsselt sind:

```python
# caching_setup.py
from langchain_core.globals import set_llm_cache
from langchain_community.cache import RedisCache
import redis

# Redis cache for distributed deployments
redis_client = redis.Redis(host="localhost", port=6379)
set_llm_cache(RedisCache(redis_client))

# Subsequent identical queries hit cache
model = ChatOpenAI(model="gpt-4o")
response1 = model.invoke("What is gradient descent?")  # API call
response2 = model.invoke("What is gradient descent?")  # Cache hit
```

Für [MLOps-Pipelines](/blog/data-science/mlops-mlflow-model-registry-interview-questions-2026) sollte LangChain mit Experiment-Tracking integriert werden, um Prompt-Versionen, Modellkonfigurationen und Antwortqualitätsmetriken über die Zeit zu überwachen.

## Fazit

- LangChain 0.3 organisiert LLM-Orchestrierung in Models, Prompts, Chains und Agents – jede Abstraktion komponierbar über LCEL-Pipe-Syntax
- RAG-Implementierungen erfordern abgestimmte Retrieval-Schwellenwerte, Relevanz-Scoring und Kontextformatierung für Produktionsgenauigkeit
- ReAct-Agents handhaben mehrstufige Datenaufgaben durch Reasoning über Tool-Auswahl zur Laufzeit
- Memory-Muster erhalten den Konversationskontext über Analysesitzungen hinweg mittels sitzungsbasierter Message-Stores
- Interview-Vorbereitung sollte Chain-vs-Agent-Unterscheidungen, Halluzinations-Reduktionsstrategien und Runnable-Kompositionsmuster abdecken
- Produktions-Deployments benötigen Caching, Token-Budgetierung und Observability-Tooling für Kosten- und Zuverlässigkeitsmanagement

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/de/blog/data-science/langchain-data-scientists-llms-agents-interview-2026