Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Les applications métier MCP connectent Microsoft 365 Copilot aux systèmes d’entreprise qui prennent en charge les fonctions métier principales, telles que CRM, la gestion des services informatiques, ERP et RH. Cet article fournit aux développeurs et aux architectes des modèles de conception de base et des pièges courants pour l’intégration des données, des relations, des autorisations et des flux de travail de ces systèmes.
Pourquoi les applications MCP métier nécessitent une conception supplémentaire
Dans un agent déclaratif, les applications MCP ajoutent un widget d’application interactif à une réponse d’un outil MCP. Microsoft 365 Copilot fournit le point d’entrée conversationnel, le serveur MCP se connecte à un système externe et le widget d’application permet aux utilisateurs de passer en revue, d’explorer ou d’agir sur les données sans quitter la conversation.
Les utilisateurs travaillant dans Microsoft 365 Copilot ont souvent besoin de récupérer des informations ou d’effectuer des actions dans les systèmes métier tels que Salesforce, ServiceNow, HubSpot, Microsoft Dynamics 365, les applications métier SAP, Workday, Jira et Coupa. Ces applications d’entreprise packagées incluent des structures de données, des relations et une logique métier prédéfinies étendues, que les organisations personnalisent souvent davantage. Par conséquent, même deux déploiements du même produit métier peuvent exposer des champs, des valeurs, des relations, des autorisations et des flux de travail différents. Les demandes des utilisateurs sont également variées et peuvent combiner des noms d’entreprise, des filtres, des enregistrements associés et des actions sans suivre une structure fixe.
Par exemple, un utilisateur peut demander à Copilot : « Rechercher Global Fizz et afficher ses enregistrements ouverts associés. » La prise en charge de demandes de ce type nécessite plus que l’exposition d’outils permettant de récupérer ou de mettre à jour les données. L’application MCP doit interpréter les termes métier, les valider par rapport à l’environnement cible, résoudre les enregistrements associés, préserver les contrôles d’accès et coordonner les flux de travail en plusieurs étapes. Ces exigences nécessitent des modèles délibérés dans la conception des outils, la gestion des données et les expériences interactives.
Pour obtenir des instructions de base, consultez Créer un plug-in MCP, Ajouter une interface utilisateur avec des applications MCP et Recommandations relatives à l’expérience utilisateur pour les applications MCP.
Les principes de conception suivants, basés sur les exemples de référence Salesforce, ServiceNow et HubSpot, relèvent ces défis du modèle de données grâce à la conception d’outils et aux flux de travail interactifs.
Mapper le modèle de données métier avant de définir les outils
Avant de définir les outils MCP que Copilot peut appeler, passez en revue les scénarios de conversation pris en charge et le modèle de données de l’application LOB. Chaque application métier dispose d’un modèle de données prêt à l’emploi, mais les organisations peuvent le personnaliser considérablement. Par conséquent, le schéma par défaut du produit ou un échantillon de référence peut ne pas correspondre à l’environnement cible. Vérifiez chaque entité et champ, y compris son nom d’API, son étiquette, son type de données, son status requis ou en lecture seule, ses valeurs acceptées et ses relations.
Travaillez avec l’équipe de personnalisation des applications métier pour identifier les changements spécifiques à l’environnement. Alignez le serveur MCP, les schémas d’outils et les widgets d’application sur le modèle de données actuel afin qu’ils ne s’écartent pas du système LOB.
Responsabilités distinctes entre les composants de l’application MCP
Les applications métier MCP doivent appliquer des règles métier personnalisées, conserver les autorisations du système source, résoudre les enregistrements associés et gérer les mises à jour conséquentes pour les instructions de l’agent, les outils MCP, l’intégration métier et le widget de l’application. Séparez ces responsabilités afin que les règles soient appliquées de manière cohérente et que chaque couche puisse être sécurisée, testée et modifiée indépendamment.
- Utilisez les instructions de l’agent et les descriptions des outils pour guider la sélection des outils et la préparation des arguments. Valider chaque appel d’outil sur le serveur ; Ne vous fiez pas aux instructions pour appliquer les autorisations, les valeurs autorisées, les relations ou la sécurité des requêtes.
- Utilisez le point d’entrée du serveur MCP (code qui reçoit les demandes MCP entrantes) pour acheminer les appels d’outils. Conservez les règles métier, la conversion de la valeur, la résolution de relations et la préparation des résultats dans les gestionnaires d’outils ou le code d’assistance utilisés par ces gestionnaires.
- Utilisez le client métier ou l’adaptateur pour l’authentification en aval et la communication API. Conservez la pagination, les tentatives, la limitation et la gestion des erreurs de système source derrière cette limite.
- Créez et gérez le widget de l’application dans ses fichiers sources. Le widget d’application affiche les résultats, collecte les entrées et utilise le pont hôte pour appeler les outils MCP. Il ne doit pas stocker d’informations d’identification, prendre des décisions d’autorisation ou appeler directement l’API LOB. Générez le widget d’application déployable HTML à partir de cette source ; Ne modifiez pas directement les fichiers générés.
Faire correspondre l’authentification au système métier
L’authentification au point de terminaison MCP et l’authentification du serveur MCP au système métier sont des limites distinctes. Les options suivantes décrivent l’authentification métier en aval. Vérifiez ce que le système cible prend en charge avant de choisir une approche :
- L’identité déléguée utilise le jeton de connexion de chaque utilisateur. Elle conserve les autorisations par utilisateur et l’historique des audits, mais nécessite la prise en charge des métiers, la configuration d’une authentification supplémentaire et la gestion des jetons.
- L’identité de l’application utilise un ID client avec un secret ou un certificat. Il simplifie l’accès de service à service, mais le système métier attribue les actions à l’application plutôt qu’à l’utilisateur.
- Les informations d’identification partagées utilisent un jeton privé, une clé API ou un mot de passe de compte de service pour tout le monde. Il est facile à configurer, mais le système métier ne peut pas appliquer d’autorisations ou d’attribution par utilisateur.
Pour connaître les options de point de terminaison MCP, consultez Authentification MCP.
Créez une expérience contextuelle, pas une autre application
Les systèmes métier fournissent déjà des applications complètes pour les flux de travail, l’exploration et l’administration. Ne recréez pas cette application ni ne répliquez ses écrans dans une application MCP. La réplication en mode plein écran augmente le temps de chargement et rend l’expérience moins conversationnelle. Utilisez une application LOB MCP pour l’interface utilisateur ciblée requise par la conversation actuelle, et dirigez le travail plus large vers le système LOB.
Laissez la conversation définir la tâche et utilisez le widget de l’application lorsque la tâche bénéficie d’une révision ou d’une interaction structurée.
Par exemple, un utilisateur peut demander :
Utilisateur : « Affiche mes opportunités ouvertes qui se terminent ce mois-ci. »
Le widget d’application peut présenter les enregistrements filtrés pour révision et modification sans reproduire l’expérience CRM complète.
Permettre aux utilisateurs de parcourir les entités métier associées dans le widget de l’application
Les informations relatives aux secteurs d’activité sont souvent diffusées entre des entités liées. Pour comprendre un compte, un incident, un employé ou un fournisseur, vous devrez peut-être afficher les enregistrements associés tout en gardant l’enregistrement principal dans son contexte. Utilisez l’état des widgets de l’application et les fonctionnalités UX, telles que les sections extensibles ou les vues détaillées, afin que les utilisateurs puissent explorer ces relations sans effectuer de requête conversationnelle distincte pour chaque entité.
Par exemple, lorsqu’un utilisateur demande un compte à Copilot, le compte retourné devient l’enregistrement principal que le widget d’application conserve en contexte :
Utilisateur : « Afficher le compte global. »
Affichez les champs clés du compte avec des contrôles pour les entités associées telles que les opportunités, les cas et les contacts. Conservez le contexte du compte à l’état de widget d’application. Lorsqu’une vue sélectionnée a besoin de données associées, appelez l’outil MCP approprié via le pont hôte en utilisant l’ID de compte actuel. Ne chargez les enregistrements associés que lorsque l’utilisateur ouvre cette vue et gardez l’enregistrement principal visible.
Utilisez des listes pour afficher les champs clés à réviser et ajoutez un bouton Modifier qui ouvre le formulaire détaillé pour l’enregistrement sélectionné.
La conversation établit le contexte métier une seule fois, et l’interface utilisateur permet à l’utilisateur de continuer à explorer ce contexte par le biais d’une interaction directe.
La demande initiale peut nommer à la place la vue associée souhaitée par l’utilisateur :
Utilisateur : « Afficher les opportunités pour le compte global. »
Utilisez l’expérience de traversée d’entité associée uniquement lorsque les utilisateurs ont besoin d’explorer plusieurs enregistrements. Les écrans de traversée sont plus lourds car ils conservent le contexte et chargent plusieurs vues associées. Garder les widgets d’application inline ciblés. Lorsque la traversée nécessite plus d’espace, utilisez une surface étendue qui préserve la conversation. Pour les opérations indépendantes, utilisez un widget d’application ciblé conçu pour cette tâche.
Préremplir les widgets de l’application avec le contexte de conversation
Lorsqu’un utilisateur crée un enregistrement métier, le formulaire peut contenir de nombreux champs obligatoires, à valeurs contrôlées et de relations. Les utilisateurs fournissent souvent certaines de ces informations dans leur demande. Remplissez à l’avance ces valeurs dans le formulaire de création afin que l’utilisateur puisse les consulter et remplir les champs restants sans répéter les informations. Ce modèle utilise la conversation pour fournir un contexte et le widget d’application pour fournir une révision et une interaction structurées.
Par exemple, la requête de l’utilisateur peut fournir des valeurs pour plusieurs champs de formulaire :
Utilisateur : « Crée un contact pour Maya Chen chez Contoso avec l’e-mail
maya@contoso.com. »
show_create_form(
entity="contact",
prefill={"first_name": "Maya", "last_name": "Chen",
"email": "maya@contoso.com", "company_name": "Contoso"}
)
Le widget de l’application s’ouvre avec ces valeurs renseignées afin que l’utilisateur puisse les examiner et compléter les champs manquants. Traiter les valeurs préremplies comme des entrées utilisateur : validez-les sur le serveur MCP avant de créer l’enregistrement.
Utilisez Work IQ lorsque le contexte de travail Microsoft 365 peut améliorer la tâche. Il peut aider à mettre en place les demandes impliquant « my » et fournir un contexte pertinent pour la création ou la mise à jour d’enregistrements.
Concevoir des outils et des interactions pour les données métier
Concevoir des outils autour des opérations commerciales
Les systèmes métier exposent généralement des API volumineuses et complexes avec de nombreuses entités et opérations. Ne mettez pas en miroir l’API entière sous forme d’outils MCP. Définissez un ensemble ciblé d’opérations commerciales dont les utilisateurs ont besoin et attribuez à chaque outil un nom, une description et un schéma d’entrée distincts. Continuez à prendre en charge les tâches, telles que la création de filtres d’API et la résolution des noms d’enregistrements associés, à l’intérieur du serveur MCP.
Concevez des outils et des widgets d’application ensemble. Réutilisez un petit ensemble de widgets d’application optimisés pour les types d’interaction courants, tels que les listes, les formulaires et les vues détaillées, plutôt que de créer un widget distinct pour chaque outil ou entité. Cette approche maintient la cohérence de l’expérience utilisateur et réduit le code de widget, les frais généraux de chargement et la maintenance.
Créez des outils distincts pour les opérations courantes telles que la recherche, la création et la mise à jour :
get_records(...)
create_record(...)
update_record(...)
Évitez également un outil sans restriction qui accepte toute entité et action. Son schéma large rend la validation, l’autorisation, le routage et le traitement des résultats moins prévisibles.
Gérer les correspondances d’enregistrement avant affichage ou modification
Les utilisateurs recherchent généralement les enregistrements métier par noms professionnels, tels que les noms de compte, d’entreprise ou de contact, plutôt que par ID d’enregistrement stable. Les identifiants d’enregistrement contiennent souvent de nombreux chiffres et ne sont pas pratiques à mémoriser ou à entrer dans la conversation. Par exemple, un enregistrement Salesforce peut avoir un ID de 18 caractères tel que 0015g00000ABCDeAAH, qu’un utilisateur a peu de chances de connaître ou de taper. Les noms d’entreprise sont souvent des noms propres, et les utilisateurs peuvent entrer des valeurs partielles ou faire des fautes d’orthographe. Une recherche peut donc correspondre à zéro, un ou plusieurs enregistrements. Utilisez un modèle de résolution nom à ID pour transformer le texte de l’utilisateur en un ID d’enregistrement stable vérifié avant l’affichage ou la modification. Cette approche permet d’éviter d’appliquer l’opération à un enregistrement incorrect. Ne présumez jamais que le premier match est l’enregistrement prévu. Déclarez les champs de recherche pris en charge et le paramètre record-ID dans le schéma de l’outil.
Par exemple, un utilisateur peut identifier le compte à modifier par son nom :
Utilisateur : « Modifier le compte global ».
Tout d’abord, appelez l’outil avec le texte de l’utilisateur :
get_accounts(name="Global")
Le serveur MCP mappe le texte à une recherche prise en charge Contains ou LIKE avec une limite de résultats. Pour plus d’informations sur le mappage de filtres vers des opérateurs de requête métier, consultez Créer des listes filtrées sur le serveur MCP. Cette approche découvre les enregistrements candidats lorsque l’utilisateur ne fournit pas le nom exact stocké. Renvoie des résultats de candidats légers avec chaque ID stable et les champs reconnaissables nécessaires pour distinguer les enregistrements :
{
"structuredContent": {
"type": "accounts",
"items": [
{
"id": "0015g00000ABCDeAAH",
"name": "Global Media"
},
{
"id": "0015g00000FGHIjAAH",
"name": "Global Manufacturing"
}
]
}
}
Une fois les résultats du candidat retournés, continuez en fonction du nombre de correspondances. Pour une correspondance unique et non ambiguë, appelez à nouveau l’outil avec son ID et l’action demandée. Pour plusieurs correspondances, affichez une liste avec des contrôles Afficher ou Modifier ; le contrôle sélectionné appelle l’outil avec l’ID de cet enregistrement. Dans les deux cas, le deuxième appel utilise l’ID résolu et l’action demandée :
get_accounts(account_id="0015g00000ABCDeAAH", action="edit")
Si aucun enregistrement ne correspond, invitez l’utilisateur à affiner la recherche.
Capturez ce modèle de deux appels dans les instructions de l’agent et déclarez à la fois le filtre de nom et l’entrée d’ID d’enregistrement dans la définition de l’outil :
{
"name": "get_accounts",
"description": "Get accounts. Pass account_id to retrieve one record; add action='edit' to open the edit form. Filters: name, industry, account_number, and type.",
"handler": get_accounts,
}
Mapper les valeurs et dépendances des listes contrôlées et choisies
Les systèmes métier utilisent souvent des champs à valeurs contrôlées, également appelés listes de sélection, champs de choix ou énumérations. Les utilisateurs voient des étiquettes telles que Closed Won, tandis que l’API peut nécessiter un code stocké tel que closedwon. Ne présumez pas qu’une étiquette familière a la même valeur stockée à chaque implémentation.
Les champs à valeurs contrôlées acceptent uniquement les valeurs configurées dans l’environnement métier cible. Les valeurs stockées peuvent être des codes texte, des chiffres ou d’autres identificateurs système. L’utilisation d’une étiquette d’affichage, de texte arbitraire ou d’une valeur stockée obsolète dans des requêtes ou d’autres demandes CRUD peut entraîner des erreurs de validation, des échecs d’écriture ou des résultats manquants.
Récupérez des étiquettes et des codes à partir de l’API de métadonnées LOB et mettez-les en cache pour référence. Si le système métier ne fournit pas d’API de métadonnées, maintenez et vérifiez les mappages via la configuration administrative. Actualisez les mappages mis en cache ou configurés lors de la modification de la configuration source afin que les outils et les widgets de l’application ne dérivent pas.
Par exemple, la recherche suivante qui ne respecte pas la casse traduit une étiquette orientée utilisateur en son code stocké :
label_to_code = {item["label"].casefold(): item["value"] for item in allowed_values}
normalized_value = user_value.casefold()
if normalized_value not in label_to_code:
raise ValueError("The value is not supported by the LOB system.")
status_code = label_to_code[normalized_value]
Lorsque les champs à valeurs contrôlées ont des dépendances (une sélection en contrôle une autre), capturez ces relations dans les métadonnées utilisées par le serveur MCP et le widget d’application. Par exemple, si la sous-catégoriedes contrôles de catégorie, la sélection de Matériel ne doit afficher que ses sous-catégories autorisées. Validez la combinaison sélectionnée sur le serveur MCP avant d’écrire dans le système LOB.
valid_codes = dependencies[category_code]
if subcategory_code not in valid_codes:
raise ValueError("The subcategory is not valid for the selected category.")
Créer des listes filtrées sur le serveur MCP
Les requêtes métier combinent souvent des conditions de différents types de champs et enregistrements associés. Les utilisateurs expriment ces conditions par des étiquettes et des noms métiers, tandis que l’API LOB nécessite des noms de champs exacts, des valeurs stockées, des types de données et des opérateurs de requête. Définissez un outil de liste ciblé pour chaque entité commerciale prise en charge afin que le serveur MCP puisse valider, traduire et exécuter la requête complète.
Par exemple, un utilisateur peut exprimer un montant minimal en termes commerciaux :
Utilisateur : « Montrer des offres d’une valeur d’au moins 20 000. »
Les instructions de l’agent indiquent à Copilot de faire correspondre la demande à un outil approprié et d’utiliser uniquement les filtres déclarés dans sa description. Le schéma et le gestionnaire de l’outil rejettent les filtres non pris en charge.
Avant d’appeler un outil de liste, faites correspondre chaque condition de la requête de l’utilisateur à un filtre déclaré dans la description de l’outil. N’omettez pas une condition non prise en charge ou ne la remplacez pas par un autre filtre. Demandez à l’utilisateur de réviser la demande lorsque l’outil ne prend pas en charge un filtre demandé.
Copilot interprète « au moins 20 000 » comme une condition de montant minimum. Il sélectionne get_deals parce que la description de l’outil déclare le filtre correspondant amount_min :
{
"name": "get_deals",
"description": "Get deals. Filters: amount_min (inclusive minimum amount), stage.",
"handler": get_deals,
}
Copilot mappe ensuite la condition au paramètre d’outil déclaré :
get_deals(amount_min="20000")
Le serveur MCP valide la valeur et mappe le paramètre de l’outil au champ et à l’opérateur requis par l’API LOB :
FILTERS = {"amount_min": ("amount", ">=")}
def build_filter(parameter: str, value: str) -> str:
field, operator = FILTERS[parameter]
return f"{field} {operator} {float(value)}"
lob_filter = build_filter("amount_min", "20000")
Les enregistrements métier contiennent de nombreux types de données et chacun peut nécessiter une forme de paramètre et un opérateur de requête différents. L’application d’un modèle de filtrage à chaque champ peut entraîner des requêtes non valides ou des résultats incorrects. Mappez chaque type de données pris en charge aux paramètres et opérateurs appropriés :
| Type de données | Opérateur | Modèle de paramètres | Exemple |
|---|---|---|---|
| Texte de forme libre | Contient ou LIKE |
Un paramètre | name |
| Valeur contrôlée | Égalité | Un paramètre | stage |
| Enregistrement connexe | Égalité | Un paramètre | account_id |
| Nombre | Limites inférieure et supérieure |
*_min, *_max |
amount_min, amount_max |
| Date | Limites de début et de fin |
*_from, *_to |
close_date_from, close_date_to |
Pour les filtres de texte utilisés pour localiser un enregistrement, Contains ou LIKE les résultats sont des candidats plutôt qu’une identité vérifiée. Résolvez le candidat prévu à son ID d’enregistrement stable avant une opération d’affichage ou de modification.
Validez et mettez en forme chaque valeur avant de l’ajouter à la requête LOB. Exécutez toutes les conditions comme une seule requête côté serveur plutôt que de demander à Copilot de combiner les résultats de plusieurs appels d’outils, ce qui peut perdre des filtres ou produire des résultats incohérents. Renvoyer une liste structurée faisant autorité.
Lorsque l’utilisateur affine la demande ultérieurement, conservez les filtres applicables et ajoutez ou remplacez uniquement les conditions qui ont changé :
Utilisateur : « Montrer des offres d’une valeur d’au moins 20 000. »
Utilisateur : « Maintenant, ne montrez que les transactions conclues. »
get_deals(amount_min="20000", stage="Closed Won")
Retournez le même type de liste structurée après chaque affinement afin que l’hôte restitue les résultats de manière cohérente.
Limiter et mettre en cache les résultats de liste
Les entités métier peuvent contenir des milliers d’enregistrements et leurs API peuvent être lentes ou ralenties. Le renvoi de listes volumineuses augmente le temps de réponse et la taille de la charge utile, tandis que leur affichage submerge le widget de l’application et occupe trop d’espace dans Microsoft 365 Copilot.
Appliquez des limites de résultats par défaut et maximales au serveur MCP, utilisez un tri prévisible et indiquez quand davantage d’enregistrements sont disponibles. Permettez aux utilisateurs d’affiner leurs filtres ou d’utiliser une action Charger plus explicite soutenue par la pagination côté serveur.
Mettez en cache les résultats de liste, de métadonnées et d’enregistrements associés appropriés pour réduire les appels répétés de l’API métier :
cache = TTLCache(maxsize=200, ttl=120)
items = None if refresh else cache.get(cache_key)
Choisissez des délais d’expiration en fonction de la fréquence à laquelle les données changent. Incluez la requête et le contexte de sécurité dans les clés de cache, ne partagez pas les résultats spécifiques à l’utilisateur entre les utilisateurs et invalidez les entrées affectées après les écritures. Lorsque l’utilisateur demande des données actualisées ou les plus récentes, contourner le cache et appeler l’API LOB.
Résoudre les noms associés dans des listes sans recherche N+1
Les données métier sont hautement relationnelles. Les enregistrements stockent souvent des liens vers des comptes, des contacts, des propriétaires ou d’autres entités en tant qu’ID système, et peuvent inclure des relations autoréférentielles telles que des comptes parents ou des hiérarchies de responsable. Les utilisateurs, cependant, ont besoin de noms d’entreprise reconnaissables. La résolution de chaque ID à l’aide d’une requête distincte crée un modèle de requête N+1 qui devient plus lent à mesure que la liste et ses relations augmentent.
Utilisez d’abord la fonctionnalité de projection, de jointure ou d’affichage de valeur de relation de l’API métier pour renvoyer des noms liés à la requête d’origine. Si cette option n’est pas prise en charge, collectez les clés étrangères uniques et utilisez la fonctionnalité d’association de lots, de lecture de lots ou IN de requête du système LOB.
Le flux de secours est le suivant :
retrieve records → collect unique foreign keys → batch-read related names
Résolvez les valeurs associées sur le serveur MCP avant de renvoyer la liste structurée. Cette approche remplace les recherches par ligne par un petit nombre de requêtes et réduit le temps de chargement et le risque de limitation.
Créer des agrégations sur le serveur MCP
Les entités métier peuvent contenir des centaines de milliers d’enregistrements ou plus. Les résumés et les tableaux de bord peuvent agréger ces données entre catégories, étapes, propriétaires ou périodes. Ne récupérez pas tous les enregistrements sous-jacents et demandez à Copilot ou au widget de l’application de calculer le résultat. Utilisez des API d’agrégation métier ou des requêtes groupées sur le serveur MCP et retournez uniquement les données calculées dont le widget d’application a besoin. Si l’API métier ne prend pas en charge l’agrégation, calculez le résultat sur le serveur MCP à partir d’un ensemble de données paginées limitées et indiquez clairement l’étendue à l’utilisateur.
Résoudre les relations avant de créer l’enregistrement
Les utilisateurs reconnaissent les enregistrements associés par des noms tels que société, contact, propriétaire ou compte parent, mais les API métier nécessitent des ID d’enregistrement que les utilisateurs ne connaissent généralement pas ou ne fournissent pas lors de la création ou de la mise à jour d’un enregistrement. Acceptez des noms reconnaissables pour les entrées de relation, puis résolvez-les en interne dans les ID d’enregistrement requis par l’API LOB.
Étiqueter le champ en tant qu’enregistrement associé ; un indicateur tel que peut Company: Contoso 🔗 renforcer le fait que le serveur résout le nom.
Lorsque l’utilisateur sélectionne Enregistrer, résolvez chaque relation en un seul enregistrement correspondant auquel l’utilisateur est autorisé à accéder et à associer avant d’appeler l’API de création. Ne sélectionnez jamais la première correspondance lorsqu’un nom est ambigu :
"Contoso" → company_id="company_123"
Si un nom n’est pas résolu ou ambigu, laissez le formulaire et ses valeurs ouverts et affichez une alerte structurée permanente avec des correspondances possibles. Laissez l’utilisateur sélectionner l’enregistrement souhaité, puis soumettre à nouveau son ID d’enregistrement stable.
Retourner cette condition corrigible dans structuredContent plutôt que de définir le niveau isErrorsupérieur , afin que le widget de l’application puisse demander une correction sans traiter l’appel d’outil comme un échec.
Protéger les modifications relationnelles pendant les mises à jour
Les modifications apportées aux relations peuvent avoir un impact commercial plus important que les modifications de champ classiques, telles que le changement de propriétaire de compte, la réattribution d’un incident ou le déplacement d’un contact vers une autre société.
Un modèle plus simple consiste à conserver les champs de relation en lecture seule dans les formulaires de modification généraux :
Company: Contoso 🔗 [read-only]
Cette approche permet à l’utilisateur de comprendre les relations de l’enregistrement sans faire ressembler une réaffectation conséquente à une modification de texte ordinaire.
Lorsque les modifications de relation sont prises en charge, un outil dédié les sépare des mises à jour générales.
Utiliser des outils dédiés pour les actions ayant des effets plus larges
Certaines actions commerciales font plus que mettre à jour un champ et disposent d’une API métier dédiée. Dans un système CRM, la conversion d’un prospect peut créer des enregistrements de compte, de contact et d’opportunité connexes et appeler des règles de flux de travail supplémentaires.
Représentez ces opérations avec des outils dédiés :
convert_lead(lead_id="lead_123", create_opportunity=true)
L’outil dédié appelle le fonctionnement natif du système métier plutôt que de le reconstruire via des appels génériques de création ou de mise à jour, qui peuvent contourner la validation, la création d’enregistrements associés, le comportement du flux de travail et l’historique d’audit.
La résolution d’un incident grâce à l’action native de ServiceNow est un autre exemple d’opération métier dédiée.
Commencer à créer une application MCP métier
Utilisez l’une des options suivantes pour appliquer ces principes de conception :
- Personnaliser une application fonctionnelle : Ouvrez l’onglet Applications MCP dans la bibliothèque d’agents du kit d’agent Microsoft Microsoft Copilot pour télécharger des applications MCP métier pour Salesforce CRM, ServiceNow ITSM et HubSpot CRM. Ensemble, ces applications illustrent les modèles décrits dans cet article et peuvent être adaptées au modèle de données et aux flux de travail de votre organisation.
- Explorez le code source : Examinez les exemples d’interface utilisateur interactive MCP pour le serveur, le widget d’application et la source de déploiement.
Connectez une application à un environnement de développement, essayez les expériences présentées dans cet article et adaptez-les à vos propres workflows métier.