Model Context Protocol (MCP): Grundlagen, Architektur und Praxisanwendung

1. Was ist MCP? — Das Universalprotokoll für KI-Integration

Stellen Sie sich vor, Sie haben einen brillanten Analysten — nennen wir ihn Sam. Er spricht fließend Deutsch und Englisch, kennt 20 Jahre Trading-Floor-Geschichten und kann jede Aktie der Welt analysieren. Aber er sitzt in einem Raum ohne Telefon, ohne Computer, ohne Zugang zur Außenwelt.

Genau so funktionieren große Sprachmodelle (LLMs) wie GPT, Gemini oder Claude: Sie sind extrem intelligent, aber ohne externe Verbindungen isoliert. MCP ist die standardisierte „Telefonleitung" die diesen Analysten mit der Welt verbindet — Datenbanken, APIs, Dateisystemen und Tools.

1.1 MCP vs. Traditionelle API-Integration

2. MCP-Architektur: Host → Client → Server

MCP folgt einer dreischichtigen Architektur, die für klare Verantwortungstrennung sorgt:

Das Entscheidende: Ein Host kann gleichzeitig mit beliebig vielen MCP-Servern kommunizieren. In unserem Projekt nutzen wir zwei MCP-Server: Supabase (Datenbank) und Cloud Run (Deployment). Der gleiche Host könnte morgen GitHub, Slack oder ein CRM anbinden — ohne eine Zeile LLM-Code zu ändern.

3. Das Problem: Sams repetitive Anekdoten

Sam ist der KI-Host und Lead Analyst von RA LUECHT ADVISORY. Täglich um 22:00 Uhr generiert ein Cloudflare Worker ein Audio-Briefing, in dem Sam die Watchlist analysiert, Trades einordnet und Anekdoten aus 20 Jahren Trading-Floor-Erfahrung erzählt.

Das Problem: Sam wiederholte sich. Jeden Tag der gleiche Espresso-Opener, die gleiche Geschichte vom Parkett in Frankfurt, die gleiche Gold-Metapher. Warum?

Die Lösung erforderte genau das, was MCP ermöglicht: Eine programmatische Brücke zwischen dem LLM (Gemini) und einer externen Datenbank (Supabase), die vergangenes Verhalten trackt und als harte Einschränkung in den Prompt injiziert.

4. MCP in Aktion: Die Anekdoten-Rotation-Engine

Die Lösung demonstriert den gesamten MCP-Lebenszyklus:

4.1 Schema: Die Datenbasis (MCP Resource)

Über den MCP-Supabase-Server wurde programmatisch eine Tabelle erstellt, die als Resource (persistente Datenquelle) dient:

-- Erstellt über MCP: mcp_supabase.apply_migration()
CREATE TABLE sam_anecdotes (
    id       BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    briefing_type  TEXT NOT NULL  -- 'daily', 'bell', 'ai_daily'
        CHECK (briefing_type IN ('daily', 'bell', 'ai_daily')),
    briefing_date  DATE NOT NULL DEFAULT CURRENT_DATE,
    anecdote_category TEXT NOT NULL,  -- z.B. 'espresso', 'vinyl', 'whisky'
    anecdote_text  TEXT NOT NULL,     -- Die exakte Passage
    language       TEXT DEFAULT 'de',
    created_at     TIMESTAMPTZ DEFAULT NOW()
);

-- Index für schnelle Abfrage der letzten 14 Tage
CREATE INDEX idx_sam_anecdotes_date 
    ON sam_anecdotes (briefing_date DESC);

4.2 Fetch: Vergangene Anekdoten laden (MCP Tool → Read)

Vor jeder Briefing-Generierung ruft der Worker die letzten 14 Tage aus Supabase ab — genau so, wie ein MCP-Tool Daten aus einer Resource liest:

// Fetch: Hole die zuletzt verwendeten Anekdoten (14-Tage-Fenster)
async function fetchRecentAnecdotes(env, days = 14) {
    const cutoffDate = new Date();
    cutoffDate.setDate(cutoffDate.getDate() - days);
    const cutoffStr = cutoffDate.toISOString().split('T')[0];

    const response = await fetch(
        `${env.SUPABASE_URL}/rest/v1/sam_anecdotes` +
        `?briefing_date=gte.${cutoffStr}&order=briefing_date.desc`,
        {
            headers: {
                'apikey': env.SUPABASE_SERVICE_KEY,
                'Authorization': `Bearer ${env.SUPABASE_SERVICE_KEY}`
            }
        }
    );
    return await response.json(); // Array von Anekdoten-Objekten
}

