Documentation du serveur MCP de Chattee

Le serveur MCP de Chattee est un serveur Model Context Protocol distant qui permet à des assistants IA comme Claude Code, Claude.ai, Cursor, Codex et ChatGPT de créer, modifier, déployer et publier des applications web complètes sur Chattee. Cette page explique comment connecter chaque client, comment fonctionnent l’authentification et les scopes, ce que font les 35 outils et quelles limites vous rencontrerez.

Qu’est-ce que le serveur MCP de Chattee ?

Le serveur MCP de Chattee permet à l’assistant IA que vous utilisez déjà de construire des applications web complètes sur Chattee : il crée un projet d’après votre brief, soumet le plan à votre approbation, suit le build et publie l’application En ligne. Tout passe par un point de terminaison distant, avec connexion OAuth ou jeton d’accès personnel.

Il implémente le Model Context Protocol (révisions 2025-11-25 et 2026-07-28) sur Streamable HTTP, à une seule URL :

https://chattee.ai/mcp/connect

Par ce serveur, votre assistant peut créer un projet à partir d’un brief, vous transmettre le plan proposé par Chattee et lui relayer votre réponse, suivre le build, vous remettre l’aperçu du Brouillon, publier En ligne, démarrer des projets à partir de modèles ou les exporter comme modèles, lire et écrire des fichiers, gérer les variables d’environnement et les ressources gérées, lire la base de données et consulter vos crédits. Chattee construit des applications web complètes : un front-end React, un back-end Node, une base de données Postgres gérée, l’authentification, le stockage de fichiers et l’e-mail, déployés et hébergés sur chattee.ai.

La règle qui façonne tout le reste : les plans et les décisions de dépense vous appartiennent. Un plan vous est présenté en entier et vous seul l’approuvez ; une exécution qui atteint son budget se met en pause, et son enveloppe n’augmente que jusqu’à un total que vous indiquez. Les crédits s’achètent dans le builder, jamais par votre assistant.

Que puis-je demander à mon assistant de faire avec Chattee ?

Demandez avec vos propres mots, comme vous briefiez un développeur : votre assistant transforme la demande en appels d’outils Chattee et vous montre ce qui revient. Une nouvelle application passe par un plan que vous approuvez ; une petite modification peut s’appliquer directement. Le tableau montre de vraies demandes et les outils qu’elles ont utilisés.

Les trois premières lignes sont de vraies exécutions du benchmark MCP de Chattee : la demande telle que l’utilisateur simulé l’a saisie (traduite, car ces exécutions se sont déroulées en anglais ou en allemand), et les outils que l’assistant a appelés, dans l’ordre de leur premier appel. Les autres sont des demandes isolées.

Prérequis

Il vous faut trois choses : un compte Chattee, un client MCP compatible Streamable HTTP et un moyen de vous connecter. Les clients hébergés se connectent avec OAuth, sans rien d’autre ; les clients à en-tête utilisent un jeton d’accès personnel. La clé d’API de votre compte est refusée volontairement, car elle n’est ni limitée par des scopes ni révocable.

• Un compte Chattee (commencer gratuitement). L’offre gratuite inclut des crédits.
• Un client MCP : Claude Code, Claude.ai ou Claude Desktop, Cursor, Codex CLI, ChatGPT, ou votre propre agent sur le Claude Agent SDK.
• Soit un jeton d’accès personnel (créé sur la page Assistants IA du builder), soit un client qui se connecte avec OAuth. La clé d’API de votre compte ne fonctionne pas ici.

Comment ajouter le serveur MCP de Chattee à Claude Code ?

Claude Code ajoute le serveur MCP de Chattee en une commande et se connecte avec OAuth : aucun jeton n’est collé nulle part. Ajoutez-le avec la portée utilisateur, afin qu’il soit présent dans tous vos projets ; une équipe qui partage un dépôt peut plutôt versionner un .mcp.json, où le jeton de chacun est lu dans une variable d’environnement.

