完全なエージェント型AIアプリを構築するためのPythonフレームワーク15選

エージェント型AIアプリケーションの構築は、数年前に比べてはるかに容易になりました。エージェントのループ、ツール連携、メモリ、検索、オーケストレーションをゼロから作る代わりに、これらの大半を備えたPythonフレームワークを活用できます。

本記事で取り上げる多くのフレームワークを用いて、RAGアプリケーションの構築、自律エージェント、マルチエージェントシステム、デプロイ可能なAIツールを作成してきました。

柔軟なエージェントワークフローにはLangChain、データ接続型アプリにはLlamaIndexやHaystack、そしてプロバイダーモデルと素早く統合したいときはOpenAI Agents SDKやGoogle ADKをよく使います。

これらのフレームワークの中には、すでに大幅に進化したものもあり、カスタム実装が不要なケースが増えています。APIキーと少量のモデルクレジット、適切なフレームワークさえあれば、エージェントを作成し、ツールやプライベートデータに接続し、テストして、APIやユーザーインターフェース経由でデプロイできます。

本記事では、15個のPythonフレームワークを5つのカテゴリで比較します。汎用エージェントフレームワーク、公式エージェントSDK、マルチエージェントのオーケストレーションフレームワーク、データおよびRAGフレームワーク、軽量なオープンモデル対応フレームワークです。

各セクションには、フレームワークの使い方をすぐ理解できる短いPythonのサンプルも用意しています。コピー＆ペーストで試してみてください。

汎用エージェントフレームワーク

これらのフレームワークは、エージェントの作成、ツール接続、状態管理、マルチステップのワークフロー制御のための幅広いビルディングブロックを提供します。

1. LangChain

多くの開発者にとって、現代的なLLMアプリ開発はLangChainから始まりました。これは、言語モデルを外部データ、ツール、API、アプリケーションロジックに接続するために設計されたオープンソースのPythonフレームワークです。OpenAI APIをウェブサイト、ドキュメント、ベクターデータベース、その他のデータソースと組み合わせ、より文脈に敏感なアプリを構築するための、最初期に広く採用されたフレームワークの1つになりました。

現在のLangChainは、RAGシステム、ツールを使うエージェント、ワークフロー、各種統合、監視、評価まで、エンドツーエンドのエージェント型AIアプリ構築を支える完全なエコシステムへと進化しています。詳しくはAI Engineering with LangChain トラックをご覧ください。

次の例では、質問に答える前にドキュメント検索ツールを使って関連情報を探せる、シンプルなLangChainエージェントを作成します。

# pip install -U langchain "langchain[openai]"

from langchain.agents import create_agent

def search_docs(query: str) -> str:
    """Search the company documentation."""
    return f"Documentation found for: {query}"

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[search_docs],
    system_prompt="Use the documentation tool when needed.",
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "What is our remote-work policy?"
    }]
})

print(result["messages"][-1].content)

2. LangGraph

LangChainがエージェントやツールの作成を容易にする一方で、LangGraphはそれらのエージェントの動作をより細かく制御できます。アプリケーションを接続されたステップのグラフとして構成でき、ループ、ツール呼び出し、共有状態、人的承認、マルチエージェントワークフローを制御しやすくなります。

特に、自律エージェントの構築で有用だと感じます。エージェントは繰り返し「次に何をするか」を判断し、適切なツールを選び、結果を確認し、タスクが完了するまで続けます。LangGraphは永続化、ストリーミング、チェックポイント、リカバリにも対応し、長時間動作するアプリケーションにも向いています。詳しくはLangGraphのチュートリアルをご覧ください。

次の例では、答えるのに十分な情報が集まるまで計算ツールを繰り返し呼び出せるエージェントを作成します。

# pip install -U langgraph langchain langchain-openai

from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langgraph.graph import MessagesState, StateGraph, START
from langgraph.prebuilt import ToolNode, tools_condition

model = init_chat_model("openai:gpt-5.5", temperature=0)

@tool
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

tools = [add, multiply]
model_with_tools = model.bind_tools(tools)

def call_model(state: MessagesState):
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

builder = StateGraph(MessagesState)
builder.add_node("agent", call_model)
builder.add_node("tools", ToolNode(tools))

builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")

agent = builder.compile()

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Add 12 and 8, then multiply the result by 3."
    }]
})

print(result["messages"][-1].content)

このグラフは、リクエストをモデルへ送り、必要なツールを実行し、最終回答が出るまでモデルにループバックします。

3. Agno

