Skip to content

Pypestream

Pypestream ist eine umfassende KI-Plattform für Konversationen, die patentiertes, All-in-One-Cloud-Messaging anbietet, um Marken in „always-on“ digitale Einheiten zu transformieren. Mit Pypestream können Marken jetzt Omnichannel-Konversationen in großem Umfang mit allen Kund:innen führen und dabei ein immersives Nutzererlebnis, fortschrittliche NLU-Funktionen und Realtime-Integrationen in Backend-Systeme nutzen.

Diese Integration wird von Pypestream gepflegt.

Über die Integration

Die Integration von Braze und Pypestream ermöglicht es Ihnen, den End-to-End-Kundenlebenszyklus nahtlos zu orchestrieren – von der ersten Kontaktaufnahme über ein konversationsbasiertes Erlebnis bis hin zu Omnichannel-Follow-up(s) durch intelligentes Retargeting.

Voraussetzungen

Anforderung Beschreibung
Pypestream-Konto Ein Pypestream-Konto ist erforderlich, um die Vorteile dieser Partnerschaft zu nutzen.

Sobald Sie registriert sind, hilft Ihnen das Pypestream-Team bei der Einrichtung Ihrer dedizierten Umgebung, damit Sie mit dem Aufbau Ihrer KI-Lösung für die Integration mit Braze beginnen können.
Braze REST-API-Schlüssel Ein Braze REST-API-Schlüssel mit users.track-Berechtigungen.

Dieser kann im Braze-Dashboard unter Einstellungen > API-Schlüssel erstellt werden.
Braze REST-Endpunkt Ihre REST-Endpunkt-URL. Ihr Endpunkt hängt von der Braze-URL für Ihre Instanz ab.

Anwendungsfälle

Die Partnerschaft zwischen Braze und Pypestream kann in Ihren Canvases genutzt werden, um gängige Anwendungsfälle zu realisieren:

  • Intelligentes Retargeting: Retargeten Sie Nutzer:innen mit Braze Canvas nach deren konversationsbasiertem Engagement mit Ihrer Marke, indem Sie alle über Pypestream erfassten Datenpunkte nutzen.
  • Dynamisches Targeting: Kontaktieren Sie bestehende und potenzielle Kund:innen auf Basis ihrer spezifischen Kohorten und Segmente und bieten Sie ihnen über Pypestream maßgeschneiderte Konversationserlebnisse.
  • Kontextuelle Kund:innen-Insights: Nachdem sich Endnutzer:innen (bestehende oder potenzielle Kund:innen) auf Ihrer Website engagiert haben, kombinieren Sie die vom Pypestream Event Listener aufgenommenen Webseiten-Tags mit den in Braze gespeicherten Kundendaten, um eine vollständig personalisierte und kontextuelle Konversationsinteraktion zu ermöglichen.

Integration

Pypestream nutzt eine serverlose Integrationsebene, um angepasste Integrationen in verschiedene Plattformen durchzuführen. Diese Schicht dient als Schnittstelle zu Diensten oder Systemen, um die Datenanforderungen des zu erstellenden Konversationsflusses zu unterstützen. Diese Integrationen, die als Action-Node-Integrationen bezeichnet werden, sind in der Regel in Python geschrieben und werden über die Pypestream-Plattform bereitgestellt. Nachdem ein Action Node instanziiert wurde, bietet er die Flexibilität, sich in jeden beliebigen Braze-API-Endpunkt zu integrieren, und erlaubt die Auswertung der Ergebnisse auf vielfältige Weise.

1. Schritt: Endpunkt-Konfigurationen festlegen

Die primären Konfigurationswerte, wie die URL des Braze REST-Endpunkts und die Braze-API-Schlüssel, sollten in der Datei app.py der Lösung festgelegt werden:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import os

NAME = '{ CUSTOMER NAME }'
BOTS = []
CSV_BOTS = ['{ SOLUTION NAME }']
PATH = os.path.dirname(__file__)

