Création de serveurs MCP pour les plugins et les intégrations API

Model Context Protocol (MCP) est un protocole ouvert qui s’impose comme la norme du secteur pour enrichir les modèles d’IA avec des outils et des connaissances supplémentaires. Les serveurs MCP distants permettent de connecter les modèles à de nouvelles sources de données et fonctionnalités via Internet.

Dans ce guide, nous verrons comment créer un serveur MCP distant qui lit les données d’une source privée (une base vectorielle) et les rend accessibles via un plugin dans ChatGPT et Codex, via la recherche approfondie et les connaissances de l’entreprise dans ChatGPT, ainsi que via l’API.

Remarque : pour créer un plugin avec un serveur MCP, commencez par la documentation des plugins : Démarrage rapide, Créez votre serveur MCP, Connectez et testez votre plugin et Authentification. Si votre serveur MCP n’a pas besoin d’interface utilisateur, vous pouvez exposer des outils sans ressources d’interface utilisateur.

Configurez une source de données

Vous pouvez alimenter un serveur MCP distant avec des données de n’importe quelle source, mais pour simplifier, nous utiliserons les bases vectorielles de l’API OpenAI. Commencez par importer un document PDF dans une nouvelle base vectorielle. Vous pouvez par exemple utiliser ce livre du XIXe siècle sur les chats, qui appartient au domaine public.

Vous pouvez importer des fichiers et créer une base vectorielle dans le tableau de bord, ou effectuer ces opérations via l’API. Suivez le guide des bases vectorielles pour configurer une base vectorielle et y importer un fichier.

Notez l’identifiant unique de la base vectorielle pour l’utiliser dans l’exemple qui suit.

Créez un serveur MCP

Créez ensuite un serveur MCP distant capable d’effectuer des recherches dans notre base vectorielle et de renvoyer le contenu des documents à partir de l’identifiant d’un fichier.

Dans cet exemple, nous allons créer notre serveur MCP avec Python et FastMCP. Vous trouverez une implémentation complète du serveur à la fin de cette section, ainsi que les instructions pour l’exécuter dans un environnement de développement accessible depuis un navigateur.

Il existe également d’autres frameworks de serveurs MCP pour différents langages de programmation. Quel que soit le framework choisi, les définitions des outils de votre serveur devront respecter la structure décrite ici.

Pour fonctionner avec la recherche approfondie et les connaissances de l’entreprise dans ChatGPT, votre serveur MCP doit implémenter deux outils en lecture seule : search et fetch, en utilisant le schéma de compatibilité décrit dans Compatibilité avec les connaissances de l’entreprise. Cette même interface est utile pour les workflows de recherche via l’API.

Déclarez un schéma de sortie pour chaque outil afin que les clients puissent valider la structure du résultat. Dans FastMCP, les modèles de retour typés peuvent générer ce schéma automatiquement ; l’exemple ci-dessous transmet explicitement output_schema à partir de ces mêmes modèles.

Outil search

L’outil search renvoie une liste de résultats de recherche pertinents issus de la source de données de votre serveur MCP, à partir de la requête d’un utilisateur.

Arguments :

Une seule chaîne de caractères contenant la requête.

Valeur de retour :

Un objet avec une seule clé, results, dont la valeur est un tableau d’objets représentant les résultats. Chaque objet de résultat doit inclure :

• id - un identifiant unique pour le document ou l’élément trouvé
• title - un titre lisible par un humain.
• url - l’URL canonique à utiliser pour citer la source.

Dans MCP, renvoyez cet objet dans structuredContent et incluez la même valeur sous forme de chaîne encodée en JSON dans le tableau content pour assurer la compatibilité.

La réponse finale de l’outil doit ressembler à ceci :

1234567891011{
  "structuredContent": {
    "results": [{ "id": "doc-1", "title": "...", "url": "..." }]
  },
  "content": [
    {
      "type": "text",
      "text": "{\"results\":[{\"id\":\"doc-1\",\"title\":\"...\",\"url\":\"...\"}]}"
    }
  ]
}

Outil fetch

