Serveurs MCP | OpenAI API

En complément des outils que vous mettez à la disposition du modèle grâce à l’appel de fonction, vous pouvez lui donner de nouvelles capacités avec des serveurs MCP distants ou Secure MCP Tunnel. Ces outils permettent au modèle de se connecter à des services externes et de les piloter lorsque le prompt d’un utilisateur le nécessite. En tant que développeur, vous pouvez autoriser ces appels d’outils automatiquement ou exiger votre approbation explicite.

Un serveur MCP distant peut être n’importe quel serveur accessible sur l’Internet public qui implémente le Model Context Protocol (MCP) pour les connexions à distance.
Secure MCP Tunnel permet de connecter un serveur MCP local ou privé sans l’exposer à l’Internet public.

Ce guide explique comment utiliser les outils MCP avec l’API Responses. Les modèles existants continuent de prendre en charge les connecteurs intégrés. Consultez la section Anciens connecteurs pour connaître les règles de dépréciation et voir des exemples compatibles. Pour les sessions de l’API Agents, consultez le guide Connexions MCP, qui décrit les connexions depuis le service géré ou depuis votre bac à sable.

Secure MCP Tunnel

Si votre serveur MCP est privé, hébergé sur site ou protégé par un pare-feu, utilisez Secure MCP Tunnel pour le connecter aux produits OpenAI compatibles sans l’exposer à l’Internet public. Téléchargez la dernière version publique depuis openai/tunnel-client.

Démarrage rapide

Utilisez le type d’outil mcp dans l’API Responses. Renseignez server_url pour un serveur MCP distant ou utilisez tunnel_id pour un serveur MCP local accessible via Secure MCP Tunnel. Selon le serveur, vous devrez peut-être aussi fournir un jeton d’accès OAuth dans le paramètre authorization.

L’exemple suivant utilise le serveur MCP public de la documentation OpenAI pour rechercher de la documentation sur la diffusion en continu des réponses de l’API Responses. Ce serveur propose des outils de consultation de la documentation en lecture seule et ne nécessite aucune authentification. L’exemple se passe d’approbation pour cette recherche dans la documentation publique. Exigez une approbation lorsque vous partagez des données sensibles.

Utilisation d’un serveur MCP distant avec l’API Responses

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://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 OpenAI

client = 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 main

import (
	"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 OPENAI001

string 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.new

response = 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)

Avec l’API Responses, utilisez uniquement des serveurs MCP distants auxquels vous faites confiance. Un serveur malveillant peut exfiltrer des données sensibles à partir de tout élément qui entre dans le contexte du modèle. Lisez attentivement la section Risques et sécurité ci-dessous avant d’utiliser cet outil.

L’API renvoie de nouveaux éléments dans le tableau output de la réponse du modèle. Si le modèle décide d’utiliser un serveur MCP, il demande d’abord au serveur la liste des outils disponibles. Cette requête crée un élément de sortie mcp_list_tools. Pour illustrer le résultat, l’exemple suivant présente uniquement l’outil de recherche, avec une description abrégée. Le serveur propose aussi d’autres outils de consultation de la documentation.

12345678910111213141516171819202122232425262728293031323334{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "openai_docs",
  "tools": [
    {
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false
      },
      "description": "Search the public OpenAI documentation.",
      "input_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "minLength": 1
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 50
          },
          "cursor": {
            "type": "string"
          }
        },
        "required": ["query"]
      },
      "name": "search_openai_docs"
    }
  ]
}

Si le modèle décide d’appeler l’un des outils disponibles sur le serveur MCP, la réponse contient également un élément mcp_call. Celui-ci indique ce que le modèle a envoyé à l’outil MCP et ce que l’outil a renvoyé.

12345678910{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "error": null,
  "name": "search_openai_docs",
  "output": "{\"hits\":[{\"url\":\"https://developers.openai.com/api/docs/guides/streaming-responses\"}]}",
  "server_label": "openai_docs"
}

La suite du guide explique comment fonctionne l’outil MCP, comment filtrer les outils disponibles et comment traiter les demandes d’approbation des appels d’outils.

Fonctionnement

La plupart des modèles récents prennent en charge l’outil MCP dans l’API Responses. Vérifiez la compatibilité de votre modèle dans la liste des modèles. Lorsque vous utilisez l’outil MCP, seuls les tokens consommés lors de l’importation des définitions d’outils ou des appels d’outils vous sont facturés. Chaque appel est exempt de frais supplémentaires.

Voici les étapes que suit l’API lorsqu’elle appelle un outil MCP.

Étape 1 : récupération de la liste des outils disponibles

Lorsque vous indiquez un serveur MCP distant dans le paramètre tools, l’API tente de récupérer la liste des outils du serveur. L’API Responses fonctionne avec les serveurs MCP distants qui prennent en charge l’un des protocoles de transport Streamable HTTP ou HTTP/SSE.

