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

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

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

Remarque : pour créer un plugin avec un serveur MCP, commencez par consulter la documentation sur les plugins : Démarrage rapide, Création de votre serveur MCP, Connexion et test de votre plugin et Authentification. Si votre serveur MCP n’a pas besoin d’interface utilisateur, vous pouvez exposer ses outils sans fournir de ressources d’interface.

Configuration d’une source de données

Vous pouvez alimenter un serveur MCP distant avec des données de n’importe quelle source. Pour simplifier cet exemple, nous utiliserons les bases vectorielles de l’API OpenAI. Commencez par importer un document PDF dans une nouvelle base vectorielle. Vous pouvez utiliser ce livre du XIXᵉ siècle sur les chats, aujourd’hui dans le domaine public.

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

Notez l’identifiant unique de la base vectorielle. Vous en aurez besoin dans l’exemple qui suit.

Création d’un serveur MCP

Créez maintenant un serveur MCP distant capable d’effectuer des recherches dans la base vectorielle et de renvoyer le contenu d’un document à partir de son identifiant.

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

D’autres frameworks permettent de créer des serveurs MCP dans différents langages de programmation. Quel que soit le framework choisi, les définitions des outils de votre serveur doivent 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 suivant le schéma décrit dans la section Compatibilité avec les connaissances de l’entreprise. Cette interface convient également aux 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. Avec FastMCP, les modèles de retour typés peuvent générer ce schéma automatiquement. L’exemple ci-dessous utilise ces mêmes modèles pour fournir explicitement output_schema.

Outil search

L’outil search reçoit la requête d’un utilisateur et renvoie la liste des résultats pertinents trouvés dans la source de données de votre serveur MCP.

Arguments :

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

Valeur de retour :

Un objet contenant une seule clé, results, dont la valeur est un tableau d’objets. Chaque objet du tableau représente un résultat et doit contenir les champs suivants :

• id – identifiant unique du document ou de l’élément trouvé.
• title – titre lisible par l’utilisateur.
• url – URL canonique à utiliser pour citer le résultat.

Pour assurer la compatibilité avec les clients MCP, renvoyez cet objet dans structuredContent et incluez la même valeur sous forme de chaîne encodée en JSON dans le tableau de contenu.

La réponse finale de l’outil doit prendre la forme suivante :

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

Outil fetch

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

Arguments :

Une chaîne de caractères contenant l’identifiant unique du document trouvé.

Valeur de retour :

Un seul objet doté des propriétés suivantes :

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

Pour assurer la compatibilité avec les clients MCP, renvoyez cet objet dans structuredContent et incluez la même valeur sous forme de chaîne encodée en JSON dans le tableau de contenu.

La réponse finale de l’outil doit prendre la forme suivante :

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

Gestion 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 si url est une chaîne de caractères non vide. Si un résultat contient un title mais aucune url exploitable, ChatGPT le conserve comme résultat ordinaire de l’outil sans créer de citation vide. Pour permettre la citation d’un résultat, renvoyez son url canonique.

Par exemple, ChatGPT peut appeler search avec la requête suivante :

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

Le serveur MCP peut renvoyer un résultat accompagné d’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 URL, ce qui permet à ChatGPT de créer des métadonnées de citation pour le résultat. La requête à elle seule ne déclenche pas ce traitement. Si le champ url est absent, vide ou contient autre chose qu’une chaîne de caractères, ChatGPT conserve le résultat comme sortie ordinaire de l’outil.

Exemple de serveur

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

Vous trouverez également ci-dessous l’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 = openai_client.files.retrieve(file_id=id).filename

        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/

Test et connexion de votre serveur MCP

Vous pouvez tester votre serveur MCP avec gpt-6.1-sol dans le tableau de bord des prompts. Créez un prompt ou modifiez un prompt existant, puis ajoutez un outil MCP à sa configuration. Cet exemple de compatibilité expose uniquement les outils en lecture seule search et fetch. La requête API de l’exemple ne demande donc pas d’approbation pour ces outils. Gardez l’approbation activée pour les outils susceptibles 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 Connexion et test de 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 aussi 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-6.1-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"
    }
  ]
}'

Gestion de l’authentification

