# 2026年版 データサイエンティストのためのLangChain: LLM、エージェント、面接対策

> LangChain 0.3をデータサイエンスで活用する方法を解説。LCELチェーン、RAGパターン、ReActエージェント、メモリシステム、MLエンジニア面接対策まで網羅。

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

---

LangChain 0.3は、本番環境のデータサイエンスワークフローにおいてLLMを活用したアプリケーションを構築するためのデファクトスタンダードとなっている。本チュートリアルでは、データサイエンティストが実務プロジェクトや技術面接で遭遇するコア抽象化、エージェントアーキテクチャ、検索パターンについて解説する。

> **2026年のLangChain**
>
> LangChain Expression Language（LCEL）は、ストリーミング、並列化、フォールバックを備えた宣言的なチェーン構成を可能にする。エージェントに取り組む前にLCEL構文をマスターすることが重要である。ほとんどの面接ではパイプ演算子とRunnableの理解が前提とされる。

## LangChainのコアコンポーネントを理解する

LangChainは、LLMオーケストレーションを4つの主要な抽象化に整理している：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)
```

統一されたインターフェースにより、データパイプラインはコスト、レイテンシ、または機能要件に基づいてプロバイダー間を切り替えることができる。

## LCELパイプ構文でチェーンを構築する

LangChain Expression Languageは、レガシーの`LLMChain`クラスをより柔軟なパイプベースの構文に置き換えた。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スキーマに構造化する。

## データアプリケーション向けRAG（検索拡張生成）

RAGパターンは、ベクターデータベースから取得したドメイン固有のコンテキストでLLMレスポンスを強化する。データサイエンスアプリケーションでは、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`は、リトリーバーが並列でコンテキストを取得する間、元の質問を保持する。このパターンは、最小限のレイテンシオーバーヘッドで本番ワークロードにスケールする。

## データタスク向けReActエージェントの実装

エージェントは、ツール呼び出し機能と推論ループでチェーンを拡張する。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`デコレータは、型ヒントとドキュメント文字列から自動スキーマ生成を行い、関数をエージェントツールとして登録する。エージェントはタスク要件に基づいて各ツールを呼び出すタイミングを決定する。

## 会話型分析のためのメモリパターン

長時間実行されるデータ分析セッションでは、インタラクション間でコンテキストを維持するための会話メモリが必要である。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エンジニアリングやデータサイエンス職の技術面接では、LangChainに関する質問が増えている。これらは通常、コア抽象化の理解、本番環境での考慮事項、デバッグ戦略を評価する。

> **よくある面接トピック**
>
> 面接官は3つの領域に焦点を当てる：チェーン構成パターン、RAG最適化技術、エージェントの信頼性戦略。検索パイプラインのホワイトボード作成やハルシネーションシナリオのデバッグが求められることがある。

**Q: LangChainにおけるチェーンとエージェントの違いを説明してください。**

チェーンは、プロンプトからモデル、パーサーへと事前に決められた操作シーケンスを実行し、実行時の意思決定は行わない。エージェントは、中間結果に基づいてツールを動的に選択する推論ループを追加する。チェーンはデータ変換パイプラインのような構造化されたワークフローに適しており、エージェントは適応的なツール選択を必要とするオープンエンドのタスクを処理する。

**Q: RAGアプリケーションでハルシネーションを減らすにはどうすればよいですか？**

複数の戦略を組み合わせることが効果的である：ハイブリッド検索（密なリトリーバーと疎なリトリーバーの組み合わせ）で検索精度を向上させる、関連性スコアリングで低信頼度のチャンクをフィルタリングする、プロンプトにソース帰属を含める、取得したコンテキストに対する回答検証を実装する、事実に基づくクエリには低い温度設定を使用する。

**Q: Runnableとは何か、なぜLangChainはそれを使用するのですか？**

Runnableは、`invoke`、`stream`、`batch`、`ainvoke`メソッドを持つ`Runnable`プロトコルを実装する基本抽象化である。すべてのコンポーネント（プロンプト、モデル、パーサー、リトリーバー）はRunnableである。この統一性により、出力型が自動的に入力期待値に一致するパイプ演算子による構成が可能になる。Runnableはまた、追加コードなしで組み込みの並列化、再試行ロジック、ストリーミングを提供する。

**Q: チャットインターフェース向けにストリーミングレスポンスをどのように実装しますか？**

```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`オブジェクトを生成する。Webアプリケーションでは、これらのチャンクは通常Server-Sent EventsまたはWebSocket接続に供給される。

**Q: LangChainアプリケーションのテスト戦略を説明してください。**

LLMアプリケーションのテストには複数のアプローチが必要である：決定論的なチェーン動作のためのモック化されたモデルレスポンスによるユニットテスト、プロンプトの効果性のための実際のモデルを使用した統合テスト、回帰検出のための期待される出力を持つ評価データセット、本番デバッグのためのLangSmithなどのトレーシングツール。APIコストと不安定性を避けるため、CI中はモデルレイヤーをモック化することが推奨される。

## 本番デプロイメントの考慮事項

LangChainアプリケーションのデプロイには、開発環境では明らかにならないレイテンシ、コスト、信頼性への注意が必要である。

> **トークンコスト管理**
>
> 本番RAGアプリケーションは大きなトークンコストを発生させる可能性がある。トークンカウントミドルウェアの実装、予算アラートの設定、繰り返しクエリのためのキャッシュ戦略の検討が必要である。複数のツール呼び出しを伴う単一のエージェントループは、リクエストあたり数千のトークンを消費する可能性がある。

キャッシングは、繰り返しクエリのレイテンシとコストの両方を削減する。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パイプラインでは、プロンプトバージョン、モデル設定、時間経過に伴うレスポンス品質メトリクスを監視するために、LangChainを実験トラッキングと統合することが推奨される。

## まとめ

- LangChain 0.3は、LLMオーケストレーションをModels、Prompts、Chains、Agentsに整理し、各抽象化はLCELパイプ構文で構成可能である
- RAG実装には、本番精度のための調整された検索閾値、関連性スコアリング、コンテキストフォーマットが必要である
- ReActエージェントは、実行時にツール選択について推論することでマルチステップのデータタスクを処理する
- メモリパターンは、セッションキー付きメッセージストアを使用して分析セッション間で会話コンテキストを維持する
- 面接準備では、チェーンとエージェントの区別、ハルシネーション削減戦略、Runnable構成パターンをカバーする必要がある
- 本番デプロイメントには、コストと信頼性管理のためのキャッシング、トークン予算設定、オブザーバビリティツールが必要である

---

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