Serveurs MCP | OpenAI API

En plus des outils que vous mettez à la disposition du modèle avec l’appel de fonction, vous pouvez lui donner de nouvelles capacités grâce aux serveurs MCP distants ou au Tunnel MCP sécurisé. Ces outils permettent au modèle de se connecter à des services externes et de les contrôler lorsque cela est nécessaire pour répondre au prompt d’un utilisateur. Vous pouvez autoriser automatiquement ces appels d’outils ou les soumettre à votre approbation explicite en tant que développeur.

Les serveurs MCP distants peuvent être n’importe quels serveurs accessibles sur l’Internet public qui implémentent un serveur distant conforme au Model Context Protocol (MCP).
Le Tunnel MCP sécurisé 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 connecteurs intégrés restent pris en charge pour les modèles existants ; consultez la section Anciens connecteurs pour connaître la politique de dépréciation et voir des exemples de compatibilité. Pour les sessions de l’API Agents, consultez la section Connexions MCP, qui traite des connexions depuis le service géré ou depuis votre bac à sable.

Tunnel MCP sécurisé

Si votre serveur MCP est privé, hébergé sur site ou derrière un pare-feu, utilisez le tunnel MCP sécurisé 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. Définissez server_url pour un serveur MCP distant, ou utilisez tunnel_id pour un serveur MCP local via le Tunnel MCP sécurisé. Selon le serveur, vous devrez peut-être aussi fournir un token d’accès OAuth dans le paramètre authorization.

Utilisation d’un serveur MCP distant dans 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": "dmcp",
        "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
        "server_url": "https://dmcp-server.deno.dev/mcp",
        "require_approval": "never"
      }
    ],
    "input": "Roll 2d4+1"
  }'

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: "dmcp",
      server_description:
        "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never",
    },
  ],
  input: "Roll 2d4+1",
});

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": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/mcp",
            "require_approval": "never",
        },
    ],
    input="Roll 2d4+1",
)

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("dmcp")
	tool.OfMcp.ServerDescription = openai.String("A Dungeons and Dragons MCP server to assist with dice rolling.")
	tool.OfMcp.ServerURL = openai.String("https://dmcp-server.deno.dev/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("Roll 2d4+1")},
	})
	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("Roll 2d4+1")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("dmcp")
                .serverDescription(
                    "A Dungeons and Dragons MCP server to assist with dice rolling.")
                .serverUrl("https://dmcp-server.deno.dev/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: "dmcp",
        serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));

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: "dmcp",
      server_description: "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never"
    }
  ],
  input: "Roll 2d4+1"
)

puts(response.output_text)

Il est essentiel que les développeurs n’utilisent avec l’API Responses que des serveurs MCP distants auxquels ils font confiance. Un serveur malveillant peut exfiltrer des données sensibles à partir de tout ce 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 envoie d’abord une requête pour obtenir la liste des outils disponibles sur ce serveur, ce qui crée un élément de sortie mcp_list_tools. Dans l’exemple de serveur MCP distant ci-dessus, cet élément ne contient qu’une seule définition d’outil :

1234567891011121314151617181920212223{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "dmcp",
  "tools": [
    {
      "annotations": null,
      "description": "Given a string of text describing a dice roll...",
      "input_schema": {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "type": "object",
        "properties": {
          "diceRollExpression": {
            "type": "string"
          }
        },
        "required": ["diceRollExpression"],
        "additionalProperties": false
      },
      "name": "roll"
    }
  ]
}

Si le modèle décide d’appeler l’un des outils disponibles sur le serveur MCP, vous trouverez également un élément de sortie mcp_call indiquant ce que le modèle a envoyé à l’outil MCP et ce que celui-ci a renvoyé en sortie.

12345678910{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"diceRollExpression\":\"2d4 + 1\"}",
  "error": null,
  "name": "roll",
  "output": "4",
  "server_label": "dmcp"
}

Poursuivez la lecture de ce guide pour en savoir plus sur le fonctionnement de l’outil MCP, le filtrage des outils disponibles et la gestion des demandes d’approbation des appels d’outils.

Fonctionnement

L’outil MCP est disponible dans l’API Responses pour la plupart des modèles récents. Vérifiez ici la compatibilité de votre modèle avec l’outil MCP. Lorsque vous utilisez cet outil, vous ne payez que les tokens utilisés lors de l’importation des définitions d’outils ou des appels d’outils. Aucun frais supplémentaire ne s’applique par appel d’outil.

Nous allons détailler ci-dessous les étapes suivies par l’API lors de l’appel d’un outil MCP.

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