Ajoutez le serveur une fois, puis connectez-vous :

claude mcp add --transport http chattee --scope user https://chattee.ai/mcp/connect

--scope user ajoute Chattee au niveau utilisateur : il est disponible dans tous vos projets, et pas seulement dans le dossier courant (la portée par défaut de Claude Code). Connectez-vous depuis votre shell :

claude mcp login chattee

Dans Claude Code, /mcp fait la même chose : choisissez-y Chattee. Dans les deux cas, Claude Code ouvre la page de consentement de Chattee, vous approuvez, et les outils apparaissent sous la forme mcp__chattee__<tool>. Pour utiliser un jeton d’accès personnel plutôt qu’OAuth, passez-le dans un en-tête :

claude mcp add --transport http chattee --scope user https://chattee.ai/mcp/connect --header "Authorization: Bearer chattee_pat_…"

Pour une configuration au niveau du projet, partagée par une équipe, placez ceci dans .mcp.json à la racine du dépôt. Le fichier ne contient aucun jeton : Claude Code remplace ${CHATTEE_PAT} par la variable d’environnement CHATTEE_PAT, si bien que chaque membre de l’équipe utilise son propre jeton d’accès personnel et que le fichier peut être versionné tel quel :

{
  "mcpServers": {
    "chattee": {
      "type": "http",
      "url": "https://chattee.ai/mcp/connect",
      "headers": {
        "Authorization": "Bearer ${CHATTEE_PAT}"
      }
    }
  }
}

Définissez la variable avant de lancer Claude Code, par exemple dans le profil de votre shell (~/.zshrc ou ~/.bashrc) : export CHATTEE_PAT=chattee_pat_…. N’écrivez jamais le jeton lui-même dans .mcp.json, et ne le versionnez nulle part.

Demandez ensuite à Claude Code, par exemple : « Créez sur Chattee une page de réservation pour mon studio de yoga et montrez-moi le plan avant de l’approuver. »

Comment ajouter Chattee comme connecteur personnalisé dans Claude.ai et Claude Desktop ?

Claude.ai, Claude Desktop et les applications mobiles Claude se connectent à Chattee par un connecteur personnalisé : vous collez une fois l’URL du serveur, vous vous connectez à Chattee et vous approuvez les autorisations. La connexion utilise OAuth 2.1, fonctionne avec toutes les offres Claude et apparaît ensuite dans chaque conversation où vous activez le connecteur.

Les connecteurs personnalisés sont disponibles dans toutes les offres (l’offre gratuite en autorise un). Les menus sont nommés ici comme dans l’interface anglaise :

1. Ouvrez Customize → Connectors (propriétaires Team et Enterprise : Organization settings → Connectors, puis Add → Custom → Web).
2. Cliquez sur +, choisissez Add custom connector, collez https://chattee.ai/mcp/connect comme URL et cliquez sur Add.
3. Cliquez sur Connect : Claude ouvre la page de consentement de Chattee. Connectez-vous, vérifiez les autorisations et approuvez.

Chattee apparaît alors comme un connecteur que vous pouvez activer conversation par conversation, sur le web, dans Claude Desktop et dans les applications mobiles. Aucun jeton n’est collé dans Claude.

Comment ajouter le serveur MCP de Chattee à Cursor ?

Cursor installe le serveur MCP de Chattee en un clic, ou depuis quelques lignes de mcp.json, puis se connecte avec OAuth sur la page de consentement de Chattee. Comme Cursor ignore les en-têtes configurés dès qu’un serveur propose OAuth, seule la connexion permet ici de s’authentifier ; un jeton d’accès personnel dans le fichier ne sert à rien.

Ajouter à Cursor

Ou ajoutez vous-même le serveur à ~/.cursor/mcp.json (ou au .cursor/mcp.json du projet) :

{
  "mcpServers": {
    "chattee": {
      "url": "https://chattee.ai/mcp/connect"
    }
  }
}

