Dein KI-Agent ist nutzlos ohne dies

Warum MCP der USB-C der künstlichen Intelligenz ist.

Du hast einen KI-Agenten gebaut. Vielleicht sogar einen guten. Die Prompts sind präzise, das Modell ist schnell, und die Antworten wirken natürlich.

Aber dann bittet jemand den Agenten, einen Kundendatensatz in Salesforce zu überprüfen. Oder die aktuellen Jira-Tickets abzurufen. Oder die interne Dokumentation zu durchsuchen.

Und dein wunderschöner Agent kann es einfach nicht.

Das ist das Integrationsproblem, auf das jede KI-Plattform irgendwann stößt. Dein Agent braucht Hände. Er braucht Zugang zu deinen echten Geschäftssystemen. Ohne diese bleibt er ein teurer Chatbot.

Die traditionelle Lösung? Für jeden Dienst, den du anbinden willst, einen eigenen API-Wrapper schreiben. Deren Doku lesen, deren Auth handhaben, mit deren Rate Limits umgehen, hoffen, dass sie nächsten Monat nicht ihre Endpunkte ändern. Und dann das Ganze wiederholen für den nächsten Dienst. Und den nächsten.

Das Model Context Protocol ändert diese Rechnung grundlegend.

Was MCP tatsächlich löst

Denk an USB vor USB-C. Es gab Mini-USB, Micro-USB, proprietäre Apple-Stecker und eine Schublade voller Kabel, die nur mit bestimmten Geräten funktionierten. USB-C hat nicht einfach einen neuen Stecker hinzugefügt – es hat einen Standard etabliert, bei dem jedes Kabel mit jedem Gerät funktioniert.

MCP macht dasselbe für KI-Tool-Integrationen.

Anstatt eigenen Code zu schreiben, um deinen Agenten mit Salesforce, HubSpot, GitHub oder irgendeinem anderen Dienst zu verbinden, implementierst du das Protokoll einmal (oder lädst einen vorgefertigten Server herunter), und jeder MCP-kompatible Agent kann sofort damit kommunizieren.

Das Protokoll übernimmt die Kommunikationsebene. Du definierst nur, was deine Tools tun und welche Daten sie benötigen.

Mehrere Integrationen einrichten

Mastra bietet native MCP-Unterstützung über seinen MCPClient. Du kannst sowohl lokale Tools (als Child-Prozesse ausgeführt) als auch entfernte Dienste (auf eigener Infrastruktur) anbinden.

Hier ist ein realistischer Produktionsaufbau mit Google Maps für Routenplanung, einem Wetterdienst und lokaler Wikipedia-Suche:

import { MCPClient } from '@mastra/mcp';

export const mcpClient = new MCPClient({
  servers: {
    // Lokales Tool (Stdio)
    wikipedia: {
      command: 'npx',
      args: ['-y', 'wikipedia-mcp'],
    },
    // Karten & Navigation (Remote/HTTP)
    googleMaps: {
      url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
      requestInit: {
        headers: {
          Authorization: `Bearer ${process.env.GOOGLE_MAPS_API_KEY}`,
        },
      },
    },
    // Wetterdienst-Integration
    weather: {
      url: new URL('https://mcp.weatherapi.dev/v1'),
      requestInit: {
        headers: {
          'X-API-Key': process.env.WEATHER_API_KEY!,
        },
      },
    },
  },
});

Der Client verwaltet den Verbindungslebenszyklus, kümmert sich um das Spawning von Prozessen für lokale Tools und hält HTTP-Verbindungen zu entfernten Servern aufrecht. Du kommst nicht direkt mit Sockets oder stdio in Berührung.

Tools mit Agenten verbinden

Sobald dein MCP-Client konfiguriert ist, ist es unkompliziert, diese Tools einem Agenten zur Verfügung zu stellen:

import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { mcpClient } from '../mcp';

export const navigationDirectionsAgent = new Agent({
  id: 'navigation-directions-agent',
  name: 'Navigation & Directions Assistant',
  instructions: `You are a helpful navigation assistant that provides route planning and travel advice.
    - Always confirm the start and destination locations
    - Use Google Maps tools to find optimal routes
    - Check weather conditions along the route
    - Provide estimated travel times and suggest alternatives if weather is poor
    - Include relevant details like traffic, road conditions, and points of interest
    - Keep responses clear and actionable`,
  model: openai('gpt-5'),
  tools: await mcpClient.getTools(), // <--- Das ist die Zauberzeile
});

Wenn ein Benutzer fragt: “Was ist die beste Route von San Francisco nach Lake Tahoe, und sollte ich mir wegen des Wetters Sorgen machen?”

