Serveur ChatArchitect Cloud MCP pour agents IA WhatsApp

Les agents d'IA ont besoin d'outils, pas seulement de discussions

Les agents IA peuvent classer les requêtes, rédiger des réponses, résumer les conversations et choisir l'étape suivante d'un flux de travail. Pour ce faire, ils ont besoin d'accéder aux outils métiers. Un agent capable de rédiger une réponse a également besoin d'un outil de messagerie pour la transmettre.

Pour de nombreuses entreprises, WhatsApp est ce canal privilégié. Les équipes commerciales l'utilisent pour le suivi des prospects, les équipes de support pour répondre aux questions des clients et les équipes opérationnelles pour envoyer des notifications de rendez-vous, de livraison, de paiement et de statut. La valeur de l'IA s'accroît lorsque l'agent peut passer de la suggestion à l'exécution contrôlée : envoyer un SMS, créer ou utiliser un modèle, demander des informations de facturation, vérifier les messages non lus, exporter des données ou configurer les points de terminaison du flux de travail.

Le serveur ChatArchitect Cloud MCP est conçu précisément pour cette couche. Il offre aux clients d'IA un moyen contrôlé d'appeler certaines actions de l'API WhatsApp de ChatArchitect via le protocole MCP, sans exiger de chaque client qu'il développe et maintienne une intégration backend personnalisée.

Qu'est-ce que le MCP en termes simples ?

Le protocole MCP (Model Context Protocol) est une méthode standard permettant aux applications d'IA de se connecter à des outils externes. Dans une configuration MCP, l'application d'IA joue le rôle de client. Le serveur MCP expose un ensemble d'actions disponibles, leurs schémas d'entrée et leurs formats de sortie. Le client d'IA peut ainsi découvrir ces actions et les appeler lorsqu'un utilisateur lui soumet une tâche nécessitant une exécution.

Considérez MCP comme un adaptateur standard entre un agent d'IA et un système métier. La sécurité repose sur l'authentification et la validation du serveur, les permissions du client et le mode de gestion de la connexion. L'agent n'a pas besoin de connaître les détails des API internes de chaque service. Il accède à une liste stable d'outils aux noms et paramètres clairs. Le serveur gère l'authentification, la validation, les appels aux API en amont, la normalisation des réponses et la gestion des erreurs.

Cette séparation est importante. Elle permet au client IA d'utiliser une fonctionnalité métier, comme `send_whatsapp_text_message`, au lieu d'apprendre l'intégralité de l'API ChatArchitect. Elle permet également à l'entreprise de préserver la confidentialité de ses données, paramètres internes et règles opérationnelles, qui ne sont pas utilisées comme arguments de l'outil d'interaction avec le modèle.

Qu'est-ce que ChatArchitect Cloud MCP Server ?

ChatArchitect Cloud MCP Server est une façade MCP distante publique pour l'API WhatsApp de ChatArchitect. Elle est implémentée en tant que service Node.js et TypeScript utilisant Express, createMcpExpressApp() de @modelcontextprotocol/expresset NodeStreamableHTTPServerTransport de @modelcontextprotocol/node.

Le serveur expose un point d'entrée de transport MCP public : POST /mcp. Les clients IA se connectent à ce point de terminaison, s'authentifient avec un jeton Bearer, découvrent les outils compatibles et appellent les actions autorisées par leur configuration client. Un jeton de compte valide donne accès à l'interface d'outils du serveur ; les restrictions et les politiques d'approbation spécifiques à chaque outil doivent être configurées dans le client IA.

Il s'agit d'une interface v1 ciblée, et non d'une reproduction intégrale des fonctionnalités de l'API ChatArchitect. L'implémentation actuelle limite volontairement l'interface publique. Elle expose 10 outils MCP pour la messagerie WhatsApp, les liens de paiement, les notifications, les modèles, les exportations, les messages d'échec, les webhooks et la facturation. Elle n'expose ni les invites ni les ressources MCP. Elle ne reçoit pas les notifications de livraison des webhooks. Elle ne prend pas en charge l'exécution de code source (SSE) sur la requête GET /mcp ; dans la v1, les GET /mcp et DELETE /mcp renvoient délibérément 405 (Méthode non autorisée).