Cursor détecte que le serveur propose OAuth et vous demande de vous connecter ; approuvez sur la page de consentement de Chattee.

Comment ajouter le serveur MCP de Chattee à Codex CLI ?

Codex CLI se connecte à Chattee avec un jeton d’accès personnel qu’il lit dans une variable d’environnement : le jeton ne figure donc jamais dans un fichier de configuration. Ajoutez le serveur en une commande ou en trois lignes de TOML, et gardez l’attente par défaut : Codex interrompt tout appel d’outil après 60 secondes.

Placez un jeton d’accès personnel dans la variable d’environnement CHATTEE_PAT, puis ajoutez le serveur :

codex mcp add chattee --url https://chattee.ai/mcp/connect --bearer-token-env-var CHATTEE_PAT

Ou écrivez la même chose dans ~/.codex/config.toml :

[mcp_servers.chattee]
url = "https://chattee.ai/mcp/connect"
bearer_token_env_var = "CHATTEE_PAT"

Codex interrompt un appel d’outil après 60 secondes : gardez donc pour wait_for_run la valeur par défaut de 45 secondes ; l’outil répond avant ce délai, et Codex le rappelle simplement.

Comment connecter le serveur MCP de Chattee à ChatGPT ?

ChatGPT connecte les serveurs MCP en Developer mode, sur la page qu’il appelle désormais Plugins (auparavant connecteurs), dans les offres payantes d’OpenAI et sur le web. Chattee s’y connecte uniquement via OAuth : vous collez l’URL du serveur, vous approuvez sur la page de consentement de Chattee, puis vous choisissez Chattee dans une conversation.

OpenAI propose le Developer mode dans ses offres payantes (Plus, Pro, Business, Enterprise et Edu) et uniquement sur le web ; dans un espace de travail Business, Enterprise ou Edu, un administrateur devra peut-être d’abord l’autoriser. Les menus sont nommés ici comme dans l’interface anglaise :

1. Ouvrez Settings → Security and login et activez Developer mode.
2. Allez dans ChatGPT Plugins, cliquez sur +, saisissez un nom (Chattee) et une courte description, puis collez https://chattee.ai/mcp/connect comme URL du serveur de la connexion. Créez-la.
3. ChatGPT vous envoie sur la page de consentement de Chattee ; connectez-vous et approuvez.
4. Dans une nouvelle conversation, choisissez Developer mode dans le menu + et sélectionnez Chattee.

ChatGPT n’accepte pas les jetons d’accès personnels, et ce n’est pas un problème : le flux OAuth accorde les mêmes scopes, et vous révoquez la connexion dans Chattee, sur la page Assistants IA.

Comment utiliser le serveur MCP de Chattee depuis le Claude Agent SDK ?

Un agent construit avec le Claude Agent SDK accède à Chattee par le même serveur distant : passez-le dans les options de query() avec un jeton d’accès personnel lu dans l’environnement. Le serveur applique les scopes, mais pas votre politique d’approbation : c’est votre agent qui décide quand un plan peut être approuvé, alors gardez un humain dans la boucle.

Passez le serveur dans les options de query(), avec un jeton d’accès personnel comme bearer, lu dans la variable d’environnement CHATTEE_PAT pour que le jeton ne figure jamais dans votre code :

mcpServers: {
  chattee: {
    type: "http",
    url: "https://chattee.ai/mcp/connect",
    headers: { Authorization: "Bearer " + process.env.CHATTEE_PAT },
  },
}

Autorisez les outils avec allowedTools: ["mcp__chattee"] et gardez un humain dans la boucle pour approve_plan : le serveur ne refuse rien ici, c’est donc la politique de votre propre agent qui empêche qu’un plan soit approuvé sans avoir été vu.

Le skill Chattee et tools.json