Lorsque vous spécifiez 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 le protocole de transport Streamable HTTP ou HTTP/SSE.

Si la liste des outils est récupérée avec succès, 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 indique les outils importés avec succès.

1234567891011121314151617181920212223{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "dmcp",
  "tools": [
    {
      "annotations": null,
      "description": "Given a string of text describing a dice roll...",
      "input_schema": {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "type": "object",
        "properties": {
          "diceRollExpression": {
            "type": "string"
          }
        },
        "required": ["diceRollExpression"],
        "additionalProperties": false
      },
      "name": "roll"
    }
  ]
}

Tant que l’élément mcp_list_tools est présent dans le contexte d’une requête API, l’API ne récupère pas à nouveau la liste des outils du serveur MCP à chaque tour d’une conversation. Nous vous recommandons de conserver cet élément dans le contexte du modèle lors de chaque conversation ou exécution de workflow afin de réduire la latence.

Filtrage des outils

Certains serveurs MCP peuvent proposer des dizaines d’outils. En exposer un grand nombre au modèle peut entraîner des coûts et une latence élevés. Si seuls certains des outils exposés par un serveur MCP vous intéressent, vous pouvez utiliser le paramètre allowed_tools pour n’importer que ceux-ci.

Limitez les 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": "dmcp",
        "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
        "server_url": "https://dmcp-server.deno.dev/mcp",
        "require_approval": "never",
        "allowed_tools": ["roll"]
      }
    ],
    "input": "Roll 2d4+1"
  }'

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: "dmcp",
      server_description:
        "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: "never",
      allowed_tools: ["roll"],
    },
  ],
  input: "Roll 2d4+1",
});

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": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/mcp",
            "require_approval": "never",
            "allowed_tools": ["roll"],
        }
    ],
    input="Roll 2d4+1",
)

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("dmcp")
	tool.OfMcp.ServerDescription = openai.String("A Dungeons and Dragons MCP server to assist with dice rolling.")
	tool.OfMcp.ServerURL = openai.String("https://dmcp-server.deno.dev/mcp")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}
	tool.OfMcp.AllowedTools = responses.ToolMcpAllowedToolsUnionParam{OfMcpAllowedTools: []string{"roll"}}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-6-astra",
		Tools: []responses.ToolUnionParam{tool},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Roll 2d4+1")},
	})
	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("Roll 2d4+1")
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("dmcp")
                .serverDescription(
                    "A Dungeons and Dragons MCP server to assist with dice rolling.")
                .serverUrl("https://dmcp-server.deno.dev/mcp")
                .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER)
                .allowedToolsOfMcp(List.of("roll"))
                .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: "dmcp",
        serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),
        allowedTools: new McpToolFilter() { ToolNames = { "roll" } },
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));

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: "Roll 2d4+1",
  tools: [
    {
      type: :mcp,
      server_label: "dmcp",
      server_description: "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/mcp",
      require_approval: :never,
      allowed_tools: ["roll"]
    }
  ]
)

puts(response.output_text)

Étape 2 : Appel des outils

Une fois que le modèle a accès à ces définitions d’outils, il peut choisir de les appeler en fonction de son contexte. Lorsque le modèle décide d’appeler un outil MCP, l’API envoie une requête au serveur MCP distant pour appeler l’outil et intégrer sa sortie au contexte du modèle. Cela crée un élément mcp_call qui se présente ainsi :

12345678910{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"diceRollExpression\":\"2d4 + 1\"}",
  "error": null,
  "name": "roll",
  "output": "4",
  "server_label": "dmcp"
}

Cet élément contient à la fois les arguments que le modèle a choisi d’utiliser pour cet appel d’outil et la valeur output renvoyée par le serveur MCP distant. Tous les modèles peuvent choisir d’effectuer plusieurs appels d’outils MCP. Plusieurs de ces éléments peuvent donc être générés au cours d’une seule requête API.

En cas d’échec d’un appel d’outil, le champ error de cet élément contient des erreurs de protocole MCP, des erreurs d’exécution d’outils MCP ou des erreurs générales de connectivité. Les erreurs MCP sont documentées ici dans la spécification MCP.

Approbations

Par défaut, OpenAI demande votre approbation avant de partager des données avec un connecteur ou un serveur MCP distant. Les approbations vous permettent de garder le contrôle et la visibilité sur 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 et, si vous le souhaitez, de les consigner dans des journaux. Une demande d’approbation pour un appel d’outil MCP crée dans la sortie de l’objet Response un élément mcp_approval_request qui se présente ainsi :

