Un nouvel OS ? Applications dans ChatGPT et SDK d'Applications (Basé sur MCP) : Déverrouiller une nouvelle plateforme

Introduction :

Les applications dans ChatGPT permettent désormais aux développeurs tiers de créer des mini-applications interactives qui vivent à l'intérieur de l'interface de chat. Plutôt que d'envoyer les utilisateurs vers des sites Web ou des applications mobiles, ces applications fonctionnent au sein de la conversation et exploitent le raisonnement du modèle pour déclencher des actions. Des partenaires précoces comme Canva, Coursera, Expedia et Zillow ont démontré comment les utilisateurs peuvent demander une playlist, concevoir une affiche ou rechercher un bien immobilier sans quitter ChatGPT[1]. Le nouveau SDK pour applications est construit sur le Model Context Protocol (MCP), une norme ouverte qui permet aux modèles d'interagir avec des outils externes et des interfaces utilisateur[2]. Ce blog explore en profondeur l'architecture des applications basées sur MCP, explique les capacités du SDK, guide la création d'une application étape par étape, explore comment les utilisateurs découvrent et utilisent les applications, et aborde les considérations de confidentialité et de sécurité. Tout au long, nous citons la documentation officielle et des articles journalistiques réputés pour ancrer l'analyse dans des sources crédibles.

Comprendre le Model Context Protocol (MCP)

Pourquoi les normes ouvertes sont importantes

Le Protocole de Contexte de Modèle est la fondation du SDK Apps. Selon la documentation du développeur, chaque intégration du SDK Apps utilise un serveur MCP pour exposer des outils, gérer l'authentification et emballer à la fois des données structurées et du HTML qui s'affichent dans ChatGPT[2]. MCP est un standard ouvert—chacun peut implémenter un serveur dans n'importe quelle langue et connecter un modèle tel que GPT‑4 ou Codex. La nature open-source signifie qu'il n'y a pas de verrouillage fournisseur ; la même application peut théoriquement fonctionner sur n'importe quelle plateforme d'IA qui implémente le protocole. Cette ouverture encourage les contributions communautaires et favorise un écosystème analogue au web des débuts, où des standards comme HTTP permettaient des sites web interopérables.

Serveurs, Outils et Ressources

Un serveur MCP expose un ou plusieurs outils. Un outil définit une action que le modèle peut appeler, comme « créer un tableau kanban », « rechercher des maisons » ou « générer une playlist ». Chaque outil est décrit par un nom machine, un titre convivial et un schéma JSON qui indique au modèle quels arguments il accepte. Lorsque ChatGPT décide que l'outil doit être invoqué, il envoie un appel structuré au serveur. Le serveur exécute la logique—que ce soit en interrogeant une API, en effectuant un calcul ou en interagissant avec une base de données—et renvoie ensuite une réponse de l'outil. Cette réponse comprend trois champs :

structuredContent – données visibles par le modèle qui décrivent l'état actuel. Par exemple, un tableau kanban peut inclure un tableau de colonnes et de tâches[3].
content – texte facultatif que l'assistant renvoie à l'utilisateur. Cela peut résumer le résultat ou donner des instructions à l'utilisateur.
_meta – métadonnées cachées non visibles par le modèle. Les développeurs utilisent cela pour stocker des identifiants ou des listes utilisés dans les composants de l'interface utilisateur. Par exemple, l'exemple du tableau utilise une carte tasksById dans _meta pour maintenir les détails des tâches sans les exposer au modèle[4].

Les outils peuvent également se référer à resources, tels que des modèles HTML ou des images, en référant à une URL ui://. Le serveur enregistre ces ressources lors du démarrage. La documentation avertit que, comme les ressources sont mises en cache par l'infrastructure d'OpenAI, les développeurs doivent les versionner en incluant un hachage de build dans le nom de fichier[5]. Sinon, les utilisateurs pourraient voir une interface obsolète après les déploiements.

Contenu structuré vs. Métadonnées