Le skill Chattee apprend à un agent à travailler avec Chattee : la boucle de build, la règle d’approbation, le sens de chaque résultat et chaque outil. C’est un fichier Markdown en anglais, plus un zip pour Claude.ai. tools.json liste les mêmes outils sous forme de données. Un plugin, une fois référencé, installe la connexion et le skill ensemble.

• Skill d’agent : skill.md apprend à un agent la boucle de build, la règle d’approbation et chaque outil, pour tout client qui lit les Agent Skills (Claude Code, Cursor, Codex, le Claude Agent SDK). Le skill est rédigé en anglais, car ce sont des agents qui le lisent. Claude.ai accepte le même skill sous la forme de chattee-skill.zip : importez-le sous Customize → Skills.
• Les outils en JSON : tools.json liste chaque outil avec son groupe, son scope, son accès et ses paramètres, pour les agents et les annuaires qui préfèrent des données à de la prose.

Authentification : OAuth ou jetons d’accès personnels

Deux façons de se connecter, un seul jeu de scopes. Les clients hébergés utilisent OAuth 2.1 et la page de consentement de Chattee ; les clients à en-tête envoient un jeton d’accès personnel. Dans les deux cas, les scopes accordés déterminent les outils utilisables, et vous révoquez une connexion ou un jeton sur la page Assistants IA.

• OAuth 2.1 est ce qu’utilisent les clients hébergés (Claude.ai, ChatGPT, Cursor, la connexion /mcp de Claude Code). Le client s’identifie par un document de métadonnées d’ID client ou par enregistrement dynamique, prouve la possession avec PKCE (S256) et vous envoie sur la page de consentement de Chattee. La page affiche le nom du client avec son domaine vérifié, ou signale comme non vérifié un client qui s’est enregistré lui-même et indique où l’approbation vous renvoie. Les jetons d’accès durent 1 heure et les jetons d’actualisation 30 jours ; une actualisation fait tourner le jeton, et un jeton réutilisé révoque toute l’autorisation.
• Les jetons d’accès personnels (chattee_pat_…) servent aux clients à en-tête : Claude Code avec --header, Codex, l’Agent SDK, les scripts. Créez-les sur la page Assistants IA, avec les scopes voulus et une date d’expiration facultative. Le jeton n’est affiché qu’une fois et il est stocké haché. Révoquez-le sur la même page.

Moindre privilège : un jeton limité à projects:read et usage:read peut tout consulter sans rien modifier ; ajoutez projects:write pour construire, et publish seulement si votre assistant doit mettre des modifications en ligne.

Un outil appelé sans son scope répond par un résultat insufficient_scope qui nomme le scope et indique où l’accorder ; rien n’est modifié. Les applications connectées et les jetons sont listés, et révoqués, sur la page Assistants IA.

Référence des outils MCP

Le serveur MCP de Chattee propose 35 outils (les « MCP tools ») en huit groupes, listés ci-dessous avec leur scope et ce que chacun peut faire de vos données. Chaque résultat associe du Markdown pour l’assistant à des données structurées, et chaque lien (chat du builder, aperçu du Brouillon, URL En ligne) est absolu : votre assistant peut vous le transmettre.

Compte et espaces de travail

Le compte avec lequel vous construisez : vos espaces de travail et les crédits que consomme un build.

Projets

Un projet est une application web, avec l’aperçu de son Brouillon et sa propre URL En ligne.

¹ Avec des pièces jointes, create_project, send_message et refine_plan nécessitent aussi projects:read.

Chats

Chaque chat est une conversation avec l’agent ; un projet ne fait qu’une chose à la fois.

Exécutions

Lancer une exécution, attendre ses points de décision et transmettre vos décisions sur le plan et sur les questions de l’agent.

¹ Avec des pièces jointes, create_project, send_message et refine_plan nécessitent aussi projects:read.

² wait_for_run ne transmet la réponse que vous donnez que si votre client affiche la question de l’agent sous forme de formulaire.

³ stop_run met fin à l’exécution en cours, ou à une exécution en pause à sa limite de crédits ; le travail déjà fait reste dans le Brouillon.