4.3 Blacklist: Programmatische Prompt-Injektion

Der Kern der Engine: Die geladenen Anekdoten werden als harte Einschränkung in den Gemini-Prompt injiziert. Das ist der entscheidende Unterschied zu „bitte wiederhole dich nicht" — hier wird das LLM programmatisch gesteuert:

function buildAnecdoteBlacklist(recentAnecdotes) {
    // Gruppiere nach Kategorie
    const byCategory = {};
    for (const a of recentAnecdotes) {
        if (!byCategory[a.anecdote_category])
            byCategory[a.anecdote_category] = [];
        byCategory[a.anecdote_category].push(a.anecdote_text);
    }

    // Finde noch NICHT verwendete Kategorien
    const usedCategories = Object.keys(byCategory);
    const unusedCategories = ANECDOTE_CATEGORIES
        .filter(c => !usedCategories.includes(c));

    // Baue die Blacklist-Sektion für den Prompt
    let blacklist = `
=== ANEKDOTEN-ROTATION (PROGRAMMATISCH ERZWUNGEN) ===
❌ Bereits verwendet (NICHT wiederholen):`;

    for (const [cat, texts] of Object.entries(byCategory)) {
        blacklist += `\n  [${cat}]: "${texts[0].substring(0,120)}"`;
    }

    blacklist += `\n\n✅ EMPFOHLENE Kategorien:\n`
        + unusedCategories.map(c => `  - ${c}`).join('\n');

    return blacklist;
}

4.4 Persist: Neue Anekdoten extrahieren und speichern (MCP Tool → Write)

Nach der Generierung wird der Text durch einen leichtgewichtigen Gemini-Call analysiert, die verwendeten Anekdoten extrahiert und in Supabase gespeichert — das schließt den Feedback-Loop:

async function extractAndPersistAnecdotes(briefingText, type, apiKey, env) {
    // 1. Leichtgewichtiger Gemini-Call: Extraction
    const extracted = await callGemini(`
        Extrahiere Anekdoten aus diesem Text als JSON-Array:
        [{ "category": "espresso", "text": "..." }]
    `, briefingText);

    // 2. Persist: In Supabase speichern via REST API
    await fetch(`${env.SUPABASE_URL}/rest/v1/sam_anecdotes`, {
        method: 'POST',
        headers: { 'apikey': env.SUPABASE_SERVICE_KEY },
        body: JSON.stringify(extracted.map(a => ({
            briefing_type: type,       // 'daily' | 'bell' | 'ai_daily'
            briefing_date: today,
            anecdote_category: a.category,
            anecdote_text: a.text
        })))
    });
    // → Feedback-Loop geschlossen!
}

5. Warum MCP wichtig ist — Über Anekdoten hinaus

Das Anekdoten-Beispiel mag trivial erscheinen. Aber das Muster dahinter ist universell anwendbar:

In jedem Fall ist das Grundprinzip identisch: Read → Constrain → Generate → Persist. MCP standardisiert diesen Zyklus über alle denkbaren Datenquellen und LLM-Anbieter hinweg.

6. Fazit

Das Model Context Protocol löst eines der fundamentalsten Probleme moderner KI-Systeme: die Isolation des LLM von der Außenwelt. Unsere Implementierung der Anekdoten-Rotation-Engine demonstriert, dass MCP-basierte Architekturen:

1. Programmatisch statt hoffnungsbasiert arbeiten — Verhalten wird erzwungen, nicht erbeten
2. Universal skalierbar — das gleiche Muster funktioniert für Compliance, E-Commerce, Healthcare
3. LLM-agnostisch — der Wechsel von Gemini zu Claude erfordert null Änderungen an der MCP-Infrastruktur

MCP ist nicht nur ein Protokoll — es ist die Infrastruktur-Schicht der Agentic AI, die den Unterschied zwischen einem Chatbot und einem autonomen System ausmacht.