La distinction entre structuredContent et _meta est cruciale. Selon la documentation, structuredContent est visible pour le modèle et est utilisé pour hydrater le composant de l'interface utilisateur ; _meta est caché du modèle et peut contenir des données supplémentaires pour l'interface utilisateur telles que des listes pour les menus déroulants[3]. En séparant les données visibles et cachées, les développeurs peuvent protéger les informations sensibles du modèle tout en rendant des interfaces riches. Ce design encourage également le partage minimal de données ; seules les informations nécessaires à l'accomplissement de la tâche sont exposées, en accord avec les principes de confidentialité.

Authentification et Sessions

Lorsqu'un utilisateur appelle pour la première fois une application, le serveur peut avoir besoin de l'authentifier. Le SDK Apps prend en charge les flux OAuth 2.1 ; les développeurs spécifient les portées et redirigent les utilisateurs vers le fournisseur d'identité. Une fois que l'utilisateur donne son consentement, l'application obtient un jeton et peut accéder aux données de l'utilisateur. Le rôle du serveur est de gérer l'état de la session, souvent en stockant les jetons dans une base de données associée au compte ChatGPT de l'utilisateur. Cela garantit que les appels d'outils suivants peuvent réutiliser la session sans redemander l'utilisateur.

Principes de Sécurité

OpenAI met l'accent sur le principe du moindre privilège, le consentement explicite de l'utilisateur et la défense en profondeur[6]. Les applications doivent demander uniquement les autorisations minimales nécessaires, et les utilisateurs doivent autoriser explicitement le partage des données ; le modèle lui-même ne doit jamais deviner les identifiants. La rétention des données est limitée : le contenu structuré reste uniquement pendant que l'invite de l'utilisateur est active, et les journaux sont expurgés avant d'être partagés avec les développeurs[6]. L'accès réseau pour les composants d'application est restreint par une politique de sécurité de contenu ; les iframes ne peuvent pas accéder aux API de navigateur arbitraires, et toutes les requêtes HTTP doivent provenir du serveur plutôt que du client[7]. Cela empêche le script intersites et l'exfiltration de jetons.

Le SDK Apps : Créer de vraies applications dans ChatGPT

L'expérience développeur

Le SDK Apps enveloppe le MCP dans des bibliothèques clientes idiomatiques (actuellement Python et TypeScript) et des outils de structure. Lorsque vous créez une application, vous définissez les outils, enregistrez des modèles d'interface utilisateur et implémentez la logique serveur. Le serveur peut fonctionner sur votre propre infrastructure et utilise n'importe quel framework (FastAPI, Express, etc.), mais il doit implémenter les points de terminaison MCP. OpenAI fournit des serveurs de développement et un Inspecteur MCP pour tester les appels localement.

Les développeurs conçoivent à la fois la logique et l'interface utilisateur. Les interfaces utilisateur sont généralement écrites en React et compilées en ressources statiques. Elles sont servies à l'intérieur d'un iframe sécurisé dans ChatGPT. Dans cet iframe, les développeurs peuvent accéder à un objet global window.openai pour interagir avec l'hôte. Selon le guide Créer une expérience utilisateur personnalisée, cette API fournit :

Globals – displayMode, maxHeight, theme et locale informent le composant sur la mise en page et le style[8].
Charges utiles de l'outil – toolInput, toolOutput et widgetState permettent de lire les arguments, les résultats et l'état persistant à travers les rendus[8].
Actions – setWidgetState() enregistre l'état qui persiste à travers les messages; callTool() déclenche une action serveur; sendFollowupTurn() envoie une invite de suivi au modèle; requestDisplayMode() demande à passer en plein écran ou en mode image dans l'image[8].
Événements – le composant peut s'abonner à openai:set_globals lorsque l'hôte met à jour la mise en page ou le thème, et à openai:tool_response lorsqu'un appel d'outil se résout[8].

Ces API permettent aux développeurs de créer des composants interactifs riches qui restent synchronisés avec le raisonnement du modèle. Par exemple, si un utilisateur déplace une tâche vers une nouvelle colonne dans un tableau kanban, le composant peut envoyer un callTool pour mettre à jour le serveur, persister le nouvel état, puis retourner un nouveau structuredContent. Pendant ce temps, le modèle ne voit que l'état global du tableau ; l'interface utilisateur gère les détails comme le glisser-déposer.