Publication

Mettre le Brouillon En ligne, suivre la publication ou revenir à une version antérieure.

Modèles

Démarrer un projet à partir d’un modèle, ou transformer un projet déployé en modèle.

Fichiers

Lire le code, ou faire une petite modification sûre ; pour tout ce qui va plus loin, envoyez une demande de modification pour que l’agent la construise et la vérifie.

Configuration et données

Les réglages de l’application, ses ressources gérées et les requêtes en lecture seule sur la base de données.

⁴ Avec env: live, set_env_vars nécessite aussi publish.

La boucle de build et l’approbation humaine

Chaque build suit la même boucle : une exécution de planification, votre approbation, le build, puis une publication quand vous la demandez. Votre assistant la pilote avec quelques outils et attend entre les étapes, car un build prend 5–90 minutes. Deux décisions vous reviennent toujours : approuver un plan, et dépenser plus que le budget d’une exécution.

1. create_project (ou send_message dans un chat existant avec mode: plan) lance une exécution de planification.
2. wait_for_run rend la main quand le plan est prêt. Votre assistant vous montre le plan complet et le lien vers le builder.
3. Vous dites oui — approve_plan — ou vous faites un retour — refine_plan. L’approbation déploie les conteneurs et lance l’implémentation.
4. wait_for_run, à répétition, jusqu’à la fin de l’exécution. Une exécution prend 5–90 minutes ; chaque attente rend la main au bout de 240 secondes au plus, avec la progression, et un résultat timed_out_waiting signifie simplement « rappelez-le ».
5. Si l’agent pose une question (awaiting_input), votre assistant vous la transmet et votre réponse repart par answer_question. Les clients qui prennent en charge l’élicitation MCP reçoivent plutôt la question sous forme de formulaire.
6. Quand l’exécution se termine, le résumé de clôture et le lien vers l’aperçu du Brouillon reviennent. publish_project quand vous le demandez ; l’URL En ligne revient de la même façon.

Une pause liée au budget, une carte expirée ou des crédits insuffisants mettent fin à une attente avec un résultat escalate et des liens vers le builder. Le budget d’une exécution en pause augmente uniquement jusqu’à un total que vous indiquez : votre assistant transmet votre chiffre avec continue_run, et ne l’enregistre comme valeur par défaut que si vous le dites séparément. Une exécution en pause à sa limite prend fin d’elle-même après 30 minutes si personne ne décide, et stop_run y met fin immédiatement ; son travail est conservé, et votre message suivant le poursuit dans une nouvelle exécution, avec une nouvelle limite de crédits. Les crédits s’achètent dans le builder ; rien sur ce point de terminaison ne permet d’en acheter.

Limites et limitation de débit

Chaque limite ci-dessous est appliquée par le serveur et nommée dans sa réponse quand vous l’atteignez : votre assistant peut ainsi attendre ou restreindre l’appel au lieu de deviner. Les attentes sont plafonnées pour qu’aucun client ne coupe un appel, les appels sont limités par utilisateur, et les longues lectures arrivent par fenêtres que l’on parcourt une à une.

• wait_for_run attend 45 secondes par défaut ; get_release_status attend 0 secondes par défaut, et répond donc aussitôt si vous ne passez pas wait_seconds. Les deux attendent au plus 240 secondes par appel. Attendre plus longtemps ne servirait à rien : Claude Code abandonne un appel d’outil HTTP après cinq minutes sans progression.
• 120 appels par minute et par utilisateur, tous jetons et applications connectées confondus ; au-delà, un résultat rate_limited avec retry_after_seconds. L’exécution continue pendant une attente en cours.
• 20 attentes simultanées par utilisateur, une exécution par projet à la fois, et la limite de projets de votre offre.
• Pièces jointes : jusqu’à 10 par message, texte jusqu’à 256 Ko et fichiers binaires jusqu’à 5 Mo chacun, et au plus 20 Mo au total par message.
• read_file renvoie au plus 200 000 caractères par appel. Une fenêtre plus longue revient avec truncated: true et next_offset_line, et le résultat indique comment poursuivre la lecture avec offset_line et limit_lines.
• get_chat raccourcit les longs messages (truncated: true) et renvoie les messages plus anciens via before : passez le next_before du résultat pour lire la page précédente.
• get_run_logs plafonne chaque réponse et signale quand il en a coupé une ; affinez avec tail ou source.
• Les clés d’idempotence des outils qui modifient des données sont conservées 24 heures ; un redémarrage du service les efface.