Agnoは、エージェント、マルチエージェントチーム、構造化ワークフローを構築するためのPythonフレームワークです。AgentOSも同梱されており、API経由でエージェントを公開し、セッションやトレースを保存し、本番アプリとして管理できます。自社インフラで実行できるため、組織はデータとセキュリティをより強くコントロールできます。

次の例では、簡潔な回答を出す前にウェブ検索を行えるリサーチエージェントを作成します。

# pip install -U agno ddgs openai

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    name="AI Research Assistant",
    model=OpenAIResponses(id="gpt-5.5"),
    tools=[DuckDuckGoTools()],
    instructions="Search when needed and keep the answer concise.",
)

agent.print_response(
    "Find one recent development in open-source AI and summarize it.",
    stream=True,
)

このエージェントは検索ツールで最新情報を探し、短い要約をユーザーへストリーミングします。

4. Pydantic AI

Pydantic AIは、Pydanticチームが提供する、エージェントや生成AIアプリケーションを構築するためのPythonネイティブなフレームワークです。PydanticモデルやFastAPIに近い感覚で使え、エージェント、ツール、依存関係、出力を標準的なPython関数、型ヒント、デコレータ、BaseModelクラスで定義します。Pydanticのバリデーションにより、ツール引数やモデル出力を構造化・信頼可能に保ちます。

フレームワークの詳細はPydantic AIチュートリアルで学べます。

次の例では、検証済みの記事プランをPydanticモデルとして返すエージェントを作成します。

# pip install -U pydantic-ai

from pydantic import BaseModel, Field
from pydantic_ai import Agent


class ArticlePlan(BaseModel):
    title: str
    key_points: list[str]
    reading_time_minutes: int = Field(ge=1)


agent = Agent(
    "openai:gpt-5.6-sol",
    output_type=ArticlePlan,
    instructions="Create concise article plans for technical readers.",
)

result = agent.run_sync(
    "Create a short article plan about building AI agents in Python."
)

print(result.output)

エージェントはArticlePlanオブジェクトを生成し、返却前に各フィールドが要求されたPython型とルールに合致しているか検証します。

公式エージェントSDK

公式エージェントSDKはAIプロバイダーが保守しており、自社のモデル、API、ツール、デプロイメント、可観測性プラットフォームと最も簡単に統合できます。

5. OpenAI Agents SDK

OpenAI Agents SDKは、シングルエージェントおよびマルチエージェントアプリを構築するための軽量でPythonファーストなフレームワークです。ビルトインのエージェントループ、関数ツール、ハンドオフ、ガードレール、セッション、人的承認、トレーシングを、過度な抽象化なしに提供します。

OpenAI Agents SDKは、シンプルで統合が速く、理解しやすいのでとても気に入っています。大きな問題なく多くのアプリを構築できました。さらに、OpenAIダッシュボードで閲覧できるトレースを自動生成してくれるため、モデルの応答、ツール呼び出し、ハンドオフ、実行フロー全体を簡単に検査できます。

次の例では、驚きの歴史トリビアを取得するためにPython関数を呼び出せる履歴エージェントを作成します。

# pip install openai-agents

import asyncio
from agents import Agent, Runner, function_tool


@function_tool
def history_fun_fact() -> str:
    """Return a surprising historical fact."""
    return "The first computer programmer, Ada Lovelace, lived in the 1800s."


agent = Agent(
    name="History Assistant",
    instructions=(
        "Answer history questions clearly and briefly. "
        "Use history_fun_fact when it is helpful."
    ),
    tools=[history_fun_fact],
)


async def main():
    result = await Runner.run(
        agent,
        "Tell me something surprising about the history of computing.",
    )
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

SDKはエージェントを実行し、必要に応じて履歴ツールを呼び出し、その結果をモデルに返して最終応答を生成します。実行全体はトレースビューアで確認できます。

7. Google Agent Development Kit

GoogleのAgent Development Kit（ADK）は、単体エージェント、ツール使用アシスタント、グラフワークフロー、マルチエージェントシステムを構築・評価・デプロイするためのオープンソースフレームワークです。特にGeminiモデルと相性がよく、他のモデルプロバイダーもサポートします。

ADKはシンプルでGeminiと自然に連携できるため、お気に入りのフレームワークの1つになりました。

これを使っていくつかのアプリを問題なく構築してきました。統合の容易さや制御・機能の柔軟性という点では、依然としてOpenAI Agents SDKに一日の長があると感じますが、ADKも有力な選択肢であり、特にGeminiベースのアプリケーションにおいて競争力があります。

次の例では、イベントの開始時刻を取得するためにPython関数を呼び出せるイベントアシスタントを作成します。

# pip install google-adk

from google.adk.agents.llm_agent import Agent