Enregistrement des outils et modèles

In the server code you register a tool and its template. For instance, in a TypeScript server you might write:

import { Tool, StructuredToolResponse } from "@openai/apps";

// Register UI template
server.registerResource("ui://kanban-board/abc123", buildHtml());

// Define tool schema
const createBoard: Tool = {
  name: "createKanbanBoard",
  description: "Create a new kanban board with given tasks and columns",
  inputSchema: z.object({
    title: z.string(),
    columns: z.array(z.object({ name: z.string() })),
    tasks: z.array(z.object({ name: z.string(), columnIndex: z.number() }))
  }),
  async execute(input, ctx): Promise<StructuredToolResponse> {
    // compute board state
    const columns = input.columns.map((col, i) => ({
      id: i,
      title: col.name,
      taskIds: input.tasks.filter(t => t.columnIndex === i).map((_t, idx) => idx)
    }));
    const tasksById = input.tasks.map((task, id) => ({ id, name: task.name }));
    return {
      content: `Created board '${input.title}'`,
      structuredContent: { title: input.title, columns },
      _meta: { tasksById, uiTemplate: "ui://kanban-board/abc123" }
    };
  }
};

The _meta field includes tasksById for hidden metadata and uiTemplate referencing the registered HTML. When ChatGPT receives this response, it will render the template with the structured content. The window.openai.toolOutput object in the component can then read the board data and display it.

Versioning and Caching

Parce que des ressources comme les modèles d'interface utilisateur sont mises en cache sur les serveurs d'OpenAI, les développeurs doivent inclure un hachage ou une version unique dans l'identifiant ui://. Les documents avertissent que si vous déployez une nouvelle version sans mettre à jour le chemin, les utilisateurs peuvent continuer à voir l'ancienne interface utilisateur en raison de la mise en cache[5]. Une bonne pratique consiste à intégrer le SHA du commit ou l'ID de build dans l'URL. Cela garantit que chaque déploiement résulte en une ressource fraîche.

Persistance de l'état et suivis

Les composants ont souvent besoin de persister l'état. Par exemple, une application de lecture de playlists pourrait permettre aux utilisateurs de marquer des chansons en favori ; ces favoris devraient rester même lorsque l'utilisateur pose une autre question. La méthode setWidgetState() stocke les données en dehors de structuredContent et persiste à travers les tours[8]. Le modèle ne voit pas cet état, garantissant la confidentialité.

Parfois, une application doit poser à l'utilisateur une question de clarification. La méthode sendFollowupTurn() permet au composant d'envoyer une nouvelle invite à ChatGPT, qui apparaîtra alors dans la transcription comme si le modèle avait posé la question[8]. Cela est utile pour les flux de travail en plusieurs étapes : par exemple, une application de réservation de voyage pourrait demander « Combien de nuits allez-vous rester ? » après que l'utilisateur ait sélectionné un hôtel.

Building Your First App: Step‑By‑Step Guide

In this section we will build a simple Task Tracker app that demonstrates the core concepts of the Apps SDK. The app will let a user create tasks and organise them into categories. We choose this example because it is generic, easy to extend and showcases structured content, metadata, custom UI and tool calls.

Set up the MCP Server

First install the TypeScript SDK and scaffolding tool:

npm install -g @openai/apps-generator
apps init task-tracker
cd task-tracker
npm install

This command scaffolds a project with a server, a React frontend and build scripts. The server uses Express and the @openai/apps library. Run npm run dev to start the development server; the project includes an MCP Inspector that opens in your browser and simulates ChatGPT calling your app.

Define the Tool

Open src/server.ts and define a tool called createTasks. The tool accepts an array of tasks and returns structured content grouping them by category. It also provides a summary in the content field.

import { Tool, StructuredToolResponse } from "@openai/apps";



