Füge einen MCP-Server hinzu, wenn dein Plugin für einen Anwendungsfall Live-Daten, Authentifizierung, kontrollierte Aktionen oder Code benötigt, der auf einer von dir betriebenen Infrastruktur läuft. Der Server legt fest, welche Tools ChatGPT und Codex zur Verfügung stehen. Er muss keine eigene Benutzeroberfläche zurückgeben.
Gehe von den Zielen aus, die dein Plugin laut deiner Übersicht der Anwendungsfälle unterstützen soll. Jedes Tool sollte Nutzenden helfen, ein klar erkennbares Ziel zu erreichen, und nur die dafür erforderlichen Daten und Aktionen bereitstellen.
Entwickle zuerst die Tools. Sobald der Server ohne eigene Benutzeroberfläche funktioniert, kannst du für Abläufe, die eine visuelle Interaktion erfordern, den MCP-Server um eine Benutzeroberfläche erweitern.
Ein SDK für MCP auswählen
Die offiziellen Software Development Kits bieten Hilfsfunktionen für Schemas, ein Grundgerüst für den Server und Unterstützung für den Transport über Streamable HTTP.
- TypeScript-SDK, veröffentlicht als
@modelcontextprotocol/sdk. - Python-SDK, veröffentlicht als
mcp.
Installiere das SDK, das zu deinem Server-Stack passt.
# TypeScript
npm install @modelcontextprotocol/sdk zod
# Python
pip install mcp
Den Server erstellen
Erstelle einen MCP-Server mit einem stabilen Namen und einer stabilen Versionsangabe.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
const server = new McpServer({
name: "acme-projects",
version: "1.0.0",
});MCP-Server können bei der Initialisierung auch das Feld instructions zurückgeben. ChatGPT und Codex berücksichtigen diese Anweisungen zusammen mit den Metadaten der Tools.
Nutze die Serveranweisungen für Vorgaben, die für mehrere Tools gelten, etwa eine vorgeschriebene Aufrufreihenfolge oder gemeinsame Ratenlimits. Nenne die wichtigsten Details in den ersten 512 Zeichen. Wiederhole nicht jede Toolbeschreibung und versuche nicht, die Persönlichkeit des Modells zu ändern.
const server = new McpServer(
{ name: "acme-projects", version: "1.0.0" },
{
instructions:
"Before updating a project, call get_project to confirm its ID and current status.",
}
);Tools anhand der Nutzerziele definieren
Erstelle für jede eigenständige Aktion, die das Plugin unterstützen muss, ein eigenes Tool. Bevorzuge klar abgegrenzte Operationen wie list_projects, get_project und update_project gegenüber einem Tool mit vielen voneinander unabhängigen Modi.
Jedes Tool braucht Folgendes:
- Einen Namen, der die Aktion benennt, und einen gut verständlichen Titel.
- Eine Beschreibung, die erklärt, wann das Tool zum Einsatz kommen soll.
- Ein explizites Eingabeschema.
- Ein Ausgabeschema, wenn das Tool strukturierte Daten zurückgibt.
- Sicherheitsannotationen, die das tatsächliche Verhalten beschreiben.
- Einen Handler, der die Anfrage autorisiert und die Operation ausführt.
Anhand dieser Metadaten entscheidet das Modell, ob und wie es das Tool aufruft. Namen, Beschreibungen, Schemas und Annotationen bestimmen mit, wie sich das Plugin bei der Nutzung verhält.
// Local example data; replace this with your application data.
const projects = [
{ id: "project-1", name: "Website", status: "active" },
{ id: "project-2", name: "Launch", status: "archived" },
];
async function listProjects({ status }: { status?: string }) {
return projects.filter((project) => !status || project.status === status);
}
import { z } from "zod";
server.registerTool(
"list_projects",
{
title: "List projects",
description:
"Use this when the user wants to find or review projects in their Acme workspace.",
inputSchema: {
status: z.enum(["active", "archived"]).optional(),
},
outputSchema: {
projects: z.array(
z.object({
id: z.string(),
name: z.string(),
status: z.string(),
})
),
},
annotations: {
readOnlyHint: true,
openWorldHint: false,
destructiveHint: false,
},
},
async ({ status }) => {
const projects = await listProjects({ status });
return {
structuredContent: { projects },
content: [
{
type: "text",
text: `Found ${projects.length} projects.`,
},
],
};
}
);Ohne Benutzeroberfläche verwertbare Ergebnisse zurückgeben
Ein Tool-Ergebnis kann folgende Felder enthalten:
structuredContent: kompakte Daten, die das Modell auswerten und in späteren Aufrufen verwenden kann.content: Text oder andere MCP-Inhalte, die dem Modell helfen, die Anfrage zu beantworten._meta: clientspezifische Daten, die für das Modell nicht sichtbar sind.
Gib genügend Informationen zurück, damit das Modell den Ablauf ohne UI-Komponente abschließen kann. Verwende in strukturierten Ergebnissen stabile Kennungen, damit sich nachfolgende Tool-Aufrufe auf dieselben Datensätze beziehen können.
Gib in Tool-Ergebnissen keine Secrets, Zugriffstoken oder unnötigen personenbezogenen Daten zurück. Der Inhalt von _meta ist für das Modell unsichtbar. Das Feld ersetzt weder die Autorisierung noch die sichere Speicherung.
Anfragen authentifizieren und autorisieren
Implementiere eine Authentifizierung, wenn ein Tool private Daten liest oder im Auftrag einer Person handelt. Prüfe bei jeder Anfrage auf dem MCP-Server die Berechtigung und verweigere unzulässige Zugriffe. Überlasse die Entscheidung über den Zugriff niemals dem Modell.
Einzelheiten zu OAuth-Discovery, Sicherheitsschemata und Autorisierungs-Challenges findest du im Abschnitt Nutzende authentifizieren.
Stelle ein Profil-Tool bereit, das eine Authentifizierung voraussetzt und ohne Schreibzugriff auskommt. Kennzeichne es mit _meta["openai/profile"]: true. Das erleichtert die Nutzung mehrerer Konten. OpenAI verwendet die Profilinformationen, um verbundene Konten einheitlich zu identifizieren und Nutzenden die Unterscheidung zu erleichtern. Ermittle das Profil anhand der validierten Anmeldedaten der Anfrage und beschränke jeden Tool-Aufruf auf die damit erteilten Berechtigungen. Auch ohne Profil-Tool können Nutzende mehrere Konten verbinden. Das Schema und ein Implementierungsbeispiel findest du im Abschnitt Mehrere Konten unterstützen.
Tool-Annotationen und Elizitation
Setze die Annotationen entsprechend dem tatsächlichen Verhalten des Tools:
readOnlyHint: Setze den Wert nur dann auftrue, wenn das Tool keinen Zustand ändern kann.destructiveHint: Setze den Wert auftrue, wenn das Tool Änderungen bewirken kann, die sich nur schwer oder gar nicht rückgängig machen lassen.openWorldHint: Setze den Wert auftrue, wenn das Tool auf das öffentliche Internet zugreift oder die externen Ressourcen, auf die es zugreifen kann, nicht fest eingegrenzt sind. Das gilt auch für Aktionen ohne Schreibzugriff wie die Websuche. Beschränkt sich der Zugriff auf ein klar abgegrenztes privates Konto oder einen klar abgegrenzten privaten Workspace, kannst du den Wert auffalsesetzen, auch wenn der Dienst extern gehostet wird.
Annotationen helfen ChatGPT und Codex zu entscheiden, wann eine Bestätigung nötig ist und welche Sicherheitsmaßnahmen angemessen sind. Sie ersetzen weder Autorisierung noch Validierung oder Bestätigung auf deinem Server.
Nutze die MCP-Elizitation, wenn der Server strukturierte Angaben benötigt, die im ursprünglichen Tool-Aufruf fehlen. Frage nur nach Informationen, die Nutzende mit vertretbarem Aufwand bereitstellen können. Verwende die Elizitation nicht, um Secrets abzufragen oder die reguläre Authentifizierung zu umgehen.
Kompatibilität mit Unternehmenswissen
Die Funktion Unternehmenswissen kann Tools ohne Schreibzugriff von deinem MCP-Server nutzen. Damit dein Plugin als Quelle für Unternehmenswissen infrage kommt, implementiere die standardisierten Eingabeschemas für die Tools search und fetch. Kennzeichne weitere Tools ohne Schreibzugriff mit readOnlyHint: true.
Gib für Quellen, die das Modell zitieren soll, absolute URLs zurück, die Nutzende öffnen können. Verwende für interne Dokumentkennungen das Feld id im Ergebnis. Die erforderlichen Schemas und Ergebnisformate findest du in der Anleitung MCP-Server für ChatGPT- und API-Integrationen entwickeln.
Den Server lokal ausführen und testen
Stelle einen Endpunkt für Streamable HTTP bereit, üblicherweise unter /mcp. Prüfe ihn anschließend mit dem MCP Inspector.
npx @modelcontextprotocol/inspector
Wähle in der Oberfläche des Inspectors Streamable HTTP aus und gib http://localhost:3000/mcp ein.
Führe im Inspector folgende Prüfungen durch:
- Vergewissere dich, dass die Initialisierung erfolgreich ist.
- Prüfe die Serveranweisungen und die Liste der Tools, die der Server anbietet.
- Rufe jedes Tool sowohl mit repräsentativen als auch mit ungültigen Eingaben auf.
- Überprüfe Schemas, Ergebnisse, Fehler und Annotationen.
- Vergewissere dich, dass der Server bei Zugriffen auf private Daten und bei Schreibaktionen die Berechtigungen durchsetzt.
Verbinde anschließend deinen eigenen MCP-Server mit ChatGPT. Teste die direkten und indirekten Anfragen aus deiner Übersicht der Anwendungsfälle sowie die dort aufgeführten Grenzfälle und Anfragen außerhalb des vorgesehenen Funktionsumfangs.
Den Endpunkt bereitstellen
Wenn du dein Plugin zur Veröffentlichung einreichst, stelle den MCP-Server unter einem stabilen, öffentlich erreichbaren HTTPS-Endpunkt bereit. Über Secure MCP Tunnel kannst du einen privaten MCP-Server mit ChatGPT verbinden. Für eine öffentliche Einreichung reicht das nicht aus.
Der Produktionsendpunkt muss folgende Anforderungen erfüllen:
- Den MCP-Transport über Streamable HTTP unterstützen.
- Unter einer stabilen URL antworten, die üblicherweise auf
/mcpendet. - Die Anforderungen der Plugin-Abläufe an Latenz und Verfügbarkeit erfüllen.
- Die erforderlichen Dienste und Datenspeicher erreichen können.
- Die durch Authentifizierung und Autorisierung festgelegten Zugriffsgrenzen einhalten.
- Fehlgeschlagene Initialisierungen und Tool-Aufrufe in Logs und Metriken erfassen.
Wenn der MCP-Server privat bleiben muss, stelle einen öffentlichen HTTPS-Proxy bereit, der MCP-Anfragen an den privaten Server weiterleitet. Authentifiziere ChatGPT als MCP-Client mit von OpenAI verwaltetem mTLS. Verwende OAuth 2.1, wenn dein Plugin eine Nutzerauthentifizierung erfordert. Falls dein Netzwerk eine IP-Freigabeliste voraussetzt, verwende die veröffentlichten IP-Bereiche der ChatGPT-Konnektoren und aktualisiere die Liste automatisch. Eine IP-Freigabeliste ersetzt weder Authentifizierung noch Autorisierung.
Der öffentliche Endpunkt muss für die Prüfung des Plugins und die Domainverifizierung erreichbar bleiben. Verwende für eine öffentliche Einreichung weder Secure MCP Tunnel als alleinige Lösung noch einen temporären Tunnel oder einen lokalen Endpunkt.
Die Infrastruktur auswählen
Du kannst den MCP-Server auf einer Serverless-, Container- oder Edge-Plattform oder auf einer herkömmlichen Anwendungsinfrastruktur betreiben. Berücksichtige bei der Plattformwahl folgende Kriterien:
- Unterstützung für die benötigte Laufzeitumgebung und die Abhängigkeiten.
- Verhalten beim Streamen von Antworten.
- Latenz bei Kaltstarts und Anfragen.
- Netzwerkzugriff auf die erforderlichen Dienste.
- Anforderungen an Datenresidenz und Compliance.
- Verwaltung von Secrets.
- Protokollierung, Tracing und Alarmierung.
- Unterstützung für Rollbacks und Versionierung.
Wenn der Server auch optionale UI-Ressourcen hostet, stelle sie unter stabilen Origins bereit, die laut der Content Security Policy der Komponente zulässig sind.
Den Produktionsendpunkt konfigurieren
Vor der Bereitstellung:
- Hinterlege die Zugangsdaten für den Produktivbetrieb in der Secret-Verwaltung des Hosts.
- Konfiguriere den Autorisierungsserver und lege fest, welche Weiterleitungen zulässig sind.
- Lege für ressourcenintensive oder nach außen sichtbare Tools Zeitlimits und Ratenlimits fest.
- Entferne Debug-Antworten und unnötige personenbezogene Daten.
- Vergewissere dich, dass die Logs weder Zugriffstoken noch sensible Tool-Ergebnisse enthalten.
Rufe den Produktionsendpunkt nach der Bereitstellung mit dem MCP Inspector auf. Überprüfe Initialisierung, Serveranweisungen, Tools, Schemas, Annotationen, Authentifizierung, Ergebnisse und Fehler.
Updates planen
Halte veröffentlichte Tool-Namen und Schemas abwärtskompatibel. Ergänze Felder oder Tools so, dass bestehende Schnittstellenverträge weiterhin gelten. Wenn sich Metadaten ändern, aktualisiere die Verbindung zum eigenen MCP-Server und führe vor der Einreichung alle Evaluierungsfälle erneut aus.
Wenn du eine optionale Benutzeroberfläche anbietest, versioniere die Ressourcenkennungen, sobald Änderungen an HTML, JavaScript oder CSS die Funktion einer zwischengespeicherten Komponente beeinträchtigen könnten.
MCP-Erweiterungen hinzufügen
Mit den MCP-Erweiterungen von OpenAI kannst du dein Plugin in die Seitenleiste, den Editor und die Dateiansichten von ChatGPT integrieren. Beispiele und Hinweise zum Setup findest du im Abschnitt Plugin-Erweiterungen.
Sicherheitshinweise
- Behandle alle Tool-Eingaben als nicht vertrauenswürdig.
- Validiere Parameter und setze Berechtigungen auf dem Server durch.
- Verlange bei Schreibaktionen mit weitreichenden Folgen eine Bestätigung.
- Nimm keine Secrets oder sensiblen Daten in Tool-Metadaten oder Ergebnisse auf.
- Protokolliere genügend Kontext, um Fehler untersuchen zu können. Lass Zugangsdaten und unnötige personenbezogene Daten aus den Logs heraus.
- Begrenze die Aufrufrate für ressourcenintensive oder nach außen sichtbare Aktionen.