Liest der Agent die verfügbaren Tool-Definitionen, erkennt, dass er Zugriff auf Google Maps-Routing und Wettervorhersage-Tools hat, führt sie mit den richtigen Parametern aus und antwortet mit einer optimalen Route sowie aktuellen Wetterbedingungen entlang der Strecke.

Du hast keine einzige Zeile Google-Maps-API-Code oder Wetterdienst-Integration geschrieben.

Pro-Benutzer-Authentifizierung

Es gibt einen Sicherheitsfehler, den man hier leicht macht: Credentials fest verdrahten.

Wenn du einen einzigen Google-Maps-API-Key in deine Umgebungsvariablen legst und es gut sein lässt, teilen sich alle Benutzer dasselbe Kontingent und dieselben Rate Limits. Und wenn du Dienste verwendest, die Benutzereinstellungen speichern (wie gespeicherte Orte oder Lieblingsrouten), würden alle dieselben Daten sehen. Für Demos funktioniert das gut. In der Produktion ist es ein Haftungsrisiko.

Mastra löst dies, indem du MCP-Clients dynamisch mit benutzerspezifischen Credentials erstellen kannst:

async function handleUserRequest(userPrompt: string, userCredentials: UserCreds) {
  // Einen Client für DIESEN spezifischen Benutzer erstellen
  const userMcp = new MCPClient({
    servers: {
      googleMaps: {
        url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
        requestInit: {
          headers: {
            // Benutzerspezifischer API-Key oder Token
            Authorization: `Bearer ${userCredentials.mapsApiKey}`,
            'X-User-ID': userCredentials.userId,
          },
        },
      },
    },
  });

  const agent = mastra.getAgent('navigationDirectionsAgent');

  // Tools zur Laufzeit injizieren
  const response = await agent.generate(userPrompt, {
    toolsets: await userMcp.getToolsets(),
  });

  return response;
}

Jeder Benutzer bekommt sein eigenes isoliertes Toolset mit eigenen API-Kontingenten und Einstellungen. Die gespeicherten Orte von Benutzer A bleiben privat, die Routenhistorie von Benutzer B ist getrennt. So funktionieren Multi-Tenant-SaaS-Agenten in der Praxis.

Zusammengesetzte Tools bauen

Manchmal musst du mehrere MCP-Tools zu einer einzigen Operation kombinieren. Vielleicht möchtest du eine Route planen, die sowohl Echtzeit-Verkehrsdaten als auch Wetterbedingungen entlang der Strecke berücksichtigt.

Du kannst MCP-Tools in benutzerdefinierten Tool-Definitionen kapseln:

export const smartRouteTool = createTool({
  id: 'smart-route-planner',
  description: 'Plant die optimale Route unter Berücksichtigung von Verkehr und Wetter',
  execute: async ({ context, mastra }) => {
    // Die rohen Tools abrufen
    const tools = await mcpClient.getTools();

    // 1. Basis-Route von Google Maps abrufen
    const routeData = await tools.googleMaps_getDirections.execute({
      context: {
        origin: context.origin,
        destination: context.destination
      }
    });

    // 2. Wetter entlang der Route prüfen
    const weatherData = await tools.weather_getForecast.execute({
      context: { coordinates: routeData.waypoints }
    });

    // 3. Verbesserte Route mit Wetterwarnungen zurückgeben
    return {
      ...routeData,
      weatherAlerts: weatherData.alerts,
      recommendation: weatherData.severe ? 'Erwäge, die Reise zu verschieben' : 'Reise ist sicher'
    };
  },
});

Das gibt dir die feinkörnige Kontrolle darüber, wie Tools zusammenwirken, während du weiterhin das MCP-Protokoll für die schwere Arbeit nutzt.

Wohin das führt

Eigene API-Clients für jeden Dienst zu schreiben, mit dem dein KI-Agent kommunizieren muss, war noch nie nachhaltig. Es skaliert schlecht, bricht oft und bindet deine Plattform an bestimmte Implementierungen.

MCP löst nicht jede Integrationsherausforderung – Authentifizierung bleibt komplex, Rate Limits sind weiterhin relevant, und nicht jeder Dienst hat bereits einen MCP-Server. Aber es schafft eine Grundlage, die den Bau von Agent-Plattformen erheblich weniger schmerzhaft macht.

Wenn du ein KI-System architektonierst, das mit externen Diensten interagieren muss, ist das Verständnis von MCP wahrscheinlich deine Zeit wert.

Ressourcen

Die Serie lesen

LLM-Routing
Sicherheit & Guardrails
MCP & Tool-Integrationen (Dieser Beitrag)
Workflows & Memory