Mistral Agents API mit MCP: Wie gut ist es?

Künstliche Intelligenz (KI) geht rasant über das bloße Generieren von Text oder das Erkennen von Bildern hinaus. Die nächste Grenze ist KI, die handeln, Probleme lösen und auf sinnvolle Weise mit der Welt interagieren kann. Mistral AI, ein bekannter Name in diesem Bereich, hat mit seiner Mistral Agents API einen bedeutenden Schritt in diese Richtung unternommen. Dieses leistungsstarke Toolkit ermöglicht es Entwicklern, anspruchsvolle KI-Agenten zu erstellen, die weit mehr können als herkömmliche Sprachmodelle.

Im Kern ist die Agents API darauf ausgelegt, die Einschränkungen von Standard-KI-Modellen zu überwinden, die oft hervorragend darin sind, Sprache zu verstehen und zu generieren, aber Schwierigkeiten haben, Aktionen auszuführen, vergangene Interaktionen konsequent zu speichern oder externe Tools effektiv zu nutzen. Die Mistral Agents API begegnet diesen Herausforderungen, indem sie ihre leistungsstarken Sprachmodelle mit Funktionen wie integrierten Konnektoren zu verschiedenen Tools, persistentem Speicher über Konversationen hinweg und der Fähigkeit, komplexe Aufgaben zu koordinieren, ausstattet.

Stellen Sie sich das wie ein Upgrade von einem sehr sachkundigen Bibliothekar vor, der nur über Bücher sprechen kann, zu einem Team von erfahrenen Forschern, die nicht nur auf Informationen zugreifen, sondern auch Experimente durchführen, Berichte schreiben und miteinander zusammenarbeiten können. Diese neue API dient als Grundlage für die Erstellung von KI-Anwendungen auf Unternehmensebene, die Arbeitsabläufe automatisieren, bei komplexen Entscheidungen helfen und wirklich interaktive Erlebnisse bieten können.

Was macht Mistral Agents so leistungsfähig?

Herkömmliche Sprachmodelle, die zwar in der Texterstellung versiert sind, versagen oft, wenn es darum geht, Aktionen auszuführen oder Informationen über längere Interaktionen hinweg zu speichern. Die Mistral Agents API geht diese Einschränkungen direkt an, indem sie die hochmodernen Sprachmodelle von Mistral mit einer Reihe leistungsstarker Funktionen kombiniert, die für agentenbasierte Workflows konzipiert sind.

Kernfunktionen:

Im Kern bietet die Agents API:

• Integrierte Konnektoren: Dies sind vorab bereitgestellte Tools, die Agenten bei Bedarf aufrufen können. Dazu gehören:
• Codeausführung: Ermöglicht es Agenten, Python-Code in einer sicheren Sandbox auszuführen, nützlich für Berechnungen, Datenanalysen und wissenschaftliches Rechnen.
• Websuche: Ermächtigt Agenten mit Zugriff auf aktuelle Informationen aus dem Internet, wodurch die Antwortgenauigkeit und -relevanz erheblich verbessert wird. Im SimpleQA-Benchmark erzielte Mistral Large mit Websuche beispielsweise einen Wert von 75 %, eine massive Verbesserung gegenüber 23 % ohne sie.
• Bilderzeugung: Durch die Nutzung von Modellen wie Black Forest Lab FLUX1.1 [pro] Ultra können Agenten vielfältige Bilder für Anwendungen erstellen, die von Lernhilfen bis hin zu Marketinggrafiken reichen.
• Dokumentenbibliothek: Ermöglicht es Agenten, auf Dokumente aus der Mistral Cloud zuzugreifen und diese zu nutzen, wodurch die integrierte Retrieval Augmented Generation (RAG) zur Verbesserung ihrer Wissensbasis genutzt wird.
• MCP-Tools: Erleichtert die nahtlose Integration mit externen Systemen über das Model Context Protocol, das wir in Teil 3 ausführlich untersuchen werden.
• Persistenter Speicher: Agenten können den Kontext über Konversationen hinweg beibehalten, was zu kohärenteren und aussagekräftigeren langfristigen Interaktionen führt.
• Agentenbasierte Orchestrierung: Die API ermöglicht die Koordination mehrerer Agenten, die sich jeweils auf verschiedene Aufgaben spezialisieren können, um komplexe Probleme gemeinsam zu lösen.

