Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du
.md an die URL der Seite anhängst.
Verbinde Modelle mit Remote-MCP-Servern oder über Secure MCP Tunnel mit lokalen Servern.
Neben den Tools, die du einem Modell über Funktionsaufrufe bereitstellst, kannst du seinen Funktionsumfang mit Remote-MCP-Servern oder Secure MCP Tunnel erweitern. Mit diesen Tools kann sich das Modell bei Bedarf mit externen Diensten verbinden und sie steuern, um auf einen Prompt zu antworten. Bei der Entwicklung legst du fest, ob diese Tool-Aufrufe automatisch zulässig sind oder deine ausdrückliche Genehmigung erfordern.
Remote-MCP-Server können beliebige öffentlich im Internet erreichbare Server sein, die das Model Context Protocol (MCP) für den Remote-Zugriff implementieren.
Secure MCP Tunnel bindet einen lokalen oder privaten MCP-Server an, ohne ihn öffentlich im Internet zugänglich zu machen.
Dieser Leitfaden zeigt dir, wie du MCP-Tools mit der Responses API verwendest. Bestehende Modelle unterstützen weiterhin integrierte Konnektoren. Im Abschnitt Bisherige Konnektoren erfährst du, für welche Modelle sie als veraltet gelten, und findest Beispiele für kompatible Modelle. Wie du in Sitzungen der Agents API Verbindungen vom verwalteten Dienst oder von deiner Sandbox aus herstellst, erfährst du im Leitfaden zu MCP-Verbindungen.
Secure MCP Tunnel
Wenn dein MCP-Server privat ist, in deiner eigenen Infrastruktur läuft oder sich hinter einer Firewall befindet, kannst du ihn über Secure MCP Tunnel mit unterstützten OpenAI-Produkten verbinden, ohne ihn öffentlich im Internet zugänglich zu machen. Lade die aktuelle öffentliche Version von openai/tunnel-client herunter.
Schnellstart
Verwende den Tool-Typ mcp in der Responses API. Gib für einen Remote-MCP-Server server_url an. Verwende tunnel_id, wenn du einen lokalen MCP-Server über Secure MCP Tunnel anbindest. Je nach Server musst du außerdem ein OAuth-Zugriffstoken im Parameter authorization angeben.
Das folgende Beispiel nutzt den öffentlichen MCP-Server für die OpenAI-Dokumentation, um Dokumentation zum Streaming von Ausgaben der Responses API zu finden. Dieser Server bietet Dokumentationstools ohne Schreibzugriff und erfordert keine Authentifizierung. Das Beispiel überspringt die Genehmigungen für Tool-Aufrufe, da es öffentliche Dokumentation abfragt. Verlange eine Genehmigung, wenn du sensible Daten weitergibst.
Einen Remote-MCP-Server in der Responses API verwenden
curl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curlhttps://api.openai.com/v1/responses\-H "Content-Type: application/json"\-H "Authorization: Bearer $OPENAI_API_KEY"\-d '{ "model": "gpt-6-astra", "tools": [ { "type": "mcp", "server_label": "openai_docs", "server_description": "Search and read the public OpenAI documentation.", "server_url": "https://developers.openai.com/mcp", "require_approval": "never" } ], "input": "Search the OpenAI docs for Responses API streaming and return the relevant links." }'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import OpenAI from "openai";const client = new OpenAI();const resp = await client.responses.create({ model: "gpt-6-astra", tools: [ { type: "mcp", server_label: "openai_docs", server_description: "Search and read the public OpenAI documentation.", server_url: "https://developers.openai.com/mcp", require_approval: "never", }, ], input: "Search the OpenAI docs for Responses API streaming and return the relevant links.",});console.log(resp.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19from openai import OpenAIclient = OpenAI()resp = client.responses.create( model="gpt-6-astra", tools=[ { "type": "mcp", "server_label": "openai_docs", "server_description": "Search and read the public OpenAI documentation.", "server_url": "https://developers.openai.com/mcp", "require_approval": "never", }, ], input="Search the OpenAI docs for Responses API streaming and return the relevant links.",)print(resp.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27package mainimport ( "context" "fmt" "github.com/openai/openai-go/v3" "github.com/openai/openai-go/v3/responses")func main() { client := openai.NewClient() tool := responses.ToolParamOfMcp("openai_docs") tool.OfMcp.ServerDescription = openai.String("Search and read the public OpenAI documentation.") tool.OfMcp.ServerURL = openai.String("https://developers.openai.com/mcp") tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")} response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{ Model: "gpt-6-astra", Tools: []responses.ToolUnionParam{tool}, Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Search the OpenAI docs for Responses API streaming and return the relevant links.")}, }) if err != nil { panic(err) } fmt.Println(response.OutputText())}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.models.responses.ResponseCreateParams;import com.openai.models.responses.Tool;ResponseCreateParams params = ResponseCreateParams.builder() .model("gpt-6-astra") .input( "Search the OpenAI docs for Responses API streaming and return the relevant links.") .addTool( Tool.Mcp.builder() .serverLabel("openai_docs") .serverDescription("Search and read the public OpenAI documentation.") .serverUrl("https://developers.openai.com/mcp") .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER) .build()) .build();client.responses().create(params).output().stream() .flatMap(item -> item.message().stream()) .flatMap(message -> message.content().stream()) .flatMap(content -> content.outputText().stream()) .forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19using OpenAI.Responses;#pragma warning disable OPENAI001string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;ResponsesClient client = new(key);CreateResponseOptions options = new() { Model = "gpt-6-astra" };options.Tools.Add( ResponseTool.CreateMcpTool( serverLabel: "openai_docs", serverUri: new Uri("https://developers.openai.com/mcp"), toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval ));options.InputItems.Add(ResponseItem.CreateUserMessageItem("Search the OpenAI docs for Responses API streaming and return the relevant links."));ResponseResult response = await client.CreateResponseAsync(options);Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19require "openai"openai = OpenAI::Client.newresponse = openai.responses.create( model: "gpt-6-astra", tools: [ { type: "mcp", server_label: "openai_docs", server_description: "Search and read the public OpenAI documentation.", server_url: "https://developers.openai.com/mcp", require_approval: "never" } ], input: "Search the OpenAI docs for Responses API streaming and return the relevant links.")puts(response.output_text)
Verwende mit der Responses API nur Remote-MCP-Server, denen du vertraust. Ein bösartiger Server kann sensible Daten aus allen Inhalten abgreifen, die in den Kontext des Modells gelangen. Lies den Abschnitt Risiken und Sicherheit weiter unten sorgfältig durch, bevor du dieses Tool verwendest.
Die API gibt neue Elemente im Array output der Modellantwort zurück. Entscheidet sich das Modell für einen MCP-Server, fragt es zunächst beim Server die Liste der verfügbaren Tools ab. Dabei entsteht ein Ausgabeelement vom Typ mcp_list_tools. Die folgende Beispielausgabe zeigt nur das Suchtool mit einer gekürzten Beschreibung. Der Server stellt weitere Dokumentationstools bereit.
Ruft das Modell eines der verfügbaren Tools auf dem MCP-Server auf, enthält die Ausgabe außerdem ein Element vom Typ mcp_call. Es zeigt, was das Modell an das MCP-Tool gesendet und was das Tool zurückgegeben hat.
Im Folgenden erfährst du, wie das MCP-Tool funktioniert, wie du die verfügbaren Tools filterst und wie du Genehmigungsanfragen für Tool-Aufrufe bearbeitest.
Funktionsweise
Die meisten neueren Modelle unterstützen das MCP-Tool in der Responses API. Ob dein Modell das MCP-Tool unterstützt, erfährst du in der Modellübersicht. Bei der Nutzung des MCP-Tools zahlst du nur für die Token, die beim Import von Tool-Definitionen oder bei Tool-Aufrufen anfallen. Für einzelne Tool-Aufrufe fallen keine zusätzlichen Gebühren an.
Beim Aufruf eines MCP-Tools führt die API die folgenden Schritte aus.
Schritt 1: Verfügbare Tools auflisten
Wenn du einen Remote-MCP-Server im Parameter tools angibst, versucht die API, die Liste der Tools vom Server abzurufen. Die Responses API funktioniert mit Remote-MCP-Servern, die eines der Transportprotokolle Streamable HTTP oder HTTP/SSE unterstützen.
Ruft die API die Tool-Liste erfolgreich ab, erscheint in der Ausgabe der Modellantwort ein neues Element vom Typ mcp_list_tools. Die Eigenschaft tools dieses Objekts enthält die erfolgreich importierten Tools. Der folgende Beispielauszug zeigt nur das Suchtool mit einer gekürzten Beschreibung.
Solange das Element mcp_list_tools im Kontext einer API-Anfrage enthalten ist, ruft die API die Tool-Liste des MCP-Servers nicht bei jedem Schritt einer Unterhaltung erneut ab. Wir empfehlen, das Element während jeder Unterhaltung und bei jeder Ausführung eines Workflows im Modellkontext zu behalten, um die Latenz zu verringern.
Tools filtern
Manche MCP-Server bieten Dutzende von Tools an. Wenn du dem Modell viele Tools bereitstellst, kann das Kosten und Latenz erhöhen. Benötigst du nur einen Teil der Tools eines MCP-Servers, kannst du mit dem Parameter allowed_tools den Import auf diese Tools beschränken. Dieses Beispiel importiert nur search_openai_docs, um Links zur Dokumentation zu finden.
Zulässige Tools einschränken
curl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17curlhttps://api.openai.com/v1/responses\-H "Content-Type: application/json"\-H "Authorization: Bearer $OPENAI_API_KEY"\-d '{ "model": "gpt-6-astra", "tools": [ { "type": "mcp", "server_label": "openai_docs", "server_description": "Search and read the public OpenAI documentation.", "server_url": "https://developers.openai.com/mcp", "require_approval": "never", "allowed_tools": ["search_openai_docs"] } ], "input": "Search the OpenAI docs for Responses API streaming and return the relevant links." }'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import OpenAI from "openai";const client = new OpenAI();const resp = await client.responses.create({ model: "gpt-6-astra", tools: [ { type: "mcp", server_label: "openai_docs", server_description: "Search and read the public OpenAI documentation.", server_url: "https://developers.openai.com/mcp", require_approval: "never", allowed_tools: ["search_openai_docs"], }, ], input: "Search the OpenAI docs for Responses API streaming and return the relevant links.",});console.log(resp.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20from openai import OpenAIclient = OpenAI()resp = client.responses.create( model="gpt-6-astra", tools=[ { "type": "mcp", "server_label": "openai_docs", "server_description": "Search and read the public OpenAI documentation.", "server_url": "https://developers.openai.com/mcp", "require_approval": "never", "allowed_tools": ["search_openai_docs"], } ], input="Search the OpenAI docs for Responses API streaming and return the relevant links.",)print(resp.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.models.responses.ResponseCreateParams;import com.openai.models.responses.Tool;import java.util.List;ResponseCreateParams params = ResponseCreateParams.builder() .model("gpt-6-astra") .input( "Search the OpenAI docs for Responses API streaming and return the relevant links.") .addTool( Tool.Mcp.builder() .serverLabel("openai_docs") .serverDescription("Search and read the public OpenAI documentation.") .serverUrl("https://developers.openai.com/mcp") .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER) .allowedToolsOfMcp(List.of("search_openai_docs")) .build()) .build();client.responses().create(params).output().stream() .flatMap(item -> item.message().stream()) .flatMap(message -> message.content().stream()) .flatMap(content -> content.outputText().stream()) .forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20using OpenAI.Responses;#pragma warning disable OPENAI001string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;ResponsesClient client = new(key);CreateResponseOptions options = new() { Model = "gpt-6-astra" };options.Tools.Add( ResponseTool.CreateMcpTool( serverLabel: "openai_docs", serverUri: new Uri("https://developers.openai.com/mcp"), allowedTools: new McpToolFilter() { ToolNames = { "search_openai_docs" } }, toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval ));options.InputItems.Add(ResponseItem.CreateUserMessageItem("Search the OpenAI docs for Responses API streaming and return the relevant links."));ResponseResult response = await client.CreateResponseAsync(options);Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20require "openai"client = OpenAI::Client.newresponse = client.responses.create( model: "gpt-6-astra", input: "Search the OpenAI docs for Responses API streaming and return the relevant links.", tools: [ { type: :mcp, server_label: "openai_docs", server_description: "Search and read the public OpenAI documentation.", server_url: "https://developers.openai.com/mcp", require_approval: :never, allowed_tools: ["search_openai_docs"] } ])puts(response.output_text)
Schritt 2: Tools aufrufen
Sobald das Modell Zugriff auf die Tool-Definitionen hat, kann es anhand seines Kontexts entscheiden, welche Tools es aufruft. Entscheidet sich das Modell für ein MCP-Tool, sendet die API eine Anfrage an den Remote-MCP-Server, um das Tool aufzurufen. Die API übernimmt die Ausgabe des Tools in den Modellkontext. Dabei entsteht ein Element vom Typ mcp_call. Die folgende Beispielausgabe lässt die Metadaten der Suchergebnisse der Übersichtlichkeit halber weg.
Dieses Element enthält die Argumente, die das Modell für den Tool-Aufruf gewählt hat. Das Feld output enthält die Ausgabe des Remote-MCP-Servers. Alle Modelle können mehrere MCP-Tool-Aufrufe ausführen. Deshalb kann eine einzelne API-Anfrage mehrere solcher Elemente erzeugen.
Schlägt ein Tool-Aufruf fehl, enthält das Fehlerfeld des Elements einen MCP-Protokollfehler, einen Fehler bei der Ausführung des MCP-Tools oder einen allgemeinen Verbindungsfehler. Die MCP-Fehler sind in der MCP-Spezifikation dokumentiert.
Genehmigungen
Standardmäßig fordert OpenAI deine Genehmigung an, bevor Daten an einen Konnektor oder Remote-MCP-Server übermittelt werden. So siehst du, welche Daten an einen MCP-Server gehen, und kannst die Übermittlung steuern. Wir empfehlen dir dringend, alle Daten, die an einen Remote-MCP-Server gehen, sorgfältig zu prüfen und bei Bedarf zu protokollieren. Um den Genehmigungsablauf auszuprobieren, setze require_approval auf "always" statt auf "never" und führe das Schnellstartbeispiel aus. Fordert die API eine Genehmigung für einen MCP-Tool-Aufruf an, enthält die Ausgabe des Response-Objekts ein Element vom Typ mcp_approval_request. Das folgende Beispiel zeigt eine solche Anfrage.
Prüfe das angeforderte Tool und seine Argumente, bevor du den Aufruf genehmigst. Erstelle für deine Antwort ein neues Response-Objekt und füge ihm ein Element vom Typ mcp_approval_response hinzu. Ersetze in den folgenden Beispielen die IDs der Antwort und der Genehmigungsanfrage durch die IDs, die deine Anfrage zurückgibt. Das .NET-Beispiel entnimmt diese IDs der ersten Antwort. Jede Genehmigung gilt für einen einzelnen Tool-Aufruf. Bearbeite weitere Genehmigungsanfragen auf dieselbe Weise.
Hier verknüpft der Parameter previous_response_id das neue Response-Objekt mit dem vorherigen, das die Genehmigungsanfrage erzeugt hat. Du kannst auch die Ausgaben einer Antwort als Eingaben für die nächste übergeben. So bestimmst du genau, was in den Modellkontext gelangt.
Wenn du einem Remote-MCP-Server vertraust, kannst du Genehmigungen überspringen, um die Latenz zu verringern. Setze dazu den Parameter require_approval des MCP-Tools wie im folgenden Beispiel auf ein Objekt, das nur die Tools auflistet, für die du Genehmigungen überspringen möchtest. Mit dem Wert 'never' überspringst du Genehmigungen für alle Tools dieses Remote-MCP-Servers.
Für bestimmte Tools nie eine Genehmigung anfordern
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29using OpenAI.Responses;#pragma warning disable OPENAI001string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;ResponsesClient client = new(key);CreateResponseOptions options = new() { Model = "gpt-6-astra" };options.Tools.Add( ResponseTool.CreateMcpTool( serverLabel: "deepwiki", serverUri: new Uri("https://mcp.deepwiki.com/mcp"), toolCallApprovalPolicy: new CustomMcpToolCallApprovalPolicy { ToolsNeverRequiringApproval = new McpToolFilter { ToolNames = { "ask_question", "read_wiki_structure" }, }, } ));options.InputItems.Add( ResponseItem.CreateUserMessageItem( "What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?" ));ResponseResult response = await client.CreateResponseAsync(options);Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20require "openai"client = OpenAI::Client.newresponse = client.responses.create( model: "gpt-6-astra", input: "What transport protocols does the 2025-03-26 version of the MCP spec support?", tools: [ { type: :mcp, server_label: "deepwiki", server_url: "https://mcp.deepwiki.com/mcp", require_approval: { never: { tool_names: ["ask_question", "read_wiki_structure"] } } } ])puts(response.output_text)
Authentifizierung
Der MCP-Server für die OpenAI-Dokumentation erfordert keine Authentifizierung. Andere MCP-Server können eine Authentifizierung verlangen. Am häufigsten kommt dabei ein OAuth-Zugriffstoken zum Einsatz. Übergib dieses Token im Feld authorization des MCP-Tools.
Damit sensible Token nicht unbefugt bekannt werden, speichert die Responses API den Wert aus dem Feld authorization nicht. Auch im erstellten Response-Objekt ist er nicht sichtbar. Deshalb musst du den Wert für authorization bei jeder Anfrage zum Erstellen eines Response-Objekts erneut mitsenden.
Bisherige Konnektoren
Für Modelle, die nach dem 1. September 2026 veröffentlicht wurden, gilt connector_id als veraltet. Verwende server_url für die Verbindung zu einem Remote-MCP-Server oder
tunnel_id für die Verbindung zu einem lokalen MCP-Server über
Secure MCP Tunnel. Bestehende Modelle unterstützen Konnektoren weiterhin. Die Beispiele in diesem Abschnitt verwenden
gpt-5.2, das vor dem Stichtag veröffentlicht wurde.
Die Responses API unterstützt eine begrenzte Auswahl integrierter Konnektoren für Dienste von Drittanbietern. Über diese Konnektoren kannst du Kontext aus verbreiteten Anwendungen wie Dropbox und Gmail abrufen, damit das Modell mit diesen Diensten interagieren kann.
Konnektoren verwendest du genauso wie Remote-MCP-Server. Beide ermöglichen einem OpenAI-Modell, in einer API-Anfrage auf zusätzliche Tools von Drittanbietern zuzugreifen. Beim Aufruf eines Remote-MCP-Servers übergibst du server_url. Für einen Konnektor übergibst du stattdessen connector_id. Dieser Wert identifiziert den in der API verfügbaren Konnektor eindeutig.
Konnektoren erfordern ein OAuth-Zugriffstoken, das deine Anwendung im Parameter authorization übergibt.
Wir haben Dienste bevorzugt, die keine offiziellen Remote-MCP-Server anbieten. GitHub hat beispielsweise einen offiziellen MCP-Server. Um dich mit ihm zu verbinden, übergib https://api.githubcopilot.com/mcp/ im Feld server_url des MCP-Tools.
Einen Konnektor autorisieren
Übergib im Feld authorization ein OAuth-Zugriffstoken. Deine Anwendung muss die Registrierung des OAuth-Clients und die Autorisierung separat übernehmen.
Für Tests kannst du im OAuth 2.0 Playground von Google temporäre Zugriffstoken für API-Anfragen generieren.
Um die Konnektoren der API mit dem Playground zu testen, gib zunächst den folgenden Berechtigungsbereich ein.
https://www.googleapis.com/auth/calendar.events
Gib diesen Berechtigungsbereich unter „Step 1: Select and authorize APIs“ ein, damit die API Termine aus Google Kalender lesen kann.
Nachdem du die Anwendung mit deinem Google-Konto autorisiert hast, gelangst du zu „Step 2: Exchange authorization code for tokens“. Tausche dort den Autorisierungscode gegen ein Zugriffstoken ein, das du für eine API-Anfrage mit dem Konnektor für Google Kalender verwenden kannst.
Den Konnektor für Google Kalender verwenden
curl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curlhttps://api.openai.com/v1/responses\-H"Content-Type: application/json"\-H"Authorization: Bearer $OPENAI_API_KEY"\-d'{ "model": "gpt-5.2", "tools": [ { "type": "mcp", "server_label": "google_calendar", "connector_id": "connector_googlecalendar", "authorization": "ya29.A0AS3H6...", "require_approval": "never" } ], "input": "What is on my Google Calendar for today?" }'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import OpenAI from "openai";const client = new OpenAI();const resp = await client.responses.create({ model: "gpt-5.2", tools: [ { type: "mcp", server_label: "google_calendar", connector_id: "connector_googlecalendar", authorization: "ya29.A0AS3H6...", require_approval: "never", }, ], input: "What's on my Google Calendar for today?",});console.log(resp.output_text);
Ein MCP-Tool-Aufruf über einen Konnektor sieht genauso aus wie ein Aufruf über einen Remote-MCP-Server. Beide verwenden den Ausgabeelementtyp mcp_call. In diesem Beispiel sind sowohl die Argumente für den Konnektor als auch seine Antwort JSON-Zeichenfolgen.
Welche Tools verfügbar sind, hängt von den Berechtigungsbereichen deines OAuth-Tokens ab. Klappe die Tabellen auf, um zu sehen, welche Tools du mit der jeweiligen Anwendung verwenden kannst.
Tool
Beschreibung
Berechtigungsbereiche
search
Sucht in Dropbox nach Dateien, die zur Suchanfrage passen
files.metadata.read, account_info.read
fetch
Ruft eine Datei anhand ihres Pfads ab und ermöglicht optional den Download der Rohdaten
files.content.read
search_files
Durchsucht Dropbox-Dateien und gibt die Ergebnisse zurück
files.metadata.read, account_info.read
fetch_file
Ruft den Text oder den unverarbeiteten Inhalt einer Datei ab
files.content.read, account_info.read
list_recent_files
Gibt die zuletzt geänderten Dateien zurück, auf die das Konto zugreifen kann
files.metadata.read, account_info.read
get_profile
Ruft das Profil des aktuellen Dropbox-Kontos ab
account_info.read
Tool
Beschreibung
Berechtigungsbereiche
get_profile
Gibt das Profil des aktuellen Gmail-Kontos zurück
userinfo.email, userinfo.profile
search_emails
Sucht in Gmail nach E-Mails, die zu einer Suchanfrage oder einem Label passen
gmail.modify
search_email_ids
Ruft die IDs der Gmail-Nachrichten ab, die zur Suchanfrage passen
gmail.modify
get_recent_emails
Gibt die zuletzt empfangenen Gmail-Nachrichten zurück
gmail.modify
read_email
Ruft eine einzelne Gmail-Nachricht einschließlich des Nachrichtentexts ab
gmail.modify
batch_read_email
Liest mehrere Gmail-Nachrichten mit einem Aufruf
gmail.modify
Tool
Beschreibung
Berechtigungsbereiche
get_profile
Gibt das Profil des aktuellen Google-Kalender-Kontos zurück
userinfo.email, userinfo.profile
search
Sucht nach Kalenderterminen, optional innerhalb eines bestimmten Zeitraums
calendar.events
fetch
Ruft Details zu einem einzelnen Kalendertermin ab
calendar.events
search_events
Sucht anhand von Filtern nach Kalenderterminen
calendar.events
read_event
Liest einen Termin aus Google Kalender anhand seiner ID
calendar.events
Tool
Beschreibung
Berechtigungsbereiche
get_profile
Gibt das Profil des aktuellen Drive-Kontos zurück
userinfo.email, userinfo.profile
list_drives
Listet geteilte Ablagen auf, auf die das Konto zugreifen kann
drive.readonly
search
Durchsucht Drive-Dateien anhand einer Suchanfrage
drive.readonly
recent_documents
Gibt die zuletzt geänderten Dokumente zurück
drive.readonly
fetch
Lädt den Inhalt einer Drive-Datei herunter
drive.readonly
Tool
Beschreibung
Berechtigungsbereiche
search
Durchsucht Chats und Kanalnachrichten in Microsoft Teams
Chat.Read, ChannelMessage.Read.All
fetch
Ruft eine Teams-Nachricht anhand ihres Pfads ab
Chat.Read, ChannelMessage.Read.All
get_chat_members
Listet die Mitglieder eines Teams-Chats auf
Chat.Read
get_profile
Gibt das Profil des authentifizierten Teams-Kontos zurück
User.Read
Tool
Beschreibung
Berechtigungsbereiche
search_events
Sucht mit Datumsfiltern nach Terminen im Outlook-Kalender
Calendars.Read
fetch_event
Ruft Details zu einem einzelnen Termin ab
Calendars.Read
fetch_events_batch
Ruft mehrere Termine mit einem Aufruf ab
Calendars.Read
list_events
Listet Kalendertermine innerhalb eines Datumsbereichs auf
Calendars.Read
get_profile
Ruft das Profil des aktuellen Kontos ab
User.Read
Tool
Beschreibung
Berechtigungsbereiche
get_profile
Gibt Profilinformationen zum Outlook-Konto zurück
User.Read
list_messages
Ruft Outlook-E-Mails aus einem Ordner ab
Mail.Read
search_messages
Durchsucht Outlook-E-Mails mit optionalen Filtern
Mail.Read
get_recent_emails
Gibt die zuletzt empfangenen E-Mails zurück
Mail.Read
fetch_message
Ruft eine einzelne E-Mail anhand ihrer ID ab
Mail.Read
fetch_messages_batch
Ruft mehrere E-Mails mit einer Anfrage ab
Mail.Read
Tool
Beschreibung
Berechtigungsbereiche
get_site
Ermittelt eine SharePoint-Website anhand von Hostname und Pfad
Sites.Read.All
search
Durchsucht Dokumente in SharePoint und OneDrive nach Stichwörtern
Sites.Read.All, Files.Read.All
list_recent_documents
Gibt die zuletzt aufgerufenen Dokumente zurück
Files.Read.All
fetch
Ruft Dateiinhalte über eine Download-URL von Graph ab
Files.Read.All
get_profile
Ruft das Profil des aktuellen Kontos ab
User.Read
Tools eines MCP-Servers bei Bedarf laden
Wenn du die Tool-Suche verwendest, kannst du die Funktionen eines MCP-Servers erst dann laden, wenn das Modell sie benötigt. Setze dazu in der Tool-Definition des MCP-Servers defer_loading: true.
Auch beim verzögerten Laden kann das Modell anhand der Bezeichnung und Beschreibung des MCP-Servers entscheiden, wann es dort nach Tools sucht. Die einzelnen Funktionsdefinitionen werden erst bei Bedarf geladen. Das kann den Tokenverbrauch insgesamt senken und ist besonders bei MCP-Servern mit vielen Funktionen sinnvoll.
1
2
3
4
5
6
7
8{"type": "mcp","server_label": "openai_docs","server_description": "Search and read the public OpenAI documentation.","server_url": "https://developers.openai.com/mcp","defer_loading": true,"require_approval": "never"}
Risiken und Sicherheit
Mit dem MCP-Tool kannst du OpenAI-Modelle mit externen Diensten verbinden. Die weitreichenden Zugriffsmöglichkeiten bringen Risiken mit sich.
Bei Konnektoren besteht das Risiko, dass sensible Daten an OpenAI gesendet werden oder Modelle Lesezugriff auf potenziell sensible Daten in den angebundenen Diensten erhalten.
Bei Remote-MCP-Servern bestehen dieselben Risiken. Zudem hat OpenAI diese Server nicht überprüft. Über sie können Modelle auf Daten zugreifen, Daten senden und empfangen sowie Aktionen in den angebundenen Diensten ausführen. Alle MCP-Server sind Dienste von Drittanbietern, für die jeweils eigene Geschäftsbedingungen gelten.
Wenn du auf einen bösartigen MCP-Server stößt, melde ihn an security@openai.com.
Beachte beim Einbinden von Konnektoren und Remote-MCP-Servern die folgenden Empfehlungen.
Prompt Injection
Prompt Injection ist ein wichtiges Sicherheitsrisiko für jede LLM-Anwendung. Das gilt besonders, wenn du dem Modell Zugriff auf MCP-Server und Konnektoren gibst, die sensible Daten abrufen oder Aktionen ausführen können. Wenn der Prompt Benutzereingaben enthält, setze diese Tools mit entsprechender Vorsicht und geeigneten Schutzmaßnahmen ein.
Eine Webseite könnte das Modell beispielsweise anweisen, in deinem CRM-System nach einem Kundenkontakt zu suchen und dessen E-Mail-Adresse in eine URL einzufügen. Schon der Abruf dieser URL würde die E-Mail-Adresse offenlegen, selbst wenn das CRM-Tool ohne Schreibzugriff arbeitet.
Wenn du eine öffentliche Unternehmensmitteilung mit privaten CRM-Datensätzen vergleichen möchtest, sammle die öffentlich verfügbaren Fakten in einer Anfrage, für die nur die Websuche aktiviert ist. Übergib die relevanten Fakten an eine zweite Anfrage, die ausschließlich auf dein internes CRM-Suchtool zugreifen kann. So gelangen keine Kundendaten aus dem CRM in Websuchanfragen oder URLs.
Für sensible Aktionen immer eine Genehmigung verlangen
Konfiguriere die Parameter require_approval und allowed_tools so, dass jede sensible Aktion eine Genehmigung erfordert.
URLs in MCP-Tool-Aufrufen und deren Ausgaben
Es kann gefährlich sein, URLs aus den Ausgaben von Tool-Aufrufen abzurufen oder Bild-URLs aus solchen Ausgaben einzubetten. Das gilt für Konnektoren ebenso wie für Remote-MCP-Server. Vergewissere dich, dass du den Domains und Diensten vertraust, von denen die URLs stammen, bevor du sie in deinem Anwendungscode einbettest oder anderweitig verwendest.
Verbindungen zu vertrauenswürdigen Servern herstellen
Wähle offizielle Server, die der jeweilige Dienstanbieter selbst hostet. Für Stripe empfehlen wir beispielsweise den von Stripe gehosteten Server unter mcp.stripe.com anstelle eines Stripe-MCP-Servers, den ein Drittanbieter hostet. Da es derzeit nur wenige offizielle Remote-MCP-Server gibt, kommt für dich vielleicht ein MCP-Server infrage, den eine andere Organisation hostet. Diese Organisation betreibt den eigentlichen Dienst nicht selbst, sondern leitet Anfragen über deine API an ihn weiter. Wenn du auf einen solchen „Aggregator“ angewiesen bist, prüfe besonders gründlich, ob er vertrauenswürdig ist und wie er deine Daten verwendet.
Daten protokollieren und prüfen, die an MCP-Server von Drittanbietern gehen
MCP-Server legen ihre Tool-Definitionen selbst fest. Sie können daher Daten anfordern, die du dem jeweiligen Serverbetreiber möglicherweise nicht anvertrauen möchtest. Deshalb verlangt das MCP-Tool in der Responses API standardmäßig für jeden MCP-Tool-Aufruf eine Genehmigung. Prüfe bei der Entwicklung deiner Anwendung gründlich und systematisch, welche Arten von Daten sie an diese MCP-Server weitergibt. Sobald du dem jeweiligen MCP-Server vertraust, kannst du die Genehmigungen überspringen, um die Latenz bei der Ausführung zu verringern.
Wir empfehlen außerdem, alle Daten zu protokollieren, die an MCP-Server gesendet werden. Wenn du die Responses API mit store=true verwendest, protokolliert die API diese Daten bereits für 30 Tage, sofern für deine Organisation nicht die Option „Keine Datenaufbewahrung“ aktiviert ist. Du kannst die Daten zusätzlich in deinen eigenen Systemen protokollieren und regelmäßig prüfen, ob deine Anwendung die Daten wie vorgesehen weitergibt.
Bösartige MCP-Server können versteckte Anweisungen (Prompt Injections) enthalten, die OpenAI-Modelle gezielt zu unerwartetem Verhalten verleiten sollen. OpenAI hat Schutzmechanismen integriert, die helfen, solche Bedrohungen zu erkennen und zu blockieren. Prüfe dennoch Ein- und Ausgaben sorgfältig und stelle sicher, dass deine Anwendung nur Verbindungen zu vertrauenswürdigen Servern herstellt.
MCP-Server können die Funktionsweise ihrer Tools unerwartet ändern. Das kann unbeabsichtigtes oder bösartiges Verhalten zur Folge haben.
Auswirkungen auf die Vorgabe „Keine Datenaufbewahrung“ und auf die Datenresidenz
Das MCP-Tool ist mit der Vorgabe „Keine Datenaufbewahrung“ und mit Anforderungen an die Datenresidenz kompatibel. MCP-Server sind jedoch Dienste von Drittanbietern. Für Daten, die du an einen MCP-Server sendest, gelten die Richtlinien des jeweiligen Anbieters zur Datenaufbewahrung und Datenresidenz.
Gilt für deine Organisation Datenresidenz in Europa, beschränkt OpenAI die Inferenz und die Speicherung von Kundeninhalten auf Europa. Das gilt bis zu dem Punkt, an dem Nachrichten oder Daten an den MCP-Server gesendet werden. Du bist dafür verantwortlich, dass auch der MCP-Server deine jeweiligen Anforderungen an die Datenaufbewahrung („Keine Datenaufbewahrung“) und die Datenresidenz erfüllt. Weitere Informationen zu diesen Vorgaben findest du im Leitfaden zum Umgang mit deinen Daten.