LangChain アーキテクチャ

エージェント、チェーン、メモリ、ツール統合を使用して、高度な LLM アプリケーションを構築するための LangChain フレームワークをマスターしましょう。

このスキルを使用しないケース

• タスクが langchain アーキテクチャと関係のない場合
• このスコープ外の異なるドメインやツールが必要な場合

指示

• 目標、制約、必要な入力を明確にします。
• 関連するベストプラクティスを適用し、結果を検証します。
• 実行可能なステップと検証方法を提供します。
• 詳細な例が必要な場合は、resources/implementation-playbook.md を開いてください。

このスキルを使用するケース

• ツールアクセス付きの自律型 AI エージェントの構築
• 複雑なマルチステップ LLM ワークフローの実装
• 会話メモリと状態の管理
• 外部データソースと API への LLM の統合
• モジュール化された再利用可能な LLM アプリケーションコンポーネントの作成
• ドキュメント処理パイプラインの実装
• 本番グレードの LLM アプリケーションの構築

コア概念

1. エージェント

どのアクションを取るかを決定するために LLM を使用する自律的なシステム。

エージェントタイプ：

• ReAct: インターリーブされた方式での推論 + 行動
• OpenAI Functions: 関数呼び出し API を活用
• Structured Chat: マルチ入力ツールに対応
• Conversational: チャットインターフェースに最適化
• Self-Ask with Search: 複雑なクエリを分解

2. チェーン

LLM または他のユーティリティへの呼び出しのシーケンス。

チェーンタイプ：

• LLMChain: 基本的なプロンプト + LLM の組み合わせ
• SequentialChain: 複数のチェーンを連続実行
• RouterChain: 入力を特定のチェーンにルーティング
• TransformChain: ステップ間のデータ変換
• MapReduceChain: 集約を含む並列処理

3. メモリ

インタラクション全体にわたってコンテキストを維持するシステム。

メモリタイプ：

• ConversationBufferMemory: すべてのメッセージを保存
• ConversationSummaryMemory: 古いメッセージを要約
• ConversationBufferWindowMemory: 最後の N 個のメッセージを保持
• EntityMemory: エンティティに関する情報を追跡
• VectorStoreMemory: セマンティック類似度検索

4. ドキュメント処理

検索用のドキュメントの読み込み、変換、保存。

コンポーネント：

• Document Loaders: 様々なソースから読み込み
• Text Splitters: ドキュメントをインテリジェントにチャンク化
• Vector Stores: 埋め込みを保存および取得
• Retrievers: 関連ドキュメントを取得
• Indexes: 効率的なアクセスのためにドキュメントを整理

5. コールバック

ロギング、監視、デバッグのためのフック。

ユースケース：

• リクエスト/レスポンスログ
• トークン使用量追跡
• レイテンシ監視
• エラーハンドリング
• カスタムメトリクス収集

クイックスタート

from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory

# Initialize LLM
llm = OpenAI(temperature=0)

# Load tools
tools = load_tools(["serpapi", "llm-math"], llm=llm)

# Add memory
memory = ConversationBufferMemory(memory_key="chat_history")

# Create agent
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    verbose=True
)

# Run agent
result = agent.run("What's the weather in SF? Then calculate 25 * 4")

アーキテクチャパターン

パターン 1: LangChain を使用した RAG

from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# Load and process documents
loader = TextLoader('documents.txt')
documents = loader.load()

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
texts = text_splitter.split_documents(documents)

# Create vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# Create retrieval chain
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(),
    return_source_documents=True
)

# Query
result = qa_chain({"query": "What is the main topic?"})

パターン 2: カスタムエージェントとツール

from langchain.agents import Tool, AgentExecutor
from langchain.agents.react.base import ReActDocstoreAgent
from langchain.tools import tool

@tool
def search_database(query: str) -> str:
    """Search internal database for information."""
    # Your database search logic
    return f"Results for: {query}"

@tool
def send_email(recipient: str, content: str) -> str:
    """Send an email to specified recipient."""
    # Email sending logic
    return f"Email sent to {recipient}"

tools = [search_database, send_email]

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

パターン 3: マルチステップチェーン

from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate

# Step 1: Extract key information
extract_prompt = PromptTemplate(
    input_variables=["text"],
    template="Extract key entities from: {text}\n\nEntities:"
)
extract_chain = LLMChain(llm=llm, prompt=extract_prompt, output_key="entities")

# Step 2: Analyze entities
analyze_prompt = PromptTemplate(
    input_variables=["entities"],
    template="Analyze these entities: {entities}\n\nAnalysis:"
)
analyze_chain = LLMChain(llm=llm, prompt=analyze_prompt, output_key="analysis")