Le principal avantage pour les clients est simple : ils peuvent connecter un agent IA aux flux de travail WhatsApp et ChatArchitect sans avoir à concevoir à partir de zéro leur propre serveur MCP, interface OAuth, validation de jetons, gestion du contexte de requête, client en amont, schémas d’outils et normalisation des réponses.

Pourquoi le MCP cloud est utile aux clients

ChatArchitect Cloud MCP Server fournit une couche d'intégration prête à l'emploi. Les clients connectent leur outil d'IA à un point de terminaison cloud, autorisent l'accès et disposent d'un ensemble stable d'actions WhatsApp et ChatArchitect. Les mises à jour, les mappages internes en amont, la validation des requêtes et le transport MCP sont gérés de manière centralisée.

Une équipe peut commencer par une simple réponse au support ou une notification interne, puis étendre ses flux de travail avec un CRM, un service d'assistance, n8n, l'API OpenAI Responses, ChatGPT, des outils d'IDE d'IA et des backends personnalisés. Il est essentiel de valider le comportement de chaque client en matière de transport, d'authentification et d'approbation avant le déploiement.

Ce que les clients peuvent faire avec

Pour les équipes commerciales, ChatArchitect MCP permet à un agent IA de répondre à une demande WhatsApp, de préparer une offre ou d'alerter un responsable lorsqu'un prospect devient urgent. Un formulaire web ne suffit pas à déclencher l'accès au service client de WhatsApp : toute prise de contact initiée par une entreprise en dehors des 24 heures de disponibilité nécessite un modèle de message validé.

Pour le support client, la connexion peut confirmer la réception d'une demande, envoyer une mise à jour de statut dans une fenêtre de service client ouverte ou transférer le contexte à un autre flux de travail.

Pour les opérations, les outils permettent de connecter les vérifications de facturation, les exportations, les notifications internes et les réponses WhatsApp aux flux de travail CRM. L'outil d'envoi WhatsApp actuel est limité au texte. La création ou la consultation de modèles ne fournit pas d'outil pour l'envoi de messages préétablis ; utilisez un flux ChatArchitect distinct lorsqu'un modèle est requis.

Pour les développeurs et les équipes d'automatisation, l'avantage principal réside dans la stabilité du protocole. Au lieu d'offrir à chaque flux de travail d'IA un accès direct aux identifiants API bruts et aux points de terminaison ChatArchitect, les développeurs peuvent connecter la couche d'IA à un serveur MCP sécurisé. Ce serveur valide les entrées à l'aide des schémas Zod, injecte les paramètres internes en amont, transforme les réponses ChatArchitect en contenu structuréet renvoie des erreurs prévisibles.

Comment ça marche

Agent IA / ChatGPT / API de réponses OpenAI / n8n / VSCode / Backend personnalisé | Serveur ChatArchitect Cloud MCP | API et logique métier ChatArchitect WhatsApp | Client sur WhatsApp

Le processus est simple :

Un agent IA reçoit une tâche, comme par exemple envoyer un suivi à un nouveau prospect.
Le client IA découvre les outils disponibles sur le serveur ChatArchitect MCP.
Le client appelle un outil via POST /mcp avec Authorization: Bearer <token>.
Le serveur MCP valide le jeton et extrait les informations d'identification du compte ChatArchitect du corps du jeton chiffré.
Le serveur valide les arguments de l'outil et appelle le point de terminaison amont requis de ChatArchitect.
La réponse est normalisée en contenu structuré.
Le résultat est renvoyé au client IA ou au flux de travail d'automatisation.

Le client IA ne reçoit ni app_id ni secret en tant que paramètres d'outil. Ces informations d'identification sont gérées au niveau de la couche d'autorisation, et non dans les invites ou les schémas exposés au modèle.

Modèle d'autorisation et de sécurité