Diese API ist nicht nur eine Erweiterung ihrer Chat Completion API; sie ist ein dediziertes Framework, das speziell entwickelt wurde, um die Implementierung von agentenbasierten Anwendungsfällen zu vereinfachen. Sie soll das Rückgrat von agentenbasierten Plattformen auf Unternehmensebene bilden und es Unternehmen ermöglichen, KI auf praktischere, wirkungsvollere und handlungsorientiertere Weise einzusetzen.

Mistral Agents in Aktion: Anwendungen in der realen Welt

Die Vielseitigkeit der Agents API wird durch verschiedene innovative Anwendungen demonstriert:

• Coding Assistant mit GitHub: Ein agentenbasierter Workflow, bei dem ein Agent einen Entwickleragenten (angetrieben von DevStral) überwacht, der mit GitHub interagiert und Softwareentwicklungsaufgaben mit voller Repository-Autorität automatisiert.
• Linear Tickets Assistant: Ein intelligenter Assistent, der eine Multi-Server-MCP-Architektur verwendet, um Call-Transkripte in Product Requirements Documents (PRDs) umzuwandeln, dann in umsetzbare Linear-Probleme und anschließend Projektleistungen zu verfolgen.
• Finanzanalyst: Ein beratender Agent, der mehrere MCP-Server orchestriert, um Finanzkennzahlen zu beschaffen, Erkenntnisse zusammenzustellen und Ergebnisse sicher zu archivieren, was eine komplexe Datenaggregation und -analyse demonstriert.
• Reiseassistent: Ein umfassendes KI-Tool, das Benutzern hilft, Reisen zu planen, Unterkünfte zu buchen und verschiedene reisebezogene Bedürfnisse zu verwalten.
• Ernährungsassistent: Ein KI-gestützter Ernährungsbegleiter, der Benutzern hilft, Ziele zu setzen, Mahlzeiten zu protokollieren, personalisierte Ernährungsvorschläge zu erhalten, den täglichen Fortschritt zu verfolgen und Restaurants zu finden, die ihren Ernährungszielen entsprechen.

Speicher, Kontext und zustandsbehaftete Konversationen

Ein Eckpfeiler der Agents API ist ihr robustes Konversationsverwaltungssystem. Es stellt sicher, dass Interaktionen zustandsbehaftet sind, d. h. der Kontext wird über die Zeit beibehalten. Entwickler können Konversationen auf zwei Arten initiieren:

1. Mit einem Agenten: Durch die Angabe einer agent_id nutzen Sie die vorkonfigurierten Fähigkeiten, Tools und Anweisungen eines bestimmten Agenten.
2. Direkter Zugriff: Sie können eine Konversation starten, indem Sie das Modell und die Vervollständigungsparameter direkt angeben, wodurch Sie schnell auf integrierte Konnektoren zugreifen können, ohne einen vordefinierten Agenten.

Jede Konversation behält einen strukturierten Verlauf durch "Konversationseinträge" bei, wodurch sichergestellt wird, dass der Kontext sorgfältig erhalten bleibt. Diese Zustandsbehaftung ermöglicht es Entwicklern, vergangene Konversationen anzuzeigen, jede Interaktion nahtlos fortzusetzen oder sogar abzweigen, um neue Konversationspfade von jedem Punkt in der Historie aus zu initiieren. Darüber hinaus unterstützt die API Streaming-Ausgaben, wodurch Echtzeit-Updates und dynamische Interaktionen ermöglicht werden.

Agenten-Orchestrierung: Die Kraft der Zusammenarbeit

Die wahre differenzierende Kraft der Agents API zeigt sich in ihrer Fähigkeit, mehrere Agenten zu orchestrieren. Hier geht es nicht um eine einzelne monolithische KI; es geht um eine Symphonie spezialisierter Agenten, die im Konzert arbeiten. Durch dynamische Orchestrierung können Agenten nach Bedarf zu einer Konversation hinzugefügt oder daraus entfernt werden, wobei jeder seine einzigartigen Fähigkeiten einbringt, um verschiedene Facetten eines komplexen Problems anzugehen.