L’outil fetch permet de récupérer le contenu intégral d’un document ou d’un élément trouvé lors d’une recherche.

Arguments :

Une chaîne de caractères qui identifie de manière unique le document trouvé.

Valeur de retour :

Un seul objet avec les propriétés suivantes :

• id - un identifiant unique pour le document ou l’élément trouvé
• title - le titre de l’élément trouvé, sous forme de chaîne de caractères
• text - le texte intégral du document ou de l’élément
• url - une URL vers le document ou l’élément trouvé. Utile pour citer des ressources précises dans une recherche.
• metadata - des données facultatives sur le résultat, sous forme de paires clé/valeur

Dans MCP, renvoyez cet objet dans structuredContent et incluez la même valeur sous forme de chaîne encodée en JSON dans le tableau content pour assurer la compatibilité.

La réponse finale de l’outil doit ressembler à ceci :

123456789101112131415{
  "structuredContent": {
    "id": "doc-1",
    "title": "...",
    "text": "full text...",
    "url": "https://example.com/doc",
    "metadata": { "source": "vector_store" }
  },
  "content": [
    {
      "type": "text",
      "text": "{\"id\":\"doc-1\",\"title\":\"...\",\"text\":\"full text...\",\"url\":\"https://example.com/doc\",\"metadata\":{\"source\":\"vector_store\"}}"
    }
  ]
}

Fonctionnement des citations

Pour les résultats de search comme pour les réponses de fetch, ChatGPT crée des métadonnées de citation uniquement lorsque url est une chaîne non vide. Un résultat avec un champ title mais sans champ url exploitable reste une sortie d’outil ordinaire au lieu de devenir une citation vide. Pour qu’un résultat puisse être cité, renvoyez son url canonique.

Par exemple, ChatGPT peut appeler search avec :

{ "query": "What is the quarterly plan?" }

Le serveur MCP peut répondre avec un résultat associé à une URL :

1234567891011121314151617{
  "structuredContent": {
    "results": [
      {
        "id": "quarterly-plan",
        "title": "Quarterly plan",
        "url": "https://example.com/quarterly-plan"
      }
    ]
  },
  "content": [
    {
      "type": "text",
      "text": "{\"results\":[{\"id\":\"quarterly-plan\",\"title\":\"Quarterly plan\",\"url\":\"https://example.com/quarterly-plan\"}]}"
    }
  ]
}

Dans cette réponse, le champ url contient une valeur, ce qui permet d’associer au résultat des métadonnées de citation. La requête elle-même ne déclenche pas le traitement des citations. Si le résultat ne contient pas de champ url, ou si sa valeur est vide ou n’est pas une chaîne de caractères, ChatGPT conserve le résultat comme une sortie d’outil ordinaire.

Exemple de serveur

Vous pouvez essayer cet exemple de serveur MCP dans un environnement de développement accessible depuis un navigateur. Configurez l’exemple avec vos propres identifiants d’API et les informations de votre base vectorielle.

Pour vous faciliter la tâche, vous trouverez également ci-dessous une implémentation complète des outils search et fetch avec FastMCP.

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211# Replace the illustrative IDs and URLs below with your own resource values.
"""
Sample MCP Server for ChatGPT Integration

This server implements the Model Context Protocol (MCP) with search and fetch
capabilities designed to work with ChatGPT's chat and deep research features.
"""

import logging
import os
from typing import Any

from fastmcp import FastMCP
from openai import OpenAI
from pydantic import BaseModel


class SearchResult(BaseModel):
    id: str
    title: str
    url: str


class SearchOutput(BaseModel):
    results: list[SearchResult]


class FetchOutput(BaseModel):
    id: str
    title: str
    text: str
    url: str
    metadata: dict[str, Any] | None = None


# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# OpenAI configuration
OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
VECTOR_STORE_ID = "vs_123"

# Initialize OpenAI client
openai_client = OpenAI(api_key=OPENAI_API_KEY)

server_instructions = """
This MCP server provides search and document retrieval capabilities
for ChatGPT Apps and deep research. Use the search tool to find relevant documents
based on keywords, then use the fetch tool to retrieve complete
document content with citations.
"""