Le point de terminaison MCP public n'accepte que l'authentification Bearer au niveau de la requête MCP. Le contrat de jeton est imbriqué : un JWE compact externe contient un JWT signé interne. Le jeton d'accès est chiffré avec dir et A256GCM, tandis que le JWT interne est signé avec HS256.

Le jeton doit contenir les revendications requises par le serveur : sub=chatarchitect-session, app_id, secret, exp, isset aud. L’émetteur doit correspondre à PUBLIC_BASE_URLet l’audience à ${PUBLIC_BASE_URL}/mcp. La portée fixe optionnelle est mcp.

Cette conception empêche l'utilisation des identifiants ChatArchitect dans les champs de saisie des outils d'interface et leurs réponses habituelles. La couche d'autorisation les transmet au serveur, qui utilise l'authentification Basic interne lors de l'appel à l'API ChatArchitect. Les identifiants restent confidentiels : saisissez-les uniquement sur la page d'autorisation sécurisée et évitez d'utiliser les jetons dans les invites, les fichiers de configuration partagés et les captures d'écran.

L'implémentation comprend également des délais d'expiration de requêtes, des délais d'expiration en amont, des limites de taille du corps, une protection de l'en-tête hôte via createMcpExpressApp() et ALLOWED_HOSTS optionnel , des identifiants d'application masqués dans les journaux enfants et des assistants de rédaction pour les valeurs sensibles.

Pour le contrôle côté client, les outils d'écriture peuvent être soumis à approbation dans l'application d'IA. Les outils en lecture seule, comme la consultation de la facturation ou l'affichage des modèles, peuvent généralement être autorisés sans approbation, tandis que les outils d'écriture, comme l'envoi d'un message WhatsApp ou la configuration de webhooks, peuvent nécessiter une confirmation humaine.

Outils MCP pris en charge

Le contrat MCP externe constitue la couche d'outils. Les noms des outils sont fixes et doivent être considérés comme des noms d'intégration stables.

Outils et types d'opérations de ChatArchitect MCP
Outil	Taper	Description
`envoyer_un_message_textuel_whatsapp`	Écrire	Envoie un message texte WhatsApp via ChatArchitect. Prend uniquement en charge le `WhatsApp` et les messages textuels. Les champs obligatoires sont `le canal`, `la destination`et `le texte` ; `l’identifiant externe` est facultatif.
`obtenir_url_de_paiement`	Création du lien de paiement	Génère et renvoie une URL de paiement ChatArchitect pour une adresse e-mail et un montant entier. `Le type de paiement` par défaut `carte »` ; les valeurs prises en charge sont `« carte »` et `« virement »`. Pour les comptes facturés en euros, le montant minimum est de 30 € quel que soit le mode de paiement. La création du lien n'effectue aucun paiement.
`envoyer_notification`	Écrire	Envoie une notification ChatArchitect avec `nom`, `source`et `texte`. La sortie normalisée confirme que la notification a été envoyée.
`créer_modèle`	Écrire	Crée un modèle ChatArchitect en mode texte uniquement. Les paramètres d'entrée incluent `element_name` (avec slug) , `language_code` , `category` , `content` , `example` (facultatif ) et `vertical` (obligatoire) . L'appel en amont utilise `templateType : « TEXT »` .
`export_chatarchitect_data`	Lecture seule	Exporte les données CSV de ChatArchitect. Les actions prises en charge sont : `appels téléphoniques`, `appels envoyés`, `appels reçus`et `conversations`. Les périodes prises en charge sont : `le mois dernier`, `ce mois-ci`, `hier`et `aujourd’hui`. `Le nombre de pages` doit être d’au moins 1.
`liste_modèles`	Lecture seule	Affiche les modèles ChatArchitect pour une destination WhatsApp. Les paramètres d'entrée sont `channel=whatsapp` et `destination`. La sortie est un tableau stable contenant les noms des modèles, les statuts et, éventuellement, les codes de langue.
`obtenir_derniers_messages_échoués`	Lecture seule	Renvoie les derniers messages non lus pour une destination WhatsApp. Les entrées sont `channel=whatsapp` et `destination`.
`définir_webhooks`	Écrire	Configure les URL des webhooks ChatArchitect. Les entrées publiques incluent les paramètres optionnels `webhook`, `webhook_separate`, `webhook_message_event`et `webhook_user_event`. Les URL des webhooks doivent utiliser `https://`.
`obtenir_webhooks`	Lecture seule	Lit la configuration actuelle du webhook ChatArchitect. Si le serveur backend en amont ne prend pas en charge la requête `GET /webhook` et renvoie une erreur `404` ou `405`, le serveur MCP associe cette erreur à l'état `« unsupported_by_backend »`.
`obtenir_facturation`	Lecture seule	Renvoie le récapitulatif de facturation avec `clients_max`, `due_date`, `clients_active`, `balance`et `billing_status` (`active` ou `expired`). Il s'agit d'un outil synthétique implémenté via un flux de requêtes interne à ChatArchitect.

