Blog

Mistral Agents APIとMCPの活用：その実力とは？

Mark Ponomarev

Mark Ponomarev

28 5月 2025

Mistral Agents APIとMCPの活用：その実力とは？

人工知能（AI）は、単にテキストを生成したり画像を認識したりする段階を急速に超えつつあります。次のフロンティアは、行動を起こし、問題を解決し、世界と有意義な方法で相互作用できるAIです。この分野で著名なMistral AIは、Mistral Agents APIでこの方向へ大きな一歩を踏み出しました。この強力なツールキットにより、開発者は従来の言語モデルよりもはるかに多くのことができる洗練されたAIエージェントを構築できます。

Agents APIは、その核心において、標準的なAIモデルの限界を克服するように設計されています。標準的なAIモデルは、言語の理解や生成には優れていることが多いですが、行動の実行、過去のインタラクションの一貫した記憶、外部ツールの効果的な使用には苦労します。Mistral Agents APIは、強力な言語モデルに、さまざまなツールへの組み込みコネクタ、会話全体にわたる永続的なメモリ、複雑なタスクを調整する能力などの機能を装備することで、これらの課題に対処します。

これは、本について話すことしかできない非常に博識な司書から、情報にアクセスできるだけでなく、実験を行い、レポートを書き、互いに協力できる専門研究者のチームにアップグレードするようなものだと考えてください。この新しいAPIは、ワークフローを自動化し、複雑な意思決定を支援し、真にインタラクティブな体験を提供するエンタープライズグレードのAIアプリケーションを作成するための基盤として機能します。

💡
美しいAPIドキュメントを生成する優れたAPIテストツールをお探しですか？

最大限の生産性で開発チームが協力して作業できる統合されたオールインワンプラットフォームをお探しですか？

Apidogはあなたのすべての要求を満たし、Postmanをはるかに手頃な価格で置き換えます！
button

Mistral Agentsがこれほど有能な理由は何ですか？

従来の言語モデルは、テキスト生成には熟練していますが、拡張されたインタラクション全体でアクションを実行したり情報を記憶したりすることに関しては、しばしば不十分です。Mistral Agents APIは、これらの限界に直接対処するために、Mistralの最先端の言語モデルと、エージェントワークフロー用に設計された一連の強力な機能を相乗効果で活用しています。

コア機能：

その中心には、Agents APIが提供するものがあります：

このAPIは、Chat Completion APIの単なる拡張ではありません。これは、エージェントユースケースの実装を簡素化するために特別に設計された専用フレームワークです。これは、エンタープライズグレードのエージェントプラットフォームの基盤となるように設計されており、企業がAIをより実用的、影響力があり、アクション指向の方法で展開できるようにします。

Mistral Agentsの活用：実際のアプリケーション

Agents APIの多用途性は、さまざまな革新的なアプリケーションによって示されています：

メモリ、コンテキスト、およびステートフルな会話

Agents APIの基礎となるのは、堅牢な会話管理システムです。これにより、インタラクションがステートフルになり、コンテキストが時間の経過とともに保持されます。開発者は、主に2つの方法で会話を開始できます：

  1. エージェントを使用する：agent_idを指定することで、特定の事前構成されたエージェントの機能、ツール、および指示を活用します。
  2. 直接アクセス：モデルと完了パラメータを直接指定することで会話を開始でき、事前定義されたエージェントなしで組み込みコネクタにすばやくアクセスできます。

各会話は、「会話エントリ」を介して構造化された履歴を維持し、コンテキストが細心の注意を払って保持されるようにします。このステートフル性により、開発者は過去の会話を表示したり、任意のインタラクションをシームレスに続行したり、履歴の任意の時点から新しい会話パスを開始したりすることもできます。さらに、APIはストリーミング出力をサポートしており、リアルタイムの更新と動的なインタラクションを可能にします。

エージェントオーケストレーション：コラボレーションの力

Agents APIの真の差別化力は、複数のエージェントをオーケストレーションする能力にあります。これは単一のモノリシックなAIに関するものではありません。これは、専門のエージェントが連携して機能するシンフォニーに関するものです。動的なオーケストレーションを通じて、エージェントは必要に応じて会話に追加または削除でき、それぞれが複雑な問題の異なる側面に取り組むために独自のスキルを提供します。

ハンドオフを使用してエージェントワークフローを構築するには：

  1. エージェントを作成する：必要なすべてのエージェントを定義および作成し、それぞれに役割に合わせた特定のツール、モデル、および指示を装備します。
  2. ハンドオフを定義する：どのエージェントがタスクを他のエージェントに委任できるかを指定します。たとえば、主要なカスタマーサービスエージェントは、技術的なクエリを専門のトラブルシューティングエージェントに、または請求に関する問い合わせを財務エージェントにハンドオフする場合があります。