Sécurité

Le point de terminaison est la seule surface publique du serveur MCP de Chattee ; la vérification des jetons et chaque appel vers Chattee s’exécutent derrière lui, sur le même hôte. Les jetons sont stockés hachés, les scopes sont vérifiés à chaque appel, le contenu passe par les garde-fous du builder, et chaque appel d’outil est consigné dans un journal d’audit.

• Le point de terminaison est la seule surface publique. La vérification des jetons et chaque appel au plan de contrôle de Chattee passent par l’interface loopback du même hôte.
• Les jetons sont stockés hachés. OAuth utilise PKCE S256, des URI de redirection exactes (ports loopback exceptés, selon la RFC 8252), des codes à usage unique et des jetons d’actualisation tournants ; la page de consentement affiche le domaine vérifié d’un client et signale comme non vérifié un client auto-enregistré, si bien qu’un client qui se fait passer pour un autre se remarque.
• Les scopes sont appliqués à chaque appel ; le point de terminaison refuse la clé d’API du compte.
• Le contenu passe par les mêmes garde-fous que dans le builder. Un blocage par les garde-fous révoque tous les jetons et toutes les applications connectées du compte.
• Chaque appel d’outil est consigné dans un journal d’audit conservé 30 jours. Dans le chat du builder, un message envoyé par votre assistant porte le nom du client qui l’a envoyé, par exemple « via Claude Code ».
• Révoquez un jeton ou une application connectée à tout moment sur la page Assistants IA.

Dépannage

La plupart des erreurs indiquent elles-mêmes leur solution : le résultat contient un code, une phrase sur ce qui s’est passé et souvent un lien vers le builder. Voici les codes que vous rencontrerez le plus probablement, chacun avec la marche à suivre. Si un appel échoue sans code, signalez-le en précisant l’heure de l’appel.

• 401 invalid_token — le jeton a été révoqué, a expiré, ou c’est la clé d’API du compte. Créez un jeton d’accès personnel, ou reconnectez le client pour qu’il se connecte à nouveau.
• token_inactive — l’identifiant a cessé de fonctionner pendant l’appel : il a été révoqué ou il a expiré. Une application connectée se reconnecte à sa prochaine requête (sinon, reconnectez-la) ; un jeton d’accès personnel ne peut pas être récupéré : créez-en un nouveau sur la page Assistants IA et utilisez-le à la place.
• email_unconfirmed — l’adresse e-mail de votre compte Chattee n’est pas encore confirmée. Confirmez-la avec le lien de l’e-mail que Chattee vous a envoyé (le builder peut le renvoyer), puis réessayez.
• account_blocked — votre compte Chattee est suspendu, et rien ne fonctionne sur ce point de terminaison tant qu’il n’est pas rétabli. Contactez-nous.
• internal_error — un problème est survenu dans Chattee. Réessayez l’appel une fois ; s’il échoue encore, signalez-le en précisant l’heure de l’appel.
• insufficient_scope — le résultat nomme le scope manquant. Accordez-le au jeton, ou reconnectez l’application et acceptez l’autorisation.
• rate_limited — attendez retry_after_seconds ; rien n’est perdu et l’exécution continue.
• conflict_busy — un autre chat du projet occupe l’espace de travail ; le résultat le nomme. Attendez dans ce chat, ou arrêtez cette exécution.
• attachment_invalid — le base64 d’une pièce jointe n’est pas du base64 valide. Encodez à nouveau le fichier, ou envoyez un fichier texte en text.
• too_many_tasks — votre compte a trop de tâches longues ouvertes sur le serveur (clients qui utilisent les tâches MCP). Laissez-en se terminer ou annulez-les, puis réessayez ; les exécutions elles-mêmes ne sont pas affectées.
• Cursor redemande sans cesse la connexion — Cursor ignore les en-têtes Authorization quand un serveur propose OAuth. Supprimez l’en-tête et connectez-vous.
• Codex signale un délai dépassé — Codex interrompt les appels d’outils à 60 secondes. Gardez l’attente par défaut ; ne passez pas de timeout_seconds supérieur à 50.
• 503 introspection_unavailable — Chattee n’a pas pu vérifier les jetons pendant un instant. Réessayez après quelques secondes ; le client garde son jeton.