PARAMS = {
    'sandbox': {
        #Braze
        'braze_url': '{ BRAZE ENDPOINT URL }',
        'braze_api_key': '{ BRAZE API KEY }',
        'braze_user_track': 'users/track'
    },
    'prod': {

        #Braze
        'braze_url': '{ BRAZE ENDPOINT URL }',
        'braze_api_key': '{ BRAZE API KEY }',
        'braze_user_track': 'users/track'
    },
}

2. Schritt: Action-Node-Template entwickeln

Action Nodes nutzen die Umgebung, in der die Lösung bereitgestellt wird, um mit den entsprechenden Braze-Endpunkten zu interagieren, die im vorherigen Schritt festgelegt wurden. In diesem Schritt wird ein Action Node entwickelt, um bestimmte Braze-Endpunkte zu integrieren. Verwenden Sie das folgende Template als Leitfaden für die Entwicklung der Integrationen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# -*- coding: utf-8 -*-
r'''
    ______  ______  _____________________  _________    __  ___
   / __ \ \/ / __ \/ ____/ ___/_  __/ __ \/ ____/   |  /  |/  /
  / /_/ /\  / /_/ / __/  \__ \ / / / /_/ / __/ / /| | / /|_/ /
 / ____/ / / ____/ /___ ___/ // / / _, _/ /___/ ___ |/ /  / /
/_/     /_/_/   /_____//____//_/ /_/ |_/_____/_/  |_/_/  /_/
Action Node Script for Braze Integration

Parameters
----------
POST Request to the User Track Braze Endpoint (users/track)

{
  "api_base_url": "{env.braze_url}",
  "req_endpoint_path": "users/track",
  "req_method": "POST",
  "req_headers": {
    "Authorization": "{YOUR-REST-API-KEY}"
    "Content-Type": "application/json"
  },
  "req_body": {
        "api_key": "{env.braze_api_key}",
        "attributes": [{
                "external_id": "{HOLDER_EMAIL}",
                ...
        }],
        "events": [
            ...
        ]
}

Returns
-------
Creates and/or Updates User Details within Braze dashboard

'''
import requests
from .. import app

class BrazeExample:
    def execute(self, log, payload=None, context=None):
        try:
            # initialize payload variables
            app_params = app.PARAMS[context['env']]
            req_params = {
                "attributes": [{
                    "external_id": "{ USER_ID }",
                    # include add'tl user details in this section
                    # refer to the Braze API Documentation for User Track REST API Endpoint for more details
                }],
                "events": [],
                "partner" : 'pypestream'
            }
            req_url = '{}/{}'.format(
                app_params['braze_url'],
                app_params['braze_user_track']
            )
            req_headers = {
                "Authorization": app_params['braze_api_key']
                "Content-Type": "application/json"
            }

            resp = requests.post(req_url,
                                params=req_params,
                                headers=req_headers)

            log('BrazeExample API response: {}'.format(resp.text))

            if resp.status_code == 400:
                return {'success': 'error'}

            return {'success': 'true'}

        except Exception as err:
            log('BrazeExample Exception error: {}'.format(err))

        return {'success': 'error'}

3. Schritt: Lösungsdesigns aktualisieren

Der letzte Schritt der Integration mit der Braze REST API besteht darin, die Abläufe im Design Studio von Pypestream so zu konfigurieren, dass sie den Action Node verwenden, der im vorherigen Schritt entwickelt wurde.

Anwendungsfall der Integration

Nachdem die Voraussetzungen erfüllt sind und eine Action-Node-Struktur erstellt wurde, steht Entwickler:innen ein leeres Canvas zur Verfügung, um mit den Braze-API-Endpunkten zu arbeiten. Dieses Beispiel zeigt die Schritte, die für die Integration eines Action Nodes in den Braze-/user/track-Endpunkt erforderlich sind – insbesondere für die Erstellung eines Nutzerprofils zum Tracking von Nutzer:innen, die einen Pypestream-Konversationsfluss betreten.

1. Schritt: Daten von Nutzer:innen im Gespräch erfassen

Wenn Nutzer:innen eine Pypestream-Sitzung betreten, hängt die Art der erfassten Daten ganz vom jeweiligen Anwendungsfall ab. Um ein Nutzerprofil innerhalb von Braze erstellen zu können, muss die Konversation die erforderlichen Felder erfassen, die für den gewünschten Endpunkt benötigt werden.

