# LangChain для Data Scientists у 2026: LLM, Агенти та Питання на Співбесідах

> Повний туторіал LangChain для аналітиків даних. Вивчіть LCEL, патерни RAG, агентів ReAct та найпоширеніші питання на технічних співбесідах з практичними прикладами коду Python.

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

---

LangChain 0.3 став стандартним фреймворком для побудови LLM-додатків у продакшн-процесах data science. Цей туторіал охоплює базові абстракції, архітектури агентів та патерни retrieval, з якими аналітики даних стикаються як у реальних проектах, так і на технічних співбесідах.

> **LangChain у 2026**
>
> LangChain Expression Language (LCEL) забезпечує декларативну композицію ланцюгів зі стримінгом, паралелізацією та fallback-ами. Опанування синтаксису LCEL перед переходом до агентів є критичним—більшість питань на співбесідах передбачає знання pipe-операторів та runnable-ів.

## Розуміння Базових Компонентів LangChain

LangChain організовує оркестрацію LLM у чотири основні абстракції: Models, Prompts, Chains та Agents. Кожна абстракція будується на попередній, створюючи композиційну систему для складних AI-процесів.

Шар Model обгортає різних провайдерів LLM (OpenAI, Anthropic, локальні моделі) в уніфікований інтерфейс. Ця абстракція дозволяє змінювати провайдерів без зміни логіки застосунку—критично важливо для оптимізації витрат та гнучкості щодо вендорів.

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

Уніфікований інтерфейс означає, що data pipeline-и можуть перемикатися між провайдерами залежно від вимог до вартості, затримки або можливостей.

## Побудова Ланцюгів із Синтаксисом Pipe LCEL

LangChain Expression Language замінює застарілий клас `LLMChain` гнучкішим синтаксисом на основі pipe. Ланцюги LCEL — це runnable-и, що підтримують стримінг, батчинг та асинхронне виконання за замовчуванням.

