# LangChain voor Data Scientists in 2026: LLMs, Agents en Sollicitatievragen

> Beheers LangChain 0.3 voor data science: LCEL-chains, RAG-patronen, ReAct-agents en memory-systemen. Inclusief sollicitatievragen en productie-deployment strategieën.

- 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 heeft zich gevestigd als het de facto framework voor het bouwen van LLM-aangedreven applicaties in productie data science workflows. Deze tutorial behandelt de kernabstracties, agent-architecturen en retrieval-patronen die data scientists tegenkomen in zowel echte projecten als technische sollicitatiegesprekken.

> **LangChain in 2026**
>
> LangChain Expression Language (LCEL) maakt declaratieve chain-compositie mogelijk met streaming, parallelisatie en fallbacks. LCEL-syntax moet worden beheerst voordat men aan agents begint - de meeste sollicitatievragen veronderstellen bekendheid met pipe-operators en runnables.

## Begrip van LangChain Kerncomponenten

LangChain organiseert LLM-orchestratie in vier primaire abstracties: Models, Prompts, Chains en Agents. Elke abstractie bouwt voort op de vorige, waardoor een composeerbaar systeem ontstaat voor complexe AI-workflows.

De Model-laag wikkelt verschillende LLM-providers (OpenAI, Anthropic, lokale modellen) achter een uniforme interface. Deze abstractie maakt het mogelijk om van provider te wisselen zonder applicatielogica te wijzigen - cruciaal voor kostenoptimalisatie en leveranciersflexibiliteit.

```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)
```

De uniforme interface betekent dat datapipelines kunnen schakelen tussen providers op basis van kosten-, latentie- of capaciteitsvereisten.

## Chains Bouwen met LCEL Pipe-Syntax

LangChain Expression Language vervangt de verouderde `LLMChain`-klasse met een flexibelere pipe-gebaseerde syntax. LCEL-chains zijn runnables die standaard streaming, batching en asynchrone uitvoering ondersteunen.

