MCP zur Agenten-Ermächtigung mittels Datenbanken und Tools

Model Context Protocol: Wie MCP für KI-Agenten funktioniert

Das Model Context Protocol (kurz MCP) beschreibt einen offenen Protokollstandard zur Verbindung von KI-Agenten (oft basierend auf Large Language Models, LLMs) mit externen Datenquellen, Tools und Systemen. Umgesetzt wird dies mit einer einheitlichen Konfiguration der Schnittstelle für alle Komponenten, weswegen MCP auch oft als “USB‑C für KI” bezeichnet wird. Hierbei ist das große Ziel die Reduktion von vielen individuellen Integrationen auf eine Integration pro angebundener Komponente.

KI-Agenten sind in diesem Kontext LLMs, die eigenständig User-Anweisungen umsetzen. Tools bezeichnet zusätzliche Software, die von diesen Agenten mittels generierter Syntax bedient werden kann. Hierbei passiert die Verknüpfung über MCP.

*Über MCP sind mittlerweile diverse KI-Anwendungen und andere Tools angebunden, alle über die gleiche Schnittstelle.*

Entwickelt wurde MCP von Anthropic (Entwickler von Claude), welche die Rechte an MCP zur Wahrung der Unabhängigkeit mittlerweile an die Linux-Foundation abgegeben haben.

Warum ist MCP so hilfreich?

KI-Agenten, welche auf Large Language Models (LLM) basieren, finden in immer mehr Bereichen von digitalen Services Anwendung, um eigenständig User-Anfragen zu bearbeiten.

Bisher war oft das Problem, dass KI-Agenten hier eine andere „Sprache“ als geläufige Software-Tools sprechen, weswegen der User die Kommunikation übernehmen musste.

MCP löst als neuer Standard dieses Problem, indem die Kommunikation vereinheitlicht wird. Daraus resultierend kann ein einmal angeschlossener KI-Agent direkt mit diversen Tools kommunizieren und interagieren.

Komponenten von MCP

Grundlegend ist MCP in einer Client-Server Architektur aufgebaut, mit folgenden Bestandteilen:

MCP-Host:
- KI Anwendung, welche n MCP-Clients verwendet, koordiniert und verwaltet
MCP-Client:
- Komponente, die Verbindung zu MCP-Server verwaltet, hier Informationen und Kontext erhält und diese an MCP-Host zur Verwendung weitergibt.
MCP-Server:
- Programm, das MCP-Client Informationen und Kontext bereitstellt.

Die Kommunikation zwischen den Komponenten erfolgt über den JSON RPC 2.0 Standard.

*Der Aufbau der MCP Struktur beinhaltet den MCP-Client, den MCP-Server und die angebundenen Komponenten, die Kommunikation erfolgt über Json RPC 2.0.*

Vorteile der MCP Technologie

MCP bietet für die Anbindung von KI-Agenten mannigfaltige Vorteile, darunter:

MCP-Server als ressourcengünstiger Ansatz, KI in Prozesse zu integrieren
- Host fungiert als Mediator und Connector zwischen verschieden Datenbanken/Tools/Websites
- Diverse Tools und Funktionalitäten können von Agenten oder User angesteuert werden
KI-Agent direkt ansteuerbar und selbstständig
- Anbindung von z.B.:
  - Datenbanken zur query
  - Git repos
  - Web und API integrations
  - Buisness tools (Beantworten von Slack Nachrichten/ Google Drive Verwaltung)
MCP-Schnittstellen sind wiederverwendbar, d.h. aus diversen Quellen ansteuerbar
- Von N(KI-Clients) x M(Server) zu N+M an Integrationen
- KI-Agenten austauschbar

Vor MCP musste für jede Verbindung eines Tools mit einem KI-Agenten eine eigene Schnittstelle bereitgestellt werden. Durch MCP kann die Kommunikation über eine universelle, wiederverwendbare Schnittstelle laufen. Quelle

Unsicherheiten der MCP-Technologie

Aus der großen Einfachheit in der Kommunikation mittels MCP erwachsen natürlich auch Sicherheitsrisiken.

