Erfassen von Analysen und Anwenden von Personalisierung in ChatGPT-Apps (MCP-Datenerfassung)

Dieser Anwendungsfall zeigt, wie Sie eine ChatGPT-App (Model Context Protocol Server + optionale UI-Komponenten) mit der Adobe Experience Platform Edge Network verbinden. Diese Art der Datenerfassung ermöglicht es Ihnen, Analysen für Gesprächsinteraktionen aufzuzeichnen, die Ihre Tools aufrufen und Personalisierungsentscheidungen aus der Edge Network in ein von ChatGPT gerendertes Widget liefern.

In diesem Anwendungsfall wird ein hybrider Ansatz bevorzugt, bei dem sowohl eine Server-seitige Implementierung zum Erfassen von Daten als auch eine Client-seitige Implementierung zum Rendern personalisierter Inhalte verwendet werden. Dieser Ansatz ist ideal, da der Aufruf des MCP-Tools der zuverlässigste Zeitpunkt für die Erfassung von Analysen ist. Das Widget wird im Browser-Kontext ausgeführt und ist der richtige Ort, um Identitäten (in einem Cookie) zu speichern und Personalisierungsentscheidungen anzuwenden.

Dieser Anwendungsfall enthält ein begleitendes voll funktionsfähiges Code-Beispiel. Unter ChatGPT-App + Adobe Experience Platform Edge im alloy-samples-Repository auf GitHub finden Sie Beispiel-Code und Implementierungsanweisungen.

Architektur

Insgesamt gibt es fünf bewegliche Teile:

Datenfluss

In den folgenden Abschnitten werden die einzelnen Schritte im Detail beschrieben.

Schritt 1: Der Benutzer fordert ChatGPT mithilfe Ihres MCP-Servers auf

Dieser Schritt ist der Einstiegspunkt für den Workflow. Der Benutzer bietet eine natürliche Sprachabsicht:

"Use the Adobe Office Information Tool to show me details about which office that is the most pet-friendly."

Weitere Informationen finden ​ in der OpenAIEntwicklerdokumentation unter „MCP-Server erstellen“.

Schritt 2: ChatGPT interpretiert Absicht und ruft ein MCP-Tool auf

Basierend auf den Metadaten Ihres MCP-Servers interpretiert ChatGPT die Absicht und ruft den entsprechenden Tool-Handler auf Ihrem MCP-Server auf. Dieser Tool-Aufruf erstellt einen Server-seitigen Wahrheitspunkt für die Interaktion, der unabhängig vom Rendering-Erfolg der Benutzeroberfläche ist. Eines Ihrer Tools enthält möglicherweise die folgenden Metadaten:

{
  "name": "office_details",
  "description": "Fetch details for a single office by ID and return personalization handles for the UI.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "sessionId": { "type": "string", "description": "Server-issued session identifier." },
      "officeId": { "type": "string", "description": "Office identifier." }
    },
    "required": ["sessionId", "officeId"],
    "additionalProperties": false
  },
  "_meta": {
    "ui": {
      "visibility": ["model", "app"]
    }
  }
}

Weitere Informationen , wie Sie ChatGPT mitteilen, was jedes MCP-Tool tut, finden Sie ​ der OpenAI Developers-Dokumentation unter „Tools definieren“.

Schritt 3: Ihr MCP-Server sendet ein Erlebnisereignis an die Edge Network

Trigger Wenn Ihr MCP-Server eine Anfrage erhält, führt er einen Aufruf an Adobe Experience Platform Edge Network durch, um Analysedaten aufzuzeichnen und optional eine Entscheidungsfindung/Personalisierung anzufordern. Da es sich bei dieser Anfrage um eine Server-zu-Server-Anfrage handelt, verwenden Sie den authentifizierten interact-Endpunkt als Teil der Datenerfassungs-APIs. Adobe empfiehlt die Verwendung eines benutzerdefinierten Namespace, um die eindeutige OpenAI-Kennung weiterzugeben. Stellen Sie sicher, dass der Namespace, den Sie in der Identities-Benutzeroberfläche erstellen, und der Identity-Namespace, den Sie in Ihrem Aufruf definieren, übereinstimmen (Groß-/Kleinschreibung beachten).

curl -X POST "https://server.adobedc.net/ee/v2/interact?datastreamId={DATASTREAM_ID}"
  -H "Authorization: Bearer {TOKEN}"
  -H "x-gw-ims-org-id: {ORG_ID}"
  -H "x-api-key: {API_KEY}"
  -H "Content-Type: application/json"
  -d '{
    "event": {
      "xdm": {
        "eventType": "office.details.view",
        "identityMap": {
          "{IDENTITY_NAMESPACE}": [
            { "id": "{PSEUDONYMOUS_SUBJECT_ID}", "primary": true }
          ]
        },
        "timestamp": "YYYY-02-20T19:00:00.000Z"
      }
    },
    "query": {
      "personalization": {
        "decisionScopes": ["__view__"]
      }
    },
    "meta": {
      "state": {
        "entries": [
          { "key": "kndctr_orgid_cluster", "value": "{CLUSTER_HINT_IF_KNOWN}" },
          { "key": "kndctr_orgid_identity", "value": "{ECID_BLOB_IF_KNOWN}" }
        ]
      }
    }
  }'