So erstellen Sie einen agentenbasierten Workflow mit Übergaben:

1. Agenten erstellen: Definieren und erstellen Sie alle erforderlichen Agenten, die jeweils mit spezifischen Tools, Modellen und Anweisungen ausgestattet sind, die auf ihre Rolle zugeschnitten sind.
2. Übergaben definieren: Geben Sie an, welche Agenten Aufgaben an andere delegieren können. Beispielsweise könnte ein primärer Kundendienstagent eine technische Anfrage an einen spezialisierten Troubleshooting-Agenten oder eine Rechnungsanfrage an einen Finanzagenten weiterleiten.

Diese Übergaben ermöglichen eine nahtlose Kette von Aktionen. Eine einzelne Benutzeranfrage kann eine Kaskade von Aufgaben über mehrere Agenten auslösen, die jeweils autonom ihren zugewiesenen Teil bearbeiten. Dieser kollaborative Ansatz eröffnet beispiellose Effizienz und Effektivität bei der Problemlösung für anspruchsvolle Anwendungen in der realen Welt.

Grundlegende Verwendung der Mistral Agents API

Nachdem wir die Fähigkeiten der Mistral Agents API verstanden haben, wollen wir untersuchen, wie man mit ihr interagiert. Die API führt drei neue primäre Objekte ein:

• Agenten: Dies sind Konfigurationen, die die Fähigkeiten eines Modells erweitern. Eine Agentendefinition enthält vorgewählte Werte wie das zu verwendende Modell, die Tools, auf die es zugreifen kann, Systemanweisungen (Prompts) und Standard-Vervollständigungsparameter.
• Konversation: Dieses Objekt stellt den Verlauf der Interaktionen und vergangenen Ereignisse mit einem Assistenten dar. Es enthält Benutzernachrichten, Antworten des Assistenten und Aufzeichnungen von Tool-Ausführungen.
• Eintrag: Ein Eintrag ist eine einzelne Aktion oder ein einzelnes Ereignis innerhalb einer Konversation, das entweder vom Benutzer oder von einem Assistenten erstellt wurde. Er bietet eine flexible und ausdrucksstarke Möglichkeit, Interaktionen darzustellen, wodurch eine feinere Kontrolle über die Beschreibung von Ereignissen ermöglicht wird.

Beachten Sie, dass Sie viele Funktionen wie zustandsbehaftete Konversationen und integrierte Konnektoren nutzen können, ohne zuerst explizit ein formelles "Agent"-Objekt zu erstellen und zu referenzieren. Dies bietet Flexibilität für einfachere Anwendungsfälle.

Einen Agenten erstellen

Um einen spezialisierten Agenten zu definieren, stellen Sie eine Anfrage an die API, in der Sie mehrere Parameter angeben:

• model: Das zugrunde liegende Mistral-Modell (z. B. mistral-medium-latest).
• name: Ein beschreibender Name für Ihren Agenten.
• description: Eine kurze Erläuterung des Zwecks des Agenten oder der Aufgabe, die er ausführen soll.
• instructions (optional): Der System-Prompt, der das Verhalten und die Antworten des Agenten steuert.
• tools (optional): Eine Liste der Tools, die der Agent verwenden kann. Tooltypen umfassen:
• function: Benutzerdefinierte Tools, ähnlich wie Standard-Funktionsaufrufe bei Chat-Vervollständigungen.
• web_search / web_search_premium: Integrierte Websuch-Tools.
• code_interpreter: Das integrierte Tool zur Codeausführung.
• image_generation: Das integrierte Tool zur Bilderzeugung.
• completion_args (optional): Standard-Chat-Vervollständigungs-Sampler-Argumente wie Temperatur, top_p usw.

Hier ist ein Beispiel für eine cURL-Anfrage zum Erstellen eines einfachen Agenten:

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."
     }'

Einen Agenten aktualisieren