Zum einen sind viele Server offen erreichbar, wodurch es zu Mängeln in der Sicherheit der gesendeten und empfangenen Daten kommen kann.

Zum Anderen bietet die Bereitstellung einer Schnittstelle zu den eigenen KI-Agenten eine Angriffsstelle für Prompt injections (insbesondere bei einem so genannten „tödlichem triple“):

Agent verarbeitet kompromittierte Inputs
- z.B. Mails, Github pull requests
Darüber hinaus Agent mit Zugang zu internen Daten
- Kann beispielsweise Datenbanken querien
Agent hat Möglichkeit, Informationen aus internem System zu versenden
- Beispielsweise per Mail

Wenn alle drei Punkte erfüllt werden, kann der KI-Agent mit bösartigen Anfragen kompromittiert werden und dadurch z.B. interne Unternehmensdaten an Dritte versenden. Der erste Sicherheitsmechanismus zur Prävention wäre eine Freigabe durch die zuständige Person (human-in-the-loop, s.u.). Allerdings können die bösartigen Prompts bei geschickter Konfiguration (Verstecken am Ende eines langen Prompts, weißer Text auf weißem Grund) auch an einem aufmerksamen Beobachter vorbeigeschleust werden. Auf die Frage, wie viele Rechte ein KI-Agent für eine bestimmte Aufgabe wirklich braucht, sollte also immer besonderes Augenmerk gelegt werden.

Darüber hinaus können komplizierte Fragestellungen falsche, womöglich halluzinierte, Ergebnisse liefern, da oft ein probalististisches Modell für deterministische Aufgaben eingesetzt wird. Für Problemstellungen, in denen KI-Agenten auf SQL-fähigen Datenbanken deterministische Antworten liefern sollen, bieten Multi-Agenten Systeme in Text-to-SQL einen Ausweg.

In der Kommunikation zwischen User und KI-Agent kann es zu bösartigen Resultaten kommen, wenn beispielsweise angebundene MCP Server oder Tools kompromittiert sind. Quelle

Mögliche Sicherheitsmaßnahmen

Zur Absicherung von MCP Architekturen gibt es verschiedene Möglichkeiten.

Für Authentifizierung von remote HTTP Servern steht das OAuth 2.1 Framework zur Verfügung.

Außerdem gibt es verschiedene Best Practices um Sicherheitslücken im Vorhinein zu vermeiden:

Vorherige Überprüfung (Input Validation):
- Bevor ein Programm Befehle des Agenten ausführt, müssen Input Parameter rigoros validiert werden.
So wenig Rechte wie möglich (Least Privilege):
- Jedes Tool erhält nur kleinstmögliche Berechtigung (sensible Datenbanken).
Finale Überprüfung (Human-in-the-Loop):
- Für wichtige Aktionen (z.B. Überweisungen) bereitet Agent nur alles vor, finale Bestätigung erfordert immer Menschen.
Verschlüsselung (Data Masking):
- Besonders sensible Daten (Passwörter, Sozialversicherungsnummern) werden unkenntlich gemacht oder verschlüsselt, bevor Agent Zugang bekommt.

MCPs goldene Zukunft?

Mittlerweile setzt sich MCP immer mehr als der Standard durch und ist mit allen großen kommerziellen LLMs (ChatGPT, Claude, Gemini etc.) kompatibel. Die Vorteile für den Arbeitsalltag überwiegen klar mögliche Risiken durch die Neuheit der Technologie:

Der User wird zum Manager im Arbeitsalltag
- Ausgewählte Agenten mit bereitgestellten Tools erledigen die Fleißarbeit im Arbeitsalltag.
- Hierarchische Systeme von Agenten können auch komplexe Workloads bewältigen.
Schnell wachsendes Öko-Systeme liefern vielfältige Lösungen
- Anthropic bietet schon vorgefertigte Server an.
- Viele große Unternehmen folgen direkt (Git, Slack, Google Drive, …).
- Darüberhinaus ersetzt MCP nicht nur bisherige Schnittstellen, sondern bietet teilweise auch neue Interfaces für anderweitig schwierige anzusprechende Programme an, die direkt über MCP anzusprechen sind.
Für neue Sicherheitskonzepte bietet MCP auch Abhilfe, indem z.B. Proxy-Systeme zwischen Server geschaltet werden können,
MCP ermöglicht die Austauschbarkeit der KI-Agenten:
- Verschiedenste Firmen haben ihre KI-Agenten an MCP angeschlossen.
- Dadurch ist ein einfaches Auswechseln je nach Usecase möglich, ohne die Codebase ändern zu müssen.
Insegesamt bietet MCP ein gewaltiges Potential in KI-Workflows:
- Denn es eröffnet einen einfachen und vorgefertigten Weg diverse Aufgaben an KI auszulagern.