def create_server():
    """Create and configure the MCP server with search and fetch tools."""

    # Initialize the FastMCP server
    mcp = FastMCP(name="Sample MCP Server", instructions=server_instructions)

    @mcp.tool(output_schema=SearchOutput.model_json_schema())
    async def search(query: str) -> SearchOutput:
        """
        Search for documents using OpenAI Vector Store search.

        This tool searches through the vector store to find semantically relevant matches.
        Returns a list of search results with basic information. Use the fetch tool to get
        complete document content.

        Args:
            query: Search query string. Natural language queries work best for semantic search.

        Returns:
            Dictionary with 'results' key containing list of matching documents.
            Each result includes id, title, and URL.
        """
        if not query or not query.strip():
            return SearchOutput(results=[])

        if not openai_client:
            logger.error("OpenAI client not initialized - API key missing")
            raise ValueError("OpenAI API key is required for vector store search")

        # Search the vector store using OpenAI API
        logger.info(f"Searching {VECTOR_STORE_ID} for query: '{query}'")

        response = openai_client.vector_stores.search(
            vector_store_id=VECTOR_STORE_ID, query=query
        )

        results = []

        # Process the vector store search results
        if hasattr(response, "data") and response.data:
            for i, item in enumerate(response.data):
                # Extract file_id, filename, and content
                item_id = getattr(item, "file_id", f"vs_{i}")
                item_filename = getattr(item, "filename", f"Document {i + 1}")

                result = SearchResult(
                    id=item_id,
                    title=item_filename,
                    url=f"https://platform.openai.com/storage/files/{item_id}",
                )

                results.append(result)

        logger.info(f"Vector store search returned {len(results)} results")
        return SearchOutput(results=results)

    @mcp.tool(output_schema=FetchOutput.model_json_schema())
    async def fetch(id: str) -> FetchOutput:
        """
        Retrieve complete document content by ID for detailed
        analysis and citation. This tool fetches the full document
        content from OpenAI Vector Store. Use this after finding
        relevant documents with the search tool to get complete
        information for analysis and proper citation.

        Args:
            id: File ID from vector store (file-xxx) or local document ID

        Returns:
            Complete document with id, title, full text content,
            optional URL, and metadata

        Raises:
            ValueError: If the specified ID is not found
        """
        if not id:
            raise ValueError("Document ID is required")

        if not openai_client:
            logger.error("OpenAI client not initialized - API key missing")
            raise ValueError(
                "OpenAI API key is required for vector store file retrieval"
            )

        logger.info(f"Fetching content from vector store for file ID: {id}")

        # Fetch file content from vector store
        content_response = openai_client.vector_stores.files.content(
            vector_store_id=VECTOR_STORE_ID, file_id=id
        )

        # Get file metadata
        file_info = openai_client.vector_stores.files.retrieve(
            vector_store_id=VECTOR_STORE_ID, file_id=id
        )

        # Extract content from paginated response
        file_content = ""
        if hasattr(content_response, "data") and content_response.data:
            # Combine all content chunks from FileContentResponse objects
            content_parts = []
            for content_item in content_response.data:
                if hasattr(content_item, "text"):
                    content_parts.append(content_item.text)
            file_content = "\n".join(content_parts)
        else:
            file_content = "No content available"

        # Use filename as title and create proper URL for citations
        filename = getattr(file_info, "filename", f"Document {id}")

        result = FetchOutput(
            id=id,
            title=filename,
            text=file_content,
            url=f"https://platform.openai.com/storage/files/{id}",
        )

        # Add metadata if available from file info
        if hasattr(file_info, "attributes") and file_info.attributes:
            result.metadata = dict(file_info.attributes)

        logger.info(f"Fetched vector store file: {id}")
        return result

    return mcp