export const createTasks: Tool = {
  name: "createTasks",
  description: "Create a list of tasks grouped by category",
  inputSchema: z.object({ tasks: z.array(z.object({ name: z.string(), category: z.string() })) }),
  async execute({ tasks }): Promise<StructuredToolResponse> {
    const categories = Array.from(new Set(tasks.map(t => t.category)));
    const grouped = categories.map(category => ({
      name: category,
      taskIds: tasks.filter(t => t.category === category).map((_, i) => i)
    }));
    const tasksById = tasks.map((task, id) => ({ id, name: task.name, category: task.category }));
    return {
      content: `Created ${tasks.length} tasks in ${categories.length} categories`,
      structuredContent: { categories: grouped },
      _meta: { tasksById, uiTemplate: "ui://task-tracker/1.0.0" }
    };
  }
};

server.registerResource("ui://task-tracker/1.0.0", fs.readFileSync(path.join(__dirname, "../dist/index.html"), "utf8"));
server.registerTool(createTasks);

Build the Custom UI

Next open src/frontend/App.tsx. This React component will read the structuredContent and display categories and tasks. It will also allow users to mark tasks as complete and persist that state using setWidgetState.

import { useEffect, useState } from "react";

declare global {
  interface Window {
    openai: any;
  }
}



export default function App() {
  const [complete, setComplete] = useState<{ [id: string]: boolean }>(() => window.openai.widgetState?.complete || {});
  const output = window.openai.toolOutput;
  const tasksById = output?._meta?.tasksById || [];
  const categories = output?.structuredContent?.categories || [];

  // persist completion state
  useEffect(() => {
    window.openai.setWidgetState({ complete });
  }, [complete]);

  return (
    <div className="task-tracker">
      {categories.map((cat: any, ci: number) => (
        <div key={ci} className="category">
          <h3>{cat.name}</h3>
          <ul>
            {cat.taskIds.map((tid: number) => (
              <li key={tid}>
                <label>
                  <input type="checkbox" checked={complete[tid]} onChange={() => setComplete(prev => ({ ...prev, [tid]: !prev[tid] }))} />
                  {tasksById[tid].name}
                </label>
              </li>
            ))}
          </ul>
        </div>
      ))}
    </div>
  );
}

This component uses window.openai.toolOutput to access the structuredContent and _meta fields. It stores completion state in widgetState so that checking a box persists even when the user continues the conversation. On subsequent tool calls, the component can fetch new tasks or update existing ones. This demonstrates how to combine model reasoning with client‑side interactions.

Testing and Iterating

Run npm run dev again and open the MCP Inspector. In the prompt area, type:

@task‑tracker create a list of tasks: buy milk in shopping, finish report in work, call mom in personal

The inspector will show the structured content and render the task list UI. You can check tasks off; the state persists across turns. You can then ask ChatGPT: “Remind me of my tasks later.” Because the model retains context, it can call the tool again, display the UI and summarise your progress.

How Users Discover and Use Apps

Named Mention and In‑Conversation Discovery

ChatGPT surfaces apps when it believes they can assist the user. There are two primary discovery modes. Named mention occurs when the user explicitly mentions the app name at the beginning of a prompt; in this case, the app will be surfaced automatically[9]. For instance, “@Spotify create a workout playlist” immediately invokes the Spotify integration. The user must place the app name at the start; otherwise the assistant may treat it as part of the conversation.

In‑conversation discovery happens when the model infers that an app could help based on context. The documentation explains that the model evaluates the conversation context, prior tool results and the user’s linked apps to determine which app might be relevant[9]. For example, if you are discussing travel plans, ChatGPT might suggest the Expedia app to book flights. The algorithm uses metadata like tool descriptions and keywords to match the conversation with potential actions[10]. Developers can improve discoverability by writing action‑oriented descriptions and clear UI component names.

Directory and Launcher

OpenAI plans to release an app directory where users can browse and discover new apps[10]. Each listing will include the app name, description, supported prompts and any onboarding instructions. Users can also access the launcher via the “+” button in chat; this shows a menu of available apps based on context. These entry points will help less technical users find and enable apps without memorising names.