これらのハンドオフにより、アクションのシームレスな連鎖が可能になります。単一のユーザー要求は、複数のエージェントにわたるタスクのカスケードをトリガーでき、それぞれが指定された部分を自律的に処理します。この共同アプローチは、洗練された実際のアプリケーションの問題解決において、前例のない効率と有効性を解き放ちます。

Mistral Agents APIの基本的な使用法

Mistral Agents APIの機能を理解したところで、それとの相互作用方法を見てみましょう。APIは3つの新しい主要なオブジェクトを導入しています：

特に、まず正式な「エージェント」オブジェクトを明示的に作成して参照することなく、ステートフルな会話や組み込みコネクタなど、多くの機能を活用できます。これにより、より単純なユースケースに対して柔軟性が提供されます。

エージェントの作成

専門エージェントを定義するには、いくつかのパラメータを指定してAPIにリクエストを行います：

単純なエージェントを作成するためのcURLリクエストの例を次に示します：

curl --location "https://api.mistral.ai/v1/agents" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "model": "mistral-medium-latest",
         "name": "Simple Agent",
         "description": "A simple Agent with persistent state."
     }'

エージェントの更新

エージェントは作成後に更新できます。引数は作成時と同じです。この操作により、更新された設定を持つ新しいエージェントオブジェクトが生成され、エージェントのバージョン管理が可能になります。

curl --location "https://api.mistral.ai/v1/agents/<agent_id>" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "completion_args": {
           "temperature": 0.3,
           "top_p": 0.95
         },
         "description": "An edited simple agent."
     }'

会話の管理

エージェントが作成されたら（または直接アクセスを使用している場合）、会話を開始できます。

会話の開始：
以下を提供する必要があります：

例（単純な文字列入力）：

curl --location "https://api.mistral.ai/v1/conversations" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Who is Albert Einstein?",
         "stream": false,
         "agent_id": "<agent_id>"
     }'

会話の続行：
既存の会話に追加するには：

例：

curl --location "https://api.mistral.ai/v1/conversations/<conv_id>" \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Translate to French.",
         "stream": false,
         "store": true,
         "handoff_execution": "server"
     }'

出力のストリーミング

リアルタイムのインタラクションの場合、stream: trueを設定し、Acceptヘッダーがtext/event-streamであることを確認することで、会話の開始と続行の両方をストリーミングできます。

curl --location "https://api.mistral.ai/v1/conversations" \
     --header 'Content-Type: application/json' \
     --header 'Accept: text/event-stream' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
         "inputs": "Who is Albert Einstein?",
         "stream": true,
         "agent_id": "ag_06811008e6e07cb48000fd3f133e1771"
     }'

ストリーミング時には、応答の進行状況と内容を示すさまざまなイベントタイプ（例：）を受信します：

これらの基本的な操作は、Mistralエージェントを使用した動的でインタラクティブなアプリケーションを構築するための基盤を形成します。

Mistral Agents APIとModel Context Protocol（MCP）の統合

組み込みコネクタは大きなパワーを提供しますが、Mistral Agentsの真の拡張性は、Model Context Protocol（MCP）と組み合わせたときに発揮されます。

MCPとは？

Model Context Protocol（MCP）は、AIモデルと多様な外部データソース、ツール、APIの統合を合理化するために設計されたオープン標準です。AIシステムが実際のコンテキスト情報に効率的にアクセスして利用できるようにする、標準化された安全なインターフェイスを提供します。多数のカスタム統合を構築および維持する代わりに、MCPはAIモデルがライブデータやシステムに接続するための統一された方法を提供し、より関連性があり、正確で、強力な応答につながります。詳細については、公式のModel Context Protocolドキュメントを参照してください。

MistralのPython SDKは、エージェントをMCPクライアントと接続するためのシームレスな統合メカニズムを提供します。これにより、エージェントは、ローカルツール、サードパーティAPI、または独自のエンタープライズシステムなど、MCPインターフェイスを公開するあらゆるサービスまたはデータソースと相互作用できます。

Mistral AgentsとMCPを使用する3つの一般的なシナリオを探ります：ローカルMCPサーバー、認証なしのリモートMCPサーバー、認証ありのリモートMCPサーバーです。すべての例では、非同期Pythonコードを使用します。

シナリオ1：ローカルMCPサーバーの使用

Mistralエージェントが相互作用させたいローカルスクリプトまたはサービス（例：カスタム天気情報プロバイダー）があると想像してください。