```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 handelen automatisch typeconversie tussen componenten af. Het prompt-template produceert een `PromptValue`, die het model omzet in een respons, die de parser structureert in het Pydantic-schema.

## Retrieval-Augmented Generation voor Data-Applicaties

[RAG-patronen](/blog/data-science/rag-retrieval-augmented-generation-llm-data-science-interview-2026) verbeteren LLM-responses met domeinspecifieke context opgehaald uit vectordatabases. Voor data science-applicaties maakt RAG het mogelijk om documentatie, eerdere analyses of domeinkennisbases te bevragen.

```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?")
```

De `RunnablePassthrough` bewaart de oorspronkelijke vraag terwijl de retriever parallel de context ophaalt. Dit patroon schaalt naar productie-workloads met minimale latentie-overhead.

## ReAct-Agents Implementeren voor Datataken

Agents breiden chains uit met tool-calling mogelijkheden en redeneerloops. Het ReAct-patroon (Reasoning + Acting) verweft denk- en actiestappen, waardoor agents meerstaps-problemen kunnen oplossen.

```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")]
})
```

De `@tool`-decorator registreert functies als agent-tools met automatische schemageneratie uit type hints en docstrings. De agent beslist wanneer elke tool wordt aangeroepen op basis van de taakvereisten.

## Memory-Patronen voor Conversationele Analytics

Langlopende data-analysesessies vereisen conversatie-memory om context te behouden over interacties heen. LangChain biedt meerdere memory-strategieën geoptimaliseerd voor verschillende use cases.

```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
```

Productie-deployments vervangen typisch `InMemoryChatMessageHistory` door Redis- of PostgreSQL-backed stores voor persistentie over server-herstarts.

## LangChain Sollicitatievragen en Antwoorden

Technische sollicitatiegesprekken voor ML engineering- en data science-posities bevatten steeds vaker LangChain-vragen. Deze beoordelen typisch begrip van kernabstracties, productie-overwegingen en debuggingstrategieën.

> **Veelvoorkomende Sollicitatieonderwerpen**
>
> Interviewers richten zich op drie gebieden: chain-compositiepatronen, RAG-optimalisatietechnieken en agent-betrouwbaarheidsstrategieën. Verwacht een retrieval-pipeline op het whiteboard te ontwerpen of een hallucinatiescenario te debuggen.

**V: Leg het verschil uit tussen chains en agents in LangChain.**

Chains voeren een vooraf bepaalde reeks operaties uit - prompt naar model naar parser - zonder runtime-beslissingen. Agents voegen een redeneerloop toe die dynamisch tools selecteert op basis van tussenresultaten. Chains zijn geschikt voor gestructureerde workflows zoals datatransformatie-pipelines; agents handelen open-ended taken af die adaptieve toolselectie vereisen.

**V: Hoe verminder je hallucinaties in een RAG-applicatie?**

Meerdere strategieën werken samen: verhoog retrieval-precisie met hybride zoeken (combinatie van dense en sparse retrievers), voeg relevantie-scoring toe om chunks met lage confidence te filteren, neem bronattributie op in prompts, implementeer antwoordverificatie tegen opgehaalde context en gebruik lagere temperature-instellingen voor feitelijke queries. De [feature engineering-patronen](/technologies/data-science/interview-questions/feature-engineering) voor embedding-kwaliteit beïnvloeden ook de retrieval-nauwkeurigheid.

**V: Wat zijn runnables en waarom gebruikt LangChain ze?**

Runnables zijn de basisabstractie die het `Runnable`-protocol implementeert met `invoke`, `stream`, `batch` en `ainvoke`-methoden. Elk component - prompts, modellen, parsers, retrievers - is een runnable. Deze uniformiteit maakt compositie mogelijk met de pipe-operator, waarbij outputtypes automatisch aansluiten bij inputverwachtingen. Runnables bieden ook ingebouwde parallelisatie, retry-logica en streaming zonder extra code.

**V: Hoe zou je streaming-responses implementeren voor een chat-interface?**

```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)
```

De `stream`-methode produceert `AIMessageChunk`-objecten met gedeeltelijke responses. Voor webapplicaties voeden deze chunks typisch Server-Sent Events of WebSocket-verbindingen.

**V: Beschrijf strategieën voor het testen van LangChain-applicaties.**

Het testen van LLM-applicaties vereist meerdere benaderingen: unit tests met gemockte modelresponses voor deterministisch chain-gedrag, integratietests met echte modellen voor prompt-effectiviteit, evaluatiedatasets met verwachte outputs voor regressiedetectie en tracing-tools zoals [LangSmith](https://smith.langchain.com/) voor productie-debugging. Mock de modellaag tijdens CI om API-kosten en flakyness te vermijden.

## Productie-Deployment Overwegingen

Het deployen van LangChain-applicaties vereist aandacht voor latentie, kosten en betrouwbaarheid voorbij wat ontwikkelomgevingen onthullen.

> **Token-Kostenbeheer**
>
> Productie-RAG-applicaties kunnen aanzienlijke tokenkosten genereren. Implementeer token-telling middleware, stel budgetalarmen in en overweeg cachingstrategieën voor herhaalde queries. Een enkele agent-loop met meerdere tool-calls kan duizenden tokens per verzoek verbruiken.

Caching vermindert zowel latentie als kosten voor herhaalde queries. De cachinglaag van LangChain slaat modelresponses op geïndexeerd op prompt-hash:

```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
```

Voor [MLOps-pipelines](/blog/data-science/mlops-mlflow-model-registry-interview-questions-2026), integreer LangChain met experiment tracking om promptversies, modelconfiguraties en response-kwaliteitsmetrieken in de tijd te monitoren.

## Conclusie

- LangChain 0.3 organiseert LLM-orchestratie in Models, Prompts, Chains en Agents - elke abstractie composeerbaar via LCEL pipe-syntax
- RAG-implementaties vereisen afgestemde retrieval-drempels, relevantie-scoring en contextformattering voor productie-nauwkeurigheid
- ReAct-agents handelen meerstaps-datataken af door te redeneren over toolselectie tijdens runtime
- Memory-patronen behouden conversatiecontext over analysesessies heen met sessie-gebaseerde message stores
- Sollicitatievoorbereiding moet chain-vs-agent-onderscheidingen, hallucinatie-reductiestrategieën en runnable-compositiepatronen omvatten
- Productie-deployments hebben caching, token-budgettering en observability-tooling nodig voor kosten- en betrouwbaarheidsbeheer

---

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