Les outils de lecture sont : export_chatarchitect_data, list_templates, get_last_failed_messages, get_webhookset get_billing. Les outils permettant de modifier l’état ou de créer un objet sont : send_whatsapp_text_message, send_notification, create_template, set_webhookset get_payment_url.

Ces étiquettes décrivent les opérations ; il ne s’agit pas d’autorisations par outil appliquées par le serveur ni d’annotations de sécurité MCP. Configurez les outils autorisés et les approbations par nom d’outil dans votre client IA. Un pilote prudent exige une confirmation avant d’envoyer un message, de modifier des webhooks, de créer un modèle ou de générer un lien de paiement.

Exemple de scénario : répondre à une demande de renseignements sur WhatsApp

Un client contacte votre entreprise via WhatsApp pour demander une démonstration. Le message et son contexte CRM sont transmis à un système d'IA. Dans les 24 heures suivant ce message, l'agent prépare une réponse confirmant la demande et proposant un créneau horaire pour la démonstration.

Le client peut demander :

Veuillez rédiger une réponse à cette demande WhatsApp et proposer un appel de démonstration demain. Demandez-moi d'approuver le texte final avant de l'envoyer.

Le client IA constate que ChatArchitect MCP propose l'envoi de messages texte WhatsApp. Si l'outil est autorisé et que les règles d'approbation sont respectées, le client appelle le serveur MCP. Le serveur valide le jeton Bearer, vérifie que les champs de texte WhatsApp utilisés par l'outil sont uniquement compatibles, envoie le message via ChatArchitect et renvoie le résultat normalisé.

Conservez l'approbation du client et intégrez le résultat de l'outil à votre flux de travail. Pour les messages initiés par l'entreprise, obtenez le consentement requis. En dehors des heures d'ouverture du service client (24 h/24), utilisez un modèle approuvé via un flux d'envoi de modèles compatible plutôt que cet outil de messagerie uniquement. Consultez la politique de messagerie WhatsApp Business.

Options de connexion prises en charge

ChatArchitect Cloud MCP peut être utilisé depuis différents environnements d'IA et d'automatisation. L'interface utilisateur exacte dépend du client, mais la règle importante reste la même partout : utiliser l'URL complète du point de terminaison MCP, y compris /mcp.

https://api-mcp.chatarchitect.com/mcp

Si un client est configuré uniquement avec le domaine de base, il peut envoyer des requêtes MCP à / au lieu de /mcp, et les outils n'apparaîtront pas.

ChatGPT Web

Si votre abonnement ChatGPT et votre espace de travail autorisent les intégrations MCP personnalisées, ajoutez ChatArchitect en tant que plugin MCP personnalisé. Les administrateurs de l'espace de travail devront peut-être activer ou approuver l'accès.

Exemple de configuration :

Ouvrez la section Plugins de ChatGPT.
Sélectionnez +, puis Ajouter un serveur MCP personnalisé.
Saisissez cette URL de serveur et choisissez l'authentification OAuth :

https://api-mcp.chatarchitect.com/mcp