Si l’API récupère la liste des outils, un nouvel élément de sortie mcp_list_tools apparaît dans la réponse du modèle. La propriété tools de cet objet contient les outils que l’API a pu importer. L’extrait suivant présente uniquement l’outil de recherche, avec une description abrégée.

12345678910111213141516171819202122232425262728293031323334{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "openai_docs",
  "tools": [
    {
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false
      },
      "description": "Search the public OpenAI documentation.",
      "input_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "minLength": 1
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 50
          },
          "cursor": {
            "type": "string"
          }
        },
        "required": ["query"]
      },
      "name": "search_openai_docs"
    }
  ]
}

Tant que l’élément mcp_list_tools figure dans le contexte d’une requête API, l’API réutilise la liste des outils du serveur MCP à chaque tour de conversation. Pour réduire la latence, nous vous recommandons de conserver cet élément dans le contexte du modèle tout au long de chaque conversation ou de chaque exécution de workflow.

Filtrage des outils

Certains serveurs MCP proposent des dizaines d’outils. En mettre un grand nombre à la disposition du modèle peut augmenter les coûts et la latence. Si seuls certains outils d’un serveur MCP vous intéressent, utilisez le paramètre allowed_tools pour importer uniquement ceux dont vous avez besoin. Cet exemple importe uniquement search_openai_docs pour rechercher des liens vers la documentation.

Restriction de la liste des outils autorisés

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17curl https://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 OpenAI

client = 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
26
27
28package main

import (
	"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")}
	tool.OfMcp.AllowedTools = responses.ToolMcpAllowedToolsUnionParam{OfMcpAllowedTools: []string{"search_openai_docs"}}

	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
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 OPENAI001

string 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.new

response = 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)

Étape 2 : appel des outils

Une fois que le modèle a accès aux définitions des outils, il peut choisir de les appeler selon le contenu de son contexte. Lorsqu’il décide d’appeler un outil MCP, l’API envoie au serveur MCP distant une requête pour exécuter l’outil, puis ajoute le résultat au contexte du modèle. Cet appel crée un élément mcp_call. Pour plus de concision, l’exemple de sortie suivant omet les métadonnées des résultats de recherche.

12345678910{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "error": null,
  "name": "search_openai_docs",
  "output": "{\"hits\":[{\"url\":\"https://developers.openai.com/api/docs/guides/streaming-responses\"}]}",
  "server_label": "openai_docs"
}

Cet élément contient les arguments choisis par le modèle pour cet appel d’outil ainsi que la valeur output renvoyée par le serveur MCP distant. Tous les modèles peuvent choisir d’effectuer plusieurs appels d’outils MCP. Une seule requête API peut donc produire plusieurs éléments de ce type.

Si l’appel échoue, le champ error de cet élément contient une erreur du protocole MCP, une erreur d’exécution de l’outil MCP ou une erreur de connexion. La spécification MCP décrit les erreurs MCP.

Approbations

Par défaut, OpenAI vous demande votre approbation avant de transmettre des données à un connecteur ou à un serveur MCP distant. Les approbations vous permettent de voir et de contrôler les données envoyées à un serveur MCP. Nous vous recommandons vivement d’examiner attentivement toutes les données partagées avec un serveur MCP distant. Vous pouvez également les consigner dans vos journaux. Pour essayer la procédure d’approbation, exécutez l’exemple de démarrage rapide en définissant require_approval sur "always" au lieu de "never". Lorsqu’un appel d’outil MCP nécessite votre approbation, l’API crée un élément mcp_approval_request dans la sortie de l’objet Response, comme dans cet exemple :

1234567{
  "id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
  "type": "mcp_approval_request",
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "name": "search_openai_docs",
  "server_label": "openai_docs"
}

Avant d’approuver l’appel, vérifiez l’outil demandé et ses arguments. Pour répondre, créez un nouvel objet Response et ajoutez-y un élément mcp_approval_response. Dans les exemples suivants, remplacez les identifiants de réponse et de demande d’approbation fournis à titre d’exemple par ceux que renvoie votre requête. L’exemple .NET récupère ces identifiants dans la réponse initiale. Chaque approbation porte sur un seul appel d’outil. Traitez les demandes d’approbation suivantes de la même manière.

Approbation des appels d’outils dans une requête API

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21curl https://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": "always"
      }
    ],
    "previous_response_id": "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
    "input": [{
      "type": "mcp_approval_response",
      "approve": true,
      "approval_request_id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa"
    }]
  }'

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 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: "always",
    },
  ],
  previous_response_id: "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
  input: [
    {
      type: "mcp_approval_response",
      approve: true,
      approval_request_id:
        "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
    },
  ],
});