def get_event_time(city: str) -> dict:
    """Return the event starting time for a city."""
    return {
        "status": "success",
        "city": city,
        "time": "6:00 PM",
    }


root_agent = Agent(
    model="gemini-flash-latest",
    name="event_assistant",
    description="Provides information about events in different cities.",
    instruction=(
        "Answer event questions clearly. "
        "Use the get_event_time tool when the starting time is requested."
    ),
    tools=[get_event_time],
)

このエージェントは、特定の都市のイベント時刻が必要なときに、その関数をツールとして使用します。

8. Claude Agent SDK

Claude Agent SDKは、Anthropicが提供するPythonおよびTypeScript向けのフレームワークで、Claude Codeを支えるのと同じエージェントループ、ツール、コンテキスト管理で自律エージェントを構築できます。ファイルの読み取り、コード編集、コマンド実行、MCPツール接続、長時間タスクの遂行が必要なエージェントに特に有用です。

Anthropic、OpenAI、Googleは、自社のモデルを自社エージェントフレームワークと密接に統合しており、ツール、セッション、トレーシングなど高度な機能を素早く設定できます。

ただし、Claude Agent SDKは任意のオープンソースやローカルホストのモデルではなく、Claude専用に設計されています。詳しくはClaude Agent SDKのチュートリアルをご覧ください。

次の例では、Pythonファイルをレビューしてバグを特定し、自動で修正するコーディングエージェントを作成します。

# pip install claude-agent-sdk

import asyncio
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ResultMessage,
    query,
)


async def main():
    async for message in query(
        prompt="Review app.py for errors that could cause crashes and fix them.",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Glob"],
            permission_mode="acceptEdits",
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text)
                elif hasattr(block, "name"):
                    print(f"Tool used: {block.name}")

        elif isinstance(message, ResultMessage):
            print(f"Completed: {message.subtype}")


if __name__ == "__main__":
    asyncio.run(main())

SDKはエージェントループを実行し、Claudeがファイルを読み、必要なツールを選び、コードを編集し、タスク完了まで進捗をストリーミングします。

マルチエージェント・オーケストレーションフレームワーク

マルチエージェントフレームワークは、特定の役割、目標、ツールセット、または大規模ワークフロー内の段階を各エージェントに割り当て、複数の専門エージェントを連携させます。

9. CrewAI

CrewAIは、マルチエージェントチームを構築するための人気のPythonフレームワークです。開発者は異なる役割、目標、タスクを持つエージェントを作成し、自律的に協働するクルーに編成できます。タスクは逐次的に実行することも、マネージャーが最適なエージェントに仕事を割り当てる階層型プロセスで実行することもできます。

次のPython例は、研究者とライターが協力して短いレポートを作成するものです。

# pip install crewai
# Set OPENAI_API_KEY before running

from crewai import Agent, Crew, Process, Task

researcher = Agent(
    role="AI Researcher",
    goal="Find the key facts about {topic}",
    backstory="You research technical topics carefully.",
)

writer = Agent(
    role="Technical Writer",
    goal="Turn research into a clear summary",
    backstory="You explain complex topics simply.",
)

research_task = Task(
    description="Research {topic} and identify three key findings.",
    expected_output="Three concise findings.",
    agent=researcher,
)

writing_task = Task(
    description="Write a short summary using the research findings.",
    expected_output="A clear one-paragraph report.",
    agent=writer,
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
)

result = crew.kickoff(inputs={"topic": "agentic AI"})
print(result.raw)

研究者が最初のタスクを完了し、その出力を文脈としてライターが最終レポートを作成します。

10. MetaGPT

MetaGPTは、プロダクトマネージャー、アーキテクト、プロジェクトマネージャー、エンジニアなど、専門エージェントによるソフトウェア企業をモデル化するマルチエージェントフレームワークです。これらのエージェントは定型のオペレーション手順に従い、短い要件を計画、技術設計、ドキュメント、動作するコードへと変換します。

次の例では、ソフトウェアチームを作成し、簡単なコマンドラインのタスク管理ツールを作るよう依頼します。

# pip install metagpt
# Configure a supported LLM API before running

import asyncio

from metagpt.roles import (
    Architect,
    Engineer,
    ProductManager,
    ProjectManager,
)
from metagpt.team import Team


async def startup(idea: str):
    company = Team()

    company.hire([
        ProductManager(),
        Architect(),
        ProjectManager(),
        Engineer(),
    ])

    company.invest(investment=3.0)
    company.run_project(idea=idea)

    await company.run(n_round=5)


if __name__ == "__main__":
    asyncio.run(
        startup("Build a simple command-line task manager")
    )