Onboarding and Consent

Lorsqu'un utilisateur active une application pour la première fois, ChatGPT initie un processus d'intégration. Le modèle demande à l'utilisateur de connecter son compte (si nécessaire) et explique quelles données l'application requiert. Les lignes directrices pour les développeurs soulignent que les applications doivent respecter la vie privée des utilisateurs, se comporter de manière prévisible et avoir des politiques claires[11]. Les utilisateurs doivent explicitement accorder ou refuser l'accès ; il n'y a pas d'accès aux données en silence. Une fois connecté, l'application peut rester liée pour les interactions futures, mais les utilisateurs ont toujours la possibilité de déconnecter et de révoquer les autorisations.

Confidentialité, Sécurité et Conception Responsable

Principes des Applications Fiables

Les lignes directrices pour les développeurs d'applications d'OpenAI définissent plusieurs principes pour garantir que l'écosystème reste sûr et digne de confiance. Les applications doivent fournir un service légitime, avoir une politique de confidentialité et des pratiques de conservation des données claires, et se conformer aux politiques d'utilisation[11]. Elles doivent minimiser la collecte de données, éviter de stocker des informations personnelles sensibles et ne pas partager les données des utilisateurs sans consentement[12]. Les applications doivent se comporter de manière prévisible ; elles ne peuvent pas manipuler le modèle pour produire un contenu nuisible ou trompeur.

Limites et minimisation des données

Les directives insistent sur le fait que les applications ne doivent collecter que les données essentielles à leur fonctionnement et ne doivent pas demander ou stocker de données sensibles telles que les dossiers de santé ou les identifiants gouvernementaux[12]. Le contenu structuré envoyé au modèle ne doit pas contenir de secrets ; les métadonnées cachées ne doivent pas stocker de jetons utilisateur ou de détails privés. Les développeurs doivent mettre en œuvre un chiffrement fort et un stockage sécurisé pour tous les jetons obtenus lors de l'OAuth. Le serveur doit maintenir des limites strictes entre les sessions utilisateur ; les données d'un utilisateur ne doivent jamais fuir dans le contexte d'un autre.

Mesures de sécurité dans le SDK

Le Guide de sécurité et de confidentialité décrit les mécanismes de défense intégrés à la plateforme. Il met l'accent sur le principe du moindre privilège et le consentement explicite de l'utilisateur comme principes centraux[6]. La rétention des données est limitée ; les journaux accessibles aux développeurs sont expurgés pour supprimer les informations personnelles identifiables, et le contenu structuré n'est conservé que le temps nécessaire au prompt[6]. L'accès réseau depuis l'iframe est restreint par la politique de sécurité du contenu ; les requêtes externes doivent passer par le serveur, empêchant les requêtes inter-origines non autorisées[7]. L'authentification utilise des flux OAuth standard de l'industrie avec des jetons de courte durée. Les développeurs sont tenus de mettre en place des revues de sécurité, des canaux de signalement de bugs et une surveillance des incidents pour maintenir l'état de préparation opérationnelle[7].

Équité et pertinence

Les applications doivent être adaptées à un large public. Les directives interdisent les applications qui fournissent du contenu long, une automatisation complexe ou des publicités[13]. Par exemple, une application ne doit pas essayer de diffuser une vidéo de 30 minutes ou de reproduire un réseau social entier au sein de ChatGPT. La plateforme encourage des interactions succinctes qui complètent le flux conversationnel. Les violations peuvent entraîner un rejet ou une suppression.

Opportunités et Considérations

Un Nouveau Canal de Distribution pour les Développeurs

En ouvrant ChatGPT aux applications tierces, OpenAI se positionne comme une « couche d'intention » entre les utilisateurs et les services. Les développeurs peuvent désormais atteindre des millions d'utilisateurs via l'interface de chat sans créer d'applications web ou mobiles distinctes. Les applications ont le potentiel de réduire les frictions : au lieu de télécharger une application ou de visiter un site web, les utilisateurs mentionnent simplement le service dans la conversation. Cela pourrait démocratiser l'accès aux outils et égaliser les chances pour les petits développeurs.