Schritt 4: Edge Network gibt Handles zurück

Wenn der Edge Network Ihren interact-Aufruf erhält, antwortet er mit einem handle Array. Dieses Array kann je nach Konfiguration Ihres Datenstroms Identitäts- und Personalisierungsentscheidungen enthalten. Eine Beispielantwort könnte wie folgt aussehen:

{
  "requestId": "60a2f...2294d",
  "handle": [
    {
      "type": "locationHint:result",
      "payload": [
        { "scope": "EdgeNetwork", "hint": "or2", "ttlSeconds": 1800 }
      ]
    },
    {
      "type": "state:store",
      "payload": [
        { "key": "kndctr_..._identity", "value": "CiYzM...snTI=", "maxAge": 34128000 },
        { "key": "kndctr_..._cluster", "value": "or2", "maxAge": 1800 }
      ]
    }
  ]
}

Ihr MCP-Server kann dann Informationen aus der Edge Network-Antwort extrahieren, um Identitätsinformationen beizubehalten:

type EdgeHandle = { type: string; payload?: Array<{ key?: string; value?: string }> };

export function extractStateStore(handles: EdgeHandle[]) {
  const store = handles.find(h => h.type === "state:store");
  const entries = store?.payload ?? [];

  const identity = entries.find(e => e.key?.includes("_identity"))?.value;
  const cluster  = entries.find(e => e.key?.includes("_cluster"))?.value;

  return { identity, cluster };
}

Schritt 5: Der MCP-Server gibt die strukturierte Tool-Ausgabe plus Adobe-Metadaten an ChatGPT zurück.

Ihre MCP-Tool-Antwort umfasst sowohl die strukturierte Tool-Ausgabe als auch die Personalisierung aus der Edge Network.

{
  "content": "Displayed details for office seattle.",
  "structuredContent": {
    "office": {
      "id": "seattle",
      "name": "Seattle",
      "amenities": ["Pet Friendly", "Cafe", "Bike Storage"]
    }
  },
  "_meta": {
    "adobe": {
      "identityMap": {
        "{IDENTITY_NAMESPACE}": [
          { "id": "{PSEUDONYMOUS_SUBJECT_ID}", "primary": true }
        ]
      },
      "handles": [
        {
          "type": "state:store",
          "payload": [
            { "key": "kndctr_..._identity", "value": "..." }
          ]
        },
        {
          "type": "personalization:decisions",
          "payload": [
            { "id": "..." }
          ]
        }
      ]
    }
  }
}

Weitere Informationen finden ​ unter ​ in der OpenAI-Entwicklerreferenz .

Schritt 6: Das Widget rendert das Ergebnis und wendet _adobe.handles mithilfe von applyResponse an

Das Widget rendert die Geschäftsdaten aus structuredContent und liest dann die Adobe-Metadaten aus _meta.adobe. In ChatGPT stehen dem Widget dieselben Daten über die Kompatibilitätsebene zur Verfügung:

Das Widget verwendet den applyResponse-Befehl der Web-SDK-JavaScript-Bibliothek, um den Client-seitigen Status einzubinden und Personalisierungsentscheidungen zu rendern, die vom Server-seitigen interact-Aufruf zurückgegeben werden. Stellen Sie sicher, dass Sie den configure-Befehl aufrufen, bevor Sie applyResponse aufrufen. Da Ihr MCP-Server einen interact-Aufruf ausgeführt hat, müssen Sie den sendEvent-Befehl für die Interaktion des Tool-Aufrufs nicht sofort aufrufen.

// Configure the Web SDK before any other commands.
alloy("configure", {
  datastreamId: "YOUR_DATASTREAM_ID",
  orgId: "YOUR_EXPERIENCE_CLOUD_ORG_ID"
});

// Business data exposed to ChatGPT and the widget.
const { office } = window.openai?.toolOutput ?? {};

// Adobe metadata available only to the widget.
const adobe = window.openai?.toolResponseMetadata?.adobe ?? {};
const { identityMap, handles } = adobe;

// Hydrate client-side state and render personalization decisions from the
// server-side interact response.
alloy("applyResponse", {
  renderDecisions: true,
  responseBody: { handle: handles ?? [] }
});

Wenn das Widget später zusätzliche benutzeroberflächenseitige Ereignisse sendet, können Sie dieselben identityMap in diese Aufrufe einbeziehen:

alloy("sendEvent", {
  xdm: {
    eventType: "office.details.widgetView",
    identityMap
  }
});

Dieses Muster hält die Server-seitige und die UI-seitige Identitätsnutzung in Einklang, während es weiterhin ermöglicht, dass der Server-seitige interact-Aufruf die Quelle der Wahrheit für die Analytics-Erfassung und -Entscheidung bleibt.

Validierung

Sobald alle oben genannten Schritte konfiguriert sind, können Sie Folgendes überprüfen:

Überlegungen zu Sicherheit und Datenschutz