# LangChain untuk Data Scientist 2026: LLM, Agent, dan Pertanyaan Interview

> Kuasai LangChain 0.3 untuk data science: LCEL chain, pola RAG, ReAct agent, sistem memori, dan pertanyaan interview untuk posisi ML engineering.

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

---

LangChain 0.3 telah menjadi framework standar untuk membangun aplikasi berbasis LLM dalam workflow data science produksi. Tutorial ini membahas abstraksi inti, arsitektur agent, dan pola retrieval yang sering ditemui data scientist dalam proyek nyata maupun interview teknis.

> **LangChain di 2026**
>
> LangChain Expression Language (LCEL) memungkinkan komposisi chain secara deklaratif dengan streaming, paralelisasi, dan fallback. Kuasai sintaks LCEL sebelum mendalami agent—sebagian besar pertanyaan interview mengasumsikan pemahaman tentang operator pipe dan runnable.

## Memahami Komponen Inti LangChain

LangChain mengorganisasi orkestrasi LLM ke dalam empat abstraksi utama: Model, Prompt, Chain, dan Agent. Setiap abstraksi dibangun di atas abstraksi sebelumnya, menciptakan sistem yang dapat dikomposisi untuk workflow AI yang kompleks.

Layer Model membungkus berbagai penyedia LLM (OpenAI, Anthropic, model lokal) di balik interface yang seragam. Abstraksi ini memungkinkan pergantian penyedia tanpa mengubah logika aplikasi—penting untuk optimasi biaya dan fleksibilitas vendor.

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

Interface yang seragam berarti pipeline data dapat beralih antar penyedia berdasarkan persyaratan biaya, latensi, atau kemampuan.

## Membangun Chain dengan Sintaks Pipe LCEL

LangChain Expression Language menggantikan kelas `LLMChain` lama dengan sintaks berbasis pipe yang lebih fleksibel. Chain LCEL adalah runnable yang mendukung streaming, batching, dan eksekusi async secara default.

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

Chain LCEL secara otomatis menangani konversi tipe antar komponen. Template prompt menghasilkan `PromptValue`, yang dikonversi model menjadi respons, kemudian parser menyusunnya ke dalam skema Pydantic.

## Retrieval-Augmented Generation untuk Aplikasi Data

Pola [RAG](/blog/data-science/rag-retrieval-augmented-generation-llm-data-science-interview-2026) meningkatkan respons LLM dengan konteks spesifik domain yang diambil dari database vektor. Untuk aplikasi data science, RAG memungkinkan kueri terhadap dokumentasi, analisis sebelumnya, atau basis pengetahuan domain.

```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` mempertahankan pertanyaan asli sementara retriever mengambil konteks secara paralel. Pola ini dapat diskalakan untuk workload produksi dengan overhead latensi minimal.

## Implementasi ReAct Agent untuk Tugas Data

Agent memperluas chain dengan kemampuan pemanggilan tool dan loop penalaran. Pola ReAct (Reasoning + Acting) menginterleave langkah pemikiran dan aksi, memungkinkan agent menyelesaikan masalah multi-langkah.

```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` mendaftarkan fungsi sebagai tool agent dengan pembuatan skema otomatis dari type hint dan docstring. Agent memutuskan kapan memanggil setiap tool berdasarkan persyaratan tugas.

## Pola Memori untuk Analitik Percakapan

Sesi analisis data yang berjalan lama memerlukan memori percakapan untuk mempertahankan konteks di seluruh interaksi. LangChain menyediakan beberapa strategi memori yang dioptimalkan untuk berbagai kasus penggunaan.

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

Deployment produksi biasanya mengganti `InMemoryChatMessageHistory` dengan penyimpanan berbasis Redis atau PostgreSQL untuk persistensi di seluruh restart server.

## Pertanyaan dan Jawaban Interview LangChain

Interview teknis untuk posisi ML engineering dan data science semakin sering menyertakan pertanyaan LangChain. Pertanyaan ini biasanya menilai pemahaman tentang abstraksi inti, pertimbangan produksi, dan strategi debugging.

> **Topik Interview Umum**
>
> Pewawancara fokus pada tiga area: pola komposisi chain, teknik optimasi RAG, dan strategi keandalan agent. Bersiaplah untuk menggambar pipeline retrieval di whiteboard atau men-debug skenario halusinasi.

