LangGraph 2026 - エージェントワークフロー構築の事実上の標準

LangGraphとは何か

LangGraphはLangChain AIが2024年初頭に開発を開始したPython/TypeScript製のエージェントワークフローライブラリで、有向グラフ(Directed Graph)でAIエージェントの処理フローを定義します。従来のLangChain AgentExecutorが単純な「ツール呼び出しループ」しか表現できなかったのに対し、LangGraphは条件分岐・並列実行・サブグラフ・状態の永続化・人間の承認待ちなど、実世界のエージェントシステムに必要な複雑な制御構造を扱えます。

2026年4月時点でバージョン0.2.18に到達し、LangSmith統合・LangGraph Cloud(マネージドホスティング)も提供されています(LangGraph公式ブログ、2026年3月)。Autonomous AI Agents 2026で解説した自律エージェントの基盤技術として、企業でのPoCから本番展開まで幅広く採用されています。

LangGraphのコアコンセプト

1. グラフベースのワークフロー定義

LangGraphではStateGraphクラスで処理ノードとエッジ(遷移)を定義します。

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from langchain_anthropic import ChatAnthropic

# 状態の型定義
class AgentState(TypedDict):
    messages: Annotated[list, "The conversation history"]
    next_step: str

# ノード関数
def call_model(state: AgentState):
    llm = ChatAnthropic(model="claude-4-sonnet-20260229")
    response = llm.invoke(state["messages"])
    return {
        "messages": state["messages"] + [response],
        "next_step": "human" if "承認" in response.content else "end"
    }

def human_approval(state: AgentState):
    # Human-in-the-loop
    approval = input("実行しますか? (yes/no): ")
    return {"next_step": "execute" if approval == "yes" else "end"}

# グラフ構築
workflow = StateGraph(AgentState)
workflow.add_node("agent", call_model)
workflow.add_node("approval", human_approval)
workflow.set_entry_point("agent")

# 条件分岐エッジ
workflow.add_conditional_edges(
    "agent",
    lambda x: x["next_step"],
    {
        "human": "approval",
        "end": END
    }
)
workflow.add_edge("approval", END)

app = workflow.compile()

2. ステート管理とチェックポイント

LangGraphの最大の特徴は自動的な状態の永続化です。各ノード実行後、状態がチェックポイントとして保存され、後から特定時点に戻ったり、実行を中断・再開できます。

from langgraph.checkpoint.sqlite import SqliteSaver

# SQLiteにチェックポイントを保存
memory = SqliteSaver.from_conn_string("checkpoints.db")
app = workflow.compile(checkpointer=memory)

# スレッドIDで実行を管理
config = {"configurable": {"thread_id": "session-123"}}
result = app.invoke({
    "messages": [("user", "売上分析レポートを作成して")],
    "next_step": ""
}, config)

# 同じthread_idで再実行すると、前回の続きから実行される
result2 = app.invoke({
    "messages": [("user", "もう少し詳しく")]
}, config)

2026年時点では以下のチェックポインターが提供されています。

3. Human-in-the-Loop(人間の承認待ち)

LangGraphは処理の途中で人間の介入を待つinterrupt機能を標準搭載しています。

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.sqlite import SqliteSaver

def risky_action(state):
    # 重要なアクションの前に中断
    return {**state, "action": "delete_database"}

workflow = StateGraph(dict)
workflow.add_node("plan", lambda s: s)
workflow.add_node("execute", risky_action)
workflow.set_entry_point("plan")
workflow.add_edge("plan", "execute")
workflow.add_edge("execute", END)

memory = SqliteSaver.from_conn_string("checkpoints.db")
app = workflow.compile(
    checkpointer=memory,
    interrupt_before=["execute"]  # executeノードの前で中断
)

# 初回実行(executeの前で停止)
config = {"configurable": {"thread_id": "task-456"}}
result = app.invoke({"input": "クリーンアップ実行"}, config)

# 人間が確認後、続きを実行
app.invoke(None, config)  # 同じthread_idで再開

この機能により、金融取引・医療判断・インフラ操作など高リスク領域でのエージェント活用が可能になります(LangGraph公式ドキュメント)。

4. 並列実行とファンアウト

複数のタスクを並列実行し、結果を集約する「ファンアウト・ファンイン」パターンが実装可能です。

from langgraph.graph import StateGraph, END

def analyze_sentiment(state):
    # 感情分析
    return {**state, "sentiment": "positive"}

def extract_entities(state):
    # 固有表現抽出
    return {**state, "entities": ["Apple", "iPhone"]}

def summarize(state):
    # 並列実行結果を統合
    return {
        **state,
        "summary": f"感情: {state['sentiment']}, エンティティ: {state['entities']}"
    }

workflow = StateGraph(dict)
workflow.add_node("sentiment", analyze_sentiment)
workflow.add_node("entities", extract_entities)
workflow.add_node("summary", summarize)
workflow.set_entry_point("sentiment")
workflow.set_entry_point("entities")  # 複数のエントリーポイント
workflow.add_edge("sentiment", "summary")
workflow.add_edge("entities", "summary")
workflow.add_edge("summary", END)