def main():
    """Main function to start the MCP server."""
    logger.info(f"Using vector store: {VECTOR_STORE_ID}")

    # Create the MCP server
    server = create_server()

    # Configure and start the server
    logger.info("Starting MCP server on 0.0.0.0:8000")
    logger.info("Server will be accessible via SSE transport")

    try:
        # Use FastMCP's built-in run method with SSE transport
        port = int(os.environ.get("OPENAI_EXAMPLE_PORT", "8000"))
        server.run(
            transport="sse",
            host="0.0.0.0",
            port=port,
            uvicorn_config={"loop": "asyncio"},
        )
    except KeyboardInterrupt:
        logger.info("Server stopped by user")
    except Exception as e:
        logger.error(f"Server error: {e}")
        raise


if __name__ == "__main__":
    main()

https://777xxx.janeway.replit.dev/sse/

Testez et connectez votre serveur MCP

Vous pouvez tester votre serveur MCP avec un modèle de recherche approfondie dans le tableau de bord des prompts. Créez un prompt ou modifiez-en un existant, puis ajoutez un nouvel outil MCP à sa configuration. Cet exemple de compatibilité expose uniquement les outils search et fetch en lecture seule ; sa requête API ne demande donc pas d’approbation pour ces outils. Gardez l’approbation activée pour les outils capables de modifier des données ou d’effectuer d’autres actions aux conséquences importantes.

Si vous testez ce serveur dans le cadre d’un plugin, suivez le guide Connectez et testez votre plugin.

Une fois votre serveur MCP configuré, vous pouvez discuter avec un modèle qui l’utilise depuis l’interface des prompts.

Vous pouvez tester le serveur MCP directement avec l’API Responses en envoyant une requête comme celle-ci :

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
38
39
40
41curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
  "model": "gpt-5.6-sol",
  "input": [
    {
      "role": "developer",
      "content": [
        {
          "type": "input_text",
          "text": "You are a research assistant that searches MCP servers to find answers to your questions."
        }
      ]
    },
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "Are cats attached to their homes? Give a succinct one page overview."
        }
      ]
    }
  ],
  "reasoning": {
    "summary": "auto"
  },
  "tools": [
    {
      "type": "mcp",
      "server_label": "cats",
      "server_url": "https://777ff573-9947-4b9c-8982-658fa40c7d09-00-3le96u7wsymx.janeway.replit.dev/sse/",
      "allowed_tools": [
        "search",
        "fetch"
      ],
      "require_approval": "never"
    }
  ]
}'

Gérez l’authentification

Lorsque vous développez un serveur MCP distant personnalisé, l’autorisation et l’authentification vous aident à protéger vos données. Nous recommandons d’utiliser OAuth avec les documents de métadonnées d’identifiant client pour l’enregistrement des clients, lorsque votre serveur d’autorisation prend en charge CIMD et que le créateur du plugin choisit cette méthode. ChatGPT prend en charge CIMD avec l’échange de tokens pour les clients publics (none) ou l’échange de tokens avec une assertion client signée (private_key_jwt). L’enregistrement dynamique des clients reste pris en charge lorsqu’il est configuré. Pour connaître les exigences d’authentification des plugins, consultez Authentification. Pour en savoir plus sur le protocole, consultez le guide d’utilisation de MCP ou la spécification d’autorisation.

Si vous connectez votre serveur MCP distant personnalisé via un plugin, les utilisateurs de votre espace de travail suivront un parcours OAuth pour accéder à votre service.

Connectez votre serveur dans ChatGPT

1. Dans ChatGPT, ouvrez Paramètres → Sécurité et connexion et activez le Mode développeur.
2. Accédez aux Plugins ChatGPT, sélectionnez le bouton plus, puis connectez votre serveur à l’aide de son URL en mode développeur.
3. Testez votre plugin en exécutant des prompts dans la discussion et la recherche approfondie.

Pour connaître les étapes de configuration détaillées, consultez Connectez et testez votre plugin.

Risques et sécurité

Les serveurs MCP personnalisés vous permettent de connecter votre espace de travail ChatGPT à des applications externes. ChatGPT peut ainsi accéder aux données de ces applications, en envoyer et en recevoir. Les serveurs MCP personnalisés ne sont ni développés ni vérifiés par OpenAI : il s’agit de services tiers soumis à leurs propres conditions générales.

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

Risques liés aux attaques par injection de prompt

