---
term: 'MCP (Model Context Protocol)'
seoTitle: 'MCP (Model Context Protocol): Server, Tools, Sicherheit'
headline: 'Was ist MCP (Model Context Protocol)?'
slug: mcp
category: ai-modern-stack
shortDefinition: 'MCP ist ein offener Standard, mit dem KI-Anwendungen über ein einziges Protokoll auf externe Tools und Daten zugreifen statt über eigene Integrationen.'
relatedTerms:
  - api
  - rest-api
  - webhooks
  - api-key-security
contrastsWith:
  - api
aboutTerms:
  - 'MCP Server'
  - 'Tools, Resources, Prompts'
  - 'Host, Client, Server'
faq:
  - question: 'Was ist MCP, einfach erklärt?'
    answer: 'Ein offener Standard, mit dem KI-Anwendungen über ein gemeinsames Protokoll auf externe Tools und Daten zugreifen, statt pro Tool eine maßgeschneiderte Integration zu bauen. Der übliche Vergleich ist ein USB-C-Anschluss für KI: ein Stecker, viele Geräte – und das Modell entscheidet zur Laufzeit, zu welchem Tool es greift.'
  - question: 'Wer hat MCP entwickelt und wann?'
    answer: 'Anthropic hat es im November 2024 vorgestellt. Im Lauf des Jahres 2025 übernahmen es die großen KI-Modellanbieter und die Hersteller von Entwicklungswerkzeugen, Tausende von Community-Servern entstanden, und die Steuerung ging zum Jahresende an eine herstellerneutrale Open-Source-Stiftung über – der Weg vom Protokoll eines einzelnen Unternehmens zum Industriestandard.'
  - question: 'Ist MCP eine API, und ersetzt es APIs?'
    answer: 'Nein – MCP ist eine Protokollschicht, die bestehende APIs in der Regel umhüllt statt sie zu ersetzen. Die meisten MCP Server rufen darunter eine klassische REST- oder GraphQL-API auf; MCP standardisiert, wie ein KI-Modell diese Fähigkeiten entdeckt, beschreibt und aufruft, nicht worin die Fähigkeiten bestehen. Eine API richtet sich an Entwickler, MCP an das Modell – mit Entdeckung zur Laufzeit.'
  - question: 'Was ist der Unterschied zwischen MCP und Function Calling?'
    answer: 'Function Calling ist die Fähigkeit des Modells – das LLM gibt eine strukturierte Anfrage aus, eine benannte Funktion auszuführen. MCP standardisiert, wie diese Funktionen über verschiedene Anwendungen und Anbieter hinweg entdeckt, beschrieben und ausgeführt werden. Function Calling ist die Absicht, MCP die portable Ausführungsschicht. Sie ergänzen sich; keines ersetzt das andere.'
  - question: 'Was ist ein MCP Server?'
    answer: 'Ein Programm, das Tools, Resources und Prompts über das Protokoll an KI-Clients bereitstellt – lokal über stdio oder entfernt über HTTP. Ein Datenbank-MCP-Server bietet vielleicht ein Query-Tool, eine Schema-Resource und ein paar Prompt-Vorlagen. Achten Sie auf das Vokabular: MCP ist das Protokoll; das Artefakt, das Sie betreiben, ist ein "MCP Server".'
  - question: 'Was sind Tools, Resources und Prompts?'
    answer: 'Die drei Primitive eines Servers. Tools sind vom Modell aufrufbare Funktionen, die mit Zustimmung des Benutzers ausgeführt werden. Resources sind lesbare Kontextdaten, dateiartig. Prompts sind wiederverwendbare Interaktionsvorlagen. Zusammen erlauben sie einem Server zu sagen: "Das kann ich, das weiß ich, und so fragen Sie mich."'
  - question: 'Ist MCP sicher?'
    answer: 'Das Protokoll ist neutral; die Risiken sind real: Prompt Injection über Tool-Ausgaben, Tool Poisoning (schädliche Anweisungen, versteckt in der Beschreibung eines Tools), Rug Pulls (ein Server ändert seine Definitionen nach der Freigabe) und die Lieferkette ungeprüfter Community-Server. Gegenmaßnahmen sind Scopes nach dem Prinzip der geringsten Rechte, menschliche Freigabe von Tool-Aufrufen, das Pinnen und Allowlisten von Servern sowie echte Authentifizierung auf entfernten Servern.'
  - question: 'Funktioniert MCP mit jedem KI-Modell?'
    answer: 'Genau dafür wurde es standardisiert – ein einmal geschriebener Server funktioniert mit jedem Host, der das Protokoll spricht, anbieterübergreifend. Dieselbe Integration, die ein Coding-Agent nutzt, ist auch für einen Chat-Assistenten oder einen eigenen Agenten erreichbar, und genau das ist die Reduktion von N×M auf N+M, für die der Standard existiert.'