console.log(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
26from openai import OpenAI

client = 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": "always",
        }
    ],
    previous_response_id="resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
    input=[
        {
            "type": "mcp_approval_response",
            "approve": True,
            "approval_request_id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
        }
    ],
)

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
27
28
29
30package main

import (
	"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("always")}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:              "gpt-6-astra",
		PreviousResponseID: openai.String("resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa"),
		Tools:              []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{
			responses.ResponseInputItemParamOfMcpApprovalResponse("mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa", true),
		}},
	})
	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
24
25
26
27
28
29
30
31
32
33
34
35
36
37import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import com.openai.models.responses.Tool;
import java.util.List;

String responseId = "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa";

String approvalRequestId = "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input(
            ResponseCreateParams.Input.ofResponse(
                List.of(
                    ResponseInputItem.ofMcpApprovalResponse(
                        ResponseInputItem.McpApprovalResponse.builder()
                            .approvalRequestId(approvalRequestId)
                            .approve(true)
                            .build()))))
        .previousResponseId(responseId)
        .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.ALWAYS)
                .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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    ToolChoice = ResponseToolChoice.CreateRequiredChoice(),
    ParallelToolCallsEnabled = false
};
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.AlwaysRequireApproval
    )
);

// Step 1: Create a response that requests tool-call approval.
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Search the OpenAI docs for Responses API streaming and return the relevant links."));
ResponseResult response1 = await client.CreateResponseAsync(options);

McpToolCallApprovalRequestItem approvalRequest =
    response1.OutputItems.OfType<McpToolCallApprovalRequestItem>().Single();

// Step 2: Approve the tool call and get the final response.
options.PreviousResponseId = response1.Id;
options.ToolChoice = ResponseToolChoice.CreateNoneChoice();
options.InputItems.Clear();
options.InputItems.Add(
    ResponseItem.CreateMcpApprovalResponseItem(approvalRequest.Id, approved: true)
);
ResponseResult response2 = await client.CreateResponseAsync(options);

Console.WriteLine(response2.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  previous_response_id: "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
  input: [
    {
      type: :mcp_approval_response,
      approval_request_id: "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
      approve: true
    }
  ],
  tools: [
    {
      type: :mcp,
      server_label: "openai_docs",
      server_url: "https://developers.openai.com/mcp",
      server_description: "Search and read the public OpenAI documentation.",
      require_approval: :always
    }
  ]
)

puts(response.output_text)

Dans cet exemple, le paramètre previous_response_id relie le nouvel objet Response à celui qui a généré la demande d’approbation. Pour contrôler plus précisément ce qui entre dans le contexte du modèle, vous pouvez aussi transmettre les sorties d’une réponse en entrée de la suivante.

Si vous estimez pouvoir faire confiance à un serveur MCP distant, vous pouvez désactiver les approbations pour réduire la latence. Pour cela, affectez au paramètre require_approval de l’outil MCP un objet qui répertorie uniquement les outils à dispenser d’approbation, comme dans l’exemple ci-dessous. Vous pouvez aussi lui affecter la valeur 'never' pour désactiver les approbations pour tous les outils de ce serveur MCP distant.

Désactivation des approbations pour certains outils

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19curl https://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": "deepwiki",
        "server_url": "https://mcp.deepwiki.com/mcp",
        "require_approval": {
          "never": {
            "tool_names": ["ask_question", "read_wiki_structure"]
          }
        }
      }
    ],
    "input": "What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?"
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "deepwiki",
      server_url: "https://mcp.deepwiki.com/mcp",
      require_approval: {
        never: {
          tool_names: ["ask_question", "read_wiki_structure"],
        },
      },
    },
  ],
  input:
    "What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?",
});

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 OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    tools=[
        {
            "type": "mcp",
            "server_label": "deepwiki",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "require_approval": {
                "never": {"tool_names": ["ask_question", "read_wiki_structure"]}
            },
        },
    ],
    input="What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?",
)

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
27
28
29
30
31
32package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("deepwiki")
	tool.OfMcp.ServerURL = openai.String("https://mcp.deepwiki.com/mcp")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{
		OfMcpToolApprovalFilter: &responses.ToolMcpRequireApprovalMcpToolApprovalFilterParam{
			Never: responses.ToolMcpRequireApprovalMcpToolApprovalFilterNeverParam{
				ToolNames: []string{"ask_question", "read_wiki_structure"},
			},
		},
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?")},
	})
	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
24
25
26
27
28
29import 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("What transport protocols does the 2025-03-26 version of the MCP spec support?")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("deepwiki")
                .serverUrl("https://mcp.deepwiki.com/mcp")
                .requireApproval(
                    Tool.Mcp.RequireApproval.McpToolApprovalFilter.builder()
                        .never(
                            Tool.Mcp.RequireApproval.McpToolApprovalFilter.Never.builder()
                                .addToolName("ask_question")
                                .addToolName("read_wiki_structure")
                                .build())
                        .build())
                .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