Journal des modifications

• 2026-10-15 — La documentation et la page de présentation existent désormais aussi en espagnol, en français et en portugais, en plus de l’anglais et de l’allemand : /es/docs/mcp, /fr/docs/mcp et /pt/docs/mcp, chacune avec sa version Markdown. Le skill pour agents et tools.json restent en anglais.
• 2026-10-02 — Une exécution en pause à sa limite de crédits prend fin d’elle-même après 30 minutes si personne ne décide, et stop_run y met fin immédiatement (résultat ended) ; get_credits indique la limite avec laquelle une exécution démarre et le maximum jusqu’auquel elle peut être relevée ; create_project accepte la limite de la première exécution et approve_plan l’enveloppe propre du build, chaque fois uniquement sous la forme d’un nombre que vous indiquez.
• 2026-10-01 — Les outils sont présentés dans un tableau par groupe, avec le scope de chaque outil et ce qu’il peut faire de vos données ; des exemples de prompts tirés de vraies exécutions ; le skill Chattee (skill.md, et un zip pour Claude.ai) et tools.json ; un assistant n’augmente le budget d’une exécution en pause que jusqu’à un total que vous indiquez. Claude Code : la commande de configuration ajoute Chattee au niveau utilisateur (--scope user), et claude mcp login chattee vous connecte depuis le shell. Les étapes pour Claude.ai et ChatGPT suivent les menus actuels des deux applications.
• 2026-09-26 — Première version : 35 outils, OAuth 2.1 avec PKCE et jetons d’accès personnels, les deux révisions du protocole, élicitation MCP et tâches pour les clients qui les déclarent, un résumé de clôture à la fin de chaque build.

FAQ

Que peut faire le serveur MCP de Chattee ?

Il permet à votre assistant IA de construire une application web complète sur Chattee à partir d’un brief : créer le projet, vous transmettre le plan pour approbation, suivre le build, vous remettre l’aperçu du Brouillon et publier l’application En ligne. Il peut aussi lire et modifier des fichiers, gérer les variables d’environnement et les ressources gérées, interroger la base de données en lecture seule et partir de modèles.

Comment démarrer avec le serveur MCP de Chattee ?

Créez un compte Chattee gratuit, ajoutez https://chattee.ai/mcp/connect à votre assistant (une commande dans Claude Code, un connecteur personnalisé dans Claude.ai, une entrée JSON dans Cursor), connectez-vous avec OAuth ou un jeton d’accès personnel, et demandez à votre assistant de construire quelque chose. La configuration de chaque client se trouve sur cette page.

Quels assistants IA fonctionnent avec le serveur MCP de Chattee ?

Claude Code, Claude.ai, Claude Desktop et les applications mobiles Claude, Cursor, Codex CLI, ChatGPT en Developer mode, et les agents construits sur le Claude Agent SDK. Tout autre client MCP compatible Streamable HTTP fonctionne aussi ; mcp-remote sert de passerelle pour un client qui ne parle que stdio.

Le serveur MCP de Chattee est-il gratuit ?