Créez le plugin, installez-le et terminez le processus d'autorisation.
Saisissez votre identifiant et votre secret d'application ChatArchitect uniquement sur la page d'autorisation de confiance.
Activez les outils nécessaires à votre scénario et testez d'abord une action orientée lecture.

Les libellés et la disponibilité des interfaces peuvent changer ; veuillez utiliser les instructions de connexion officielles ChatGPT MCP pour votre compte.

Exemple de message après la connexion :

Utilisez le plugin ChatArchitect pour afficher les modèles WhatsApp destinés à cette destination. N'envoyez aucun message sans ma confirmation du texte final.

Configurez explicitement les autorisations des outils et les actions d'écriture. Une demande de confirmation est utile, mais ne remplace pas les paramètres d'approbation du client.

n8n

n8n peut utiliser les outils MCP au sein des flux de travail d'automatisation. Utilisez le nœud Client MCP lorsque vous souhaitez qu'un appel MCP apparaisse comme une étape classique de votre flux de travail. Utilisez le nœud Outil Client MCP lorsque votre agent IA n8n doit pouvoir appeler des outils MCP externes.

Configuration recommandée pour ce serveur :

Ajoutez un nœud Client MCP ou un nœud Outil Client MCP si votre version n8n prend en charge le protocole HTTP en flux continu pour ce nœud.
Définissez l'URL du point de terminaison MCP sur :

https://api-mcp.chatarchitect.com/mcp

Choisissez l'authentification Bearer ou OAuth2.
Pour l'authentification Bearer, fournissez un jeton d'accès ChatArchitect MCP à durée de vie limitée :

Autorisation : Porteur <chatarchitect-mcp-token>

Pour l'authentification OAuth2, utilisez les métadonnées du serveur et les points de terminaison exposés par ChatArchitect MCP :

Métadonnées du serveur d'autorisation : https://api-mcp.chatarchitect.com/.well-known/oauth-authorization-server Métadonnées de la ressource protégée : https://api-mcp.chatarchitect.com/.well-known/oauth-protected-resource

Choisissez l'outil à appeler ou exposez les outils sélectionnés à un agent d'IA.

Exemple de flux de travail n8n :

Message WhatsApp entrant -> Vérifier la disponibilité du service client 24h/24 -> Un agent IA rédige une réponse -> Validation humaine -> Outil client MCP : send_whatsapp_text_message -> Mise à jour CRM

Consultez la documentation de l'outil client n8n MCP et les capacités de transport de votre version installée.

ChatArchitect MCP v1 n'implémente pas SSE sur GET /mcp ; GET /mcp renvoie 405.Si un nœud n8n ou une installation n8n plus ancienne n'accepte qu'un point de terminaison SSE, utilisez un nœud MCP compatible Streamable HTTP ou placez un adaptateur compatible devant le serveur MCP.

Code Claude

Claude Code prend en charge les serveurs HTTP MCP distants. Cela s'avère utile pour les équipes techniques qui souhaitent examiner ou tester les flux de travail ChatArchitect tout en travaillant dans un dépôt.

Configuration basée sur OAuth :

claude mcp ajouter --transport http chatarchitect https://api-mcp.chatarchitect.com/mcp

Ensuite, dans Claude Code, exécutez :

/mcp

Claude Code ouvre le flux OAuth pour les serveurs distants nécessitant une authentification. Une fois le flux terminé, les outils ChatArchitect deviennent disponibles dans la session Claude Code.

Si votre serveur génère un jeton Bearer à durée de vie limitée et que vous souhaitez le transmettre directement, utilisez une configuration basée sur un en-tête :

claude mcp add --transport http chatarchitect https://api-mcp.chatarchitect.com/mcp \ --header "Authorization: Bearer <chatarchitect-mcp-token>"

Pour une configuration de projet partagé en équipe, Claude Code peut également stocker les serveurs MCP dans un .mcp.json . Évitez de stocker les identifiants dans les fichiers partagés ; consultez la documentation MCP de Claude Code pour l’authentification et les permissions.

{ "mcpServers": { "chatarchitect": { "type": "http", "url": "https://api-mcp.chatarchitect.com/mcp" } } }