*MCP ermöglicht es KI-Agenten, über Tools diverse Aufgaben zu übernehmen und somit den User wirksam zu entlasten. Quelle*

Der Einfluss von MCP wird stark von der jeweiligen Branche abhängen. Aus der Vernetzung von Tools und Agenten werden sich viele neue StartUp-Ideen ergeben. Für den Normalverbraucher wird MCP aber eine Technologie im Hintergrund bleiben, die auch ohne technisches Verständnis den Alltag erleichtert, wie beispielsweise Bluetooth.

Mögliche Einsatzfelder

MCP kann für diverse Lösungen eingesetzt werden, darunter z.B.:

Automatische Marktforschung: Der Agent sucht täglich selbstständig im Internet nach Themen und liefert Zusammenfassungen.
Eigenständiger Coding-Assistent: Git commits werden automatisch vorbereitet oder komplexe Software-Bausteine via online-Dokumentation erklärt/in Infrastrucure as code übersetzt.
Messenger als Schaltzentrale: Aufträge via KI-Agenten an Tools vergeben, direkt aus dem Messenger (z.B. Slack).
Intelligentes Zeitmanagement: Direkte Kalenderpflege aus Mails und Nachrichten.
Nahtlose Datenverknüpfung: Zeitgleicher Zugriff auf interne und externe Dokumente erlaubt Agenten begründete Antworten mit Kontext zu liefern (Stichwort RAG).
Agent im laufendem Betrieb: Agent, der CI/CD pipeline beaufsichtigt. Bei Fehlern kann dieser direkt Logs durchsuchen und Menschen mit Verweis auf fehlerhaften Code und vorgeschlagenen Fix benachrichtigen.

Building your own MCP-Server

Die Anbindung verschiedener Tools kann direkt über Python erfolgen. Im nachfolgenden Beispiel wird ein lokaler MCP Server gebaut, der direkt auf der Maschine des Users läuft. Die MCP Schnittstelle von Slack ermöglicht die Kommunikation direkt im Messenger. Ein auf Llama basierender KI-Agent benutzt je nach Anfrage verschiedene Tools. Tavily ermöglicht dem KI-Agenten, für Fragen das Web zu durchsuchen, wohingegen die Snowflake-MCP-Schnittstelle zum Abfragen einer Datenbank befähigt.

Snowflake stellt direkt eine MCP Schnittstelle auf die zugrundeliegende Datenbank bereit, auf die zugegriffen werden kann, wenn die Anfrage über die notwendigen Credentials verfügt. Die MCP Schnittstelle wird über FastMCP aus der Python-Library mcp.server.fastmcp angebunden.

mcp = FastMCP("snowflake_query_server")

load_dotenv()

# 2️⃣ Connect to Snowflake

def init_snowflake():

    user = os.getenv("SNOWFLAKE_USER")

    password = os.getenv("SNOWFLAKE_PASSWORD")

    account = os.getenv("SNOWFLAKE_ACCOUNT")

    warehouse = os.getenv("SNOWFLAKE_WAREHOUSE")

    database = os.getenv("SNOWFLAKE_DATABASE")

    schema = os.getenv("SNOWFLAKE_SCHEMA")

    role = os.getenv("SNOWFLAKE_ROLE")

    conn = snowflake.connector.connect(

        user=user,

        password=password,

        account=account,

        warehouse=warehouse,

        database=database,

        schema=schema,

        role=role,

    )

    print("✅ Connected to Snowflake", "with file", sys.stderr, file=sys.stderr)

    return conn

snowflake_conn = init_snowflake()