La connexion est gratuite. La construction consomme les crédits de votre offre Chattee, exactement comme dans le navigateur, et l’offre gratuite inclut des crédits pour démarrer. Une exécution qui atteint son budget se met en pause ; son enveloppe n’augmente que jusqu’à un total que vous indiquez, et les crédits s’achètent dans le builder.

Chattee déploie-t-il et héberge-t-il l’application ?

Oui. Chaque projet reçoit un aperçu du Brouillon, et la publication le met En ligne, sur une URL chattee.ai ou sur votre propre domaine, avec une base de données Postgres gérée, l’authentification, le stockage de fichiers et l’e-mail quand l’application en a besoin. Votre assistant ne manipule jamais de serveurs, de conteneurs ni de scripts de déploiement.

Mon assistant peut-il approuver un plan tout seul ?

Non. Chaque plan vous est présenté et c’est vous qui l’approuvez, dans votre chat ou dans le builder. Les descriptions des outils interdisent l’auto-approbation, et un jeton peut être limité à des scopes en lecture seule si vous voulez en avoir la certitude.

Mon assistant peut-il augmenter le budget d’une exécution ?

Oui, mais uniquement jusqu’à un total que vous indiquez. Une exécution qui atteint son budget se met en pause, et votre assistant vous donne le lien vers le builder. Si vous lui indiquez vous-même un nouveau total, il poursuit l’exécution avec exactement cette enveloppe, et ne l’enregistre comme valeur par défaut qu’après un oui distinct. Si personne ne décide, l’exécution en pause prend fin d’elle-même après 30 minutes et conserve son travail ; votre message suivant le poursuit dans une nouvelle exécution. Votre assistant n’achète jamais de crédits : les offres et les crédits s’achètent dans le builder.

Quelle différence avec un agent de code qui construit l’application lui-même ?

Un agent de code seul écrit du code sur votre machine, et l’hébergement, la base de données, la connexion des utilisateurs, l’e-mail et les déploiements restent à votre charge. Via Chattee, votre assistant confie le brief à un builder qui planifie, construit, déploie et héberge toute l’application, pendant que vous approuvez le plan et décidez quand elle est mise en ligne.

Quelles versions du protocole MCP sont prises en charge ?

Les deux révisions actuelles : 2025-11-25, la révision avec sessions que parlent aujourd’hui tous les clients du marché, et 2026-07-28, la révision sans état, avec les tâches et les résultats input-required. Le transport est Streamable HTTP. Il n’existe pas de paquet stdio ; mcp-remote sert de passerelle pour un client qui en a besoin.

Puis-je utiliser la clé d’API de mon compte à la place d’un jeton ?

Non. Le point de terminaison refuse volontairement la clé du compte : un jeton d’accès personnel est limité par des scopes et révocable, la clé du compte n’est ni l’un ni l’autre. Créez un jeton sur la page Assistants IA, ou laissez le client se connecter avec OAuth.

Combien de temps dure un build ?

Une application complète prend 5–90 minutes, une petite modification quelques minutes. wait_for_run rend la main à chaque point de décision, et sinon au bout de 240 secondes au plus : votre assistant continue donc d’interroger le serveur jusqu’à ce que l’exécution ait besoin de vous.

Que se passe-t-il si mon assistant se déconnecte pendant un build ?

Rien, côté Chattee : les exécutions vivent dans le backend, pas dans la connexion. Reconnectez-vous et appelez de nouveau wait_for_run, ou ouvrez le chat dans le builder, où la même exécution se poursuit.

Cette documentation existe-t-elle dans d’autres langues ?

Oui : en anglais sur /docs/mcp, en allemand sur /de/docs/mcp, en espagnol sur /es/docs/mcp et en portugais sur /pt/docs/mcp, et la page de présentation sous les mêmes préfixes (/mcp, /de/mcp, etc.). Le skill d’agent et tools.json n’existent qu’en anglais, car ce sont des agents qui les lisent.