Exemple d'invite de code Claude :

Utilisez le serveur ChatArchitect MCP pour vérifier la facturation et consulter la liste des derniers messages WhatsApp ayant échoué. N'utilisez pas d'outils d'écriture.

Manuscrit

Codex peut se connecter à des serveurs MCP distants depuis l'interface de ligne de commande ou l'extension IDE. Ceci est utile lorsque les développeurs souhaitent que Codex examine les outils MCP de ChatArchitect, teste les contrats d'outils ou contribue à la création de flux de travail appelant des actions ChatArchitect.

Configuration de l'interface de ligne de commande :

codex mcp add chatarchitect --url https://api-mcp.chatarchitect.com/mcp codex mcp login chatarchitect codex mcp list

Configuration directe équivalente dans ~/.codex/config.toml :

[mcp_servers.chatarchitect] url = "https://api-mcp.chatarchitect.com/mcp"

Exécutez la commande codex mcp login chatarchitect pour démarrer OAuth et saisissez vos identifiants ChatArchitect sur la page d'autorisation de confiance.

Pour un jeton Bearer généré par le système, utilisez une variable d'environnement plutôt qu'un jeton littéral dans la configuration :

[mcp_servers.chatarchitect] url = "https://api-mcp.chatarchitect.com/mcp" bearer_token_env_var = "CHATARCHITECT_MCP_TOKEN"

Configurez la variable d'environnement CHATARCHITECT_MCP_TOKEN de manière sécurisée avant de démarrer Codex. Utilisez OAuth ou la configuration par jeton d'accès pour la connexion. Consultez la documentation Codex MCP pour plus d'informations sur les commandes et les options d'authentification.

Exemple d'invite Codex :

Utilisez le serveur ChatArchitect MCP pour examiner les outils disponibles. Ensuite, élaborez un plan de test sécurisé pour les fonctions `get_billing`, `list_templates` et `send_whatsapp_text_message`. N'envoyez aucun message WhatsApp sans mon approbation explicite du texte exact.

Curseur

Cursor prend en charge les serveurs MCP personnalisés via le fichier mcp.json. Utilisez une configuration au niveau du projet si la connexion ne doit s'appliquer qu'à un seul dépôt, ou une configuration globale si vous souhaitez que le serveur soit accessible à tous les projets.

Fichier au niveau du projet :

.cursor/mcp.json

Fichier global :

~/.cursor/mcp.json

Configuration du serveur distant de type OAuth :

{ "mcpServers": { "chatarchitect": { "url": "https://api-mcp.chatarchitect.com/mcp" } } }

Configuration du jeton d'authentification à l'aide d'une variable d'environnement :

{ "mcpServers": { "chatarchitect": { "url": "https://api-mcp.chatarchitect.com/mcp", "headers": { "Authorization": "Bearer ${env:CHATARCHITECT_MCP_TOKEN}" } } } }

Exemple d'invite de curseur :

Utilisez les outils MCP de ChatArchitect pour lister les modèles de messages pour cette destination WhatsApp. Si vous devez envoyer un message, rédigez-le d'abord et attendez l'approbation.

Activez uniquement les outils nécessaires au flux de travail et utilisez les contrôles d'approbation client pour les actions modifiant l'état. Consultez la documentation Cursor MCP pour la configuration et la gestion des variables d'environnement.

Quand devriez-vous utiliser ChatArchitect MCP ?

Utilisez ChatArchitect MCP si vous possédez déjà, ou prévoyez de créer, un flux de travail d'IA qui doit interagir avec WhatsApp ou ChatArchitect au lieu de se limiter à la production de texte. Cette solution est idéale si vous souhaitez qu'un agent IA envoie des messages WhatsApp, utilise des modèles, exporte les données de conversation, analyse les messages non lus, vérifie la facturation ou intègre les actions WhatsApp à votre CRM et à vos flux de travail de support.

