Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Zusammenfassung und praktische Übungen

Lektion 12 von 12 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Was wir besprochen haben
  2. Die sechs Parameter auf einen Blick
  3. Kontrollen vor dem Produktiveinsatz
  4. Ihr erster Agent in drei Schritten
  5. Was nach diesem Kurs weiterhin gilt
  6. Kernaussagen
  7. Testen Sie Ihr Wissen

Was wir besprochen haben

Dieser Kurs hat Sie vom Konzept des Model Context Protocol (MCP) bis hin zu einer produktionsreifen Konfiguration geführt. Wenn Sie sich nur noch eine Sache merken, dann diese: MCP ermöglicht es Grok, über HTTPS mit externen Tool-Servern zu verbinden, wobei die exponierten Tools automatisch entdeckt und genutzt werden, ohne manuelle Client-Konfiguration.

Architektonisch strukturieren vier Punkte alles Weitere. Remote-MCP funktioniert ausschließlich über HTTPS, was reine HTTP-Verbindungen, localhost und den stdio-Transport für lokale Server ausschließt. Zwei Transportarten werden unterstützt: der moderne zustandslose Streaming-HTTP und der persistente Server-Sent Events (SSE). Der Server bestimmt, welche Art verwendet wird; Sie können dies nicht selbst wählen. Schließlich bieten drei Schnittstellen den Zugang zu diesem Mechanismus: das native xAI SDK (empfohlen), die Responses API für OpenAI-Kompatibilität und die Voice Agent API für Sprachagenten.

Die sechs Parameter auf einen Blick

ParameterErforderlichFunktion
server_urlJaHTTPS-Adresse des MCP-Servers
server_labelJaEindeutiger Identifier, der Tools voranstellt
server_descriptionNeinNatürliche Sprachbeschreibung zur Orientierung für Grok
allowed_tool_namesNeinWhitelist zugänglicher Tools
authorizationNeinAuthentifizierungstoken (Bearer, API-Schlüssel)
headersNeinZusätzliche HTTP-Header

Zwei erforderlich, vier optional: Das ist die gesamte Konfigurationsoberfläche für Remote-MCP. Die optionalen Parameter sind jedoch nicht nur Komfortfunktionen. allowed_tool_names sorgt für Ihre Sicherheit, und server_description gewährleistet eine präzise Auswahl, wenn mehrere Server koexistieren.

Kontrollen vor dem Produktiveinsatz

Drei Kategorien von Kontrollen erfordern eine explizite Überprüfung. Auf der Sicherheitsseite stellen Sie sicher, dass URLs HTTPS mit gültigen Zertifikaten verwenden, jeder interne Server sein Authentifizierungstoken besitzt, diese Tokens in Umgebungsvariablen gespeichert sind, Tools auf das notwendige Minimum beschränkt sind und eine regelmäßige Token-Rotation geplant ist, nicht nur gehofft.

Auf der Konfigurationsseite muss jeder Server ein eindeutiges, beschreibendes server_label besitzen, und seine server_description muss präzise und aktuell sein – eine Beschreibung, die auf eine frühere Serverversion verweist, irreführt das Modell. Halten Sie die Gesamtzahl der Tools angemessen, etwa zehn bis zwanzig pro Sitzung, und entfernen Sie Server aus der Konfiguration, deren Tools niemand mehr aufruft.

Auf der Observability-Seite planen Sie Vorfälle im Voraus: Tool-Aufrufe in Ihren Logs nachverfolgt, Alarme bei MCP-Verbindungsfehlern, Tracking des Token-Verbrauchs pro Server und Messung der Aufruf-Latenz. Letzteres wird oft vernachlässigt, obwohl es das erste Signal für einen sich verschlechternden Server darstellt.

Ihr erster Agent in drei Schritten

Der beste Weg, um diesen Kurs zu festigen, ist der schrittweise Aufbau. Beginnen Sie mit einem öffentlichen Server ohne Authentifizierung, um zu validieren, dass die Mechaniken von Ende zu Ende funktionieren.

from xai_sdk import Client
from xai_sdk.tools import mcp
import os

client = Client(api_key=os.getenv("XAI_API_KEY"))

chat = client.chat.create(
    model="grok-4.20-0309-reasoning",
    tools=[
        mcp(
            server_url="https://mcp.deepwiki.com/mcp",
            server_label="deepwiki"
        )
    ],
)

Testen Sie dies mit einer Anfrage, die das Modell tatsächlich zwingt, das Repository zu konsultieren, beispielsweise: “Erkläre mir die Architektur des fastapi/fastapi-Projekts.” Wenn die Antwort eintrifft und die tatsächliche Projektstruktur zitiert, ist Ihre MCP-Verbindung funktionsfähig.