Les partenariats précoces montrent les possibilités : les utilisateurs peuvent regarder des conférences Coursera tout en posant des questions à ChatGPT ; concevoir des affiches dans Canva ; parcourir les options de voyage sur Expedia ou les annonces immobilières sur Zillow ; générer des playlists Spotify ; ou diagrammer des idées avec Figma[14][13]. Comme les applications fonctionnent à l'intérieur du chat, le modèle peut résumer, analyser et générer des recommandations, transformant du contenu statique en leçons interactives. Les applications offrent également plusieurs modes d'affichage—cartes intégrées, plein écran ou image dans l'image—offrant de la flexibilité pour différentes tâches[15].

Transformer les attentes des utilisateurs

La capacité d'utiliser des applications sans changer de contexte pourrait transformer la manière dont les gens interagissent avec les services. ChatGPT devient non seulement un chatbot, mais un système d'exploitation universel pour les intentions. Comme l'a observé Casey Newton, cela nous fait passer du lancement d'applications distinctes à simplement exprimer ce que nous voulons[16]. Certains analystes comparent ce changement au lancement de l'App Store ou du navigateur : une plateforme unique qui agrège fonctionnalité et compétition.

Cependant, cette transformation soulève des questions sur le contrôle et le pouvoir. Si ChatGPT détermine quelles applications mettre en avant, il pourrait devenir un gardien. Newton avertit qu'un « graphe IA » basé sur les préférences des utilisateurs pourrait engendrer des risques de confidentialité plus graves que ceux des réseaux sociaux[16]. Les incitations économiques pourraient mener à un placement ou classement payant des applications. Les développeurs pourraient se sentir obligés de concevoir pour ChatGPT plutôt que de garder leur relation avec les utilisateurs. Il est crucial que la plateforme reste transparente et équitable pour maintenir la confiance.

Implications Réglementaires et Éthiques

Les applications pouvant accéder à des données personnelles—localisation, contacts, méthodes de paiement—les régulateurs pourraient examiner comment les données circulent à travers ChatGPT. Les développeurs doivent se conformer aux lois sur la confidentialité comme le RGPD, même si la plateforme n'est pas encore disponible dans l'Union Européenne[17]. OpenAI a promis des contrôles de confidentialité plus précis et des options de monétisation, y compris un protocole de commerce agentique qui permettra un paiement instantané dans le chat[18]. Le succès de cet écosystème dépendra d'une sécurité robuste, d'un consentement utilisateur clair et de modèles économiques équitables.

Orientations futures et recherche

Le SDK Apps est encore en aperçu, et de nombreuses fonctionnalités doivent encore être développées. La feuille de route des développeurs inclut :

Flux de soumission et de révision – Actuellement, les développeurs peuvent créer des applications mais ne peuvent pas les répertorier publiquement. Un processus de révision formel garantira la conformité aux directives et la confiance.
Partage des revenus et monétisation – OpenAI a suggéré un protocole de commerce agentique qui pourrait permettre aux utilisateurs d'acheter des produits directement dans le chat[18]. Cela ouvre des opportunités pour le commerce électronique mais pose également des questions sur les frais, les classements et la concurrence.
Outils pour développeurs – Plus de langages et de frameworks, des outils de débogage améliorés et des pipelines de déploiement simplifiés abaisseront la barrière à l'entrée. La nature ouverte du MCP pourrait conduire à des implémentations et des fournisseurs d'hébergement pilotés par la communauté.
Interopérabilité – Comme le MCP est ouvert, d'autres plateformes ou modèles pourraient l'adopter. Cela pourrait permettre un écosystème d'applications multi-modèles où les développeurs écrivent une fois et exécutent partout. La recherche sur la standardisation des protocoles d'agents et le partage de contexte sera importante.
Recherche sur la sécurité – Évaluer comment prévenir l'injection de commandes, le code malveillant ou l'utilisation abusive des données utilisateur reste un domaine de recherche majeur. Les articles sur les attaques adversariales contre les applications intégrant des LLM informeront les meilleures pratiques et lignes directrices.