app = workflow.compile()

内部的にはasyncio/threadingで並列化され、I/O待ち時間が平均60%削減されます(LangGraph性能レポート、2026年1月)。

実践的なエージェント実装例

ケース1: リサーチエージェント(ツール連携)

from langgraph.prebuilt import ToolNode, tools_condition
from langgraph.graph import StateGraph, MessagesState, END
from langchain_anthropic import ChatAnthropic
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.messages import HumanMessage

# ツール定義
search = TavilySearchResults(max_results=3)
tools = [search]

# LLMにツールをバインド
llm = ChatAnthropic(model="claude-4-sonnet-20260229")
llm_with_tools = llm.bind_tools(tools)

# エージェントノード
def agent(state: MessagesState):
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

# グラフ構築
workflow = StateGraph(MessagesState)
workflow.add_node("agent", agent)
workflow.add_node("tools", ToolNode(tools))
workflow.set_entry_point("agent")

# 条件分岐: ツール呼び出しが必要か判定
workflow.add_conditional_edges(
    "agent",
    tools_condition,
    {
        "tools": "tools",
        END: END
    }
)
workflow.add_edge("tools", "agent")

app = workflow.compile()

# 実行
result = app.invoke({
    "messages": [HumanMessage(content="2026年のLLM市場規模を調べて")]
})
print(result["messages"][-1].content)

この実装はAI Agents 2025で解説したReActパターンの標準的な実装例です。

ケース2: マルチエージェント協調(主席・研究員・評価者)

from langgraph.graph import StateGraph, END
from typing import Literal

class ResearchState(TypedDict):
    topic: str
    outline: str
    draft: str
    feedback: str
    final_report: str
    step: Literal["outline", "draft", "review", "done"]

def supervisor(state: ResearchState):
    # 主席が次のステップを判断
    if not state.get("outline"):
        return {**state, "step": "outline"}
    elif not state.get("draft"):
        return {**state, "step": "draft"}
    elif not state.get("feedback"):
        return {**state, "step": "review"}
    else:
        return {**state, "step": "done"}

def researcher(state: ResearchState):
    llm = ChatAnthropic(model="claude-4-sonnet-20260229")
    outline = llm.invoke(f"{state['topic']}のアウトラインを作成").content
    return {**state, "outline": outline}

def writer(state: ResearchState):
    llm = ChatAnthropic(model="claude-4-sonnet-20260229")
    draft = llm.invoke(f"以下のアウトラインで本文を執筆:\n{state['outline']}").content
    return {**state, "draft": draft}

def reviewer(state: ResearchState):
    llm = ChatAnthropic(model="claude-4-opus-20260301")
    feedback = llm.invoke(f"以下の原稿を評価:\n{state['draft']}").content
    return {**state, "feedback": feedback, "final_report": state["draft"]}

workflow = StateGraph(ResearchState)
workflow.add_node("supervisor", supervisor)
workflow.add_node("researcher", researcher)
workflow.add_node("writer", writer)
workflow.add_node("reviewer", reviewer)
workflow.set_entry_point("supervisor")

# 動的ルーティング
workflow.add_conditional_edges(
    "supervisor",
    lambda x: x["step"],
    {
        "outline": "researcher",
        "draft": "writer",
        "review": "reviewer",
        "done": END
    }
)
workflow.add_edge("researcher", "supervisor")
workflow.add_edge("writer", "supervisor")
workflow.add_edge("reviewer", "supervisor")

app = workflow.compile()
result = app.invoke({"topic": "量子コンピューティングの現状"})
print(result["final_report"])

LangChainとの使い分け

LangChain 2026とLangGraphは補完関係にあります。

実際のプロジェクトでは、LangChainでRAG・プロンプトを構築し、複雑なフローはLangGraphで制御するハイブリッド構成が一般的です。

from langchain.chains import create_retrieval_chain
from langgraph.graph import StateGraph, END

# LangChainでRAGチェーン構築
rag_chain = create_retrieval_chain(retriever, qa_chain)

# LangGraphでワークフロー制御
def rag_node(state):
    answer = rag_chain.invoke({"input": state["query"]})
    return {**state, "answer": answer}

workflow = StateGraph(dict)
workflow.add_node("search", rag_node)
workflow.add_node("verify", verify_facts)
workflow.set_entry_point("search")
workflow.add_edge("search", "verify")
workflow.add_edge("verify", END)

app = workflow.compile()

他フレームワークとの比較

LangGraph vs CrewAI

CrewAIはロールベースのマルチエージェントフレームワークで、より高レベルな抽象化を提供します。

CrewAIは「営業チーム」「開発チーム」のようなメタファーでエージェントを定義し、初学者に優しい反面、複雑な制御フローでは制約が生じます。LangGraphは逆に、グラフ構造を直接制御できるため自由度が高いですが、コード量は増えます。

LangGraph vs AutoGen

AutoGen(Microsoft Research)はマルチエージェント会話フレームワークで、エージェント間のメッセージ交換に特化しています。

# AutoGenの例(比較用)
from autogen import AssistantAgent, UserProxyAgent

