# Veri Bilimciler için LangChain 2026: LLM'ler, Ajanlar ve Mülakat Soruları

> Veri bilimciler için kapsamlı LangChain eğitimi. LCEL, RAG kalıpları, ReAct ajanları ve pratik Python kod örnekleriyle en sık sorulan mülakat sorularını öğrenin.

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

---

LangChain 0.3, üretim veri bilimi iş akışlarında LLM destekli uygulamalar oluşturmak için standart çerçeve haline geldi. Bu eğitim, veri bilimcilerin hem gerçek projelerde hem de teknik mülakatlarda karşılaştıkları temel soyutlamaları, ajan mimarilerini ve retrieval kalıplarını kapsamaktadır.

> **2026'da LangChain**
>
> LangChain Expression Language (LCEL), streaming, paralelleştirme ve fallback'lerle deklaratif zincir kompozisyonunu sağlar. Ajanlara geçmeden önce LCEL sözdizimini öğrenmek kritik öneme sahiptir—çoğu mülakat sorusu pipe operatörleri ve runnable'lar konusunda bilgi sahibi olmayı varsayar.

## LangChain Temel Bileşenlerini Anlama

LangChain, LLM orkestasyonunu dört ana soyutlama altında düzenler: Models, Prompts, Chains ve Agents. Her soyutlama bir öncekinin üzerine inşa edilir ve karmaşık AI iş akışları için kompozisyonel bir sistem oluşturur.

Model katmanı, farklı LLM sağlayıcılarını (OpenAI, Anthropic, yerel modeller) birleşik bir arayüz altında sarar. Bu soyutlama, uygulama mantığını değiştirmeden sağlayıcı değişikliğine olanak tanır—maliyet optimizasyonu ve satıcı esnekliği için kritik bir özelliktir.

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

Birleşik arayüz, veri pipeline'larının maliyet, gecikme veya yetenek gereksinimlerine göre sağlayıcılar arasında geçiş yapabilmesi anlamına gelir.

## LCEL Pipe Sözdizimi ile Zincir Oluşturma

LangChain Expression Language, eski `LLMChain` sınıfını daha esnek bir pipe tabanlı sözdizimi ile değiştirir. LCEL zincirleri, varsayılan olarak streaming, batching ve asenkron yürütmeyi destekleyen runnable'lardır.