**T: Jelaskan perbedaan antara chain dan agent di LangChain.**

Chain mengeksekusi urutan operasi yang telah ditentukan—prompt ke model ke parser—tanpa pengambilan keputusan runtime. Agent menambahkan loop penalaran yang secara dinamis memilih tool berdasarkan hasil antara. Chain cocok untuk workflow terstruktur seperti pipeline transformasi data; agent menangani tugas terbuka yang memerlukan pemilihan tool adaptif.

**T: Bagaimana cara mengurangi halusinasi dalam aplikasi RAG?**

Beberapa strategi bekerja bersama: tingkatkan presisi retrieval dengan pencarian hybrid (menggabungkan retriever dense dan sparse), tambahkan penilaian relevansi untuk memfilter chunk dengan confidence rendah, sertakan atribusi sumber dalam prompt, implementasikan verifikasi jawaban terhadap konteks yang diambil, dan gunakan pengaturan temperature rendah untuk kueri faktual. Pola [feature engineering](/technologies/data-science/interview-questions/feature-engineering) untuk kualitas embedding juga mempengaruhi akurasi retrieval.

**T: Apa itu runnable dan mengapa LangChain menggunakannya?**

Runnable adalah abstraksi dasar yang mengimplementasikan protokol `Runnable` dengan method `invoke`, `stream`, `batch`, dan `ainvoke`. Setiap komponen—prompt, model, parser, retriever—adalah runnable. Keseragaman ini memungkinkan komposisi dengan operator pipe, di mana tipe output secara otomatis cocok dengan ekspektasi input. Runnable juga menyediakan paralelisasi bawaan, logika retry, dan streaming tanpa kode tambahan.

**T: Bagaimana cara mengimplementasikan respons streaming untuk interface chat?**

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

Method `stream` menghasilkan objek `AIMessageChunk` yang berisi respons parsial. Untuk aplikasi web, chunk ini biasanya dimasukkan ke koneksi Server-Sent Events atau WebSocket.

**T: Jelaskan strategi untuk menguji aplikasi LangChain.**

Pengujian aplikasi LLM memerlukan beberapa pendekatan: unit test dengan respons model yang di-mock untuk perilaku chain deterministik, integration test dengan model nyata untuk efektivitas prompt, dataset evaluasi dengan output yang diharapkan untuk deteksi regresi, dan tool tracing seperti [LangSmith](https://smith.langchain.com/) untuk debugging produksi. Mock layer model selama CI untuk menghindari biaya API dan ketidakstabilan.

## Pertimbangan Deployment Produksi

Men-deploy aplikasi LangChain memerlukan perhatian pada latensi, biaya, dan keandalan di luar apa yang terungkap di environment development.

> **Manajemen Biaya Token**
>
> Aplikasi RAG produksi dapat menghasilkan biaya token yang signifikan. Implementasikan middleware penghitungan token, atur alert budget, dan pertimbangkan strategi caching untuk kueri berulang. Satu loop agent dengan beberapa pemanggilan tool dapat mengonsumsi ribuan token per request.

Caching mengurangi latensi dan biaya untuk kueri berulang. Layer caching LangChain menyimpan respons model yang di-key berdasarkan hash prompt:

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

Untuk [pipeline MLOps](/blog/data-science/mlops-mlflow-model-registry-interview-questions-2026), integrasikan LangChain dengan experiment tracking untuk memantau versi prompt, konfigurasi model, dan metrik kualitas respons dari waktu ke waktu.

## Kesimpulan

- LangChain 0.3 mengorganisasi orkestrasi LLM ke dalam Model, Prompt, Chain, dan Agent—setiap abstraksi dapat dikomposisi melalui sintaks pipe LCEL
- Implementasi RAG memerlukan threshold retrieval yang disetel, penilaian relevansi, dan pemformatan konteks untuk akurasi produksi
- ReAct agent menangani tugas data multi-langkah dengan bernalar tentang pemilihan tool saat runtime
- Pola memori mempertahankan konteks percakapan di seluruh sesi analisis menggunakan penyimpanan pesan berbasis sesi
- Persiapan interview harus mencakup perbedaan chain vs agent, strategi pengurangan halusinasi, dan pola komposisi runnable
- Deployment produksi membutuhkan caching, budgeting token, dan tooling observability untuk manajemen biaya dan keandalan

---

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