assistant = AssistantAgent("assistant")
user_proxy = UserProxyAgent("user_proxy")

user_proxy.initiate_chat(
    assistant,
    message="Pythonでフィボナッチ数列を実装して"
)

AutoGenは会話ベースで直感的ですが、状態管理・チェックポイント・複雑な分岐には向きません。LangGraphは状態を明示的に管理し、再現性の高いワークフローが構築できます。

LangSmith統合とデバッグ

LangGraphはLangSmithと統合され、グラフ実行の可視化が可能です。

import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-api-key"

app = workflow.compile()
result = app.invoke({"input": "..."})

LangSmithダッシュボードでは以下が確認できます。

• グラフのノード遷移図(どのノードをどの順序で通ったか)
• 各ノードの入出力・実行時間
• チェックポイントの履歴
• エラーが発生したノードのスタックトレース

LangGraph Cloudとデプロイ

LangGraph Cloudは2026年1月にベータリリースされたマネージドホスティングサービスで、月額100ドルからの従量課金です(LangChain公式、2026年3月)。

主な機能:

• GitHubリポジトリ連携による自動デプロイ
• REST API / WebSocket エンドポイントの自動生成
• チェックポイントの自動管理(PostgreSQL)
• スケジュール実行・Webhook連携
• LangSmith統合による監視

# LangGraph CLIでデプロイ
pip install langgraph-cli
langgraph deploy --project my-agent

デプロイ後は以下のようなREST APIが生成されます。

curl -X POST https://api.langgraph.cloud/v1/my-agent/invoke \
  -H "Content-Type: application/json" \
  -d '{"input": "タスク実行"}'

セルフホスティングの場合、FastAPI/Flaskで独自エンドポイントを構築します。

from fastapi import FastAPI
from langgraph.graph import StateGraph

app_fastapi = FastAPI()
graph_app = workflow.compile()

@app_fastapi.post("/run")
async def run_agent(request: dict):
    result = graph_app.invoke(request)
    return result

TypeScript版の状況

LangGraph.jsは2026年4月時点でバージョン0.2.5に到達し、Python版の主要機能を80%カバーしています。

import { StateGraph, END } from "@langchain/langgraph";
import { ChatAnthropic } from "@langchain/anthropic";

interface AgentState {
  messages: string[];
  nextStep: string;
}

const callModel = async (state: AgentState) => {
  const llm = new ChatAnthropic({
    model: "claude-4-sonnet-20260229",
  });
  const response = await llm.invoke(state.messages);
  return {
    messages: [...state.messages, response.content],
    nextStep: "end",
  };
};

const workflow = new StateGraph<AgentState>({
  channels: {
    messages: { value: (x, y) => x.concat(y) },
    nextStep: { value: (x, y) => y ?? x },
  },
});

workflow.addNode("agent", callModel);
workflow.setEntryPoint("agent");
workflow.addEdge("agent", END);

const app = workflow.compile();
const result = await app.invoke({
  messages: ["量子コンピューティングを説明して"],
  nextStep: "",
});

よくある質問

LangGraphは初心者に向いていますか?
LangGraphはグラフ理論とステート管理の知識が前提となるため、初心者には学習曲線が急です。まずはLangChainのAgentExecutorで簡単なエージェントを作り、条件分岐や状態管理が必要になったタイミングでLangGraphに移行するのが推奨パターンです。公式チュートリアルは充実しており、基本パターンを習得すれば応用は容易です。

本番環境での実績はありますか?
2026年時点で金融・ヘルスケア・カスタマーサポート領域での採用事例が報告されています。特にhuman-in-the-loopとチェックポイントによる再現性が評価されています。ただし、まだ0.x系のため後方互換性に注意が必要で、バージョン固定とテストの徹底が求められます。

LangGraphとCrewAI、どちらを選ぶべきですか?
定型的なマルチエージェント(リサーチチーム、開発チームなど)であればCrewAIが早く実装できます。複雑な条件分岐・ループ・状態管理が必要な場合や、既存システムとの統合が必要な場合はLangGraphの方が適しています。小規模プロトタイプではCrewAI、本番システムではLangGraphという使い分けも有効です。

まとめ

LangGraph 2026はステートフルなAIエージェントワークフロー構築のデファクトスタンダードとして成熟しつつあります。以下のポイントを再確認します。

• グラフベースの宣言的な制御フローで複雑なエージェントシステムを構築可能
• チェックポイント・ロールバック・human-in-the-loopが標準機能
• LangChainと補完関係で、RAGはLangChain、制御フローはLangGraph
• CrewAI・AutoGenと比較して低レベルだが柔軟性が高い
• LangGraph CloudでマネージドなAPI提供が可能

MCP Protocol 2026やClaude Code CLIと組み合わせることで、ツール連携を含む高度な自律エージェントが実現可能です。学習コストは高いですが、複雑なワークフローを扱う場合は投資に見合う価値があります。

参考リソース

• LangGraph公式ドキュメント - API リファレンスと実装例
• LangGraph GitHub - ソースコードとIssue管理
• LangGraph Cloud - マネージドホスティングサービス
• LangGraph Tutorials - 公式サンプルコード集