エージェントは各自の役割に応じて要件を分担し、協力してソフトウェアプロジェクトを計画・開発します。

11. AgentScope

AgentScopeは、制御可能で可観測なエージェントやマルチエージェントアプリを構築するためのPythonフレームワークです。既成のエージェント、ツール、メモリ、メッセージルーティング、ストリーミング、並列ツール呼び出し、ワークフロー、トレーシング、人的介入を提供します。AgentScope Studioでエージェントの実行を検査・可視化することもできます。

次の例では、計算を完了するためにPythonコードを書いて実行できるReActエージェントを作成します。

# pip install agentscope
# Set DASHSCOPE_API_KEY before running

import asyncio
import os

from agentscope.agent import ReActAgent
from agentscope.formatter import DashScopeChatFormatter
from agentscope.memory import InMemoryMemory
from agentscope.message import Msg
from agentscope.model import DashScopeChatModel
from agentscope.tool import Toolkit, execute_python_code


async def main():
    toolkit = Toolkit()
    toolkit.register_tool_function(execute_python_code)

    agent = ReActAgent(
        name="Nova",
        sys_prompt="You are a helpful Python assistant named Nova.",
        model=DashScopeChatModel(
            model_name="qwen-max",
            api_key=os.environ["DASHSCOPE_API_KEY"],
            stream=True,
        ),
        formatter=DashScopeChatFormatter(),
        toolkit=toolkit,
        memory=InMemoryMemory(),
    )

    await agent(
        Msg(
            name="user",
            content="Use Python to calculate the sum of numbers from 1 to 100.",
            role="user",
        )
    )


if __name__ == "__main__":
    asyncio.run(main())

このエージェントはPython実行ツールを呼び出す判断を行い、生成コードを実行し、その結果を使ってユーザーに回答します。

12. CAMEL-AI

CAMEL-AIは、エージェント、マルチエージェント社会、ロールプレイシミュレーションを構築するためのオープンソースPythonフレームワークです。研究色が強く、エージェント協調、ツール、メモリ、検索、データ生成、世界シミュレーションのコンポーネントを提供します。Ollama、vLLM、SGLangといったプラットフォーム経由で、クラウドモデルやローカルホストモデルもサポートします。

次の例では、回答する前にウェブ検索を行えるエージェントを作成します。

# pip install "camel-ai[web_tools]"
# Set OPENAI_API_KEY before running

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.toolkits import SearchToolkit
from camel.types import ModelPlatformType, ModelType

model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_5_5,
    model_config_dict={"temperature": 0.0},
)

agent = ChatAgent(
    system_message="You are a helpful AI research assistant.",
    model=model,
    tools=[SearchToolkit().search_duckduckgo],
)

response = agent.step(
    "What are the main uses of multi-agent AI systems?"
)

print(response.msgs[0].content)

エージェントは最新情報が必要なときにDuckDuckGo検索を使い、その後に最終回答を返します。

データとRAGのエージェントフレームワーク

これらのフレームワークは、LLMやエージェントをドキュメント、データベース、API、その他のプライベートデータソースに接続し、回答前に関連コンテキストを取得できるようにします。

13. LlamaIndex

LlamaIndexは、プライベートまたはドメイン特化データ上に文脈対応アプリを構築するためのPythonフレームワークです。コネクタ、インデックス、リトリーバ、クエリエンジン、エージェント、ワークフローを提供し、RAG、エンタープライズ検索、ドキュメントアシスタントといった用途に適します。

RAGアプリを作り始めた頃、LlamaIndexはお気に入りのフレームワークでした。データのロード、インデックス作成、クエリが非常に簡単で、同等のアプリをLangChainで作るよりコードが単純で短いと感じることが多いです。詳しくはLlamaIndexコースをご覧ください。

次の例では、フォルダからドキュメントを読み込み、検索可能なインデックスを作り、取得したコンテキストを使って質問に答えます。

# pip install llama-index
# Set OPENAI_API_KEY before running

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query(
    "What are the main findings in these documents?"
)

print(response)

LlamaIndexはdataフォルダ内のファイルをインデックスし、回答の生成前に関連情報を取得します。

14. Haystack

Haystackは、本番運用可能なRAGパイプライン、セマンティック検索システム、エージェント、データ中心のAIアプリを構築するためのオープンソースPythonフレームワークです。モジュール型のパイプライン構造により、情報の取得、プロンプトへの追加、モデルへの送信を明確に制御できます。

Haystackは、RAGやマルチエージェントアプリの構築に問題なく使用できました。汎用フレームワークではありますが、特にLLMをドキュメント、テキスト、検索システム、その他のデータソースに接続するアプリに有用です。