Agenten können nach der Erstellung aktualisiert werden. Die Argumente sind die gleichen wie bei der Erstellung. Diese Operation führt zu einem neuen Agentenobjekt mit den aktualisierten Einstellungen, wodurch effektiv eine Versionierung Ihrer Agenten ermöglicht wird.

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."
     }'

Konversationen verwalten

Sobald ein Agent erstellt wurde (oder wenn Sie direkten Zugriff verwenden), können Sie Konversationen initiieren.

Eine Konversation starten:
Sie müssen Folgendes angeben:

• agent_id: Die ID des Agenten (wenn Sie einen vordefinierten Agenten verwenden).
• inputs: Die ursprüngliche Nachricht, die eine einfache Zeichenfolge oder eine Liste von Nachrichtenobjekten sein kann.
  Diese Anfrage gibt eine conversation_id zurück.

Beispiel (einfache Zeichenfolge als Eingabe):

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>"
     }'

Eine Konversation fortsetzen:
So fügen Sie einer bestehenden Konversation hinzu:

• conversation_id: Die ID der Konversation, die fortgesetzt werden soll.
• inputs: Die nächste Nachricht oder Antwort (Zeichenfolge oder Liste von Nachrichten).
  Jede Fortsetzung liefert eine neue conversation_id, wenn der Zustand gespeichert wird. Sie können die Cloud-Speicherung deaktivieren, indem Sie store=False festlegen. Der Parameter handoff_execution steuert, wie Agentenübergaben verwaltet werden: server (Standard, wird von Mistrals Cloud verarbeitet) oder client (Antwort wird an den Benutzer zurückgegeben, um die Übergabe zu verwalten).

Beispiel:

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"
     }'

Streaming-Ausgabe

Für Echtzeit-Interaktionen können sowohl das Starten als auch das Fortsetzen von Konversationen gestreamt werden, indem stream: true festgelegt und sichergestellt wird, dass der Accept-Header text/event-stream ist.

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"
     }'

Beim Streaming erhalten Sie verschiedene Ereignistypen, die den Fortschritt und den Inhalt der Antwort anzeigen, z. B.:

• conversation.response.started: Markiert den Beginn der Konversationsantwort.
• message.output.delta: Ein Teil des Inhalts (Token) für die Antwort des Modells.
• tool.execution.started / tool.execution.done: Zeigt den Lebenszyklus einer Toolausführung an.
• agent.handoff.started / agent.handoff.done: Signalisiert den Start und das Ende einer Agentenübergabe.

Diese grundlegenden Operationen bilden die Grundlage für die Erstellung dynamischer und interaktiver Anwendungen mit Mistral-Agenten.

Integration der Mistral Agents API mit dem Model Context Protocol (MCP)

Während die integrierten Konnektoren erhebliche Leistung bieten, zeigt sich die wahre Erweiterbarkeit von Mistral Agents in Kombination mit dem Model Context Protocol (MCP).

Was ist MCP?

Das Model Context Protocol (MCP) ist ein offener Standard, der darauf ausgelegt ist, die Integration von KI-Modellen mit verschiedenen externen Datenquellen, Tools und APIs zu rationalisieren. Es bietet eine standardisierte, sichere Schnittstelle, die es KI-Systemen ermöglicht, effizient auf reale Kontextinformationen zuzugreifen und diese zu nutzen. Anstatt zahlreiche maßgeschneiderte Integrationen zu erstellen und zu verwalten, bietet MCP eine einheitliche Möglichkeit für KI-Modelle, sich mit Live-Daten und -Systemen zu verbinden, was zu relevanteren, genaueren und leistungsfähigeren Antworten führt. Ausführliche Informationen finden Sie in der offiziellen Model Context Protocol-Dokumentation.

Das Python SDK von Mistral bietet nahtlose Integrationsmechanismen für die Verbindung von Agenten mit MCP-Clients. Dies ermöglicht es Ihren Agenten, mit jedem Dienst oder jeder Datenquelle zu interagieren, die eine MCP-Schnittstelle bereitstellt, egal ob es sich um ein lokales Tool, eine API von Drittanbietern oder ein proprietäres Unternehmenssystem handelt.