```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 автоматично обробляють конвертацію типів між компонентами. Шаблон промпту генерує `PromptValue`, який модель конвертує у відповідь, а парсер структурує у схему Pydantic.

## Retrieval-Augmented Generation для Застосунків Data Science

[Патерни RAG](/blog/data-science/rag-retrieval-augmented-generation-llm-data-science-interview-2026) збагачують відповіді LLM доменно-специфічним контекстом, отриманим з векторних баз даних. У застосунках data science RAG дозволяє запитувати документацію, попередні аналізи або бази знань предметної області.

```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` зберігає оригінальне питання, поки retriever паралельно отримує контекст. Цей патерн масштабується до продакшн-навантажень з мінімальними накладними витратами на затримку.

## Імплементація Агентів ReAct для Задач Data Science

Агенти розширюють ланцюги можливостями виклику інструментів та циклами міркування. Патерн ReAct (Reasoning + Acting) чергує кроки мислення та дії, дозволяючи агентам вирішувати багатокрокові проблеми.

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

Декоратор `@tool` реєструє функції як інструменти агента з автоматичною генерацією схеми з type hint-ів та docstring-ів. Агент вирішує, коли викликати кожен інструмент на основі вимог задачі.

## Патерни Пам'яті для Розмовної Аналітики

Довготривалі сесії аналізу даних потребують пам'яті розмови для підтримки контексту між взаємодіями. LangChain надає кілька стратегій пам'яті, оптимізованих для різних випадків використання.

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

Продакшн-розгортання зазвичай замінюють `InMemoryChatMessageHistory` на сховища на базі Redis або PostgreSQL для збереження даних між перезапусками сервера.

## Питання та Відповіді на Співбесідах з LangChain

Технічні співбесіди на позиції ML engineering та data science дедалі частіше включають питання про LangChain. Зазвичай вони оцінюють розуміння базових абстракцій, продакшн-аспектів та стратегій налагодження.

> **Поширені Теми Співбесід**
>
> Інтерв'юери зосереджуються на трьох областях: патерни композиції ланцюгів, техніки оптимізації RAG та стратегії надійності агентів. Варто очікувати малювання retrieval pipeline на дошці або налагодження сценарію галюцинацій.

**П: Поясніть різницю між ланцюгами та агентами в LangChain.**

Ланцюги виконують заздалегідь визначену послідовність операцій—промпт до моделі до парсера—без прийняття рішень під час виконання. Агенти додають цикл міркування, який динамічно вибирає інструменти на основі проміжних результатів. Ланцюги підходять для структурованих робочих процесів, як-от pipeline-и трансформації даних; агенти обробляють відкриті задачі, що потребують адаптивного вибору інструментів.

**П: Як зменшити галюцинації в RAG-застосунку?**

Кілька стратегій працюють разом: підвищення точності retrieval через гібридний пошук (поєднання dense та sparse retriever-ів), додавання скорингу релевантності для фільтрації чанків з низькою впевненістю, включення атрибуції джерел у промптах, імплементація верифікації відповідей відносно отриманого контексту та використання нижчих налаштувань temperature для фактичних запитів. [Патерни feature engineering](/technologies/data-science/interview-questions/feature-engineering) для якості ембедингів також впливають на точність retrieval.

**П: Що таке runnable-и і чому LangChain їх використовує?**

Runnable-и — це базова абстракція, що імплементує протокол `Runnable` з методами `invoke`, `stream`, `batch` та `ainvoke`. Кожен компонент—промпти, моделі, парсери, retriever-и—є runnable. Ця однорідність забезпечує композицію через pipe-оператор, де типи виходу автоматично відповідають очікуванням входу. Runnable-и також надають вбудовану паралелізацію, логіку повторних спроб та стримінг без додаткового коду.

**П: Як імплементувати стримінг відповідей для чат-інтерфейсу?**

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

Метод `stream` повертає об'єкти `AIMessageChunk`, що містять часткові відповіді. У веб-застосунках ці чанки зазвичай передаються до Server-Sent Events або WebSocket з'єднань.

**П: Опишіть стратегії тестування LangChain-застосунків.**

Тестування LLM-застосунків потребує кількох підходів: юніт-тести з mock-відповідями моделі для детерміністичної поведінки ланцюга, інтеграційні тести з реальними моделями для ефективності промптів, оціночні датасети з очікуваними виходами для виявлення регресій та інструменти трейсингу як-от [LangSmith](https://smith.langchain.com/) для продакшн-налагодження. Мокання шару моделі під час CI допомагає уникнути витрат на API та нестабільності.

## Аспекти Продакшн-Розгортання

Розгортання LangChain-застосунків вимагає уваги до затримки, вартості та надійності понад те, що показують середовища розробки.

> **Управління Витратами на Токени**
>
> Продакшн RAG-застосунки можуть генерувати значні витрати на токени. Необхідно імплементувати middleware для підрахунку токенів, налаштувати бюджетні сповіщення та розглянути стратегії кешування для повторюваних запитів. Один цикл агента з кількома викликами інструментів може споживати тисячі токенів на запит.

Кешування зменшує як затримку, так і вартість для повторюваних запитів. Шар кешування LangChain зберігає відповіді моделі з ключем хешу промпту:

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

Для [MLOps pipeline-ів](/blog/data-science/mlops-mlflow-model-registry-interview-questions-2026) варто інтегрувати LangChain з відстеженням експериментів для моніторингу версій промптів, конфігурацій моделей та метрик якості відповідей з часом.

## Висновок

- LangChain 0.3 організовує оркестрацію LLM у Models, Prompts, Chains та Agents—кожна абстракція є композиційною через синтаксис pipe LCEL
- Імплементації RAG потребують налаштованих порогів retrieval, скорингу релевантності та форматування контексту для продакшн-точності
- Агенти ReAct обробляють багатокрокові задачі data science через міркування про вибір інструментів під час виконання
- Патерни пам'яті підтримують контекст розмови між сесіями аналізу, використовуючи сховища повідомлень з ключем сесії
- Підготовка до співбесід повинна охоплювати розрізнення ланцюг vs агент, стратегії зменшення галюцинацій та патерни композиції runnable-ів
- Продакшн-розгортання потребують кешування, бюджетування токенів та інструментів спостережуваності для управління вартістю та надійністю

---

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