Lorsque vous créez un serveur MCP distant personnalisé, l’autorisation et l’authentification vous aident à protéger vos données. Pour enregistrer les clients, nous recommandons d’utiliser OAuth avec les documents de métadonnées d’identifiant client (CIMD) si votre serveur d’autorisation prend en charge cette méthode et que le créateur du plugin la choisit. ChatGPT prend en charge CIMD avec échange de jetons pour un client public (none) ou avec échange de jetons au moyen d’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 la section Authentification. Pour plus de détails 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 accéderont à votre service en suivant un parcours OAuth.

Connexion dans ChatGPT

1. Ouvrez la page des plugins de ChatGPT, sélectionnez le bouton plus, puis Ajouter un serveur MCP personnalisé.
2. Saisissez l’URL du serveur et les informations d’authentification. Lisez l’avertissement sur les risques et sélectionnez Je comprends et souhaite continuer, puis Créer en tant que plugin.
3. Installez votre plugin et testez-le en envoyant des prompts dans une discussion et en recherche approfondie.

Pour obtenir les instructions de configuration détaillées, consultez le guide Connexion et test de votre plugin.

Risques et sécurité

Les serveurs MCP personnalisés 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. Ces serveurs MCP sont des services tiers soumis à leurs propres conditions d’utilisation. OpenAI ne les développe pas et ne les vérifie pas.

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

Risques liés aux attaques par injection de prompt

Lors d’une attaque par injection de prompt, un attaquant insère des instructions malveillantes dans un contenu que l’un de nos modèles est susceptible de consulter, par exemple une page web. Son but est de détourner ChatGPT de son comportement prévu. Si le modèle suit ces instructions, il risque d’effectuer des actions que ni l’utilisateur ni le développeur n’avaient prévues, comme envoyer des données privées à un destinataire externe.

Par exemple, vous pourriez demander à ChatGPT de consulter votre agenda et vos e-mails récents pour trouver un restaurant où dîner en groupe. Au cours de ses recherches, ChatGPT pourrait rencontrer un commentaire malveillant conçu pour tromper l’agent et lui faire exécuter une action imprévue. Ce commentaire pourrait lui demander de récupérer un code de réinitialisation de mot de passe dans Gmail et de l’envoyer à un site malveillant.

Le tableau suivant présente plusieurs scénarios à prendre en compte. Nous vous recommandons de les examiner attentivement avant de décider d’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, indépendants des attaques par injection de prompt :

• Les opérations d’écriture peuvent rendre les serveurs MCP plus utiles et accroître les risques associés, car le serveur peut alors effectuer des opérations potentiellement destructrices en plus de fournir des informations à ChatGPT. Actuellement, dans toute conversation, ChatGPT exige une confirmation manuelle avant d’effectuer une opération d’écriture. La demande de confirmation signale les données potentiellement sensibles. N’utilisez ces opérations que si vous avez soigneusement évalué et accepté le risque que ChatGPT commette une erreur en les exécutant. Une opération d’écriture peut avoir lieu même si le serveur MCP l’a marquée comme étant en lecture seule. Il est donc d’autant plus important de vous assurer que vous pouvez 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 un serveur sans intention malveillante a accès à toutes les données que ChatGPT lui fournit lors de l’interaction, y compris, potentiellement, à des données sensibles que l’utilisateur a communiquées à ChatGPT auparavant. Ces données peuvent par exemple figurer dans les requêtes que ChatGPT envoie au serveur MCP lors d’une recherche approfondie ou lorsqu’il utilise les outils d’une application dans une discussion.

Connexion à des serveurs de confiance

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

Choisissez par exemple des serveurs officiels hébergés par les fournisseurs de services eux-mêmes. Pour Stripe, connectez-vous au serveur 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 d’utiliser un serveur hébergé par une organisation qui relaie les requêtes vers un autre service via une API. Avant de vous connecter, examinez la manière dont cette organisation utilise vos données et vérifiez que vous pouvez faire confiance au serveur. Si vous créez votre propre serveur MCP, vérifiez au moment de la connexion qu’il s’agit bien du bon serveur. Lorsqu’OpenAI appelle votre serveur MCP, prêtez attention aux données que vous fournissez en réponse aux requêtes et à la façon dont vous traitez celles que vous recevez.

Votre serveur MCP distant permet à d’autres personnes de connecter OpenAI à vos services. OpenAI peut alors accéder aux données de ces services, en envoyer et en recevoir, ainsi qu’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 créez un serveur MCP, veillez à ce que les définitions de vos outils ne contiennent aucun élément malveillant.