Genauso hat der Messenger Slack eine MCP Schnittstelle, über die Unterhaltungen abgefragt oder ein Bot angesteuert werden kann. Dadurch kann der Slack Messenger als Interface für die Interaktion mit dem KI-Agenten genutzt werden.

APP_TOKEN = os.environ.get("SLACK_APP_TOKEN")

BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")

app = App(token=BOT_TOKEN)

slack_post_queue = queue.Queue()

# --- Slack Post Worker ---

def slack_post_worker():

    while True:

        item = slack_post_queue.get()

        if item is None:

            break

        msg_id, channel, text = item

        try:

            app.client.chat_postMessage(channel=channel, text=text)

            print(f"[INFO] Slack API Success: {channel}", file=sys.stderr, flush=True)

        except Exception as e:

            print(f"[ERROR] Slack API Failure: {e}", file=sys.stderr, flush=True)

Der lokale Server in diesem Beispiel startet die Subprozesse, damit diese via MCP ansprechbar sind.

# ---------------------------

# Server Startup Function

# ---------------------------

def start_mcp(cmd, name):

    proc = subprocess.Popen(

        cmd,

        stdin=subprocess.PIPE,

        stdout=subprocess.PIPE,

        stderr=subprocess.PIPE,

        text=True,

        bufsize=1,

    )

    q = queue.Queue()

    threading.Thread(

        target=read_output, args=(proc.stdout, q, name), daemon=True

    ).start()

    return proc, q

# --- Server Start ---

chat_proc, chat_q = start_mcp([sys.executable, "chatgpt_mcp_server.py"], "ChatGPT")

snow_proc, snow_q = start_mcp([sys.executable, "snowflake_mcp_server.py"], "Snowflake")

duck_proc, duck_q = start_mcp([sys.executable, "tavily_mcp_server.py"], "Tavily")

slack_proc, slack_q = start_mcp([sys.executable, "slack_mcp_server.py"], "Slack")

# --- Server Start ---

chat_proc, chat_q = start_mcp([sys.executable, "chatgpt_mcp_server.py"], "ChatGPT")

snow_proc, snow_q = start_mcp([sys.executable, "snowflake_mcp_server.py"], "Snowflake")

duck_proc, duck_q = start_mcp([sys.executable, "tavily_mcp_server.py"], "Tavily")

slack_proc, slack_q = start_mcp([sys.executable, "slack_mcp_server.py"], "Slack")

# --- MCP Handshakes (Crucial for starting servers) ---

def initialize_mcp(proc, q, name):

    if name == "ChatGPT":

        payload = {

            "jsonrpc": "2.0",

            "id": 0,

            "method": "session/initialize",

            "params": {},

        }

    else:

        payload = {

            "jsonrpc": "2.0",

            "id": 0,

            "method": "initialize",

            "params": {

                "protocolVersion": "2024-11-05",

                "clientInfo": {"name": name, "version": "1.0"},

                "capabilities": {},

            },

        }

    send(proc, payload)

    recv(q, timeout=10)

    if name == "Snowflake":

        send(

            proc,

            {"jsonrpc": "2.0", "method": "notifications/initialized", "params": {}},

        )

initialize_mcp(chat_proc, chat_q, "ChatGPT")

initialize_mcp(snow_proc, snow_q, "Snowflake")

initialize_mcp(slack_proc, slack_q, "Slack")

Um dem KI-Agenten zu erlauben, verschiedene Tools fundiert auszuwählen, können die zugrundeliegenden Prompts mit zusätzlichen Informationen versehen oder über Schlüsselwörter angesteuert werden. Im unten gezeigten Code-Snippet ist der Prompt gezeigt, wie der KI-Agent entscheiden soll, ob eine Websuche oder eine SQL