20
21
22
23
24
25
26
27
28
29using OpenAI.Responses;
#pragma warning disable OPENAI001

string 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.new

response = 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)

Authentification

Le serveur MCP de la documentation OpenAI ne nécessite aucune authentification. D’autres serveurs MCP peuvent en exiger une. La méthode la plus courante utilise un jeton d’accès OAuth. Fournissez ce jeton dans le champ authorization de l’outil MCP :

Utilisation de l’outil MCP de Stripe

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "input": "Create a payment link for $20",
    "tools": [
      {
        "type": "mcp",
        "server_label": "stripe",
        "server_url": "https://mcp.stripe.com",
        "authorization": "$STRIPE_OAUTH_ACCESS_TOKEN"
      }
    ]
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  input: "Create a payment link for $20",
  tools: [
    {
      type: "mcp",
      server_label: "stripe",
      server_url: "https://mcp.stripe.com",
      authorization: "$STRIPE_OAUTH_ACCESS_TOKEN",
    },
  ],
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import os
from openai import OpenAI

client = OpenAI()
authorization = os.environ["STRIPE_OAUTH_ACCESS_TOKEN"]

resp = client.responses.create(
    model="gpt-6-astra",
    input="Create a payment link for $20",
    tools=[
        {
            "type": "mcp",
            "server_label": "stripe",
            "server_url": "https://mcp.stripe.com",
            "authorization": authorization,
        }
    ],
)

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
27
28
29
30
31package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	authorization := os.Getenv("STRIPE_OAUTH_ACCESS_TOKEN")
	if authorization == "" {
		panic("STRIPE_OAUTH_ACCESS_TOKEN is required")
	}
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("stripe")
	tool.OfMcp.ServerURL = openai.String("https://mcp.stripe.com")
	tool.OfMcp.Authorization = openai.String(authorization)

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Create a payment link for $20")},
	})
	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;

String stripeAccessToken = System.getenv("STRIPE_OAUTH_ACCESS_TOKEN");

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Create a payment link for $20.")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("stripe")
                .serverUrl("https://mcp.stripe.com")
                .authorization(stripeAccessToken)
                .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
20
21
22
23using OpenAI.Responses;
#pragma warning disable OPENAI001

string authToken =
    Environment.GetEnvironmentVariable("STRIPE_OAUTH_ACCESS_TOKEN")!;
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-6-astra" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "stripe",
        serverUri: new Uri("https://mcp.stripe.com"),
        authorizationToken: authToken
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Create a payment link for $20")
);

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
17require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  input: "Create a payment link for $20.",
  tools: [
    {
      type: :mcp,
      server_label: "stripe",
      server_url: "https://mcp.stripe.com",
      authorization: ENV.fetch("STRIPE_OAUTH_ACCESS_TOKEN")
    }
  ]
)

puts(response.output_text)

Pour éviter toute fuite de jetons sensibles, l’API Responses ne conserve pas la valeur fournie dans le champ authorization. Cette valeur n’apparaît pas non plus dans l’objet Response créé. Vous devez donc envoyer la valeur de authorization dans chaque requête de création de réponse adressée à l’API Responses.

Anciens connecteurs

connector_id est obsolète pour les modèles publiés après le 1er septembre 2026. Utilisez server_url pour vous connecter à un serveur MCP distant ou tunnel_id pour vous connecter à un serveur MCP local via Secure MCP Tunnel. Les modèles existants continuent de prendre en charge les connecteurs. Les exemples de cette section utilisent gpt-5.2, publié avant cette date.

L’API Responses intègre un nombre limité de connecteurs vers des services tiers. Ces connecteurs récupèrent des éléments de contexte dans des applications courantes comme Dropbox et Gmail, ce qui permet au modèle d’interagir avec ces services.

Les connecteurs s’utilisent comme les serveurs MCP distants. Dans les deux cas, un modèle OpenAI peut accéder à des outils tiers supplémentaires dans une requête API. Pour appeler un serveur MCP distant, vous transmettez un server_url. Pour utiliser un connecteur, vous transmettez un connector_id qui identifie de manière unique un connecteur disponible dans l’API.

Les connecteurs nécessitent un jeton d’accès OAuth que votre application fournit dans le paramètre authorization.

Utilisation d’un ancien connecteur avec GPT-5.2

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://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": "Dropbox",
        "connector_id": "connector_dropbox",
        "authorization": "<oauth access token>",
        "require_approval": "never"
      }
    ],
    "input": "Summarize the Q2 earnings report."
  }'

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: "Dropbox",
      connector_id: "connector_dropbox",
      authorization: "<oauth access token>",
      require_approval: "never",
    },
  ],
  input: "Summarize the Q2 earnings report.",
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import os

from openai import OpenAI

