Skip to content

Pypestream

A Pypestream é uma plataforma de IA conversacional full-stack que oferece envio de mensagens patenteado e completo na nuvem para transformar marcas em entidades digitais “sempre ativas”. Com a Pypestream, as marcas agora podem se engajar em conversas omnicanais em escala com cada cliente, aproveitando uma experiência de usuário imersiva, recursos avançados de NLU e integrações em tempo real com sistemas back-end.

Essa integração é mantida pela Pypestream.

Sobre a integração

A integração entre a Braze e a Pypestream permite orquestrar com perfeição o ciclo de vida do cliente de ponta a ponta, desde o contato inicial, encaminhado para uma experiência de conversação, até o(s) acompanhamento(s) omnicanal(is) por meio de redirecionamento inteligente.

Pré-requisitos

Requisito Descrição
Conta Pypestream É necessário ter uma conta Pypestream para usar essa parceria.

Uma vez inscrito, a equipe da Pypestream ajudará você a configurar seu ambiente dedicado para começar a criar sua solução de IA conversacional para integração com a Braze.
Chave da API REST da Braze Uma chave da API REST da Braze com permissões users.track.

Isso pode ser criado no dashboard da Braze em Settings > API Keys.
Endpoint REST da Braze Sua URL de endpoint REST. Seu endpoint dependerá da URL da Braze para sua instância.

Casos de uso

A parceria entre a Braze e a Pypestream pode ser usada nos seus Canvas para atender a casos de uso comuns, como:

  • Redirecionamento inteligente: Redirecione os usuários com o Braze Canvas após o engajamento de conversação com a sua marca, aproveitando todos os pontos de dados avançados coletados por meio da Pypestream.
  • Direcionamento dinâmico: Entre em contato com clientes existentes e potenciais com base em suas coortes e segmentos específicos, atendendo-os com experiências de conversação personalizadas por meio da Pypestream.
  • Insights contextuais sobre o cliente: Depois que um usuário final (cliente existente ou potencial) se engajar em seu site, combine as tags de página da web ingeridas pelo Pypestream Event Listener com os dados de cliente armazenados na Braze para fornecer uma interação de conversação contextual e totalmente personalizada.

Integração

A Pypestream utiliza uma camada de integração sem servidor para realizar integrações personalizadas em várias plataformas. Essa camada é usada para fazer interface com serviços ou sistemas para dar suporte aos requisitos de dados do fluxo de conversação que está sendo criado. Essas integrações, chamadas de integrações de Action Node, geralmente são escritas em Python e implantadas usando a plataforma Pypestream. Depois que um nó de ação é instanciado, ele oferece a flexibilidade de se integrar a qualquer endpoint da API da Braze e permite que os resultados sejam avaliados de várias maneiras.

Etapa 1: Definir configurações de endpoint

Os valores de configuração primária, como a URL do endpoint REST da Braze e as chaves de API da Braze, devem ser definidos no arquivo app.py da solução:

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'
    },
}

Etapa 2: Desenvolver modelo de nó de ação

Os nós de ação aproveitam o ambiente com o qual a solução é implantada para interagir, com os respectivos endpoints da Braze definidos na etapa anterior. Essa etapa desenvolve um nó de ação para integrar endpoints específicos da Braze. Use o modelo a seguir como guia para desenvolver as integrações:

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'}

Etapa 3: Atualizar os designs da solução

A etapa final da integração com a REST API da Braze envolve a configuração dos fluxos no Design Studio da Pypestream para usar o nó de ação que foi desenvolvido na etapa anterior.

Caso de uso de integração

Depois que os pré-requisitos forem atendidos e uma estrutura de nó de ação tiver sido criada, o desenvolvedor terá um Canvas em branco para trabalhar ao interagir com os endpoints da API da Braze. Este exemplo mostra as etapas necessárias para integrar um nó de ação ao endpoint /user/track da Braze — especificamente para criar um perfil de usuário para rastrear um usuário específico que entra em um fluxo de conversação da Pypestream.

Etapa 1: Coletar dados do usuário na conversa

Quando um usuário entra em uma sessão da Pypestream, as especificidades dos dados coletados dependem inteiramente do caso de uso em questão. Para poder criar um perfil de usuário na Braze, a conversa deve coletar os campos necessários exigidos pelo endpoint desejado.

Por exemplo, se a solução coletou as seguintes informações do usuário durante a conversa para o endpoint /user/track da Braze:

  • Nome
  • Sobrenome
  • Endereço de e-mail
  • Data de nascimento
  • Cidade de residência
  • Sistema operacional

Esses dados agora podem ser enviados para a plataforma da Braze para rastrear o engajamento desse usuário, com a possibilidade de redirecioná-lo no futuro. Confira a lista de casos de uso para ver as aplicações comuns.

Etapa 2: Preencher os dados na estrutura do nó de ação

Aproveitando a mesma estrutura para desenvolver nós de ação, os dados coletados do usuário podem ser preenchidos no nó de ação para serem enviados à Braze por meio do nosso endpoint /user/track.

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'}

Etapa 3: Atualizar os fluxos da solução para redirecionar após sucesso/falha do nó de ação

Por fim, no design de cada solução, você pode encaminhar os usuários para os nós com base no sucesso da chamada à API do nó de ação. Se o nó de ação receber uma mensagem de erro, o usuário final deverá ser tratado com cuidado.
New Stuff!