codeLanguages: [javascript, dart, swift, kotlin]
externalAuthorities:
  - name: 'Model Context Protocol — official documentation'
    url: 'https://modelcontextprotocol.io/docs/getting-started/intro'
  - name: 'MCP architecture — host, client, server'
    url: 'https://modelcontextprotocol.io/docs/learn/architecture'
  - name: 'Introducing the Model Context Protocol — Anthropic'
    url: 'https://www.anthropic.com/news/model-context-protocol'
  - name: 'MCP Tool Poisoning — OWASP'
    url: 'https://owasp.org/www-community/attacks/MCP_Tool_Poisoning'
  - name: 'Model Context Protocol — Wikipedia'
    url: 'https://en.wikipedia.org/wiki/Model_Context_Protocol'
cta:
  title: 'Ihr Backend, bereit für Agenten'
  text: 'Eine Back4app-Anwendung stellt bereits REST- und GraphQL-APIs bereit – genau die Fläche, die ein MCP Server als Tools umhüllt, sodass Agenten Ihre Daten über dieselben ACLs, Schlüssel und Rate Limits erreichen wie Ihre Anwendung.'
  linkText: 'Kostenlos starten'
  linkUrl: 'https://www.back4app.com/signup'
author: 'Back4app Engineering'
publishedDate: '2026-09-25'
translationKey: model-context-protocol-mcp
---

**MCP ist ein offener Standard, mit dem KI-Anwendungen über ein einziges Protokoll auf externe Tools und Daten zugreifen statt über eigene Integrationen.** Im November 2024 von Anthropic vorgestellt und binnen eines Jahres zum Industriestandard geworden, leistet es für KI-Agenten ungefähr das, was ein gemeinsamer Anschluss für Peripheriegeräte leistete – daher der Satz vom "USB-C für KI", zu dem jede Erklärung greift. Die schärfere Sicht für Backend-Entwickler: **ein MCP Server ist ein API-Adapter.** Ihr bestehendes Backend weiß bereits, wie es Anfragen beantwortet; MCP ist der Weg, es auffindbar und aufrufbar zu machen – für ein KI-Modell statt für handgeschriebenen Client-Code.

## Das Wichtigste in Kürze

| Frage | Antwort |
| --- | --- |
| Was es ist | Ein offenes Protokoll (JSON-RPC), das KI-Anwendungen mit Tools und Daten verbindet |
| Das gelöste Problem | N Clients × M Tools an Einzelintegrationen → N + M über einen Standard |
| Die Bestandteile | Host (die KI-Anwendung) · Client (eine Verbindung pro Server) · Server (die Fähigkeit) |
| Die Primitive | Tools (handeln) · Resources (lesen) · Prompts (Vorlagen) |
| Der ehrliche Vorbehalt | Eine reale Sicherheitsfläche – Tool Poisoning, Rug Pulls, ungeprüfte Server |

## Ein MCP Server, der ein vorhandenes Backend umhüllt

**JavaScript:**

```javascript
// JavaScript / Node.js — an MCP server wrapping an existing backend API

const server = new McpServer({ name: 'tasks', version: '1.0.0' });

// A tool is a described, discoverable wrapper over the API you already have
server.registerTool(
  'query_tasks',
  { description: 'List tasks by status', inputSchema: z.object({ status: z.string() }) },
  async ({ status }) => {
    const res = await fetch(`${BASE}/classes/Task?where=${q({ status })}`, {
      headers: { 'X-Parse-Application-Id': APP_ID, 'X-Parse-REST-API-Key': KEY },
    });
    return { content: [{ type: 'text', text: await res.text() }] };
  }
);
// The agent discovers this tool at runtime and decides when to call it —
// same backend, same ACLs and rate limits; just a new kind of client.
```

**Flutter:**