client = OpenAI()
connector_authorization = os.environ["OPENAI_CONNECTOR_AUTHORIZATION"]

resp = client.responses.create(
    model="gpt-5.2",
    tools=[
        {
            "type": "mcp",
            "server_label": "Dropbox",
            "connector_id": "connector_dropbox",
            "authorization": connector_authorization,
            "require_approval": "never",
        },
    ],
    input="Summarize the Q2 earnings report.",
)

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 main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("Dropbox")
	tool.OfMcp.ConnectorID = "connector_dropbox"
	tool.OfMcp.Authorization = openai.String("<oauth access token>")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-5.2",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Summarize the Q2 earnings report.")},
	})
	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
24
25import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;

String oauthAccessToken = "<oauth access token>";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.2")
        .input("Summarize the Q2 earnings report.")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("Dropbox")
                .connectorId(Tool.Mcp.ConnectorId.of("connector_dropbox"))
                .authorization(oauthAccessToken)
                .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
19
20
21
22
23
24using OpenAI.Responses;
#pragma warning disable OPENAI001

string dropboxToken =
    Environment.GetEnvironmentVariable("DROPBOX_OAUTH_ACCESS_TOKEN")!;
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-5.2" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "Dropbox",
        connectorId: McpToolConnectorId.Dropbox,
        authorizationToken: dropboxToken,
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Summarize the Q2 earnings report.")
);

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
18require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.2",
  input: "Summarize the Q2 earnings report.",
  tools: [
    {
      type: :mcp,
      server_label: "Dropbox",
      connector_id: "connector_dropbox",
      authorization: "<oauth access token>",
      require_approval: :never
    }
  ]
)

puts(response.output_text)

Connecteurs disponibles

Dropbox : connector_dropbox
Gmail : connector_gmail
Google Agenda : connector_googlecalendar
Google Drive : connector_googledrive
Microsoft Teams : connector_microsoftteams
Calendrier Outlook : connector_outlookcalendar
Messagerie Outlook : connector_outlookemail
SharePoint : connector_sharepoint

Nous avons donné la priorité aux services qui ne disposent pas de serveur MCP distant officiel. GitHub, par exemple, propose un serveur MCP officiel auquel vous pouvez vous connecter en transmettant https://api.githubcopilot.com/mcp/ dans le champ server_url de l’outil MCP.

Autorisation d’un connecteur

Dans le champ authorization, fournissez un jeton d’accès OAuth. Votre application doit gérer séparément l’enregistrement du client OAuth et son autorisation.

Pour vos tests, vous pouvez utiliser l’OAuth 2.0 Playground de Google pour générer des jetons d’accès temporaires utilisables dans une requête API.

Pour tester les connecteurs de l’API dans le Playground, commencez par saisir la valeur suivante :

https://www.googleapis.com/auth/calendar.events

Saisissez cette portée d’autorisation sous Step 1: Select and authorize APIs pour permettre à l’API de lire les événements Google Agenda.

Après avoir autorisé l’application avec votre compte Google, passez à l’étape Step 2: Exchange authorization code for tokens. Vous obtiendrez un jeton d’accès utilisable dans une requête API avec le connecteur Google Agenda :

Utilisation du connecteur Google Agenda

curl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://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);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import os
from openai import OpenAI

client = OpenAI()
authorization = os.environ["GOOGLE_CALENDAR_OAUTH_ACCESS_TOKEN"]

resp = client.responses.create(
    model="gpt-5.2",
    tools=[
        {
            "type": "mcp",
            "server_label": "google_calendar",
            "connector_id": "connector_googlecalendar",
            "authorization": authorization,
            "require_approval": "never",
        },
    ],
    input="What's on my Google Calendar for today?",
)

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 main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("google_calendar")
	tool.OfMcp.ConnectorID = "connector_googlecalendar"
	tool.OfMcp.Authorization = openai.String("<oauth access token>")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-5.2",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("What's on my Google Calendar for today?")},
	})
	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
24
25import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;

String oauthAccessToken = "<oauth access token>";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.2")
        .input("What's on my Google Calendar for today?")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("google_calendar")
                .connectorId(Tool.Mcp.ConnectorId.of("connector_googlecalendar"))
                .authorization(oauthAccessToken)
                .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
19
20
21
22
23
24using OpenAI.Responses;
#pragma warning disable OPENAI001

string authToken =
    Environment.GetEnvironmentVariable("GOOGLE_CALENDAR_OAUTH_ACCESS_TOKEN")!;
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new() { Model = "gpt-5.2" };
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        serverLabel: "google_calendar",
        connectorId: McpToolConnectorId.GoogleCalendar,
        authorizationToken: authToken,
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("What's on my Google Calendar for today?")
);

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
18require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.2",
  input: "What's on my Google Calendar for today?",
  tools: [
    {
      type: :mcp,
      server_label: "google_calendar",
      connector_id: "connector_googlecalendar",
      authorization: "<oauth access token>",
      require_approval: :never
    }
  ]
)

