Benutzerdefinierte Felder in CRM, API, Chat und MCP - Relaticle         

Benutzerdefinierte Felder, die überall funktionieren, ohne Code pro Feld
========================================================================

So macht Relaticle benutzerdefinierte Felder in Formularen, APIs, Chat und MCP verfügbar: mit gemeinsamer Normalisierung, klarer Semantik für leere Werte und ausdrücklichen Grenzen.

 Manuk Minasyan · 22. September 2026 · 10 Min. Lesezeit

 ![Benutzerdefinierte Felder, die überall funktionieren, ohne Code pro Feld](https://relaticle.com/storage/ink/01M7T4JZV14ZXNAG3BW39JW7V0.png) 

Wir haben benutzerdefinierte Attribute so gebaut, dass ein in Relaticle definiertes Attribut in der Web-App, der REST-API, in Rela (dem integrierten KI-Assistenten) und in den MCP-Tools nutzbar wird. Dafür braucht es weder ein Deployment noch Integrationscode pro Attribut. Entscheidend ist nicht eine eigene Integration für jede Oberfläche, sondern ein einziger Schreibpfad. Er akzeptiert `custom_fields`, validiert die Werte anhand der aktuellen Definition des Arbeitsbereichs und speichert sie zusammen mit dem Eintrag. Das klingt unspektakulär, bis ein Agent Bezeichnungen statt Options-IDs braucht, ein API-Konsument typisierte Werte erwartet und ein leerer Wert etwas anderes bedeuten muss als ein ausgelassener Schlüssel.

Das Ergebnis ist ein bewusst kleiner Vertrag. Sie definieren das Attribut in der Oberfläche. Sie senden es zusammen mit den übrigen beschreibbaren Attributen des Eintrags. Den Rest erledigt die Anwendung. Dieser Beitrag behandelt die Mechanik und eine Berechtigungsgrenze. Ein deaktiviertes Attribut blockiert Schreibzugriffe, bleibt dem Chat aber bekannt. Steuerungen für die Sichtbarkeit pro Oberfläche gibt es nicht.

[](#eine-definition-vier-oberflächen "Permalink")Eine Definition, vier Oberflächen
----------------------------------------------------------------------------------

Benutzerdefinierte Attribute sind keine zusätzlichen Nutzdaten, die jede Integration unabhängig interpretieren muss. Das Modell des Eintrags verantwortet das Verhalten über `UsesCustomFields`. Der Trait nimmt `custom_fields` in die beschreibbaren Attribute auf und speichert die Werte, sobald der Eintrag gespeichert wird. Aktionen reichen `custom_fields` unverändert weiter. Sie extrahieren keine einzelnen Felder und behandeln deren Namen nicht als Sonderfälle.

Dadurch verhalten sich alle Oberflächen auf nützliche Weise unspektakulär. Ein Feld durchläuft denselben Aktionspfad, egal ob eine Person ein Formular bearbeitet, ein API-Client ein Update sendet, ein Assistent eine Änderung vorschlägt oder ein MCP-Tool schreibt. Ein über die Oberfläche angelegtes benutzerdefiniertes Attribut steht deshalb sofort in der API und im Chat bereit. Es folgt kein Deployment. Kein Entwickler baut für dieses eine Feld eine eigene Verzweigung.

| Oberfläche | Was sie erhält |
|---|---|
| Formular der Web-App | Feldeingabe als Teil der Bearbeitung des Eintrags |
| REST-API | `custom_fields` neben den nativen Attributen |
| Rela | Feldcodes und Optionsbezeichnungen in seinem Tool-Schema |
| MCP-Tools | Dieselbe Schreibschnittstelle für Einträge |

| Oberfläche | Was der gemeinsame Pfad liefert |
|---|---|
| Formular der Web-App | Einen gespeicherten Wert des benutzerdefinierten Attributs beim Speichern |
| REST-API | Dynamische Validierung und den normalen Schreibpfad |
| Rela | Übersetzung der Bezeichnungen, Validierung und einen Freigabevorschlag |
| MCP-Tools | Benutzerdefinierte Attribute ohne Anpassung der Tools pro Feld |

Der Unterschied zählt, weil die Alternativen auf vorhersehbare Weise scheitern. Ein statisches API-Schema ist veraltet, sobald ein Arbeitsbereich ein Feld definiert. Ein eigenes KI-Tool pro Feld macht aus Konfiguration Deployment-Arbeit. Ein separater Speicherpfad kann dazu führen, dass ein Feld auf einem Bildschirm funktioniert und auf einem anderen stillschweigend verschwindet. Wir haben das gemeinsame Modellverhalten ins Zentrum gestellt und die einzelnen Oberflächen schlank gehalten.

[](#die-feldtypen-gehen-über-ein-textfeld-hinaus "Permalink")Die Feldtypen gehen über ein Textfeld hinaus
---------------------------------------------------------------------------------------------------------

Relaticle bietet Felder für Text, Zahl, Währung, Datum, Auswahl, Kontakt, Rich-Editor und Verknüpfungen zu Einträgen. FileUpload und MarkdownEditor sind eingestellte Typen. Nutzen Sie RichEditor für formatierte Inhalte und unterstützte Anhänge.

Diese Liste zeigt, warum eine generische Zeichenketten-Map nicht genügen würde. Eine Einfachauswahl braucht Optionen. Eine Mehrfachauswahl braucht mehr als eine Option. Datum und Währung bringen unterschiedliche Anforderungen an Validierung und Darstellung mit. Die Implementierung muss diese Unterschiede bewahren, ohne dass jeder Aufrufer die Details jedes Typs kennen muss.

Der Trait des Modells bildet die Nahtstelle für die Speicherung. Die REST-Anfrage und das Chat-Schema bilden die Schnittstellen, die den jeweiligen Attributtyp berücksichtigen. So gibt es genau eine Stelle, die festlegt, welche Werte gültig sind. Jede Oberfläche kann diese Werte trotzdem in der Form zeigen, mit der ihre Nutzer arbeiten können.

![Der Builder für benutzerdefinierte Attribute mit benutzerdefinierten Attributen einer Verkaufschance neben Systemfeldern](https://relaticle.com/storage/ink/01M0YZS17J66XVASD4PG1S4H7P.png)

Die vollständige Liste der Feldtypen und Hilfe zur Konfiguration finden Sie in [der Referenz der Feldtypen](https://relaticle.com/de/help/custom-fields/field-types-you-can-add).

[](#die-rest-validierung-entsteht-aus-dem-aktuellen-schema "Permalink")Die REST-Validierung entsteht aus dem aktuellen Schema
-----------------------------------------------------------------------------------------------------------------------------

Die REST-API darf benutzerdefinierte Attribute nicht als ungeprüfte Metadaten behandeln. Jede Anfrage zum Anlegen oder Aktualisieren bindet die Validierungsregeln für die benutzerdefinierten Attribute des Arbeitsbereichs dynamisch ein. Ein benutzerdefiniertes Attribut wird daher wie ein natives Attribut validiert und geschrieben, obwohl seine Definition beim Deployment des API-Codes noch nicht existierte.

Das ist die entscheidende Richtung der Abhängigkeit. Die Anfrage bringt keine eigene Vorstellung davon mit, welche Felder existieren. Die Anwendung liest die aktuelle Felddefinition und erweitert die Validierung, bevor sie den Schreibzugriff akzeptiert. Ein neues Feld ist verfügbar, weil die Definition Daten sind. Eine Route musste dafür nicht geändert werden.

Auch die Antwortschicht gibt Clients keine Implementierungsdetails weiter. Werte von Einfach- und Mehrfachauswahl kommen als Objekte `{id, label}` zurück und nicht als rohe Options-IDs. Die ID identifiziert die Option. Die Bezeichnung gibt dem Wert in einer Client-Antwort seine Bedeutung. Werden beide Angaben zurückgegeben, muss ein API-Client keine zusätzliche Abfrage implementieren, nur um eine gespeicherte Auswahl anzuzeigen.

Damit eignet sich die REST-API für Integrationen, die einen stabilen Schreibvertrag brauchen, aber keine eigene Zuordnungsschicht für das Schema jedes Arbeitsbereichs wollen. API und Web-App teilen außerdem dieselbe Validierungsgrenze. Wir müssen nicht entscheiden, ob ein bestimmtes benutzerdefiniertes Attribut ein „API-Feld“ oder ein „Formularfeld“ ist. Es ist ein Feld des Eintrags.

Die [Dokumentation der REST-API](https://relaticle.com/developers/api) ist der richtige Einstieg, wenn ein externes System diese Einträge lesen oder schreiben soll.

[](#der-chat-braucht-eine-brücke-für-bezeichnungen "Permalink")Der Chat braucht eine Brücke für Bezeichnungen
-------------------------------------------------------------------------------------------------------------

Rela erhält keine statische Entwicklerreferenz, aus der es den Rest ableiten müsste. Es erhält ein Schema, das für die aktiven benutzerdefinierten Attribute des Arbeitsbereichs erzeugt wird. Ein Dienst zur Schema-Beschreibung bettet Feldcodes und Optionsbezeichnungen in das Tool-Schema ein, das das Modell sieht.

Diese Formulierung ist Absicht. Ein Modell soll die Bezeichnung sehen, die eine Person verwendet, statt eine Options-ID erfinden oder sich merken zu müssen. Es kann eine Anfrage mit dem Feldcode und einer Optionsbezeichnung formulieren. Bei der Validierung ordnet eine Übersetzungsschicht die Bezeichnung der Options-ID zu, die die Speicherung erwartet.

| Chat-Schritt | Darstellung |
|---|---|
| Schema-Beschreibung | Feldcodes und Optionsbezeichnungen |
| Validierung | Bezeichnungen werden in Options-IDs übersetzt |
| Vorschlagskarte | Alt-neu-Vergleich passend zum Feldtyp |

| Chat-Schritt | Grund |
|---|---|
| Schema-Beschreibung | Das Modell kann das Vokabular des Arbeitsbereichs verwenden |
| Validierung | Der gespeicherte Wert entspricht der konfigurierten Option |
| Vorschlagskarte | Eine Person kann die beabsichtigte Änderung prüfen |

Der letzte Schritt ist Teil des Produktvertrags und keine kosmetische Vorschau. Schreibzugriffe aus dem Chat werden zu Freigabekarten, die auf Bestätigung warten. Ein Mensch gibt sie frei oder verwirft sie. Der Alt-neu-Vergleich pro Feldtyp lässt diese Person die tatsächlich vorgeschlagene Änderung beurteilen, bevor sie gespeichert wird.

Das macht den Chat sicherer, als wenn man eine Anfrage in natürlicher Sprache für selbsterklärend hielte. „Ändere den Status“ liefert nicht genug Information für eine Prüfung. Der Vorschlag muss zeigen, welches benutzerdefinierte Attribut sich ändert und wie der neue Wert lautet.

![Eine Vorschlagskarte im Chat mit Alt-neu-Änderungen für vier benutzerdefinierte Attribute einer Verkaufschance](https://relaticle.com/storage/ink/01M0YZRTZSHZ02FV9MJ9F2ZJHR.png)

MCP verhält sich beim Schreiben anders. Schreibzugriffe über MCP-Tools werden direkt übernommen, ohne Freigabeschritt. Dieselbe Felddefinition und derselbe Schreibpfad gelten weiterhin, doch der Aufrufer muss seine Kontrollgrenze entsprechend wählen. Die zugehörigen Entwurfserkenntnisse zur Tool-Oberfläche finden Sie in [MCP-Tool-Suite für ein CRM entwerfen](https://relaticle.com/de/blog/mcp-tool-suite-fuer-ein-crm-entwerfen), die Einrichtung des Clients in [Claude per MCP mit Ihrem CRM verbinden](https://relaticle.com/de/blog/claude-per-mcp-mit-ihrem-crm-verbinden).

[](#fehlend-ist-nicht-leer "Permalink")Fehlend ist nicht leer
-------------------------------------------------------------

Eine Regel wiegt für Agenten schwerer, als es zunächst scheint: Bei einem optionalen Feld löscht ein ausdrückliches `null` den Wert. Felder mit mehreren Werten akzeptieren außerdem `[]`. Ausgelassene Schlüssel lassen Werte unverändert. Die Validierung von Pflichtfeldern kann das Löschen ablehnen.

| Zustand der Nutzlast | Ergebnis |
|---|---|
| Der Feldschlüssel fehlt | Der bestehende Wert bleibt unberührt |
| Der Schlüssel eines optionalen Felds hat `null` | Das Feld wird geleert |
| Ein optionales Feld mit mehreren Werten hat `[]` | Das Feld wird geleert |
| Der Feldschlüssel hat einen Wert | Der Wert wird validiert und gespeichert |

Diese Unterscheidung verhindert, dass ein Agent aus unvollständigem Kontext ein zerstörerisches Update macht. Ein Agent weiß oft, dass er eine Eigenschaft ändern soll. Den aktuellen Wert aller anderen Eigenschaften kennt er möglicherweise nicht. Würde ein fehlender Schlüssel „löschen“ bedeuten, würde ein Teil-Update unbeteiligte Daten entfernen. Würde ein ausdrücklich leerer Wert „unverändert lassen“ bedeuten, könnte ein Agent eine gewünschte Entfernung nicht zuverlässig ausführen.

Der Vertrag gibt jeder Aktion genau eine Bedeutung. Auslassen heißt: keine Anweisung. Ein ausdrückliches `null` leert ein optionales Feld. Ein leeres Array leert ebenfalls ein Feld mit mehreren Werten. Ein konkreter Wert ersetzt den bisherigen. Das lässt sich einfach in einem Tool-Schema ausdrücken und ist präzise genug, um Teil-Updates von Einträgen sicher nachvollziehbar zu machen.

Das Verhalten bleibt auch über Web-App, API, Chat und MCP-Tools hinweg gleich. Die Validierung von Pflichtfeldern greift weiterhin, wenn eine Integration versucht, einen Wert zu löschen. Die Form der Eingabe unterscheidet sich je nach Oberfläche. Die Schreibsemantik bleibt gleich.

[](#die-berechtigungsgrenze-die-wir-noch-nicht-gebaut-haben "Permalink")Die Berechtigungsgrenze, die wir noch nicht gebaut haben
--------------------------------------------------------------------------------------------------------------------------------

Hier gibt es eine echte Einschränkung. Die Deaktivierung blockiert Schreibzugriffe, der Chat erhält aber weiterhin die Codes und Typen inaktiver benutzerdefinierter Attribute. Sie ist keine Vertraulichkeitskontrolle. Unabhängige Sichtbarkeitsrechte für jede Oberfläche bieten wir nicht an.

Ein Team kann mit der Deaktivierung nicht garantieren, dass ein Attribut aus jeder Agentenantwort verschwindet. Die Sichtbarkeit von Feldern braucht eine eigene Zugriffsrichtlinie.

Die Einschränkung ergibt sich direkt aus der Stärke des Entwurfs. Eine Definition wandert durch mehrere Oberflächen, weil diese dasselbe Feldmodell teilen. Benötigt ein Team getrennte Richtlinien für die Sichtbarkeit von Attributen, müssen diese ausdrücklich im Modell abgebildet werden. Sie sollten nicht bloß aus Ausnahmen in API-Anfragen, KI-Schemata und Tool-Definitionen bestehen.

Deaktivieren Sie ein Attribut vorerst dann, wenn es keine neuen Schreibzugriffe mehr annehmen soll. Betrachten Sie Sichtbarkeitssteuerungen pro Oberfläche als eigene Produktanforderung.

[](#was-einmal-definieren-wirklich-bedeutet "Permalink")Was „einmal definieren“ wirklich bedeutet
-------------------------------------------------------------------------------------------------

„Einmal definieren“ heißt nicht, dass jede Oberfläche das Attribut gleich darstellt. Die API liefert Auswahlwerte als Objekte `{id, label}`. Der Chat-Assistent sieht Optionsbezeichnungen und übersetzt sie zurück in IDs. Vorschlagskarten zeigen Änderungen zwischen alten und neuen Werten passend zum jeweiligen Attributtyp. Das sind bewusst unterschiedliche Schnittstellen für unterschiedliche Nutzer.

Es heißt, dass die Attributdefinition die maßgebliche Quelle bleibt. Die Web-App nutzt sie zum Anzeigen und Speichern. Die API nutzt sie zum Validieren. Der Chat nutzt sie, um eine erlaubte Aktion zu beschreiben. MCP-Tools übernehmen sie ohne eigenen Codepfad pro Feld. Genau das beseitigt den Deployment-Zyklus, nachdem ein Administrator ein Attribut hinzugefügt hat.

Wir halten das für die richtige technische Grenze für ein KI-natives CRM. Konfigurierbare Daten sollen konfigurierbar bleiben, wenn ein Assistent oder eine Integration mit ihnen arbeitet. Die Anwendung soll Teams nicht zwingen, sich zwischen benutzerdefinierten Attributen und Automatisierung zu entscheiden.

Wenn Sie einen externen Client mit derselben Schnittstelle für Einträge verbinden möchten, beginnen Sie mit [der Dokumentation der REST-API](https://relaticle.com/developers/api). Wenn Sie das Attribut selbst definieren, nutzen Sie [die Anleitung zu den Feldtypen](https://relaticle.com/de/help/custom-fields/field-types-you-can-add).

 Mit Tag [ #mcp ](https://relaticle.com/de/blog/tag/mcp) 

 Auf dieser Seite

 Weiterlesen

 Ähnliche Beiträge. 
--------------------

- [  2. Nov 2026  Engineering 

    ###  Gratis-Testphase für Premium-KI-Modelle missbraucht: Was wir geändert haben 

    Eine Testphase ohne Karte, die Premium-KI-Modelle freischaltete, zog Konten an, die das CRM nie nutzten. Statt einer Karte binden wir Premium-Modelle jetzt an den ersten echten Eintrag.

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

     ](https://relaticle.com/de/blog/testphase-fuer-premium-ki-modelle-missbraucht-was-wir-geaendert-haben)
- [  21. Okt 2026  Engineering 

    ###  php2shell: So haben wir Relaticle gepatcht und so patchen Sie Ihre Installation 

    php2shell sind zwei kritische PHP-Lücken, die einem Angreifer Code-Ausführung auf einem Webserver erlauben. Was wir bei Relaticle Cloud gepatcht haben und was eine selbst gehostete Installation heute tun muss.

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

     ](https://relaticle.com/de/blog/php2shell-php-in-docker-und-forge-patchen)
- [  11. Sep 2026  Engineering 

    ###  MCP-Tool-Suite für ein CRM entwerfen: vier Lektionen 

    Was uns der Bau des MCP-Servers von Relaticle über Schemas, gemeinsame Validierung benutzerdefinierter Felder, Autorisierung und Client-Erkennung beigebracht hat.

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

     ](https://relaticle.com/de/blog/mcp-tool-suite-fuer-ein-crm-entwerfen)