```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 zincirleri, bileşenler arasında otomatik tip dönüşümü yapar. Prompt şablonu `PromptValue` çıktısı üretir, model bunu yanıta dönüştürür ve parser Pydantic şemasına göre yapılandırır.

## Veri Bilimi Uygulamaları için Retrieval-Augmented Generation

[RAG kalıpları](/blog/data-science/rag-retrieval-augmented-generation-llm-data-science-interview-2026), LLM yanıtlarını vektör veritabanlarından alınan alan-spesifik bağlamla zenginleştirir. Veri bilimi uygulamalarında RAG, dokümantasyon, önceki analizler veya alan bilgi tabanlarını sorgulamayı sağlar.

```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` orijinal soruyu korurken retriever paralel olarak bağlamı alır. Bu kalıp, minimum gecikme yüküyle üretim iş yüklerine ölçeklenir.

## Veri Görevleri için ReAct Ajanlarının Implementasyonu

Ajanlar, zincirleri araç çağırma yetenekleri ve muhakeme döngüleri ile genişletir. ReAct (Reasoning + Acting) kalıbı, düşünme ve eylem adımlarını iç içe geçirir ve ajanların çok adımlı problemleri çözmesini sağlar.

```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` dekoratörü, fonksiyonları type hint'lerden ve docstring'lerden otomatik şema üretimi ile ajan araçları olarak kaydeder. Ajan, görev gereksinimlerine göre hangi aracı çağıracağına karar verir.

## Konuşmalı Analitik için Bellek Kalıpları

Uzun süreli veri analizi oturumları, etkileşimler arasında bağlamı korumak için konuşma belleği gerektirir. LangChain, farklı kullanım durumları için optimize edilmiş çeşitli bellek stratejileri sağlar.

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

Üretim dağıtımları, sunucu yeniden başlatmaları arasında veri kalıcılığı için `InMemoryChatMessageHistory` yerine genellikle Redis veya PostgreSQL destekli depoları kullanır.

## LangChain Mülakat Soruları ve Cevapları

ML mühendisliği ve veri bilimi pozisyonları için teknik mülakatlar giderek daha fazla LangChain soruları içermektedir. Bunlar genellikle temel soyutlamaların anlaşılmasını, üretim değerlendirmelerini ve hata ayıklama stratejilerini değerlendirir.

> **Yaygın Mülakat Konuları**
>
> Mülakatçılar üç alana odaklanır: zincir kompozisyon kalıpları, RAG optimizasyon teknikleri ve ajan güvenilirlik stratejileri. Bir retrieval pipeline'ı tahtada çizme veya bir halüsinasyon senaryosunu debug etme beklentisi içinde olmak gerekir.

**S: LangChain'de zincirler ve ajanlar arasındaki farkı açıklayın.**

Zincirler önceden belirlenmiş bir işlem dizisi yürütür—prompt'tan modele, parser'a—çalışma zamanında karar verme olmadan. Ajanlar, ara sonuçlara dayalı olarak dinamik araç seçimi yapan bir muhakeme döngüsü ekler. Zincirler, veri dönüşüm pipeline'ları gibi yapılandırılmış iş akışları için uygundur; ajanlar adaptif araç seçimi gerektiren açık uçlu görevleri yönetir.

**S: Bir RAG uygulamasında halüsinasyonları nasıl azaltırsınız?**

Birden fazla strateji birlikte çalışır: hibrit arama ile retrieval hassasiyetini artırma (dense ve sparse retriever'ları birleştirme), düşük güvenli chunk'ları filtrelemek için uygunluk puanlaması ekleme, prompt'larda kaynak atfı dahil etme, alınan bağlama karşı yanıt doğrulaması uygulama ve olgusal sorgular için düşük temperature ayarları kullanma. Embedding kalitesi için [feature engineering kalıpları](/technologies/data-science/interview-questions/feature-engineering) da retrieval doğruluğunu etkiler.

**S: Runnable'lar nedir ve LangChain neden kullanır?**

Runnable'lar, `invoke`, `stream`, `batch` ve `ainvoke` metodlarıyla `Runnable` protokolünü uygulayan temel soyutlamadır. Her bileşen—prompt'lar, modeller, parser'lar, retriever'lar—bir runnable'dır. Bu tekdüzelik, pipe operatörü ile kompozisyonu sağlar ve çıktı tipleri otomatik olarak girdi beklentileriyle eşleşir. Runnable'lar ayrıca ek kod olmadan yerleşik paralelleştirme, yeniden deneme mantığı ve streaming sağlar.

**S: Bir chat arayüzü için streaming yanıtları nasıl uygularsınız?**

```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` metodu, kısmi yanıtlar içeren `AIMessageChunk` nesneleri döndürür. Web uygulamalarında bu chunk'lar genellikle Server-Sent Events veya WebSocket bağlantılarına beslenir.

**S: LangChain uygulamalarını test etme stratejilerini açıklayın.**

LLM uygulamalarını test etmek birden fazla yaklaşım gerektirir: deterministik zincir davranışı için mock'lanmış model yanıtları ile birim testleri, prompt etkinliği için gerçek modellerle entegrasyon testleri, regresyon tespiti için beklenen çıktılarla değerlendirme veri setleri ve üretim hata ayıklaması için [LangSmith](https://smith.langchain.com/) gibi izleme araçları. CI sırasında API maliyetlerinden ve kararsızlıktan kaçınmak için model katmanını mock'lamak önerilir.

## Üretim Dağıtım Hususları

LangChain uygulamalarını dağıtmak, geliştirme ortamlarının ortaya koymadığı gecikme, maliyet ve güvenilirlik konularına dikkat gerektirir.

> **Token Maliyet Yönetimi**
>
> Üretim RAG uygulamaları önemli token maliyetleri oluşturabilir. Token sayma middleware'i uygulamak, bütçe uyarıları ayarlamak ve tekrarlayan sorgular için önbelleğe alma stratejilerini değerlendirmek gerekir. Birden fazla araç çağrısı olan tek bir ajan döngüsü, istek başına binlerce token tüketebilir.

Önbelleğe alma, tekrarlayan sorgular için hem gecikmeyi hem de maliyeti azaltır. LangChain'in önbelleğe alma katmanı, model yanıtlarını prompt hash'i ile anahtarlayarak depolar:

```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'ları](/blog/data-science/mlops-mlflow-model-registry-interview-questions-2026) için, prompt sürümlerini, model konfigürasyonlarını ve zaman içindeki yanıt kalitesi metriklerini izlemek amacıyla LangChain'i deney takibi ile entegre etmek önerilir.

## Sonuç

- LangChain 0.3, LLM orkestasyonunu Models, Prompts, Chains ve Agents olarak düzenler—her soyutlama LCEL pipe sözdizimi ile kompozisyoneldir
- RAG implementasyonları, üretim doğruluğu için ayarlanmış retrieval eşikleri, uygunluk puanlaması ve bağlam biçimlendirmesi gerektirir
- ReAct ajanları, çalışma zamanında araç seçimi hakkında muhakeme yaparak çok adımlı veri görevlerini yönetir
- Bellek kalıpları, oturum anahtarlı mesaj depoları kullanarak analiz oturumları arasında konuşma bağlamını korur
- Mülakat hazırlığı, zincir-ajan ayrımı, halüsinasyon azaltma stratejileri ve runnable kompozisyon kalıplarını kapsamalıdır
- Üretim dağıtımları, maliyet ve güvenilirlik yönetimi için önbelleğe alma, token bütçeleme ve gözlemlenebilirlik araçları gerektirir

---

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