Wir werden drei gängige Szenarien für die Verwendung von MCP mit Mistral Agents untersuchen: einen lokalen MCP-Server, einen Remote-MCP-Server ohne Authentifizierung und einen Remote-MCP-Server mit Authentifizierung. Alle Beispiele verwenden asynchronen Python-Code.

Szenario 1: Verwenden eines lokalen MCP-Servers

Stellen Sie sich vor, Sie haben ein lokales Skript oder einen Dienst (z. B. einen benutzerdefinierten Wetterinformationsanbieter), mit dem Ihr Mistral-Agent interagieren soll.

Schritt 1: Initialisieren des Mistral-Clients und -Setups
Importieren Sie die erforderlichen Module von mistralai und mcp. Dazu gehören Mistral, RunContext, StdioServerParameters (für lokale prozessbasierte MCP-Server) und 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())

In diesem Setup wäre stdio_server.py Ihr Skript, das die MCP-Serverlogik implementiert und über stdin/stdout kommuniziert. Der RunContext verwaltet die Interaktion, und register_mcp_client macht den lokalen MCP-Server als Tool für den Agenten verfügbar. Sie können auch lokale Python-Funktionen direkt mit @run_ctx.register_func registrieren.

Streaming mit einem lokalen MCP-Server:
Um zu streamen, verwenden Sie client.beta.conversations.run_stream_async und verarbeiten Sie Ereignisse, sobald sie eintreffen:

    # 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

Szenario 2: Verwenden eines Remote-MCP-Servers ohne Authentifizierung

Viele öffentliche oder interne Dienste könnten eine MCP-Schnittstelle über HTTP/SSE verfügbar machen, ohne dass eine Authentifizierung erforderlich ist.

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())

Hier wird MCPClientSSE mit SSEServerParams verwendet, das auf die Remote-URL verweist. Der Agent kann dann Tools nutzen, die von diesem Remote-MCP-Server bereitgestellt werden. Das Streaming folgt dem gleichen Muster wie im lokalen MCP-Beispiel, wobei run_stream_async verwendet wird.

Szenario 3: Verwenden eines Remote-MCP-Servers mit Authentifizierung (OAuth)

Für Dienste, die eine OAuth2-Authentifizierung erfordern (wie Linear, Jira usw.), umfasst der Prozess ein paar weitere Schritte zur Handhabung des Autorisierungsflusses.

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())

Dies beinhaltet das Einrichten eines lokalen HTTP-Servers, um die OAuth-Umleitung abzufangen, den Benutzer durch die Autorisierungsseite des Anbieters zu führen, den empfangenen Code gegen ein Zugriffstoken auszutauschen und dann den MCPClientSSE mit diesem Token zu konfigurieren. Nach der Authentifizierung kann der Agent mit dem geschützten MCP-Dienst interagieren. Das Streaming folgt wiederum dem etablierten Muster.

Fazit: Die Zukunft ist agentenbasiert und vernetzt

Die Mistral Agents API, insbesondere wenn sie durch das Model Context Protocol erweitert wird, bietet eine robuste und flexible Plattform für die Erstellung von KI-Anwendungen der nächsten Generation. Indem Agenten in die Lage versetzt werden, nicht nur zu argumentieren und zu kommunizieren, sondern auch mit einem riesigen Ökosystem von Tools, Datenquellen und Diensten zu interagieren, können Entwickler wirklich intelligente Systeme erstellen, die in der Lage sind, komplexe Probleme in der realen Welt zu bewältigen. Unabhängig davon, ob Sie komplizierte Arbeitsabläufe automatisieren, tiefgreifend kontextualisierte Unterstützung leisten oder neue Formen der Mensch-KI-Zusammenarbeit vorantreiben, bietet die Kombination aus Mistral Agents und MCP das grundlegende Toolkit für diese aufregende Zukunft. Da der MCP-Standard eine breitere Akzeptanz findet, wird das Potenzial für die Erstellung vernetzter und hochleistungsfähiger KI-Agenten nur weiter wachsen.