```dart
// Flutter / Dart — Back4app Flutter SDK
// One backend, two kinds of consumers: your app via the SDK…
final tasks =
    await QueryBuilder<ParseObject>(ParseObject('Task')).query();
// …and AI agents via an MCP server wrapping the SAME REST/GraphQL API,
// exposing "query_tasks" and "run_function" as tools the model can call.
// Same data, same ACLs, same rate limits — a new client type, not a new backend.
```

**Swift:**

```swift
// iOS / Swift — Back4app Swift SDK
// One backend, two kinds of consumers: your app via the SDK…
let tasks = try await Task_.query().find()
// …and AI agents via an MCP server wrapping the SAME REST/GraphQL API,
// exposing "query_tasks" and "run_function" as tools the model can call.
// Same data, same ACLs, same rate limits — a new client type, not a new backend.
```

**Kotlin:**

```kotlin
// Android / Kotlin — Back4app Android SDK
// One backend, two kinds of consumers: your app via the SDK…
val tasks = ParseQuery.getQuery<ParseObject>("Task").find()
// …and AI agents via an MCP server wrapping the SAME REST/GraphQL API,
// exposing "query_tasks" and "run_function" as tools the model can call.
// Same data, same ACLs, same rate limits — a new client type, not a new backend.
```

Der JavaScript-Tab enthält die ganze Idee in fünfzehn Zeilen: Ein Tool `query_tasks` ist ein *beschriebener, auffindbarer* Wrapper um einen REST-Aufruf, den das Backend ohnehin bedient. Der Agent liest die Beschreibung zur Laufzeit, entscheidet, wann das Tool passt, und ruft es auf – und trifft dabei dieselben Endpoints, [ACLs](/glossary/de/zugriffskontrolllisten-acl/) und Rate Limits wie Ihre Anwendung. Ein neuer Typ von Client, kein neues Backend.

## Wie MCP das N×M-Integrationsproblem löst

```mermaid
flowchart LR
  accTitle: MCP Host, Client und Server ersetzen Einzelintegrationen
  accDescr: Eine KI-Host-Anwendung startet pro Serververbindung einen MCP Client. Jeder Client spricht das Standardprotokoll mit einem MCP Server, der Tools, Resources und Prompts bereitstellt, hinterlegt mit einer darunterliegenden API oder Datenbank. Weil jeder Client und jeder Server dasselbe Protokoll umsetzt, wachsen die Integrationen mit N plus M statt mit N mal M.
  H["Host<br/>(die KI-Anwendung)"] --> C1["Client 1"] --> S1["MCP Server:<br/>Datenbank (Tools + Schema)"]
  H --> C2["Client 2"] --> S2["MCP Server:<br/>Dateien (Resources)"]
  H --> C3["Client 3"] --> S3["MCP Server:<br/>Ihre REST-/GraphQL-API"]
  S1 -.-> API[("Darunterliegende APIs<br/>und Daten")]
  S2 -.-> API
  S3 -.-> API
```