Il est également utile pour définir un périmètre d'intégration précis. Le client IA peut être autorisé à appeler uniquement les outils sélectionnés. Les opérations d'écriture peuvent nécessiter une approbation. Les schémas d'outils restent restreints. Les secrets ne sont pas inclus dans les invites ni les arguments des outils. Les informations en amont restent au sein du serveur MCP.

Le point de terminaison cloud permet à votre équipe de se connecter sans déployer sa propre infrastructure MCP. Vous pouvez ainsi vous concentrer sur le flux de travail et l'expérience client, tandis que ChatArchitect assure la couche d'exécution.

Ce dont vous avez besoin pour commencer

Pour commencer à utiliser ChatArchitect Cloud MCP, vous avez besoin d'un compte ChatArchitect, d'une configuration active de l'API WhatsApp Business, d'un accès au point de terminaison MCP, d'une méthode d'autorisation pour le jeton Bearer MCP ou le flux OAuth, et d'un client d'IA ou d'un outil d'automatisation capable d'appeler MCP. Pour un premier test, choisissez un scénario simple : suivi d'un prospect, confirmation de prise en charge, rappel de paiement ou notification interne.

À partir de là, définissez les outils que le client IA peut utiliser. Une configuration prudente autorise généralement les outils en lecture seule sans approbation et exige une approbation pour les outils d'écriture. Par exemple, le client peut consulter librement les factures ou les modèles de listes, mais doit demander l'autorisation à un humain avant d'envoyer un message WhatsApp ou de modifier les paramètres d'un webhook.

FAQ

Est-ce réservé aux développeurs ?

Non. Les développeurs peuvent se connecter via l'API OpenAI Responses ou un backend personnalisé, mais les équipes d'automatisation peuvent également utiliser des outils sans code ou à faible code compatibles avec MCP. L'objectif est de fournir une interface d'outil standard utilisable par différents clients d'IA.

Dois-je héberger mon propre serveur MCP ?

Non. ChatArchitect Cloud MCP Server est conçu comme un point de terminaison MCP hébergé. Les clients se connectent à ce point de terminaison cloud au lieu de déployer et de gérer leur propre serveur MCP.

L'IA peut-elle envoyer des messages WhatsApp automatiquement ?

Oui, lorsque le client a configuré l'autorisation, les outils autorisés et les règles d'approbation. Pour les flux de travail sensibles, les outils d'écriture doivent exiger une confirmation avant exécution.

Puis-je exiger une approbation avant l'envoi ?

Oui. Configurez les règles d'approbation dans le client IA par nom d'outil. Le serveur actuel n'applique pas ces règles et ne publie pas d'annotations de sécurité par outil ; il est donc conseillé d'examiner le comportement du client plutôt que de supposer une classification automatique.

Puis-je désactiver ou restreindre l'accès ultérieurement ?

Vous pouvez déconnecter l'intégration ou désactiver les outils côté client. Cela contrôle le client, mais ne révoque pas les jetons déjà émis. Le serveur v1 actuel ne dispose pas de point de terminaison de révocation OAuth ; les jetons d'accès émis restent utilisables jusqu'à leur expiration. En cas de modification d'accès côté serveur, veuillez contacter ChatArchitect.

Est-ce adapté à la production ?

Le serveur inclut l'authentification Bearer, des jetons d'accès chiffrés, la validation de schéma, la gestion des délais d'expiration, la normalisation des réponses et des outils de rédaction. Ces fonctionnalités ne garantissent pas la conformité pour tous les déploiements. Avant la mise en production, il est recommandé de valider des flux de travail représentatifs dans un compte de test, de confirmer les approbations des clients, de surveiller les erreurs et de respecter les règles de WhatsApp Business.

Démarrez votre flux de travail MCP

Vous souhaitez connecter votre agent IA à WhatsApp ? Contactez ChatArchitect et nous vous aiderons à configurer Cloud MCP pour votre cas d’utilisation.

Vous avez déjà un flux de travail d'IA ? Envoyez-nous votre scénario et nous vous montrerons comment le connecter via MCP.

Décrivez votre flux de travail MCP

ChatArchitectCloud MCP pour agents IA WhatsApp