Champs personnalisés : CRM, API, chat et MCP - Relaticle         

Des champs personnalisés qui fonctionnent partout, sans code par champ
======================================================================

Comment Relaticle rend les champs personnalisés disponibles dans les formulaires, les API, le chat et MCP, avec une normalisation commune, une sémantique claire des valeurs vides et des limites explicites.

 Manuk Minasyan · 22 septembre 2026 · 12 min de lecture

 ![Des champs personnalisés qui fonctionnent partout, sans code par champ](https://relaticle.com/storage/ink/01M7T4K2T308H2TFQG07X6QH92.png) 

Nous avons conçu les attributs personnalisés pour les utiliser dans l'application web, l'API REST, Rela, l'assistant IA intégré, et les outils MCP. Une fois l'attribut défini dans Relaticle, aucun déploiement ni code d'intégration propre à cet attribut n'est nécessaire. La clé n'est pas une intégration distincte pour chaque surface. Un chemin d'écriture unique accepte `custom_fields`. Il valide les valeurs selon la définition actuelle de l'espace de travail et les sauvegarde avec l'enregistrement. Cela paraît banal, jusqu'à ce qu'un agent ait besoin de libellés plutôt que d'ID d'options. Un client de l'API attend des valeurs typées. Et une valeur vide doit signifier autre chose qu'une clé omise.

Le résultat est un contrat volontairement réduit. Vous définissez le champ dans l'interface. Vous l'envoyez avec les autres attributs modifiables de l'enregistrement. L'application s'occupe du reste. Cet article présente le mécanisme et une limite de permissions. Désactiver un champ bloque les écritures, mais ne cache pas son existence au chat. Il n'existe pas de contrôle de visibilité par surface.

[](#une-définition-quatre-surfaces "Permalink")Une définition, quatre surfaces
------------------------------------------------------------------------------

Les attributs personnalisés ne sont pas une charge utile annexe que chaque intégration devrait interpréter seule. Le modèle de l'enregistrement porte le comportement grâce à `UsesCustomFields`. Le trait ajoute `custom_fields` aux attributs modifiables et enregistre les valeurs quand l'enregistrement est sauvegardé. Les actions transmettent `custom_fields` tel quel. Elles n'en extraient aucun champ et ne traitent pas leurs noms comme des cas particuliers.

Ce choix rend le comportement des surfaces ennuyeux, au bon sens du terme. Un champ accompagne l'enregistrement dans le même chemin d'action, quelle que soit l'origine de la modification. Une personne peut modifier un formulaire ou un client de l'API envoyer une mise à jour. Un assistant peut proposer une modification ou un outil MCP écrire la valeur. Un champ ajouté depuis l'interface est donc disponible immédiatement dans l'API et dans le chat. Aucun déploiement ne suit. Aucun développeur n'ajoute de branche conditionnelle pour ce champ.

| Surface | Ce qu'elle reçoit |
|---|---|
| Formulaire de l'application web | La saisie du champ dans le cadre de la modification de l'enregistrement |
| API REST | `custom_fields` à côté des attributs natifs |
| Rela | Les codes de champ et les libellés d'options dans le schéma de ses outils |
| Outils MCP | La même surface d'écriture des enregistrements |

| Surface | Ce que fournit le chemin commun |
|---|---|
| Formulaire de l'application web | Une valeur d'attribut personnalisé enregistrée à la sauvegarde |
| API REST | Une validation dynamique et le chemin d'écriture normal |
| Rela | La traduction des libellés, la validation et une proposition à approuver |
| Outils MCP | Des attributs personnalisés disponibles sans modifier les outils champ par champ |

Cette distinction compte, car les alternatives échouent de façon prévisible. Un schéma d'API statique devient obsolète dès qu'un espace de travail définit un champ. Un outil d'IA sur mesure pour chaque champ transforme la configuration en travail de déploiement. Un chemin de persistance séparé peut faire fonctionner un champ sur un écran et le faire disparaître sans bruit sur un autre. Nous avons placé le comportement commun du modèle au centre, puis gardé les surfaces individuelles légères.

[](#léventail-des-champs-dépasse-la-zone-de-texte "Permalink")L'éventail des champs dépasse la zone de texte
------------------------------------------------------------------------------------------------------------

Relaticle propose des champs de type texte, nombre, devise, date, choix, contact, éditeur enrichi et lien vers un enregistrement. FileUpload et MarkdownEditor sont des types retirés. Utilisez RichEditor pour le contenu mis en forme et les pièces jointes prises en charge.

Cette liste explique pourquoi une simple table de chaînes ne suffirait pas. Un choix unique a besoin d'options. Un choix multiple en a besoin de plusieurs. Une date et une devise n'ont pas les mêmes exigences de validation et de présentation. L'implémentation doit préserver ces différences sans obliger chaque appelant à connaître les détails de chaque type.

Le trait du modèle fournit le point d'intégration pour la persistance. La requête REST et le schéma du chat fournissent des points d'intégration adaptés aux types. Il existe ainsi un seul endroit où définir les valeurs valides, et chaque surface peut tout de même les présenter sous la forme qui convient à son utilisateur.

![Le constructeur d'attributs personnalisés, avec des attributs d'opportunité définis par l'utilisateur à côté des champs système](https://relaticle.com/storage/ink/01M0YZS17J66XVASD4PG1S4H7P.png)

Pour la liste complète des champs et l'aide à la configuration, consultez [la référence des types d'attributs personnalisés](https://relaticle.com/fr/help/custom-fields/field-types-you-can-add).

[](#la-validation-rest-est-assemblée-à-partir-du-schéma-actuel "Permalink")La validation REST est assemblée à partir du schéma actuel
-------------------------------------------------------------------------------------------------------------------------------------

L'API REST ne peut pas traiter les attributs personnalisés comme des métadonnées non vérifiées. Chaque requête de création et de mise à jour intègre dynamiquement les règles de validation des attributs personnalisés de l'espace de travail. Un attribut personnalisé est donc validé et écrit comme un attribut natif, alors que sa définition n'existait pas lors du déploiement du code de l'API.

Le sens de cette dépendance est essentiel. La requête ne définit pas elle-même les champs existants. L'application lit la définition actuelle du champ, puis étend la validation avant d'accepter l'écriture. Un nouveau champ est disponible parce que la définition est une donnée, et non parce qu'une route a changé.

La couche de réponse évite aussi de donner aux clients un détail d'implémentation. Les valeurs de choix unique et de choix multiple sont renvoyées sous forme d'objets `{id, label}` et non d'ID d'options bruts. L'ID identifie l'option. Le libellé donne du sens à la valeur dans la réponse au client. Renvoyer les deux évite à un client de l'API d'inventer une seconde requête rien que pour afficher un choix enregistré.

L'API REST convient donc aux intégrations qui veulent un contrat d'écriture stable, mais pas de couche de correspondance propre au schéma de chaque espace de travail. Elle donne aussi à l'API et à l'application web la même frontière de validation. Nous n'avons pas à décider si un attribut personnalisé est un « champ d'API » ou un « champ de formulaire ». C'est un champ de l'enregistrement.

La [documentation de l'API REST](https://relaticle.com/developers/api) est le point de départ quand un système externe doit lire ou écrire ces enregistrements.

[](#le-chat-a-besoin-dune-correspondance-entre-libellés-et-identifiants "Permalink")Le chat a besoin d'une correspondance entre libellés et identifiants
--------------------------------------------------------------------------------------------------------------------------------------------------------

Rela ne reçoit pas une référence statique pour développeurs dont il devrait déduire le reste. Il reçoit un schéma construit à partir des champs actifs de l'espace de travail. Un service de description de schéma insère les codes de champ et les libellés d'options dans le schéma d'outils que voit le modèle.

Cette formulation est volontaire. Un modèle doit voir le libellé qu'emploie une personne, plutôt que d'avoir à inventer ou à mémoriser un ID d'option. Il peut formuler une requête avec le code du champ et un libellé d'option. Au moment de la validation, une couche de traduction convertit le libellé en ID d'option, celui qu'attend la persistance.

| Étape du chat | Représentation |
|---|---|
| Description du schéma | Codes de champ et libellés d'options |
| Validation | Libellés traduits en ID d'options |
| Carte de proposition | Comparaison ancienne et nouvelle valeur selon le type de champ |

| Étape du chat | Raison |
|---|---|
| Description du schéma | Le modèle peut employer le vocabulaire de l'espace de travail |
| Validation | La valeur enregistrée correspond à l'option configurée |
| Carte de proposition | Une personne peut examiner la modification prévue |

La dernière étape fait partie du contrat du produit et n'est pas un aperçu cosmétique. Les écritures du chat deviennent des cartes d'approbation en attente. Un humain les approuve ou les écarte. Afficher la comparaison entre l'ancienne et la nouvelle valeur selon le type de champ permet à cette personne d'évaluer la modification réellement proposée avant son enregistrement.

Le chat est ainsi plus sûr que s'il supposait qu'une demande en langage naturel se suffit à elle-même. « Change le statut » ne donne pas assez d'informations pour une revue. La proposition doit montrer quel attribut personnalisé change et quelle est la nouvelle valeur.

![Une carte de proposition du chat montrant les changements entre ancienne et nouvelle valeur pour quatre attributs personnalisés d'une opportunité](https://relaticle.com/storage/ink/01M0YZRTZSHZ02FV9MJ9F2ZJHR.png)

MCP se comporte autrement à l'écriture. Les écritures des outils MCP sont enregistrées directement, sans étape d'approbation. La même définition de champ et le même chemin d'écriture s'appliquent toujours, mais l'appelant doit choisir sa frontière de contrôle en conséquence. Pour les enseignements de conception liés à la surface d'outils, lisez [Concevoir une suite d'outils MCP pour un CRM](https://relaticle.com/fr/blog/concevoir-une-suite-d-outils-mcp-pour-un-crm). Pour la configuration du client, lisez [connecter Claude à votre CRM avec MCP](https://relaticle.com/fr/blog/connecter-claude-a-votre-crm-avec-mcp).

[](#absent-nest-pas-vide "Permalink")Absent n'est pas vide
----------------------------------------------------------

Une règle pèse plus lourd pour les agents qu'il n'y paraît : pour un champ facultatif, un `null` explicite efface sa valeur. Les champs à valeurs multiples acceptent aussi `[]`. Les clés omises laissent les valeurs inchangées. La validation des champs obligatoires peut refuser l'effacement.

| État de la charge utile | Résultat |
|---|---|
| La clé du champ est absente | La valeur existante reste intacte |
| La clé d'un champ facultatif vaut `null` | Le champ est effacé |
| Un champ facultatif à valeurs multiples vaut `[]` | Le champ est effacé |
| La clé du champ a une valeur | La valeur est validée et enregistrée |

Cette distinction empêche un agent de transformer un contexte incomplet en mise à jour destructrice. Un agent sait souvent qu'il doit modifier une propriété. Il ne connaît pas forcément la valeur actuelle de toutes les autres. Si une clé absente signifiait « effacer », une mise à jour partielle supprimerait des données sans rapport. Si une valeur vide explicite signifiait « laisser inchangé », un agent ne pourrait pas supprimer une valeur de façon fiable quand on le lui demande.

Le contrat donne à chaque action une seule signification claire. Omettre ne donne aucune instruction. Un `null` explicite efface un champ facultatif. Un tableau vide efface aussi un champ à valeurs multiples. Une valeur concrète la remplace. Ce contrat est assez simple pour être décrit dans un schéma d'outil. Sa précision permet de raisonner de manière fiable sur les mises à jour partielles d'enregistrements.

Le comportement reste aussi aligné entre l'application web, l'API, le chat et les outils MCP. La validation des champs obligatoires s'applique toujours quand une intégration tente d'effacer une valeur. La forme de la saisie change selon la surface. La sémantique d'écriture ne change pas.

[](#la-frontière-de-permissions-que-nous-navons-pas-encore-construite "Permalink")La frontière de permissions que nous n'avons pas encore construite
----------------------------------------------------------------------------------------------------------------------------------------------------

Il existe une vraie limite. La désactivation bloque les écritures, mais le chat reçoit toujours les codes et les types des champs inactifs. Ce n'est pas un contrôle de confidentialité. Nous ne proposons pas de permissions de visibilité indépendantes pour chaque surface.

Une équipe ne peut pas s'appuyer sur la désactivation pour garantir qu'un champ disparaisse de toutes les réponses d'un agent. La visibilité des champs demande sa propre politique de contrôle d'accès.

Cette contrainte découle directement de la force de la conception. Une définition circule dans plusieurs surfaces parce que celles-ci partagent le même modèle de champs. Quand une équipe a besoin de politiques d'exposition des champs distinctes, cette politique doit avoir sa propre représentation. Un amas d'exceptions dans les requêtes de l'API, les schémas d'IA et les définitions d'outils ne suffit pas.

Pour l'instant, désactivez un champ quand il doit refuser les nouvelles écritures. Considérez les contrôles de visibilité par surface comme un besoin produit à part.

[](#ce-que--définir-une-fois--veut-vraiment-dire "Permalink")Ce que « définir une fois » veut vraiment dire
-----------------------------------------------------------------------------------------------------------

« Définir une fois » ne signifie pas que chaque surface présente le champ à l'identique. L'API renvoie les choix sous forme d'objets `{id, label}`. L'assistant du chat voit des libellés d'options, puis les retraduit en ID. Les cartes de proposition affichent des changements entre ancienne et nouvelle valeur adaptés au type. Ce sont des interfaces volontairement différentes pour des utilisateurs différents.

Cela signifie que la définition du champ reste la source de vérité. L'application web s'en sert pour afficher et enregistrer. L'API s'en sert pour valider. Le chat s'en sert pour décrire une action autorisée. Les outils MCP en héritent sans chemin de code propre à chaque champ. C'est ce qui supprime le cycle de déploiement après qu'un administrateur a ajouté un champ.

Nous pensons que c'est la bonne frontière d'ingénierie pour un CRM natif IA. Les données configurables doivent le rester quand un assistant ou une intégration les touche. L'application ne doit pas obliger les équipes à choisir entre attributs personnalisés et automatisation.

Si vous voulez connecter un client externe à cette même surface d'enregistrements, commencez par [la documentation de l'API REST](https://relaticle.com/developers/api). Si vous définissez le champ lui-même, utilisez [le guide des types de champs](https://relaticle.com/fr/help/custom-fields/field-types-you-can-add).

 Tags [ #mcp ](https://relaticle.com/fr/blog/tag/mcp) 

 Sur cette page

 Continuer la lecture

 Articles associés. 
--------------------

- [  2 nov. 2026  Ingénierie 

    ###  Un essai gratuit de modèles IA premium détourné : ce que nous avons changé 

    Un essai sans carte qui débloquait des modèles IA premium a attiré des comptes qui n'ont jamais touché au CRM. Au lieu d'exiger une carte, nous lions les modèles premium au premier vrai enregistrement.

     ![](https://relaticle.com/storage/ink/01M7T553EWAS9S753X11DQK6B2.png) 

     ](https://relaticle.com/fr/blog/essai-gratuit-des-modeles-ia-premium-detourne-ce-que-nous-avons-change)
- [  21 oct. 2026  Ingénierie 

    ###  php2shell : comment nous avons corrigé Relaticle, et comment corriger le vôtre 

    php2shell désigne deux failles critiques de PHP qui permettent à un attaquant d'exécuter du code sur un serveur web. Ce que nous avons corrigé sur Relaticle Cloud, et ce qu'une installation auto-hébergée doit faire aujourd'hui.

     ![](https://relaticle.com/storage/ink/01M7T57YX58VZ4CXAYDWPTTE69.png) 

     ](https://relaticle.com/fr/blog/php2shell-corriger-php-dans-docker-et-forge)
- [  11 sept. 2026  Ingénierie 

    ###  Concevoir une suite d'outils MCP pour un CRM : quatre leçons 

    Ce que la construction du MCP server de Relaticle nous a appris sur les schémas, la validation partagée des champs personnalisés, l'autorisation et la découverte côté client.

     ![](https://relaticle.com/storage/ink/01M7T44GJS4JSH7RBXV0WGPN3S.png) 

     ](https://relaticle.com/fr/blog/concevoir-une-suite-d-outils-mcp-pour-un-crm)
