# LangChain dla Data Scientists w 2026: LLM, Agenci i Pytania Rekrutacyjne

> Kompletny tutorial LangChain dla analityków danych. Poznaj LCEL, wzorce RAG, agentów ReAct oraz najczęstsze pytania na rozmowach kwalifikacyjnych z praktycznymi przykładami kodu Python.

- Published: 2026-07-22
- Updated: 2026-07-22
- Author: SharpSkill
- Reading time: 12 min

---

LangChain 0.3 stał się standardowym frameworkiem do budowania aplikacji opartych na LLM w produkcyjnych procesach data science. Ten tutorial obejmuje podstawowe abstrakcje, architektury agentów oraz wzorce retrieval, które analitycy danych spotykają zarówno w rzeczywistych projektach, jak i na rozmowach technicznych.

> **LangChain w 2026**
>
> LangChain Expression Language (LCEL) umożliwia deklaratywną kompozycję łańcuchów ze streamingiem, równoległością i fallbackami. Opanowanie składni LCEL przed przejściem do agentów jest kluczowe—większość pytań rekrutacyjnych zakłada znajomość operatorów pipe i runnable'ów.

## Zrozumienie Podstawowych Komponentów LangChain

LangChain organizuje orkiestrację LLM w cztery główne abstrakcje: Models, Prompts, Chains i Agents. Każda abstrakcja buduje na poprzedniej, tworząc kompozycyjny system dla złożonych procesów AI.

Warstwa Model opakowuje różnych dostawców LLM (OpenAI, Anthropic, modele lokalne) w jednolity interfejs. Ta abstrakcja pozwala na wymianę dostawców bez zmiany logiki aplikacji—kluczowe dla optymalizacji kosztów i elastyczności wobec vendorów.

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

Jednolity interfejs oznacza, że pipeline'y danych mogą przełączać się między dostawcami w zależności od wymagań dotyczących kosztów, opóźnień lub możliwości.

## Budowanie Łańcuchów ze Składnią Pipe LCEL

LangChain Expression Language zastępuje starą klasę `LLMChain` bardziej elastyczną składnią opartą na pipe'ach. Łańcuchy LCEL to runnable'e obsługujące streaming, batching i asynchroniczne wykonywanie domyślnie.

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

Łańcuchy LCEL automatycznie obsługują konwersję typów między komponentami. Szablon promptu generuje `PromptValue`, który model konwertuje na odpowiedź, a parser strukturyzuje w schemat Pydantic.

## Retrieval-Augmented Generation dla Aplikacji Data Science

[Wzorce RAG](/blog/data-science/rag-retrieval-augmented-generation-llm-data-science-interview-2026) wzbogacają odpowiedzi LLM o kontekst specyficzny dla domeny pobierany z baz wektorowych. W aplikacjach data science RAG umożliwia odpytywanie dokumentacji, poprzednich analiz lub baz wiedzy domenowej.

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

`RunnablePassthrough` zachowuje oryginalne pytanie, podczas gdy retriever pobiera kontekst równolegle. Ten wzorzec skaluje się do obciążeń produkcyjnych z minimalnym narzutem opóźnień.

## Implementacja Agentów ReAct dla Zadań Data Science

Agenci rozszerzają łańcuchy o możliwości wywoływania narzędzi i pętle rozumowania. Wzorzec ReAct (Reasoning + Acting) przeplata kroki myślenia i działania, umożliwiając agentom rozwiązywanie wieloetapowych problemów.

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

Dekorator `@tool` rejestruje funkcje jako narzędzia agenta z automatycznym generowaniem schematu z type hintów i docstringów. Agent decyduje, kiedy wywołać każde narzędzie na podstawie wymagań zadania.

## Wzorce Pamięci dla Konwersacyjnej Analityki

Długotrwałe sesje analizy danych wymagają pamięci konwersacji, aby utrzymać kontekst między interakcjami. LangChain dostarcza wiele strategii pamięci zoptymalizowanych dla różnych przypadków użycia.

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

Wdrożenia produkcyjne zazwyczaj zastępują `InMemoryChatMessageHistory` magazynami opartymi na Redis lub PostgreSQL dla zachowania danych między restartami serwera.

## Pytania i Odpowiedzi Rekrutacyjne LangChain

Rozmowy techniczne na stanowiska ML engineering i data science coraz częściej zawierają pytania o LangChain. Zazwyczaj oceniają zrozumienie podstawowych abstrakcji, kwestii produkcyjnych oraz strategii debugowania.

> **Popularne Tematy Rekrutacyjne**
>
> Rekruterzy koncentrują się na trzech obszarach: wzorcach kompozycji łańcuchów, technikach optymalizacji RAG i strategiach niezawodności agentów. Należy spodziewać się rysowania pipeline'u retrieval na tablicy lub debugowania scenariusza halucynacji.

