DanLevy.net

Dein KI-Agent ist ohne das hier nutzlos

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

Du hast einen KI-Agenten gebaut. Vielleicht ist er sogar gut. Die Prompts sind straff, das Modell ist schnell und die Antworten fühlen sich natürlich an.

Aber dann bittet jemand ihn, einen Kundendatensatz in Salesforce nachzuschlagen. Oder die neuesten Jira-Tickets abzurufen. Oder die interne Dokumentation zu durchsuchen.

Und dein schöner Agent kann einfach nicht.

Das ist das Integrationsproblem, auf das jede KI-Plattform früher oder später stößt. Dein Agent braucht Hände. Er braucht Augen in deine tatsächlichen Geschäftssysteme. Ohne sie betreibst du nur einen teuren Chatbot.

Die herkömmliche Lösung? Schreibe einen eigenen API-Wrapper für jeden einzelnen Dienst, den du anbinden willst. Lies deren Dokumentation, kümmere dich um deren Authentifizierung, handle mit deren Rate-Limits und bete, dass sie ihre Endpunkte nächsten Monat nicht ändern. Und dann nochmal für den nächsten Dienst. Und den nächsten.

Das Model Context Protocol ändert diese Rechnung komplett.

Was MCP tatsächlich löst

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

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

Statt benutzerdefinierten Code zu schreiben, um deinen Agenten mit Salesforce, HubSpot, GitHub oder einem 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 Kommunikationsschicht. Du definierst nur, was deine Tools tun und welche Daten sie benötigen.

Mehrere Integrationen einrichten

Mastra unterstützt MCP nativ über den MCPClient. Du kannst sowohl lokale Tools (als Kindprozesse ausgeführt) als auch entfernte Dienste (auf eigener Infrastruktur laufend) anbinden.

Hier ist ein realistisches Produktions-Setup, das Google Maps für Routing, einen Wetterdienst und eine lokale Wikipedia-Suche verbindet:

src/mastra/mcp/index.ts
import { MCPClient } from '@mastra/mcp';


export const mcpClient = new MCPClient({
  servers: {
    // Local tool (Stdio)
    wikipedia: {
      command: 'npx',
      args: ['-y', 'wikipedia-mcp'],
    },
    // Maps & Navigation (Remote/HTTP)
    googleMaps: {
      url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
      requestInit: {
        headers: {
          Authorization: `Bearer ${process.env.GOOGLE_MAPS_API_KEY}`,
        },
      },
    },
    // Weather Service 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 Prozess-Spawning für lokale Tools und hält HTTP-Verbindungen für entfernte Server aufrecht. Du musst dich nicht direkt mit Sockets oder Stdio befassen.

Tools mit Agenten verbinden

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

src/mastra/agents/navigation-agent.ts
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(), // <--- This is the magic line
});

Wenn ein Benutzer fragt: “Was ist die beste Route von San Francisco zum Lake Tahoe, und sollte ich wegen des Wetters besorgt sein?”

Der Agent liest 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 plus aktuellen Wetterbedingungen entlang des Weges.

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

Authentifizierung pro Benutzer

Hier ist ein Sicherheitsfehler leicht gemacht: Credentials fest einzucodieren.

Wenn du einen einzigen Google Maps API-Schlüssel in deine Umgebungsvariablen legst und es dabei bewenden lässt, teilen sich alle Benutzer dasselbe Kontingent und dieselben Rate-Limits. Noch wichtiger: Wenn du Dienste nutzt, die Benutzereinstellungen speichern (wie gespeicherte Orte oder Favoritenrouten), würden alle dieselben Daten sehen. Für Demos funktioniert das gut. In der Produktion ist es ein Risiko.

Mastra löst das, indem es dir erlaubt, MCP-Clients dynamisch mit benutzerspezifischen Credentials zu erstellen:

async function handleUserRequest(userPrompt: string, userCredentials: UserCreds) {
  // Create a client for THIS specific user
  const userMcp = new MCPClient({
    servers: {
      googleMaps: {
        url: new URL(process.env.GOOGLE_MAPS_MCP_URL!),
        requestInit: {
          headers: {
            // User's specific API key or token
            Authorization: `Bearer ${userCredentials.mapsApiKey}`,
            'X-User-ID': userCredentials.userId,
          },
        },
      },
    },
  });


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


  // Inject tools at runtime
  const response = await agent.generate(userPrompt, {
    toolsets: await userMcp.getToolsets(),
  });


  return response;
}

Jeder Benutzer erhält sein eigenes isoliertes Toolset mit eigenen API-Kontingenten und Einstellungen. Benutzer A’s gespeicherte Orte bleiben privat, Benutzer B’s Routenverlauf 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 willst du eine Route planen, die sowohl Echtzeit-Verkehr als auch Wetterbedingungen entlang des Weges berücksichtigt.

Du kannst MCP-Tools in benutzerdefinierte Tool-Definitionen einbetten:

export const smartRouteTool = createTool({
  id: 'smart-route-planner',
  description: 'Plans optimal route considering traffic and weather conditions',
  execute: async ({ context, mastra }) => {
    // Get the raw tools
    const tools = await mcpClient.getTools();


    // 1. Get base route from Google Maps
    const routeData = await tools.googleMaps_getDirections.execute({
      context: {
        origin: context.origin,
        destination: context.destination
      }
    });


    // 2. Check weather along the route
    const weatherData = await tools.weather_getForecast.execute({
      context: { coordinates: routeData.waypoints }
    });


    // 3. Return enhanced route with weather warnings
    return {
      ...routeData,
      weatherAlerts: weatherData.alerts,
      recommendation: weatherData.severe ? 'Consider delaying trip' : 'Safe to travel'
    };
  },
});

Das gibt dir feingranulare Kontrolle darüber, wie Tools interagieren, während du das MCP-Protokoll weiterhin für die Schwerstarbeit nutzt.

Wohin das führt

Das Schreiben eigener API-Clients für jeden Dienst, mit dem dein KI-Agent sprechen muss, war nie nachhaltig. Es skaliert schlecht, bricht häufig und bindet deine Plattform an bestimmte Implementierungen.

MCP löst nicht jede Integrationsherausforderung – Authentifizierung bleibt komplex, Rate-Limiting bleibt wichtig und nicht jeder Dienst hat noch einen MCP-Server. Aber es schafft ein Fundament, das den Bau von Agenten-Plattformen erheblich weniger schmerzhaft macht.

Wenn du ein KI-System architektonisch aufbaust, das mit externen Diensten interagieren muss, ist es wahrscheinlich deine Zeit wert, MCP zu verstehen.

Ressourcen

Die Serie lesen

  1. LLM Routing
  2. Sicherheit & Guardrails
  3. MCP & Tool-Integrationen (Dieser Beitrag)
  4. Workflows & Speicher
Loading comments...