Vor MCP bedeutete das Verdrahten von *N* KI-Clients mit *M* Tools bis zu *N × M* Einzelintegrationen. Ein gemeinsames Protokoll bringt das auf *N + M* herunter: Jeder Client und jeder Server setzt MCP einmal um. Die [offizielle Architektur](https://modelcontextprotocol.io/docs/learn/architecture) benennt drei Rollen – der **Host** ist die KI-Anwendung; er startet pro Verbindung einen **Client**; jeder **Server** liefert eine Fähigkeit – über JSON-RPC, mit **stdio** für lokale Server auf derselben Maschine und **Streamable HTTP** für entfernte (der ursprüngliche Transport HTTP+SSE gilt inzwischen als veraltet).

## Die drei Primitive

| Primitiv | Das Modell kann… | Backend-Entsprechung |
| --- | --- | --- |
| **Tools** | *Handeln* – eine Funktion aufrufen (mit Zustimmung des Benutzers) | Ein [API-Endpoint](/glossary/de/rest-api/) oder eine [Cloud Function](/glossary/de/cloud-code-serverless-funktionen/) |
| **Resources** | *Lesen* – dateiartigen Kontext holen | Eine GET-Route / ein Dokumentspeicher |
| **Prompts** | *Wiederverwenden* – eine Interaktionsvorlage anwenden | Eine gespeicherte Abfrage oder ein Snippet |

Ein einzelner Datenbankserver stellt typischerweise alle drei bereit: ein `query`-Tool, eine `schema`-Resource und einen Few-Shot-`prompt` für häufige Fragen – "das kann ich, das weiß ich, und so fragen Sie mich."

## MCP vs. API vs. Function Calling

| | Einfache [API](/glossary/de/api/) | Function Calling | MCP |
| --- | --- | --- | --- |
| Richtet sich an | Entwickler | Das Modell, pro Anwendung | Das Modell, portabel |
| Wer wählt den Aufruf | Ihr Code | Das Modell, anwendungsspezifisch | Das Modell, in jedem Host |
| Entdeckung | Dokumentation, zur Build-Zeit | Pro Anwendung fest codiert | Zur Laufzeit, standardisiert |
| Portabilität | entfällt | An eine Integration gebunden | Einmal schreiben, jeder Host/Anbieter |
| Ergänzt | Die Fähigkeit | Die *Absicht* aufzurufen | Die standardisierte *Ausführung* |

Die beiden Vergleiche lösen sich sauber auf. **Gegenüber einer API:** MCP ersetzt sie nicht – es umhüllt sie und ergänzt die Entdeckung zur Laufzeit, sodass das *Modell* den Aufruf wählt statt Ihres Anwendungscodes. **Gegenüber Function Calling:** Function Calling ist das Modell, das eine strukturierte Anfrage ausgibt; MCP standardisiert, wie diese Anfrage über Anwendungen und Anbieter hinweg entdeckt und ausgeführt wird. MCP ergänzt *Standardisierung und Portabilität, keine Fähigkeit* – alles, was MCP tut, könnte maßgeschneidertes Function Calling für eine einzelne Integration auch tun; MCP sorgt dafür, dass es ohne Umschreiben überall funktioniert.

## Die Sicherheitsfläche, ehrlich betrachtet

Der Abschnitt, den neutrale Seiten auslassen und Sicherheitsanbieter überverkaufen. Nicht das Protokoll ist die Bedrohung, sondern das *Vertrauensmodell*. **Prompt Injection** reist über Tool-Ausgaben herein – ein Dokument, das ein Tool zurückgibt, kann Anweisungen enthalten, denen das Modell anschließend folgt. **Tool Poisoning** versteckt schädliche Anweisungen in der *Beschreibung* eines Tools, die das Modell liest, bevor ein Mensch sie zu Gesicht bekommt – inzwischen bei [OWASP](https://owasp.org/www-community/attacks/MCP_Tool_Poisoning) erfasst. **Rug Pulls:** Ein einmal freigegebener Server kann seine Tool-Definitionen später ändern. Und der stille Punkt: die **Lieferkette der Community-Server** – es gibt Tausende davon, und wer einen installiert, gewährt ihm einen Brückenkopf im Kontext seines Agenten. Die Gegenmaßnahmen sind gewöhnliche Sicherheitsdisziplin, angewandt auf eine neue Fläche: Scopes nach dem Prinzip der geringsten Rechte pro Server, menschliche Freigabe für Tool-Aufrufe mit Wirkung, das Pinnen und Allowlisten der Server, denen Sie vertrauen, echte Authentifizierung auf entfernten Servern – und einem MCP Server niemals weiter reichende [Zugangsdaten](/glossary/de/api-schluessel-sicherheit/) geben, als die Aufgabe verlangt.

## Die Spezifikation heute

MCP bewegt sich schnell, und die meisten Erklärtexte sind Mitte 2025 eingefroren – ein Aktualitätshinweis, den es zu pflegen lohnt. Der Transport hat sich auf Streamable HTTP verdichtet (HTTP+SSE ist veraltet); entfernte Server haben sich auf Authentifizierung im OAuth-Stil geeinigt; die Revision vom 2026-07-28 machte das Protokoll zustandslos – kein Handshake, keine Sessions, Metadaten pro Anfrage, ein `server/discover`-Aufruf – und erklärte Roots, Sampling und Logging für veraltet. Das größere Signal ist die Steuerung: Ende 2025 wurde das Protokoll an eine herstellerneutrale Open-Source-Stiftung übergeben – das strukturelle Kennzeichen eines echten Standards und nicht der Konvention eines einzelnen Anbieters. Die praktische Lehre für Entwickelnde: Pinnen Sie eine Spezifikationsversion, lesen Sie vor dem Upgrade das Changelog und behandeln Sie "MCP" als bewegliches Ziel mit stabilem Kern.

## Typische Anwendungsfälle

- **Coding-Agenten** – IDE-Assistenten, die Ihr Repository, Ihre Datenbank und Ihren Issue-Tracker über Server erreichen statt über eigens gebaute Plugins.
- **Unternehmensdaten im Chat** – ein Assistent, der interne Systeme abfragt, jedes davon als berechtigungsgeprüfter MCP Server umhüllt.
- **Backend bereitstellen** – eine bestehende [REST-/GraphQL-API](/glossary/de/rest-api/) in agentenaufrufbare Tools verwandeln, ohne sie neu zu bauen.
- **Desktop- und Workflow-Automatisierung** – lokale stdio-Server, die das Modell mit Dateien und Anwendungen auf einer Maschine verbinden.
- **Portabilität über Anbieter hinweg** – ein Server für jeden Host, der MCP spricht, sodass eine Integration jede einzelne Modellentscheidung überdauert.

## Sollten Sie MCP verwenden? Eine Entscheidungsmatrix

| Situation | Tendenz |
| --- | --- |
| Viele KI-Clients brauchen viele Tools | MCP – der N+M-Gewinn ist genau der Punkt |
| Ihr Backend für Agenten öffnen | Ein MCP Server, der die vorhandene [API](/glossary/de/api/) umhüllt |
| Eine Anwendung, ein Tool, ein Anbieter | Direktes Function Calling – weniger Maschinerie |
| Deterministischer serverseitiger Workflow, kein wählendes Modell | Ein schlichter [API-Aufruf](/glossary/de/rest-api/) |
| Server von Dritten installieren | Prüfen, pinnen, geringste Rechte – oder lassen |
| Portabilität über Modellanbieter hinweg zählt | MCP – den Server einmal schreiben |

## Grenzen und Trade-offs

- **Es ist ein bewegliches Ziel.** Die schnelle Entwicklung der Spezifikation verlangt von Integrationen Versionspinning und Wachsamkeit beim Changelog; "unterstützt MCP" ist eine Aussage mit Verfallsdatum.
- **Das Vertrauensmodell ist neu.** Tool-Beschreibungen und -Ausgaben sind Angriffsfläche; Agenten, die auf ungeprüften Servern handeln, sind das `curl \| bash` dieser Epoche.
- **Overhead unterhalb des Umschlagpunkts.** Für eine einzelne Integration ergänzt MCP ein Protokoll und einen Serverprozess, wo ein Funktionsaufruf genügt hätte.
- **Entdeckung verschiebt die Kontrolle zum Modell.** Tool-Auswahl zur Laufzeit ist mächtig und weniger vorhersehbar als fest codierte Aufrufe – Auditing und Freigaben zählen dadurch mehr, nicht weniger.
- **Es umhüllt, es repariert nicht.** Ein MCP Server über einer schlecht abgesicherten API stellt diese API Agenten nur schneller bereit; die eigentliche Arbeit leisten weiterhin die darunterliegenden [Berechtigungen](/glossary/de/zugriffskontrolllisten-acl/).

## MCP mit Back4app

Back4app ist eine Open-Source-Plattform für Backend as a Service (BaaS), die eine verwaltete Datenbank, automatisch generierte REST- und GraphQL-APIs, Authentifizierung, Dateispeicher und Serverless-Funktionen mit Cloud Code kombiniert. Die Sicht vom API-Adapter passt hier von selbst: Eine Back4app-Anwendung stellt *bereits* die Fläche bereit, die ein MCP Server umhüllt – REST und GraphQL über jede Klasse, dazu Cloud-Code-Funktionen –, sodass es für den Agentenzugriff genügt, `find objects`, `run function` und `read schema` auf Tool-Definitionen abzubilden, wie es die Code-Tabs skizzieren. Der Sicherheitsabschnitt wird damit zu konkreter Anleitung: Geben Sie dem MCP Server einen eingegrenzten [Schlüssel](/glossary/de/api-schluessel-sicherheit/), niemals den Master Key; lassen Sie die [ACLs und Klassenberechtigungen](/glossary/de/zugriffskontrolllisten-acl/) der Plattform begrenzen, was die Aufrufe eines Agenten berühren dürfen, genau wie sie Ihre Anwendung begrenzen; und legen Sie unumkehrbare Aktionen hinter [Cloud Functions](/glossary/de/cloud-code-serverless-funktionen/) mit eigenen Prüfungen statt hinter rohen Tabellenzugriff. Der Agent wird zu einem weiteren Client eines Backends, das bereits weiß, wie man Nein sagt.