def ask_and_execute(prompt, slack_channel=None):

    """The 'Brain': Decides between SQL or SEARCH and executes."""

    global msg_id_chat, msg_id_snow

    agent_instructions = """

    You are a Strategic Data Agent with access to two tools:

    TOOL 1: SNOWFLAKE (Internal Data)

    - Use for: Sales, customer info, product details, performance metrics.

    - Schema Context:

        * View 'V_SALES_PERFORMANCE': [SALE_DATE, CUSTOMER_NAME, COUNTRY, PRODUCT_NAME, CATEGORY, TOTAL_AMOUNT, SEGMENT]

        * Table 'CUSTOMERS': [CUSTOMER_ID, NAME, SEGMENT, COUNTRY, JOIN_DATE]

        * Table 'PRODUCTS': [PRODUCT_ID, PRODUCT_NAME, CATEGORY, PRICE]

        * Table 'SALES': [SALE_ID, SALE_DATE, CUSTOMER_ID, PRODUCT_ID, QUANTITY, TOTAL_AMOUNT]

    - Rules: Use UPPERCASE for identifiers. Return ONLY raw SQL starting with 'SQL: '.

    TOOL 2: WEB_SEARCH (External Data)

    - Use for: News, stocks, world facts, general knowledge.

    - Rules: Return 'SEARCH: <optimized search query>'.

    DECISION RULE:

    - If internal data is needed, respond with 'SQL: <sql query>'.

    - If external/current info is needed, respond with 'SEARCH: <query>'.

    """

    full_prompt = f"{agent_instructions}\n\nUser Question: {prompt}"

    with chat_lock:

        send(

            chat_proc,

            {

                "jsonrpc": "2.0",

                "id": 999,

                "method": "tools/call",

                "params": {"name": "ask_chatgpt", "arguments": {"prompt": full_prompt}},

            },

        )

        response = recv(chat_q, timeout=60)

tools:

def handle_search(request):

    params = request.get("params", {})

    args = params.get("arguments", {})

    query = args.get("query")

    if not query:

        return {

            "jsonrpc": "2.0",

            "id": request.get("id"),

            "error": {"code": -32602, "message": "Missing query"},

        }

    try:

        # Requesting search results AND a synthesized answer

        response = requests.post(

            "https://api.tavily.com/search",

            json={

                "api_key": TAVILY_API_KEY,

                "query": query,

                "search_depth": "basic",

                "max_results": 3,

                "include_answer": True,  # Get the direct answer from Tavily

            },

            timeout=15,

        )

Die Nachrichten werden im Hintergrund mittels JSON RPC 2.0 übertragen.

Ein Beispiel für den Output des lokalen MCP Servers. Alle Kommunikation in beide Richtungen wird in JSON verpackt. Snowflake beispielsweise wird über eine vom KI-Agenten generierte SQL-Query angesprochen.

Über die Slack Anbindung können User direkt im gewohnten Messenger mit ihrem KI-Agenten kommunizieren und Fragen stellen. Der KI-Agent entscheidet eigenständig, ob für diese Beantwortung eine Websuche oder eine SQL-Query auf der Snowflake Instanz besser ist, um die Frage optimal zu beantworten.

*Der User hat im Arbeitsalltag eine Frage, die der KI-Agent direkt mit eigener Websuche beantwortet.*

Außerdem kann über die angebundene Snowflake-Instanz direkt die zugrundeliegende Datenbank durchsucht werden, wenn der User schnell konkrete Zahlen zu einem bestimmten Kunden braucht.

Der User hat eine Frage zu konkreten Firmendaten. Der KI-Agent halluziniert keine Fakten, sondern generiert eine SQL-Query, welche dieses Resultat datenbasiert bereitstellt.

Fazit

Zusammenfassend lässt sich sagen, dass MCP viele Probleme vergangener KI-Lösungen behebt. MCP beendet die Ära, in der KI-Agenten „isoliert“ arbeiteten. Es standardisiert Kommunikation im digitalen Miteinander. Ein gemeinsames Protokoll erlaubt bessere Kontrolle darüber, welche Daten fließen und welche nicht. Auch bisherige technische Hürden werden nach und nach ausgeräumt, während MCP immer mehr zum Standard in der KI-Kommunikation wird. Der Zugriff auf Daten und Tools erlaubt KI-Agenten vom bloßen Gesprächspartner zu mächtigen, eigenständigen Helfern zu werden, um User vielseitig zu unterstützen. Denn es sind bereits diverse MCP-Server vorhanden, die Tools für fast jeden use case anbieten.

Am besten steigen alle jetzt schon ein und probieren diese neue Lösung aus!