ステップ1：Mistralクライアントの初期化とセットアップ
mistralaiおよびmcpから必要なモジュールをインポートします。これには、Mistral、RunContext、StdioServerParameters（ローカルプロセスベースのMCPサーバー用）、およびMCPClientSTDIOが含まれます。

import asyncio
import os
from pathlib import Path
from mistralai import Mistral
from mistralai.extra.run.context import RunContext
from mcp import StdioServerParameters
from mistralai.extra.mcp.stdio import MCPClientSTDIO
from mistralai.types import BaseModel

cwd = Path(__file__).parent
MODEL = "mistral-medium-latest" # Or your preferred model

async def main_local_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    # Define parameters for the local MCP server (e.g., running a Python script)
    server_params = StdioServerParameters(
        command="python",
        args=[str((cwd / "mcp_servers/stdio_server.py").resolve())], # Path to your MCP server script
        env=None,
    )

    # Create an agent
    weather_agent = client.beta.agents.create(
        model=MODEL,
        name="Local Weather Teller",
        instructions="You can tell the weather using a local MCP tool.",
        description="Fetches weather from a local source.",
    )

    # Define expected output format (optional, but good for structured data)
    class WeatherResult(BaseModel):
        user: str
        location: str
        temperature: float

    # Create a Run Context
    async with RunContext(
        agent_id=weather_agent.id,
        output_format=WeatherResult, # Optional: For structured output
        continue_on_fn_error=True,
    ) as run_ctx:
        # Create and register MCP client
        mcp_client = MCPClientSTDIO(stdio_params=server_params)
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        # Example of registering a local Python function as a tool
        import random
        @run_ctx.register_func
        def get_location(name: str) -> str:
            """Function to get a random location for a user."""
            return random.choice(["New York", "London", "Paris"])

        # Run the agent
        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Tell me the weather in John's location currently.",
        )

        print("Local MCP - All run entries:")
        for entry in run_result.output_entries:
            print(f"{entry}\n")
        if run_result.output_as_model:
            print(f"Local MCP - Final model output: {run_result.output_as_model}")
        else:
            print(f"Local MCP - Final text output: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_local_mcp())

この設定では、stdio_server.pyはMCPサーバーロジックを実装するスクリプトであり、stdin/stdoutを介して通信します。RunContextはインタラクションを管理し、register_mcp_clientはローカルMCPサーバーをエージェントのツールとして利用可能にします。@run_ctx.register_funcを使用してローカルPython関数を直接登録することもできます。

ローカルMCPサーバーを使用したストリーミング：
ストリーミングするには、client.beta.conversations.run_stream_asyncを使用し、到着したイベントを処理します：

    # Inside RunContext, after MCP client registration
    # events = await client.beta.conversations.run_stream_async(
    #     run_ctx=run_ctx,
    #     inputs="Tell me the weather in John's location currently, stream style.",
    # )
    # streamed_run_result = None
    # async for event in events:
    #     if isinstance(event, RunResult): # Assuming RunResult is defined or imported
    #         streamed_run_result = event
    #     else:
    #         print(f"Stream event: {event}")
    # if streamed_run_result:
    #     # Process streamed_run_result
    #     pass

シナリオ2：認証なしのリモートMCPサーバーの使用

多くのパブリックまたは内部サービスは、認証を必要とせずにHTTP/SSE経由でMCPインターフェイスを公開する場合があります。

from mistralai.extra.mcp.sse import MCPClientSSE, SSEServerParams

async def main_remote_no_auth_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    # Define the URL for the remote MCP server (e.g., Semgrep's public MCP)
    server_url = "https://mcp.semgrep.ai/sse"
    mcp_client = MCPClientSSE(sse_params=SSEServerParams(url=server_url, timeout=100))

    async with RunContext(
        model=MODEL, # Can use agent_id too if an agent is pre-created
    ) as run_ctx:
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Can you write a hello_world.py file and then check it for security vulnerabilities using available tools?",
        )

        print("Remote No-Auth MCP - All run entries:")
        for entry in run_result.output_entries:
            print(f"{entry}\n")
        print(f"Remote No-Auth MCP - Final Response: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_remote_no_auth_mcp())

ここでは、MCPClientSSEがSSEServerParamsとともにリモートURLを指して使用されます。エージェントは、このリモートMCPサーバーによって提供されるツールを活用できます。ストリーミングは、ローカルMCPの例と同じパターンに従い、run_stream_asyncを使用します。

シナリオ3：認証ありのリモートMCPサーバーの使用（OAuth）

OAuth2認証（Linear、Jiraなど）を必要とするサービスの場合、認証フローを処理するためにいくつかの追加手順が必要です。

from http.server import BaseHTTPRequestHandler, HTTPServer
import threading
import webbrowser
from mistralai.extra.mcp.auth import build_oauth_params

CALLBACK_PORT = 16010 # Ensure this port is free

# Callback server setup (simplified from source)
def run_callback_server_util(callback_func, auth_response_dict):
    class OAuthCallbackHandler(BaseHTTPRequestHandler):
        def do_GET(self):
            if "/callback" in self.path or "/oauth/callback" in self.path: # More robust check
                auth_response_dict["url"] = self.path
                self.send_response(200)
                self.send_header("Content-type", "text/html")
                self.end_headers()
                self.wfile.write(b"<html><body>Authentication successful. You may close this window.</body></html>")
                callback_func() # Signal completion
                threading.Thread(target=self.server.shutdown).start()
            else:
                self.send_response(404)
                self.end_headers()

    server_address = ("localhost", CALLBACK_PORT)
    httpd = HTTPServer(server_address, OAuthCallbackHandler)
    threading.Thread(target=httpd.serve_forever, daemon=True).start() # Use daemon thread
    redirect_url = f"http://localhost:{CALLBACK_PORT}/oauth/callback"
    return httpd, redirect_url

async def main_remote_auth_mcp():
    api_key = os.environ["MISTRAL_API_KEY"]
    client = Mistral(api_key=api_key)

    server_url = "https://mcp.linear.app/sse" # Example: Linear MCP
    mcp_client_auth = MCPClientSSE(sse_params=SSEServerParams(url=server_url))

    callback_event = asyncio.Event()
    event_loop = asyncio.get_event_loop()
    auth_response_holder = {"url": ""}

    if await mcp_client_auth.requires_auth():
        httpd, redirect_url = run_callback_server_util(
            lambda: event_loop.call_soon_threadsafe(callback_event.set),
            auth_response_holder
        )
        try:
            oauth_params = await build_oauth_params(mcp_client_auth.base_url, redirect_url=redirect_url)
            mcp_client_auth.set_oauth_params(oauth_params=oauth_params)
            login_url, state = await mcp_client_auth.get_auth_url_and_state(redirect_url)

            print(f"Please go to this URL and authorize: {login_url}")
            webbrowser.open(login_url, new=2)
            await callback_event.wait() # Wait for OAuth callback

            token = await mcp_client_auth.get_token_from_auth_response(
                auth_response_holder["url"], redirect_url=redirect_url, state=state
            )
            mcp_client_auth.set_auth_token(token)
            print("Authentication successful.")
        except Exception as e:
            print(f"Error during authentication: {e}")
            return # Exit if auth fails
        finally:
            if 'httpd' in locals() and httpd:
                httpd.shutdown()
                httpd.server_close()
    
    async with RunContext(model=MODEL) as run_ctx: # Or agent_id
        await run_ctx.register_mcp_client(mcp_client=mcp_client_auth)

        run_result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Tell me which projects do I have in my Linear workspace?",
        )
        print(f"Remote Auth MCP - Final Response: {run_result.output_as_text}")