puts(response.output_text)

Un appel d’outil MCP via un connecteur se présente comme un appel d’outil MCP via un serveur MCP distant : il produit un élément de sortie de type mcp_call. Dans cet exemple, les arguments transmis au connecteur et la réponse qu’il renvoie sont des chaînes JSON :

12345678910{
  "id": "mcp_68a62ae1c93c81a2b98c29340aa3ed8800e9b63986850588",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"time_min\":\"2025-08-20T00:00:00\",\"time_max\":\"2025-08-21T00:00:00\",\"timezone_str\":null,\"max_results\":50,\"query\":null,\"calendar_id\":null,\"next_page_token\":null}",
  "error": null,
  "name": "search_events",
  "output": "{\"events\": [{\"id\": \"2n8ni54ani58pc3ii6soelupcs_20250820\", \"summary\": \"Home\", \"location\": null, \"start\": \"2025-08-20T00:00:00\", \"end\": \"2025-08-21T00:00:00\", \"url\": \"https://www.google.com/calendar/event?eid=Mm44bmk1NGFuaTU4cGMzaWk2c29lbHVwY3NfMjAyNTA4MjAga3doaW5uZXJ5QG9wZW5haS5jb20&ctz=America/Los_Angeles\", \"description\": \"\\n\\n\", \"transparency\": \"transparent\", \"display_url\": \"https://www.google.com/calendar/event?eid=Mm44bmk1NGFuaTU4cGMzaWk2c29lbHVwY3NfMjAyNTA4MjAga3doaW5uZXJ5QG9wZW5haS5jb20&ctz=America/Los_Angeles\", \"display_title\": \"Home\"}], \"next_page_token\": null}",
  "server_label": "Google_Calendar"
}

Outils disponibles par connecteur

Les outils disponibles dépendent des portées d’autorisation accordées à votre jeton OAuth. Dépliez les tableaux ci-dessous pour voir quels outils vous pouvez utiliser avec chaque application.

Outil	Description	Portées d’autorisation
`search`	Rechercher dans Dropbox les fichiers correspondant à une requête	files.metadata.read, account_info.read
`fetch`	Récupérer un fichier à partir de son chemin, avec possibilité de télécharger son contenu brut	files.content.read
`search_files`	Rechercher des fichiers Dropbox et renvoyer les résultats	files.metadata.read, account_info.read
`fetch_file`	Récupérer le texte ou le contenu brut d’un fichier	files.content.read, account_info.read
`list_recent_files`	Renvoyer les fichiers modifiés le plus récemment auxquels l’utilisateur a accès	files.metadata.read, account_info.read
`get_profile`	Récupérer le profil Dropbox de l’utilisateur actuel	account_info.read

Outil	Description	Portées d’autorisation
`get_profile`	Renvoyer le profil Gmail de l’utilisateur actuel	userinfo.email, userinfo.profile
`search_emails`	Rechercher dans Gmail les e-mails correspondant à une requête ou à un libellé	gmail.modify
`search_email_ids`	Récupérer les identifiants des messages Gmail correspondant à une recherche	gmail.modify
`get_recent_emails`	Renvoyer les messages Gmail reçus le plus récemment	gmail.modify
`read_email`	Récupérer un message Gmail, corps du message compris	gmail.modify
`batch_read_email`	Lire plusieurs messages Gmail en un seul appel	gmail.modify

Outil	Description	Portées d’autorisation
`get_profile`	Renvoyer le profil Google Agenda de l’utilisateur actuel	userinfo.email, userinfo.profile
`search`	Rechercher des événements dans Google Agenda, avec la possibilité de préciser une période	calendar.events
`fetch`	Obtenir les détails d’un événement Google Agenda	calendar.events
`search_events`	Rechercher des événements Google Agenda à l’aide de filtres	calendar.events
`read_event`	Lire un événement Google Agenda à partir de son identifiant	calendar.events

Outil	Description	Portées d’autorisation
`get_profile`	Renvoyer le profil Drive de l’utilisateur actuel	userinfo.email, userinfo.profile
`list_drives`	Lister les Drive partagés auxquels l’utilisateur a accès	drive.readonly
`search`	Rechercher des fichiers dans Drive à l’aide d’une requête	drive.readonly
`recent_documents`	Renvoyer les documents modifiés le plus récemment	drive.readonly
`fetch`	Télécharger le contenu d’un fichier Drive	drive.readonly

Outil	Description	Portées d’autorisation
`search`	Rechercher dans les conversations et les messages des canaux Microsoft Teams	Chat.Read, ChannelMessage.Read.All
`fetch`	Récupérer un message Teams à partir de son chemin	Chat.Read, ChannelMessage.Read.All
`get_chat_members`	Lister les membres d’une conversation Teams	Chat.Read
`get_profile`	Renvoyer le profil de l’utilisateur Teams authentifié	User.Read