# Step 3: Generate summary
summary_prompt = PromptTemplate(
    input_variables=["entities", "analysis"],
    template="Summarize:\nEntities: {entities}\nAnalysis: {analysis}\n\nSummary:"
)
summary_chain = LLMChain(llm=llm, prompt=summary_prompt, output_key="summary")

# Combine into sequential chain
overall_chain = SequentialChain(
    chains=[extract_chain, analyze_chain, summary_chain],
    input_variables=["text"],
    output_variables=["entities", "analysis", "summary"],
    verbose=True
)

メモリ管理のベストプラクティス

適切なメモリタイプの選択

# For short conversations (< 10 messages)
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()

# For long conversations (summarize old messages)
from langchain.memory import ConversationSummaryMemory
memory = ConversationSummaryMemory(llm=llm)

# For sliding window (last N messages)
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(k=5)

# For entity tracking
from langchain.memory import ConversationEntityMemory
memory = ConversationEntityMemory(llm=llm)

# For semantic retrieval of relevant history
from langchain.memory import VectorStoreRetrieverMemory
memory = VectorStoreRetrieverMemory(retriever=retriever)

コールバックシステム

カスタムコールバックハンドラ

from langchain.callbacks.base import BaseCallbackHandler

class CustomCallbackHandler(BaseCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM started with prompts: {prompts}")

    def on_llm_end(self, response, **kwargs):
        print(f"LLM ended with response: {response}")

    def on_llm_error(self, error, **kwargs):
        print(f"LLM error: {error}")

    def on_chain_start(self, serialized, inputs, **kwargs):
        print(f"Chain started with inputs: {inputs}")

    def on_agent_action(self, action, **kwargs):
        print(f"Agent taking action: {action}")

# Use callback
agent.run("query", callbacks=[CustomCallbackHandler()])

テスト戦略

import pytest
from unittest.mock import Mock

def test_agent_tool_selection():
    # Mock LLM to return specific tool selection
    mock_llm = Mock()
    mock_llm.predict.return_value = "Action: search_database\nAction Input: test query"

    agent = initialize_agent(tools, mock_llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)

    result = agent.run("test query")

    # Verify correct tool was selected
    assert "search_database" in str(mock_llm.predict.call_args)

def test_memory_persistence():
    memory = ConversationBufferMemory()

    memory.save_context({"input": "Hi"}, {"output": "Hello!"})

    assert "Hi" in memory.load_memory_variables({})['history']
    assert "Hello!" in memory.load_memory_variables({})['history']

パフォーマンス最適化

1. キャッシング

from langchain.cache import InMemoryCache
import langchain

langchain.llm_cache = InMemoryCache()

2. バッチ処理

# Process multiple documents in parallel
from langchain.document_loaders import DirectoryLoader
from concurrent.futures import ThreadPoolExecutor

loader = DirectoryLoader('./docs')
docs = loader.load()

def process_doc(doc):
    return text_splitter.split_documents([doc])

with ThreadPoolExecutor(max_workers=4) as executor:
    split_docs = list(executor.map(process_doc, docs))

3. ストリーミングレスポンス

from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

llm = OpenAI(streaming=True, callbacks=[StreamingStdOutCallbackHandler()])

リソース

• references/agents.md: エージェントアーキテクチャの詳細解説
• references/memory.md: メモリシステムパターン
• references/chains.md: チェーン組成戦略
• references/document-processing.md: ドキュメント読み込みとインデックス作成
• references/callbacks.md: 監視と観測性
• assets/agent-template.py: 本番対応のエージェントテンプレート
• assets/memory-config.yaml: メモリ設定例
• assets/chain-example.py: 複雑なチェーン例

よくある落とし穴

1. メモリオーバーフロー: 会話履歴の長さを管理していない
2. ツール選択エラー: 不十分なツール説明がエージェントを混乱させる
3. コンテキストウィンドウ超過: LLM トークン制限を超える
4. エラーハンドリングなし: エージェント障害をキャッチおよび処理していない
5. 非効率な検索: ベクトルストアクエリを最適化していない

本番環境チェックリスト

• 適切なエラーハンドリングを実装する
• リクエスト/レスポンスログを追加する
• トークン使用量とコストを監視する
• エージェント実行のタイムアウト制限を設定する
• レート制限を実装する
• 入力検証を追加する
• エッジケースでテストする
• 観測性を設定する（コールバック）
• フォールバック戦略を実装する
• プロンプトと設定をバージョン管理する

制限事項

• このスキルは、タスクが上記で説明されたスコープと明確に一致する場合にのみ使用してください。
• 出力を環境固有の検証、テスト、または専門家のレビューの代わりとして扱わないでください。
• 必要な入力、権限、安全境界、または成功基準が不明な場合は、停止して明確化を求めてください。