# if __name__ == "__main__":
#     asyncio.run(main_remote_auth_mcp())

これには、OAuthリダイレクトをキャッチするためのローカルHTTPサーバーのセットアップ、プロバイダーの認証ページを介したユーザーの誘導、受信したコードをアクセストークンと交換すること、およびこのトークンでMCPClientSSEを構成することが含まれます。認証されると、エージェントは保護されたMCPサービスと相互作用できます。ストリーミングは、確立されたパターンに従います。

結論：未来はエージェント的で相互接続されている

Mistral Agents APIは、特にModel Context Protocolによって強化された場合、次世代のAIアプリケーションを構築するための堅牢で柔軟なプラットフォームを提供します。エージェントが推論し通信するだけでなく、ツール、データソース、サービスの広範なエコシステムと相互作用できるようにすることで、開発者は複雑な現実世界の問題に取り組むことができる真にインテリジェントなシステムを作成できます。複雑なワークフローの自動化、深くコンテキスト化された支援の提供、人間とAIのコラボレーションの新しい形の開拓など、Mistral AgentsとMCPの組み合わせは、このエキサイティングな未来のための基盤となるツールキットを提供します。MCP標準が広く採用されるにつれて、相互接続され非常に有能なAIエージェントを作成する可能性はさらに拡大し続けるでしょう。

💡
美しいAPIドキュメントを生成する優れたAPIテストツールをお探しですか？

最大限の生産性で開発チームが協力して作業できる統合されたオールインワンプラットフォームをお探しですか？

Apidogはあなたのすべての要求を満たし、Postmanをはるかに手頃な価格で置き換えます！
button

ApidogでAPIデザイン中心のアプローチを取る

APIの開発と利用をよりシンプルなことにする方法を発見できる

無料会員登録ダウンロード