Outil	Description	Portées d’autorisation
`search_events`	Rechercher des événements du calendrier Outlook à l’aide de filtres de date	Calendars.Read
`fetch_event`	Récupérer les détails d’un événement	Calendars.Read
`fetch_events_batch`	Récupérer plusieurs événements en un seul appel	Calendars.Read
`list_events`	Lister les événements du calendrier sur une période donnée	Calendars.Read
`get_profile`	Récupérer le profil de l’utilisateur actuel	User.Read

Outil	Description	Portées d’autorisation
`get_profile`	Renvoyer les informations de profil du compte Outlook	User.Read
`list_messages`	Récupérer les e-mails d’un dossier Outlook	Mail.Read
`search_messages`	Rechercher des e-mails Outlook avec des filtres facultatifs	Mail.Read
`get_recent_emails`	Renvoyer les e-mails reçus le plus récemment	Mail.Read
`fetch_message`	Récupérer un e-mail à partir de son identifiant	Mail.Read
`fetch_messages_batch`	Récupérer plusieurs e-mails en une seule requête	Mail.Read

Outil	Description	Portées d’autorisation
`get_site`	Identifier un site SharePoint à partir du nom d’hôte et du chemin	Sites.Read.All
`search`	Rechercher des documents SharePoint ou OneDrive par mot-clé	Sites.Read.All, Files.Read.All
`list_recent_documents`	Renvoyer les documents consultés récemment	Files.Read.All
`fetch`	Récupérer le contenu d’un fichier à partir d’une URL de téléchargement Graph	Files.Read.All
`get_profile`	Récupérer le profil de l’utilisateur actuel	User.Read

Chargement différé des outils d’un serveur MCP

Si vous utilisez la recherche d’outils, vous pouvez différer le chargement des fonctions proposées par un serveur MCP jusqu’à ce que le modèle estime en avoir besoin. Pour cela, indiquez defer_loading: true dans la définition de l’outil MCP correspondant au serveur.

Lorsque vous différez le chargement des outils d’un serveur MCP, le modèle peut toujours s’appuyer sur le libellé et la description du serveur pour décider quand y rechercher des outils. Les définitions des fonctions ne sont chargées qu’en cas de besoin. Cette méthode peut réduire la consommation totale de tokens et se révèle particulièrement utile pour les serveurs MCP qui proposent de nombreuses fonctions.

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"
}

Risques et sécurité

L’outil MCP vous permet de connecter les modèles OpenAI à des services externes. Cette fonctionnalité offre de nombreuses possibilités, mais présente aussi des risques.

Avec les connecteurs, vous risquez d’envoyer des données sensibles à OpenAI ou de donner aux modèles un accès en lecture à des données potentiellement sensibles dans ces services.

Les serveurs MCP distants présentent les mêmes risques. De plus, OpenAI ne les a pas vérifiés. Ces serveurs peuvent permettre aux modèles de consulter, d’envoyer et de recevoir des données, ainsi que d’effectuer des actions dans les services concernés. Tous les serveurs MCP sont des services tiers soumis à leurs propres conditions d’utilisation.

Si vous découvrez un serveur MCP malveillant, signalez-le à security@openai.com.

Tenez compte des bonnes pratiques suivantes lorsque vous intégrez des connecteurs et des serveurs MCP distants.

Attaque par injection de prompt

Le risque d’attaque par injection de prompt est important dans toute application utilisant un LLM, en particulier si vous donnez au modèle accès à des serveurs MCP ou à des connecteurs capables de consulter des données sensibles ou d’effectuer des actions. Si le prompt du modèle contient du contenu fourni par un utilisateur, utilisez ces outils avec prudence et mettez en place des mesures de protection adaptées.

Par exemple, une page web pourrait demander au modèle de rechercher un client dans votre CRM et d’insérer son adresse e-mail dans une URL. Si le modèle consultait cette URL, il divulguerait l’adresse e-mail du client, même si l’outil CRM ne permet qu’un accès en lecture seule.

Pour comparer une annonce publique d’une entreprise avec des fiches privées de votre CRM, recueillez les informations publiques dans une première requête où seule la recherche web est activée. Transmettez les informations pertinentes dans une seconde requête qui a uniquement accès à l’outil de recherche interne de votre CRM. Ainsi, les données des fiches clients n’apparaissent ni dans les requêtes web ni dans les URL.

Exigez toujours une approbation pour les actions sensibles

Configurez les paramètres require_approval et allowed_tools de façon à soumettre toute action sensible à une procédure d’approbation.

URL dans les appels d’outils MCP et leurs résultats