**P: Wyjaśnij różnicę między łańcuchami a agentami w LangChain.**

Łańcuchy wykonują z góry określoną sekwencję operacji—prompt do modelu do parsera—bez podejmowania decyzji w czasie wykonania. Agenci dodają pętlę rozumowania, która dynamicznie wybiera narzędzia na podstawie pośrednich wyników. Łańcuchy sprawdzają się w strukturalnych przepływach pracy jak pipeline'y transformacji danych; agenci obsługują otwarte zadania wymagające adaptacyjnego wyboru narzędzi.

**P: Jak zredukować halucynacje w aplikacji RAG?**

Wiele strategii działa razem: zwiększenie precyzji retrieval przez wyszukiwanie hybrydowe (łączenie dense i sparse retrieverów), dodanie scoringu istotności do filtrowania chunków o niskiej pewności, włączenie atrybucji źródeł w promptach, implementacja weryfikacji odpowiedzi względem pobranego kontekstu oraz użycie niższych ustawień temperature dla zapytań faktycznych. [Wzorce feature engineering](/technologies/data-science/interview-questions/feature-engineering) dla jakości embeddingów również wpływają na dokładność retrieval.

**P: Czym są runnable'e i dlaczego LangChain ich używa?**

Runnable'e to bazowa abstrakcja implementująca protokół `Runnable` z metodami `invoke`, `stream`, `batch` i `ainvoke`. Każdy komponent—prompty, modele, parsery, retrievery—jest runnable'm. Ta jednolitość umożliwia kompozycję operatorem pipe, gdzie typy wyjściowe automatycznie pasują do oczekiwań wejściowych. Runnable'e zapewniają również wbudowaną równoległość, logikę retry i streaming bez dodatkowego kodu.

**P: Jak zaimplementować streaming odpowiedzi dla interfejsu czatu?**

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

Metoda `stream` zwraca obiekty `AIMessageChunk` zawierające częściowe odpowiedzi. W aplikacjach webowych te chunki zazwyczaj są przekazywane do Server-Sent Events lub połączeń WebSocket.

**P: Opisz strategie testowania aplikacji LangChain.**

Testowanie aplikacji LLM wymaga wielu podejść: testy jednostkowe z mockowanymi odpowiedziami modelu dla deterministycznego zachowania łańcucha, testy integracyjne z prawdziwymi modelami dla skuteczności promptów, zbiory danych ewaluacyjnych z oczekiwanymi wynikami dla wykrywania regresji oraz narzędzia śledzenia jak [LangSmith](https://smith.langchain.com/) dla debugowania produkcyjnego. Mockowanie warstwy modelu podczas CI pozwala uniknąć kosztów API i niestabilności.

## Kwestie Wdrożenia Produkcyjnego

Wdrażanie aplikacji LangChain wymaga uwagi na opóźnienia, koszty i niezawodność wykraczającej poza to, co ujawniają środowiska deweloperskie.

> **Zarządzanie Kosztami Tokenów**
>
> Produkcyjne aplikacje RAG mogą generować znaczne koszty tokenów. Należy zaimplementować middleware do liczenia tokenów, ustawić alerty budżetowe i rozważyć strategie cachowania dla powtarzających się zapytań. Pojedyncza pętla agenta z wieloma wywołaniami narzędzi może zużyć tysiące tokenów na żądanie.

Cachowanie redukuje zarówno opóźnienia, jak i koszty dla powtarzających się zapytań. Warstwa cachowania LangChain przechowuje odpowiedzi modelu z kluczem hash promptu:

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

Dla [pipeline'ów MLOps](/blog/data-science/mlops-mlflow-model-registry-interview-questions-2026) warto zintegrować LangChain z śledzeniem eksperymentów w celu monitorowania wersji promptów, konfiguracji modeli i metryk jakości odpowiedzi w czasie.

## Podsumowanie

- LangChain 0.3 organizuje orkiestrację LLM w Models, Prompts, Chains i Agents—każda abstrakcja jest kompozycyjna przez składnię pipe LCEL
- Implementacje RAG wymagają dostrojonych progów retrieval, scoringu istotności i formatowania kontekstu dla dokładności produkcyjnej
- Agenci ReAct obsługują wieloetapowe zadania data science poprzez rozumowanie o wyborze narzędzi w czasie wykonania
- Wzorce pamięci utrzymują kontekst konwersacji między sesjami analizy przy użyciu magazynów wiadomości z kluczem sesji
- Przygotowanie do rozmów powinno obejmować rozróżnienie łańcuch vs agent, strategie redukcji halucynacji i wzorce kompozycji runnable'ów
- Wdrożenia produkcyjne wymagają cachowania, budżetowania tokenów i narzędzi obserwowalności dla zarządzania kosztami i niezawodnością

---

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