次の例では、いくつかのドキュメントを保存し、最も関連するものを検索し、それを使って質問に答えます。

# pip install -U haystack-ai
# Set OPENAI_API_KEY before running

from haystack import Document, Pipeline
from haystack.components.builders import ChatPromptBuilder
from haystack.components.generators.chat import (
    OpenAIResponsesChatGenerator,
)
from haystack.components.retrievers import InMemoryBM25Retriever
from haystack.dataclasses import ChatMessage
from haystack.document_stores.in_memory import InMemoryDocumentStore

document_store = InMemoryDocumentStore()
document_store.write_documents([
    Document(content="The London AI event starts at 6:00 PM."),
    Document(content="The Berlin AI event starts at 7:00 PM."),
])

template = [
    ChatMessage.from_system(
        "Answer using the following documents:\n"
        "{% for doc in documents %}{{ doc.content }}{% endfor %}"
    ),
    ChatMessage.from_user("{{ question }}"),
]

pipeline = Pipeline()
pipeline.add_component(
    "retriever",
    InMemoryBM25Retriever(document_store),
)
pipeline.add_component(
    "prompt_builder",
    ChatPromptBuilder(template=template),
)
pipeline.add_component(
    "llm",
    OpenAIResponsesChatGenerator(model="gpt-5.5"),
)

pipeline.connect("retriever", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

question = "When does the London AI event start?"

result = pipeline.run({
    "retriever": {"query": question},
    "prompt_builder": {"question": question},
})

print(result["llm"]["replies"][0].text)

Haystackは一致するドキュメントを取得してプロンプトに組み込み、GPT-5.5で根拠ある回答を生成します。

軽量・オープンモデル対応フレームワーク

これらのフレームワークは、ホスティング済みまたはローカル実行のオープンモデルでエージェントを構築するための、よりシンプルな抽象化を提供します。

15. Hugging Face smolagents

Hugging Face smolagentsは、少ないコード量でエージェントを構築できる軽量のPythonフレームワークです。CodeAgentはPythonを書いてアクションを実行し、ToolCallingAgentは構造化ツール呼び出しを使います。Hugging Faceのモデル、Inference Providers、ローカルホストのオープンソースモデルと特に相性が良いです。

次の例では、ウェブ検索エージェントを作成し、必要に応じて調査を委任する判断を行うマネージャーエージェントに渡します。

# pip install -U "smolagents[toolkit]"
# Set HF_TOKEN before running

from smolagents import (
    CodeAgent,
    InferenceClientModel,
    ToolCallingAgent,
    WebSearchTool,
)

model = InferenceClientModel(
    model_id="Qwen/Qwen3-Next-80B-A3B-Thinking"
)

web_agent = ToolCallingAgent(
    tools=[WebSearchTool()],
    model=model,
    name="web_search_agent",
    description="Searches the web and returns useful information.",
)

manager_agent = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[web_agent],
)

result = manager_agent.run(
    "Who created Hugging Face, and when was it founded?"
)

print(result)

マネージャーは最新情報が必要な場面を判断し、専門のウェブ検索エージェントに委任してから、最終回答を生成します。

クイックフレームワーク比較

以下の表は、各フレームワークの主な強みと、それが最も適しているエージェント型AIアプリのタイプを比較したものです。

まとめ

エージェント型AIをこれから始めるなら、まずはOpenAI Agents SDK、Google ADK、Claude Agent SDKといった公式SDKから始めるのがおすすめです。各社モデルとAPIに密接に連携しているため、セットアップがシンプルです。APIキーを追加し、クレジットを用意して、すぐに構築を始められます。

これらのSDKは、エージェントの作成、ツール接続、実行時の挙動の検査を容易にしてくれる点が魅力です。わずかなPythonコードで有用なエージェントや小規模なマルチエージェントシステムまで作れます。

より柔軟性が必要な場合は、LangChainやLangGraphを検討します。多数の統合が必要なときはLangChain、状態・ループ・長いワークフローをより厳密に制御したいときはLangGraphが有用です。

異なる役割のエージェントチームにはCrewAIが良い選択です。RAG、プライベート文書、データ接続型アプリにはLlamaIndexかHaystackを選びます。

最後に、smolagentsは軽量で、シンプルで、オープン／ローカルモデルと使いやすい点が魅力です。

アドバイスとしては、プロジェクトに合う中で最もシンプルなフレームワークから始めることです。小さなバージョンを作り、しっかりテストし、本当に必要になったときだけ複雑さを追加してください。