Conclusion : Un nouveau système d'exploitation en devenir

L'introduction des Applications dans ChatGPT et du SDK d'applications basé sur MCP marque un changement significatif dans notre interaction avec les logiciels. En intégrant directement des applications tierces dans l'interface de chat, OpenAI a créé une nouvelle plateforme qui mélange langage naturel, raisonnement et interfaces utilisateur interactives. Le Protocole de Contexte de Modèle offre un moyen ouvert et standardisé pour les modèles d'appeler des outils et de rendre des composants ; le SDK d'Applications simplifie le développement en gérant la communication serveur, l'intégration de l'interface utilisateur et la gestion de l'état. Des exemples étape par étape comme le Suivi de Tâches démontrent à quel point il est facile de créer une application utile tout en maintenant des limites strictes de données et de confidentialité.

Cependant, cette innovation s'accompagne de responsabilités. Les développeurs doivent suivre des directives qui privilégient la confidentialité, la sécurité et l'équité des utilisateurs[11][12]. Des mécanismes de sécurité comme le moindre privilège et le consentement explicite protègent les utilisateurs[6]. Dans le même temps, les observateurs de l'industrie avertissent que la plateforme pourrait créer de nouvelles formes de contrôle et de risques pour la vie privée[16]. À mesure que l'écosystème mûrit, la transparence, les normes ouvertes et l'engagement communautaire détermineront si la plateforme d'applications de ChatGPT devient une couche transformative et fiable pour les tâches quotidiennes.

[1] Dernières nouvelles de la course aux armes de l'IA : ChatGPT permet désormais aux utilisateurs de se connecter à Spotify et Zillow dans les discussions

https://www.forbes.com/sites/antoniopequenoiv/2025/10/06/openais-chatgpt-now-connects-with-third-party-apps-like-spotify-and-zillow-heres-the-latest-in-the-ai-arms-race/

[2] [3] [4] [5] Configurez votre serveur

https://developers.openai.com/apps-sdk/build/mcp-server

[6] [7] Sécurité et confidentialité

https://developers.openai.com/apps-sdk/guides/security-privacy

[8] Créez une UX personnalisée

https://developers.openai.com/apps-sdk/build/custom-ux

[9] [10] Interaction utilisateur

https://developers.openai.com/apps-sdk/concepts/user-interaction

[11] [12] Lignes directrices pour les développeurs d'applications

https://developers.openai.com/apps-sdk/app-developer-guidelines/

[13] Les applications ChatGPT sont en ligne : Voici les premières que vous pouvez essayer | The Verge

https://www.theverge.com/news/793081/chagpt-apps-sdk-spotify-zillow-openai

[14] OpenAI DevDay 2025 : ChatGPT obtient des applications, AgentKit pour les développeurs, et des modèles GPT moins chers

https://indianexpress.com/article/technology/artificial-intelligence/openai-devday-2025-chatgpt-gets-apps-agentkit-for-developers-and-cheaper-gpt-models-10292443/

[15] OpenAI annonce un SDK pour les applications permettant à ChatGPT de lancer et d'exécuter des applications tierces comme Zillow, Canva, Spotify | VentureBeat

https://venturebeat.com/ai/openai-announces-apps-sdk-allowing-chatgpt-to-launch-and-run-third-party

[16] Nouvelle plateforme, risques familiers : Zillow et Expedia parient sur le déploiement des applications ChatGPT d'OpenAI – GeekWire

https://www.geekwire.com/2025/new-platform-familiar-risks-zillow-and-expedia-bet-on-openais-chatgpt-apps-rollout/

[17] OpenAI DevDay : Applications ChatGPT, AgentKit et lancement en GA de Codex - SD Times

https://sdtimes.com/ai/openai-devday-chatgpt-apps-agentkit-and-ga-release-of-codex/

[18] OpenAI veut transformer ChatGPT en une interface d'application universelle - Ars Technica

https://arstechnica.com/ai/2025/10/openai-wants-to-make-chatgpt-into-a-universal-app-frontend/