Il peut être dangereux d’envoyer une requête à une URL ou d’intégrer une image à partir d’une URL fournie par un appel d’outil, que le résultat provienne d’un connecteur ou d’un serveur MCP distant. Avant d’intégrer ces URL dans le code de votre application ou de les y utiliser d’une autre manière, vérifiez que vous faites confiance aux domaines et aux services qui les fournissent.

Connexion à des serveurs de confiance

Choisissez des serveurs officiels hébergés par les fournisseurs des services eux-mêmes. Par exemple, nous vous recommandons de vous connecter au serveur Stripe hébergé par Stripe à l’adresse mcp.stripe.com, plutôt qu’à un serveur MCP pour Stripe hébergé par un tiers. Les serveurs MCP distants officiels sont encore peu nombreux. Vous pourriez donc être tenté d’utiliser un serveur MCP hébergé par une organisation qui n’exploite pas le serveur du service concerné et qui relaie les requêtes vers ce service via votre API. Si vous devez passer par ces « agrégateurs », renseignez-vous avec une vigilance particulière sur leur fiabilité et examinez attentivement la façon dont ils utilisent vos données.

Consignez et examinez les données transmises aux serveurs MCP tiers

Chaque serveur MCP définit ses propres outils. Ceux-ci peuvent demander des données que vous ne souhaitez pas partager avec l’hébergeur du serveur. C’est pourquoi l’outil MCP de l’API Responses exige par défaut une approbation pour chaque appel d’outil MCP. Lors du développement de votre application, vérifiez soigneusement et systématiquement la nature des données transmises à ces serveurs MCP. Lorsque vous estimez pouvoir faire confiance à un serveur, vous pouvez désactiver ces approbations pour réduire la latence d’exécution.

Nous vous recommandons également de consigner toutes les données envoyées aux serveurs MCP. Si vous utilisez l’API Responses avec store=true, l’API conserve déjà ces données dans ses journaux pendant 30 jours, sauf si votre organisation a activé la politique de non-conservation des données. Vous pouvez aussi les consigner dans vos propres systèmes et examiner régulièrement ces journaux pour vérifier que les données partagées correspondent à vos attentes.

Des serveurs MCP malveillants peuvent contenir des instructions cachées visant à provoquer un comportement inattendu des modèles OpenAI. Il s’agit d’attaques par injection de prompt. OpenAI a intégré des protections qui aident à détecter et à bloquer ces menaces. Il reste essentiel d’examiner attentivement les entrées et les sorties et de vous connecter uniquement à des serveurs de confiance.

Les serveurs MCP peuvent modifier leurs outils de manière imprévue, ce qui peut entraîner un comportement indésirable ou malveillant.

Incidences sur la politique de non-conservation des données et la résidence des données

L’outil MCP est compatible avec la politique de non-conservation des données et la résidence des données. Les serveurs MCP sont toutefois des services tiers. Les données que vous leur envoyez sont soumises à leurs propres politiques de conservation et de résidence des données.

Par exemple, si votre organisation bénéficie de la résidence des données en Europe, OpenAI effectue l’inférence et stocke le contenu client exclusivement en Europe jusqu’à l’envoi d’une communication ou de données au serveur MCP. Il vous appartient de vérifier que le serveur MCP respecte lui aussi vos éventuelles exigences en matière de politique de non-conservation des données ou de résidence des données. Pour en savoir plus sur ces deux sujets, consultez le guide sur vos données.

Notes d’utilisation

Disponibilité par API	Limites de débit	Notes
Responses Chat Completions Assistants	Build 1 000 requêtes/min Launch et Grow 2 000 requêtes/min	Tarifs Politique de non-conservation des données (ZDR) et résidence des données

Disponibilité par API

Limites de débit

Notes

Responses

Chat Completions

Assistants

Build
1 000 requêtes/min

Launch et Grow
2 000 requêtes/min

Tarifs
Politique de non-conservation des données (ZDR) et résidence des données

Suggestions

Premiers pas

Notions fondamentales

SDK et CLI

Fournisseurs de services cloud

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

API Agents

Agents SDK

ChatKit

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Créer des applications vocales

Connexions

Traitement audio

Mise en production

Performances et qualité

Évaluation

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts clés

Planification

Développement

Tests et publication

Spécifications de conversion

Guides

Ressources

Identité

Utilisation du forfait ChatGPT

Guides

Envoi de fichiers

API

Mesure des performances

API pour les annonceurs

Référence de l’API

Premiers pas

Premiers pas

Notions de base

Explorer

Disponible sur

Versions

Workflows

Capacités

Sites

dots

Espace ChatGPT

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendre les fonctionnalités de ChatGPT et de Codex

Linux

Windows

Workflows de développement

Extensions et automatisation

Environnements

Codex Cloud

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Premiers pas

Configuration des fonctionnalités

Identité et accès