Wenn die Lösung beispielsweise während der Konversation für den Braze-/user/track-Endpunkt die folgenden Informationen von Nutzer:innen gesammelt hat:

  • Vorname
  • Nachname
  • E-Mail-Adresse
  • Geburtsdatum
  • Wohnort
  • Betriebssystem

Diese Daten können nun an die Braze-Plattform gesendet werden, um das Engagement dieser Nutzer:innen zu verfolgen und sie möglicherweise in Zukunft zu retargeten. Sehen Sie sich die Liste der Anwendungsfälle an, um häufige Anwendungen zu entdecken.

2. Schritt: Daten in die Action-Node-Struktur einfügen

Unter Verwendung derselben Struktur für die Entwicklung von Action Nodes können die von Nutzer:innen gesammelten Daten in den Action Node eingefügt werden, um sie über den /user/track-Endpunkt an Braze zu senden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

# -*- coding: utf-8 -*-
r'''
    ______  ______  _____________________  _________    __  ___
   / __ \ \/ / __ \/ ____/ ___/_  __/ __ \/ ____/   |  /  |/  /
  / /_/ /\  / /_/ / __/  \__ \ / / / /_/ / __/ / /| | / /|_/ /
 / ____/ / / ____/ /___ ___/ // / / _, _/ /___/ ___ |/ /  / /
/_/     /_/_/   /_____//____//_/ /_/ |_/_____/_/  |_/_/  /_/
Action Node Script for Braze Integration

Parameters
----------
POST Request to the User Track Braze Endpoint (users/track)

{
  "api_base_url": "{env.braze_url}",
  "req_endpoint_path": "users/track",
  "req_method": "POST",
  "req_headers": {
    "Content-Type": "application/json"
  },
  "req_body": {
        "api_key": "{env.braze_api_key}",
        "attributes": [{
                "external_id": "{HOLDER_EMAIL}",
                ...
        }],
        "events": [
            ...
        ],
        "partner" : 'pypestream'
}

Returns
-------
Creates and/or Updates User Details within Braze dashboard

'''
import requests
from .. import app

class BrazeExample:
    def execute(self, log, payload=None, context=None):
        try:
            # initialize payload variables
            app_params = app.PARAMS[context['env']]
            req_params = {
                "attributes": [{
                    "external_id": "{ USER_ID }",
                    "first_name": "{ FIRST_NAME }",
                    "last_name": "{ LAST_NAME }",
                    "email": "{ EMAIL_ADDRESS }",
                    "dob": "{ DATE_OF_BIRTH }",
                    "home_city": "{ CITY_OF_RESIDENCE }",
                    "operating_system": "{ OPERATING_SYSTEM }" #custom attributes can be added here as well
                    # include add'tl user details in this section
                    # refer to the Braze API Documentation for User Track REST API Endpoint for more details
                }],
                "events": [{
                    "external_id": "{ USER_ID }",
                    "name": "{ NAME_OF_EVENT }",
                    "time": "{ EVENT_TIME }"
                }],
                "partner" : 'pypestream'
            }
            req_url = '{}/{}'.format(
                app_params['braze_url'],
                app_params['braze_user_track']
            )
            req_headers = {
                "Authorization": app_params['braze_api_key']
                "Content-Type": "application/json"
            }

            resp = requests.post(req_url,
                                params=req_params,
                                headers=req_headers)

            log('BrazeExample API response: {}'.format(resp.text))

            if resp.status_code == 400:
                return {'success': 'error'}

            return {'success': 'true'}

        except Exception as err:
            log('BrazeExample Exception error: {}'.format(err))

        return {'success': 'error'}

3. Schritt: Lösungsabläufe für Weiterleitung bei Erfolg/Fehler des Action Nodes aktualisieren

Abschließend können Sie im Design jeder Lösung Nutzer:innen basierend darauf zu Knoten weiterleiten, ob der API-Aufruf des Action Nodes erfolgreich war. Wenn der Action Node eine Fehlermeldung erhält, sollten Endnutzer:innen mit besonderer Sorgfalt behandelt werden.
New Stuff!