1234567{
  "id": "mcpr_68a619e1d82c8190b50c1ccba7ad18ef0d2d23a86136d339",
  "type": "mcp_approval_request",
  "arguments": "{\"diceRollExpression\":\"2d4 + 1\"}",
  "name": "roll",
  "server_label": "dmcp"
}

Vous pouvez ensuite répondre à cette demande en créant un nouvel objet Response et en y ajoutant un élément mcp_approval_response.

Approbation de l’utilisation 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": "dmcp",
        "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
        "server_url": "https://dmcp-server.deno.dev/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
26
27import OpenAI from "openai";
const client = new OpenAI();

const resp = await client.responses.create({
  model: "gpt-6-astra",
  tools: [
    {
      type: "mcp",
      server_label: "dmcp",
      server_description:
        "A Dungeons and Dragons MCP server to assist with dice rolling.",
      server_url: "https://dmcp-server.deno.dev/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": "dmcp",
            "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
            "server_url": "https://dmcp-server.deno.dev/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("dmcp")
	tool.OfMcp.ServerDescription = openai.String("A Dungeons and Dragons MCP server to assist with dice rolling.")
	tool.OfMcp.ServerURL = openai.String("https://dmcp-server.deno.dev/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("dmcp")
                .serverDescription("A Dungeons and Dragons MCP server.")
                .serverUrl("https://dmcp-server.deno.dev/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
31using 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: "dmcp",
        serverUri: new Uri("https://dmcp-server.deno.dev/mcp"),
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.AlwaysRequireApproval
    )
);

// Step 1: Create a response that requests tool-call approval.
options.InputItems.Add(ResponseItem.CreateUserMessageItem("Roll 2d4+1"));
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.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: "dmcp",
      server_url: "https://dmcp-server.deno.dev/mcp",
      server_description: "A Dungeons and Dragons MCP server.",
      require_approval: :always
    }
  ]
)

puts(response.output_text)

Ici, nous utilisons le paramètre previous_response_id pour relier cette nouvelle réponse à la réponse précédente, qui a généré la demande d’approbation. Vous pouvez aussi transmettre les sorties d’une réponse comme entrées d’une autre afin de contrôler au mieux ce qui entre dans le contexte du modèle.

Si vous estimez pouvoir faire confiance à un serveur MCP distant, vous pouvez choisir de vous passer des approbations afin de réduire la latence. Pour cela, définissez le paramètre require_approval de l’outil MCP sur un objet qui répertorie uniquement les outils pour lesquels vous souhaitez supprimer les approbations, comme dans l’exemple ci-dessous. Vous pouvez également lui attribuer la valeur 'never' pour supprimer les approbations pour tous les outils de ce serveur MCP distant.

N’exigez jamais d’approbation 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

Contrairement au serveur MCP utilisé dans l’exemple ci-dessus, la plupart des autres serveurs MCP nécessitent une authentification. La méthode la plus courante repose sur un token d’accès OAuth. Fournissez ce token dans le champ authorization de l’outil MCP :

Utilisez 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 tokens sensibles, l’API Responses ne stocke pas la valeur que vous fournissez dans le champ authorization. Cette valeur n’est pas non plus visible dans l’objet Response créé. Vous devez donc envoyer la valeur authorization dans chaque requête de création que vous adressez à l’API Responses.

Anciens connecteurs

Le paramètre connector_id est déprécié 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 le Tunnel MCP sécurisé. Les modèles existants continuent de prendre en charge les connecteurs. Les exemples de cette section utilisent gpt-5.2, qui a été publié avant cette date limite.

L’API Responses prend en charge de manière native un ensemble limité de connecteurs à des services tiers. Ces connecteurs vous permettent de récupérer du contexte depuis des applications populaires, comme Dropbox et Gmail, afin que le modèle puisse interagir avec des services populaires.

Les connecteurs s’utilisent de la même manière que les serveurs MCP distants. Tous deux permettent à un modèle OpenAI d’accéder à des outils tiers supplémentaires dans une requête API. Toutefois, au lieu de transmettre un paramètre server_url comme pour appeler un serveur MCP distant, vous transmettez un paramètre connector_id qui identifie de façon unique un connecteur disponible dans l’API.

Les connecteurs nécessitent un token d’accès OAuth fourni par votre application dans le paramètre authorization.

Utilisez 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 Calendar : connector_googlecalendar
Google Drive : connector_googledrive
Microsoft Teams : connector_microsoftteams
Outlook Calendar : connector_outlookcalendar
Outlook Email : connector_outlookemail
SharePoint : connector_sharepoint

Nous avons privilégié les services qui ne disposent pas de serveurs MCP distants officiels. GitHub, par exemple, dispose d’un serveur MCP officiel auquel vous pouvez vous connecter en passant https://api.githubcopilot.com/mcp/ dans le champ server_url de l’outil MCP.

Autorisation d’un connecteur

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

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

Pour tester les fonctionnalités des connecteurs dans l’API à l’aide du Playground, commencez par saisir :

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

Cette portée d’autorisation permettra à l’API de lire les événements de Google Calendar. Saisissez-la dans l’interface, sous « Étape 1 : Sélectionnez et autorisez les API ».

Après avoir autorisé l’application à accéder à votre compte Google, vous arriverez à l’ Étape 2 : Échangez le code d’autorisation contre des tokens. Cette étape générera un token d’accès que vous pourrez utiliser dans une requête API avec le connecteur Google Calendar :

Utilisez le connecteur Google Calendar

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 provenant d’un connecteur se présente comme un appel d’outil MCP provenant d’un serveur MCP distant : il utilise le type d’élément de sortie mcp_call. Dans ce cas, les arguments transmis au connecteur et sa réponse 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 dans chaque connecteur

Les outils disponibles dépendent des portées accordées à votre jeton OAuth. Développez les tableaux ci-dessous pour découvrir les outils que vous pouvez utiliser lorsque vous vous connectez à chaque application.

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

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

Outil	Description	Portées
`get_profile`	Renvoie le profil de l’utilisateur actuel de Calendar	userinfo.email, userinfo.profile
`search`	Recherche des événements Calendar, avec la possibilité de limiter la recherche à une période donnée	calendar.events
`fetch`	Obtient les détails d’un seul événement Calendar	calendar.events
`search_events`	Recherche des événements Calendar à l’aide de filtres	calendar.events
`read_event`	Lit un événement Google Calendar à partir de son identifiant	calendar.events

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

Outil	Description	Portées
`search`	Effectue une recherche dans les discussions et les messages des canaux Microsoft Teams	Chat.Read, ChannelMessage.Read.All
`fetch`	Récupère un message Teams à partir de son chemin	Chat.Read, ChannelMessage.Read.All
`get_chat_members`	Liste les membres d’une discussion Teams	Chat.Read
`get_profile`	Renvoie le profil de l’utilisateur authentifié dans Teams	User.Read

Outil	Description	Portées
`search_events`	Recherche des événements Outlook Calendar à l’aide de filtres de date	Calendars.Read
`fetch_event`	Récupère les détails d’un seul événement	Calendars.Read
`fetch_events_batch`	Récupère plusieurs événements en un seul appel	Calendars.Read
`list_events`	Liste les événements du calendrier compris dans une plage de dates	Calendars.Read
`get_profile`	Récupère le profil de l’utilisateur actuel	User.Read

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

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

Différez le chargement des outils d’un serveur MCP

Si vous utilisez la recherche d’outils, vous pouvez différer le chargement des fonctions exposées par un serveur MCP jusqu’à ce que le modèle décide qu’il en a besoin. Pour cela, définissez defer_loading: true dans la définition de l’outil du serveur MCP.

Lorsque vous différez le chargement d’un serveur MCP, le modèle peut toujours utiliser le libellé et la description du serveur pour décider quand y effectuer une recherche, mais les définitions des différentes fonctions ne sont chargées qu’en cas de besoin. Cela peut contribuer à réduire la consommation globale de tokens et s’avère particulièrement utile pour les serveurs MCP qui exposent un grand nombre de fonctions.

1
2
3
4
5
6
7
8{
    "type": "mcp",
    "server_label": "dmcp",
    "server_description": "A Dungeons and Dragons MCP server to assist with dice rolling.",
    "server_url": "https://dmcp-server.deno.dev/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é puissante comporte certains risques.

Avec les connecteurs, vous risquez d’envoyer des données sensibles à OpenAI ou d’accorder 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 et n’ont pas été vérifiés par OpenAI. Ils peuvent permettre aux modèles d’accéder à des données, d’en envoyer et d’en recevoir, ainsi que d’effectuer des actions dans ces services. Tous les serveurs MCP sont des services tiers soumis à leurs propres conditions générales.

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

Voici quelques bonnes pratiques à prendre en compte lors de l’intégration de connecteurs et de serveurs MCP distants.

Attaque par injection de prompt

L’attaque par injection de prompt est un risque de sécurité important à prendre en compte dans toute application utilisant un LLM, en particulier lorsque vous donnez au modèle accès à des serveurs MCP et à des connecteurs capables d’accéder à des données sensibles ou d’effectuer des actions. Si le prompt destiné au modèle contient du contenu fourni par l’utilisateur, utilisez ces outils avec la prudence et les mesures de protection nécessaires.

Exigez toujours une approbation pour les actions sensibles

Utilisez les configurations disponibles pour les paramètres require_approval et allowed_tools afin de garantir que toute action sensible passe par un processus d’approbation.

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

Il peut être dangereux d’envoyer des requêtes aux URL ou d’intégrer les URL d’images fournies dans les résultats d’appels d’outils, qu’ils proviennent de connecteurs ou de serveurs MCP distants. Assurez-vous de faire confiance aux domaines et aux services qui fournissent ces URL avant de les intégrer ou de les utiliser d’une autre manière dans le code de votre application.

Connexion à des serveurs de confiance

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

Journalisez et examinez les données partagées avec les serveurs MCP tiers.

Les serveurs MCP définissent eux-mêmes leurs outils et peuvent donc demander des données que vous ne souhaitez pas nécessairement partager avec leur hébergeur. 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, examinez attentivement et rigoureusement les types de données partagées avec ces serveurs MCP. Une fois que vous estimez pouvoir faire confiance au serveur MCP, vous pouvez vous passer de ces approbations pour réduire la latence d’exécution.

Nous recommandons également de journaliser toutes les données envoyées aux serveurs MCP. Si vous utilisez l’API Responses avec store=true, ces données sont déjà journalisées via l’API pendant 30 jours, sauf si la politique de non-conservation des données est activée pour votre organisation. Vous pouvez aussi journaliser ces données dans vos propres systèmes et les examiner régulièrement pour vérifier que leur partage correspond à vos attentes.

Les serveurs MCP malveillants peuvent inclure des instructions cachées (attaques par injection de prompt) conçues pour provoquer des comportements inattendus chez les modèles OpenAI. Bien qu’OpenAI ait intégré des protections pour aider à détecter et à bloquer ces menaces, il est essentiel d’examiner attentivement les entrées et les sorties, et de veiller à établir des connexions uniquement avec des serveurs de confiance.

Les serveurs MCP peuvent modifier le comportement des outils de manière inattendue, ce qui peut entraîner des comportements indésirables ou malveillants.

Conséquences pour 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. Toutefois, les serveurs MCP sont des services tiers : les données qui leur sont envoyées sont soumises à leurs propres politiques de conservation et de résidence des données.

Autrement dit, si votre organisation bénéficie de la résidence des données en Europe, OpenAI limite l’inférence et le stockage du Contenu client à l’Europe, jusqu’au moment où des communications ou des données sont envoyées au serveur MCP. Il vous incombe de vérifier que le serveur MCP respecte également vos éventuelles exigences en matière de non-conservation ou de résidence des données. Pour en savoir plus sur la politique de non-conservation des données et la résidence des données, consultez cette page.

Notes d’utilisation

Disponibilité dans les API	Limites de débit	Notes
Responses Chat Completions Assistants	Niveau 1 200 RPM Niveaux 2 et 3 1000 RPM Niveaux 4 et 5 2000 RPM	Tarifs ZDR et résidence des données

Disponibilité dans les API

Limites de débit

Notes

Responses

Chat Completions

Assistants

Niveau 1
200 RPM

Niveaux 2 et 3
1000 RPM

Niveaux 4 et 5
2000 RPM

Tarifs
ZDR et résidence des données

Suggestions

Bien démarrer

Concepts fondamentaux

SDK et CLI

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Conception de prompts

Raisonnement

Images et vidéo

Realtime et audio

Modèles spécialisés

API Agents

SDK Agents

ChatKit

Recherche et récupération

Connectez des outils et des données

Créez des flux de travail avec des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Développez avec la voix

Connexions

Traitement audio

Passez en production

Performances et qualité

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts fondamentaux

Plan

Build

Test and publish

Conversion specs

Guides

Ressources

Bien démarrer

Guides

File Upload

API

Measurement

Advertiser API

Référence de l’API

Bien démarrer

Fondamentaux

Explorer

Disponible sur

Versions

Flux de travail

Capacités

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendez les capacités de ChatGPT et de Codex

Linux

Windows

Flux de travail de développement

Étendre et automatiser

Environnements

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Bien démarrer

ChatGPT Work

Identité et authentification

Accès à l’espace de travail, stratégies et modèles

Contrôles des plugins et des connecteurs

Utilisation, gouvernance et conformité

Déploiement et fournisseurs de modèles

Communauté

Blog

Communauté

Blog