Une attaque par injection de prompt consiste à insérer des instructions malveillantes dans un contenu que l’un de nos modèles est susceptible de rencontrer, par exemple une page web, afin de détourner ChatGPT de son comportement prévu. Si le modèle suit les instructions injectées, il peut effectuer des actions que ni l’utilisateur ni le développeur n’avaient souhaitées, notamment envoyer des données privées vers une destination externe.

Par exemple, vous pourriez demander à ChatGPT de trouver un restaurant pour un dîner de groupe en consultant votre calendrier et vos e-mails récents. Au cours de ses recherches, il pourrait rencontrer un commentaire malveillant, c’est-à-dire un contenu conçu pour tromper l’agent et lui faire effectuer des actions non souhaitées, lui demandant de récupérer un code de réinitialisation de mot de passe dans Gmail et de l’envoyer à un site web malveillant.

Le tableau ci-dessous présente des scénarios concrets à prendre en compte. Nous vous recommandons de l’examiner attentivement pour décider en connaissance de cause si vous souhaitez utiliser des serveurs MCP personnalisés.

Risques sans lien avec les attaques par injection de prompt

Les serveurs MCP personnalisés présentent d’autres risques, sans lien avec les attaques par injection de prompt :

• Les actions d’écriture peuvent accroître à la fois l’utilité des serveurs MCP et les risques qu’ils présentent, car elles permettent au serveur d’effectuer des actions potentiellement destructrices, au lieu de simplement renvoyer des informations à ChatGPT. À l’heure actuelle, ChatGPT exige une confirmation manuelle dans chaque conversation avant de pouvoir effectuer des actions d’écriture. Cette confirmation signale les données potentiellement sensibles. Vous ne devez toutefois utiliser les actions d’écriture que si vous avez soigneusement évalué et accepté la possibilité que ChatGPT commette une erreur lors d’une telle action. Des actions d’écriture peuvent se produire même si le serveur MCP les a marquées comme étant en lecture seule. Il est donc d’autant plus important de faire confiance au serveur MCP personnalisé avant de le déployer dans ChatGPT.
• Tout serveur MCP peut recevoir des données sensibles dans les requêtes qui lui sont adressées. Même s’il n’est pas malveillant, le serveur aura accès à toutes les données fournies par ChatGPT au cours de l’interaction, y compris, potentiellement, des données sensibles que l’utilisateur aurait communiquées auparavant à ChatGPT. Ces données pourraient, par exemple, figurer dans les requêtes que ChatGPT envoie au serveur MCP lors de l’utilisation de la recherche approfondie ou des outils d’applications dans la discussion.

Connexion à des serveurs de confiance

Nous vous recommandons de ne vous connecter à un serveur MCP personnalisé que si vous connaissez l’application sous-jacente et lui faites confiance.

Par exemple, choisissez des serveurs officiels hébergés par les fournisseurs de services eux-mêmes. Connectez-vous au serveur Stripe hébergé par Stripe à l’adresse mcp.stripe.com plutôt qu’à un serveur MCP Stripe non officiel hébergé par un tiers. Comme il existe encore peu de serveurs MCP officiels, vous pouvez envisager un serveur hébergé par une organisation qui relaie les requêtes vers un autre service via une API. Ne vous connectez qu’après avoir examiné la façon dont cette organisation utilise vos données et vérifié que vous pouvez faire confiance au serveur. Lorsque vous développez votre propre serveur MCP et vous y connectez, vérifiez bien qu’il s’agit du bon serveur. Soyez attentif aux données que vous fournissez en réponse aux requêtes et à la façon dont vous traitez celles qui vous sont envoyées lorsqu’OpenAI appelle votre serveur MCP.

Votre serveur MCP distant permet à d’autres personnes de connecter OpenAI à vos services. OpenAI peut ainsi accéder aux données de ces services, en envoyer, en recevoir et y effectuer des actions. Évitez d’inclure des informations sensibles dans le JSON de vos outils et de stocker des informations sensibles provenant des utilisateurs de ChatGPT qui accèdent à votre serveur MCP distant.

Lorsque vous développez un serveur MCP, n’incluez aucun contenu malveillant dans les définitions de vos outils.