Als Nächstes fügen Sie ein natives Tool hinzu, um zu sehen, wie Grok zwischen zwei Quellen unterschiedlicher Natur abwägt. Die Serverbeschreibung wird hier nützlich, genau weil nun eine Auswahl getroffen werden muss.

tools=[
    mcp(
        server_url="https://mcp.deepwiki.com/mcp",
        server_label="deepwiki",
        server_description="Dokumentation für Open-Source-GitHub-Projekte"
    ),
    {"type": "web_search"},
]

Schließlich machen Sie den Schritt zu einem internen Server mit Authentifizierung und Tool-Beschränkung. Dies ist der Schritt, an dem alles, was Sie über Sicherheit gesehen haben, konkret wird.

tools=[
    mcp(server_url="https://mcp.deepwiki.com/mcp", server_label="deepwiki"),
    mcp(
        server_url="https://api.your-server.com/mcp",
        server_label="internal",
        server_description="Unternehmensinterne Daten und Tools",
        authorization=f"Bearer {os.getenv('INTERNAL_TOKEN')}",
        allowed_tool_names=["search", "get_document"]
    ),
    {"type": "web_search"},
]

Was nach diesem Kurs weiterhin gilt

Vier Einschränkungen werden alle Ihre MCP-Projekte mit Grok begleiten. Die Responses API im OpenAI-Format unterstützt weder require_approval noch connector_id, was Sie zurück zum nativen SDK führt, sobald Sie menschliche Validierung vor der Ausführung wünschen. Der stdio-Transport und damit lokale MCP-Server bleiben unerreichbar: nur HTTPS. Jeder exponierte Tool-Aufruf verbraucht Kontext, wodurch Minimalismus eine architektonische Entscheidung ist und kein nachträglicher Gedanke. Und Netzwerklatenz summert sich mit jedem Aufruf, sodass ein Agent, der mehrere MCP-Tools aufruft, langsamer antwortet als ein Agent, der nur eines aufruft.

Keine dieser Einschränkungen sind Blockaden. Alle werden durch Designentscheidungen umgangen, die mit vollem Wissen getroffen werden, und genau das ist es, was dieser Kurs Ihnen gegeben hat.

Kernaussagen

  • Remote-MCP verbindet Grok mit externen Tools über HTTPS in wenigen Konfigurationszeilen.
  • Sechs Parameter reichen aus, um einen MCP-Server zu konfigurieren (zwei erforderlich, vier optional).
  • Sicherheit stützt sich auf die Triade aus HTTPS + Authentifizierung + Tool-Beschränkung.
  • Beginnen Sie mit einem öffentlichen Server (DeepWiki) und schreiten Sie dann zu einem authentifizierten Multi-Server-Setup voran.
  • Kombinieren Sie MCP und native Tools, um vielseitige Agenten zu erstellen.

Testen Sie Ihr Wissen

Remote-MCP-Server in der Grok API: Sie haben sich diese Zusammenfassung verdient.

1. Was ermöglicht die MCP-Unterstützung der Grok API?

Antwort: Remote-MCP-Server als Modell-Tools verbinden: Grok ruft deren Fähigkeiten während der Generierung auf – Ihre Systeme und das MCP-Ökosystem werden zu Erweiterungen.

2. Wie deklarieren Sie einen MCP-Server in einer Anfrage?

Antwort: Über server_url und server_label, mit Beschreibung und Whitelist autorisierter Tools – sowie den für den Zugriff erforderlichen Authentifizierungs-Headern.

3. Was ermöglicht die Multi-Server-Konfiguration?

Antwort: Mehrere MCP-Server in einer einzigen Anfrage kombinieren – jeweils gekennzeichnet – und sie mit integrierten Tools (Web, X) mischen: Die Orchestrierung bleibt beim Modell.

4. Welche Transportarten werden unterstützt?

Antwort: Streaming-HTTP und SSE – die Remote-Transporte des Protokolls: Der Server lebt dort, wo Sie ihn wollen, die API verbindet sich mit ihm.

5. Welche Sicherheitsregeln für Remote-Server?

Antwort: Nur notwendige Tools autorisieren, Authentifizierung ernst nehmen und Serverantworten als Daten behandeln, die validiert werden müssen – ein externer MCP-Server ist eine potenzielle Angriffsfläche.

Deklarieren, beschränken, authentifizieren, kombinieren: Remote-MCP erweitert Grok auf Ihre Systeme – nach Ihren Regeln.