Agente de Vendas Jitterbit

Visão Geral

O Agente de Vendas Jitterbit (Agente de Vendas) é um agente de IA fornecido através do Jitterbit Marketplace que tem como objetivo capacitar a equipe interna de Vendas da sua organização. Ele faz o seguinte:

Conecta-se ao NetSuite e Salesforce para buscar pedidos de vendas, preços e dados de clientes em tempo real usando o Jitterbit Integration Studio.
Integra-se ao Azure OpenAI para alimentar um chatbot inteligente do Agente de Vendas acessado por meio de uma API personalizada criada com o Jitterbit API Manager.

Este documento explica a configuração e operação do agente. Primeiro cobre os pré-requisitos, em seguida fornece exemplos de comandos para mostrar o que o agente pode fazer, e por fim apresenta passos para instalar, configurar e operar o agente.

Pré-requisitos

Para usar o Agente de Vendas, os seguintes componentes são necessários ou assumidos no design do agente.

Componentes do Harmony

Você deve ter uma licença do Jitterbit Harmony com acesso aos seguintes componentes:

Jitterbit Integration Studio
- A ferramenta Decision (Beta)
Jitterbit API Manager
Agente de Vendas Jitterbit adquirido como um complemento de licença
Jitterbit Cloud Datastore (opcional)

Recursos do Azure

Você deve ter uma assinatura do Microsoft Azure com permissões para criar e gerenciar os seguintes recursos:

Armazenamento do Azure com um contêiner Blob para armazenar detalhes dos clientes.
Azure AI Search com um serviço de pesquisa que pode ser configurado com um índice e indexador.
Azure OpenAI com um modelo gpt-4o ou gpt-4.1 implantado.

Dica

Para selecionar níveis de preços com base em seus requisitos específicos e uso antecipado, consulte níveis de preços do Azure AI Search e preços do Azure OpenAI.

Endpoints suportados

Os seguintes endpoints estão incorporados ao design do agente, mas outros sistemas podem ser acomodados modificando as configurações de endpoint e fluxos de trabalho do projeto:

NetSuite: A fonte dos formulários de pedido de clientes.
Salesforce: A fonte das contas de clientes e preços de produtos.
Slack: A interface de chat para interagir com o agente.

Se você quiser usar um aplicativo diferente como interface de chat, um fluxo de trabalho separado e instruções para uma configuração de API genérica estão incluídos neste agente de IA.

Exemplos de prompts

Aqui estão exemplos de prompts que o Agente de Vendas pode lidar com acesso aos dados apropriados:

Perguntas de Consulta de Clientes

"Mostre-me todos os clientes na Califórnia."
"Quais clientes estão baseados em Sydney?"

Perguntas sobre Formulário de Pedido / Detalhes de Licenciamento

"Quais produtos a Acme Corp comprou?"
"Quantas 'Produto X' a ByteTech GmbH está licenciada?"
"Você pode me dar os detalhes do pedido da AcmeCloud Ltd?"
"Qual é a duração da assinatura para a Zento Systems?"

Consulta de Preços de Produtos ou Planos

"Qual é o preço de 'Produto X' em USD?"
"Quanto custa a assinatura Profissional?"
"Qual plano de assinatura permite 10 ambientes?"
"Você pode calcular o custo para 15 'Produto X' e 4 'Produto Y'?"

Consultas sobre Proprietários de Conta

"Quem gerencia a Acme Corp?"
"Quais clientes são de jsmith@abc.com?"
"Mostre os clientes atendidos por David Brown no Texas."
"Liste as contas gerenciadas por Grace no Reino Unido."

Instalação, configuração e operação

Siga estas etapas para instalar, configurar e operar este agente de IA:

Baixar personalizações e instalar o projeto do Integration Studio.
Revisar fluxos de trabalho do projeto.
Criar recursos do Microsoft Azure.
Preparar o Jitterbit Cloud Datastore.
Configurar variáveis do projeto.
Testar conexões.
Implantar o projeto.
Criar a API personalizada do Jitterbit.
Criar o aplicativo Slack, testar a conexão do Slack e reimplantar o projeto.
Acionar os fluxos de trabalho do projeto.

Baixar personalizações e instalar o projeto

Siga estas etapas para baixar arquivos de personalização e instalar o projeto do Integration Studio para o agente de IA:

Faça login no portal Harmony em https://login.jitterbit.com e abra Marketplace.
Localize o agente de IA chamado Jitterbit Sales Agent. Para localizar o agente, você pode usar a barra de pesquisa ou, no painel Filtros, sob Tipo, selecione Agente de IA para limitar a exibição aos agentes de IA disponíveis.
Clique no link Documentação do agente de IA para abrir sua documentação em uma nova aba. Mantenha a aba aberta para consultar depois de iniciar o projeto.
Clique em Iniciar Projeto para abrir um diálogo de configuração em duas etapas para baixar personalizações e importar o agente de IA como um projeto do Integration Studio.

Nota

Se você ainda não comprou o agente de IA, Adquirir este agente será exibido em vez disso. Clique nele para abrir um diálogo informativo, em seguida, clique em Enviar para que um representante entre em contato com você sobre a compra do agente de IA.
Na etapa de configuração 1, Baixar Personalizações, os seguintes arquivos são fornecidos para facilitar a configuração do índice e do indexador no Azure AI Search e para criar o aplicativo Slack. Selecione os arquivos e clique em Baixar Arquivos:
- Arquivos de definição JSON do índice e indexador do Azure AI Search
  - Azure_AI_Search_Datasource_Definition.json
  - Azure_AI_Search_Index_Definition.json
  - Azure_AI_Search_Indexer_Definition.json
- Arquivo de manifesto do aplicativo Slack
  - slack_app_manifest.json
Dica

O diálogo de configuração inclui um aviso para não importar o modelo antes de aplicar as personalizações do endpoint. Esse aviso não se aplica a este agente de IA e pode ser ignorado. Siga a ordem recomendada de etapas nesta documentação.

Clique em Próximo.
Na etapa de configuração 2, Criar um Novo Projeto, selecione um ambiente onde o projeto do Integration Studio será criado e clique em Criar Projeto.
Um diálogo de progresso será exibido. Assim que indicar que o projeto foi criado, use o link do diálogo Ir para o Integration Studio ou abra o projeto diretamente na página de Projetos do Integration Studio.

Revisar fluxos de trabalho do projeto

No projeto aberto do Integration Studio, revise os fluxos de trabalho juntamente com as descrições abaixo para entender o que eles fazem. As descrições abaixo indicam onde você pode substituir o sistema modificando as configurações de endpoint e os fluxos de trabalho do projeto.

Utilitário - Fazer Upload de Formulários de Pedido de Cliente para o Azure

Este fluxo de trabalho automatiza o processamento de formulários de pedido, extraindo detalhes do NetSuite, fazendo upload de documentos para o Azure Blob Storage e indexando-os no índice de pesquisa do Azure AI.

Este fluxo de trabalho deve ser executado primeiro para carregar todos os dados de clientes ativos, tornando os detalhes dos clientes disponíveis para o agente de IA. A execução do fluxo de trabalho é descrita em Acionar os fluxos de trabalho do projeto mais adiante nesta página.

Se os dados do formulário de pedido de cliente da sua organização estiverem em um sistema diferente do NetSuite, você deve modificar as operações do fluxo de trabalho para substituir os componentes específicos do NetSuite pelos do seu endpoint.
Entrada Principal - Manipulador de Solicitações da API do Slack

Este fluxo de trabalho gerencia as solicitações de bot do Slack recebidas e verifica a autorização do usuário. Ele é acionado via uma API personalizada do Jitterbit sempre que sua equipe de Vendas interage com a interface de chat do bot do Slack (ou seja, envia uma mensagem do Slack para ele). A configuração da API personalizada do Jitterbit é descrita em Criar a API personalizada do Jitterbit mais adiante nesta página.

Se você não estiver usando o Slack, este fluxo de trabalho pode ser ignorado e não será acionado. Para usar uma interface de chat diferente para sua equipe de Vendas interagir, utilize o fluxo de trabalho Manipulador de Solicitações de API Genérico, também acionado via uma API personalizada do Jitterbit.
Main - Lógica das Ferramentas do Agente de IA

Após receber a autorização do usuário a partir dos fluxos de trabalho Main Entry - Slack API Request Handler ou Generic API Request Handler, este fluxo de trabalho gerencia solicitações de chamada de função para o modelo de linguagem grande (LLM), tomando decisões sobre qual ferramenta executar com base na resposta do LLM. Existem três chamadas principais de ferramentas:
1. Customer_Order_Function: Esta ferramenta aborda consultas de usuários sobre formulários de pedidos de clientes, invocando a operação Main - Get Customer Order Form Details dentro do fluxo de trabalho Tool-Customer Order Details.
2. Pricing_Function: Esta ferramenta aborda consultas de usuários sobre preços de produtos, invocando a operação Main - Pricing Sheet dentro do fluxo de trabalho Tool-Pricing Sheets.
3. Customer_Lookup_By_Location_Function: Esta ferramenta aborda consultas de usuários para obter clientes por localização ou proprietário da conta, invocando a operação Main - Customer Lookup dentro do fluxo de trabalho Tool - Customer Lookup.
Tool-Customer Order Details

Este fluxo de trabalho recupera detalhes do pedido do cliente do NetSuite.

Para usar um endpoint diferente do NetSuite, crie uma nova operação para recuperar formulários de pedidos do sistema e atribua os resultados à variável global extractedContent variável global. Em seguida, acione a nova operação a partir da operação Main - Get Customer Order Form Details.
Tool-Pricing Sheets

Este fluxo de trabalho recupera preços de produtos do Salesforce.

Na configuração da atividade de consulta do Salesforce, a seguinte consulta recupera informações de preços de produtos por agente. Se sua organização Salesforce não usar esses objetos e campos, ou se as informações de preços de produtos estiverem armazenadas em objetos/campos diferentes, este fluxo de trabalho não funcionará corretamente. Nesse caso, o agente não poderá responder a perguntas sobre preços. Personalize a consulta neste fluxo de trabalho para alinhar-se ao modelo de dados da sua organização Salesforce:

    SELECT Product2.Description,
           Product2.Family,
           Product2.ProductCode,
           CurrencyIsoCode,
           Name,
           UnitPrice,
           Pricebook2.Name,
           Id
    FROM   PricebookEntry
    WHERE  IsDeleted = false
           AND IsArchived = false
           AND IsActive = true
           AND Pricebook2.IsActive = true
           AND Pricebook2.IsDeleted = false
           AND Pricebook2.IsArchived = false
           AND Product2.IsActive = true
           AND Product2.IsDeleted = false
           AND Product2.IsArchived = false
           AND CurrencyIsoCode = '{{ currencycode }}'
    ORDER BY Name
    ```

    Para usar um endpoint diferente do Salesforce, crie uma nova operação para recuperar o preço dos produtos do sistema e atribua os resultados à variável global `pricing_sheet`. Em seguida, acione a nova operação a partir da operação `Main - Pricing Sheet`.

6.  **Ferramenta - Consulta de Clientes**

    Este fluxo de trabalho recupera clientes do Salesforce.

    Na configuração da [atividade de Consulta do Salesforce](/pt/integration-studio/design/connectors/salesforce/salesforce-connector-configuration/salesforce-query-activity/), a seguinte consulta recupera informações da conta do cliente. Se sua organização Salesforce usar campos ou objetos diferentes para os detalhes do cliente, personalize esta consulta neste fluxo de trabalho conforme necessário:

    ```sql
    SELECT Id,
           BillingCity,
           BillingCountry,
           BillingState,
           Name
    FROM   Account
    WHERE  Type = 'Customer'
    ```

    Para usar um endpoint diferente do Salesforce, crie uma nova operação para recuperar clientes do sistema e atribua os resultados à variável global `extractedContent`. Em seguida, acione a nova operação a partir da operação `Main - Customer Lookup`.

7.  **Utilitário - Obter Todos os Proprietários de Conta**

    Este fluxo de trabalho recupera proprietários de conta do Salesforce.

    Na configuração da [atividade de Consulta do Salesforce](/pt/integration-studio/design/connectors/salesforce/salesforce-connector-configuration/salesforce-query-activity/), a seguinte consulta recupera os proprietários de conta (nome e email) para todas as contas do tipo `Cliente` ou `Parceiro`. Se sua organização Salesforce usar tipos de conta diferentes ou campos personalizados para classificar contas, personalize esta consulta neste fluxo de trabalho conforme necessário:

    ```sql
    SELECT OwnerId,
           Owner.Email,
           Owner.Name
    FROM   Account
    WHERE  Type IN ('Customer', 'Partner')
    ```

    Para usar um endpoint diferente do Salesforce, crie uma nova operação para recuperar proprietários de conta do sistema e atribua os resultados à variável `Account_Owner_List`. Em seguida, acione a nova operação a partir da operação `Main  - Get Owner List`.

8.  **Utilitário - Autorização de Usuário e Sessão**

    Este fluxo de trabalho gerencia a autorização e a sessão do usuário. Ele utiliza o [Jitterbit Cloud Datastore](/pt/cloud-datastore/) para manter uma lista de usuários autorizados e suas sessões ativas.

Para configurar este fluxo de trabalho com um armazenamento de dados alternativo ou mecanismo de autorização para gerenciar o acesso e as sessões dos usuários, modifique as operações do fluxo de trabalho conforme necessário.

9.  **Utilitário - Armazenamento do Histórico de Chat do Bot**

    Este fluxo de trabalho gerencia o armazenamento do histórico de chat do bot, que é essencial para fornecer contexto de memória aos LLMs. Ele utiliza o Jitterbit Cloud Datastore para esse fim.

    Para integrar com outras soluções de armazenamento de dados para armazenar e recuperar o histórico de chat, modifique as operações do fluxo de trabalho conforme necessário.

10. **Manipulador de Solicitações de API Genérico**

    Este fluxo de trabalho processa solicitações de API HTTP de qualquer aplicativo. Para integrar com seus aplicativos, crie uma API Jitterbit personalizada que acione a operação `Manipulador de Solicitações de API Genérico`. A URL dessa API pode então ser usada por qualquer aplicativo para enviar e receber solicitações.

    A configuração da API Jitterbit personalizada é descrita em [Criar a API personalizada do Jitterbit](#create-the-jitterbit-custom-api) mais adiante nesta página.

### Criar recursos do Microsoft Azure {: #create-microsoft-azure-resources }

Crie os seguintes recursos do Microsoft Azure e retenha as seguintes informações para configurar o agente de IA. Para criar e gerenciar esses recursos, você deve ter uma assinatura do Microsoft Azure com as [permissões](https://learn.microsoft.com/en-us/azure/role-based-access-control/resource-provider-operations) apropriadas.

#### Contêiner Blob do Azure {: #azure-blob-container }

Você deve [criar um contêiner Blob do Azure](https://learn.microsoft.com/en-us/azure/storage/blobs/blob-containers-portal) para armazenar os detalhes do cliente. Os dados do contêiner Blob serão indexados no Azure AI Search usando um índice e um indexador.

Você precisará da URL SAS do contêiner para usar na determinação dos valores das [variáveis do projeto de Armazenamento Blob do Azure](#azure-blob-storage). Para gerar a URL SAS:

1.  No portal do Azure, navegue até [Contas de armazenamento](https://portal.azure.com/#browse/Microsoft.Storage%2FStorageAccounts) e abra a conta de armazenamento específica.
2.  No menu de recursos sob **Armazenamento de dados**, selecione **Contêineres** e abra o contêiner específico.
3.  No menu de recursos sob **Configurações**, selecione **Tokens de acesso compartilhado**.
4.  Use o menu **Permissões** para verificar se a URL da assinatura de acesso compartilhado (SAS) para este contêiner possui, no mínimo, permissões de **Leitura** e **Gravação**:

    ![Permissões de URL SAS](/_download/images/other/azure-sas.png)

5.  Clique em **Gerar token e URL SAS**.
6.  Copie o **Blob SAS URL** exibido na parte inferior.
7.  Determine os valores das variáveis do projeto do Azure Blob Storage a partir do URL SAS. O URL SAS está no formato `{{ azure_blob_base_url }}`/`{{ Azure_Customer_Details_Container }}`?`{{ azure_customer_detail_blob_sig }}`.

Se estiver usando os arquivos de definição JSON incluídos nos arquivos de personalização do agente de IA para gerar o índice e o indexador, você também precisará da chave da conta do Azure Blob Storage. Para [visualizar as chaves de acesso da conta](https://learn.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage?tabs=azure-portal#view-account-access-keys):

1.  No portal do Azure, navegue até [Contas de armazenamento](https://portal.azure.com/#browse/Microsoft.Storage%2FStorageAccounts) e abra a conta de armazenamento específica.
2.  No menu de recursos, sob **Segurança + rede**, selecione **Chaves de acesso**.
3.  Clique em **Mostrar chaves** para revelar a chave de acesso a ser usada durante a configuração do [Azure AI Search](#azure-ai-search).

    ![Chaves da conta de armazenamento](/_download/images/other/azure-keys.png)

#### Serviço Azure AI Search {: #azure-ai-search-service }

Você deve [criar um serviço Azure AI Search](https://learn.microsoft.com/en-us/azure/search/search-create-service-portal) e configurar seu índice e indexador para processar os dados do contêiner Blob.

Você precisará da URL do serviço Azure AI Search e da chave da API para determinar os valores das [variáveis do projeto Azure AI Search](#azure-ai-search):

-   **URL:** Para obter o valor a ser usado para `azure_ai_search_url`, consulte a documentação do Azure [Obter informações do serviço](https://learn.microsoft.com/en-us/azure/search/search-get-started-rbac?pivots=rest#get-service-information).
-   **Chave da API:** Para obter o valor a ser usado para `azure_ai_search_api_key`, consulte a documentação do Azure [Configurar acesso baseado em função](https://learn.microsoft.com/en-us/azure/search/search-get-started-rbac?pivots=rest#configure-role-based-access).

Você pode usar os arquivos de definição JSON incluídos nos arquivos de personalização do agente de IA para gerar o índice e o indexador, ou pode criá-los você mesmo.

Se você estiver usando os arquivos de definição fornecidos, deve substituir os seguintes espaços reservados pelos seus próprios valores de configuração:


**Azure_AI_Search_Indexer_Definition.json**

| Espaço Reservado                             | Descrição                              |
| --------------------------------------- | ---------------------------------------- |
| `{{Seu Nome do Serviço de Pesquisa AI do Azure}}` | O nome do serviço de pesquisa AI do Azure. |

**Azure_AI_Search_Datasource_Definition.json**

| Espaço Reservado                             | Descrição                                                                                                                      |
| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `{{Seu Nome do Serviço de Pesquisa AI do Azure}}` | O nome do serviço de pesquisa AI do Azure.                                                                                         |
| `{{Seu Nome da Conta de Blob do Azure}}`      | O nome da conta de Blob do Azure.                                                                                              |
| `{{Sua Chave de Conta de Blob do Azure}}`       | A chave de acesso para a conta de Armazenamento Blob do Azure, obtida conforme descrito em [contêiner Blob do Azure](#azure-blob-container) acima. |
| `{{seu_nome_do_contêiner_blob_azure}}`    | O nome do contêiner Blob do Azure.                                                                                            |



#### Recurso Azure OpenAI {: #azure-openai-resource }

Você deve [criar um recurso Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/create-resource?pivots=web-portal) e implantar um modelo `gpt-4o` ou `gpt-4.1` através do portal Azure AI Foundry.

Você precisará do nome da implantação, da URL do endpoint do Azure OpenAI e da chave da API para determinar os valores das [variáveis do projeto Azure OpenAI](#azure-openai). Para encontrar esses valores:

1.  No portal Azure AI Foundry, abra o recurso OpenAI específico.
2.  Os valores a serem usados para a URL do endpoint (`azure_openai_base_url`) e a chave da API (`azure_openai_api_key`) são exibidos na página inicial do recurso:

    ![Chave e URL do AI Foundry](/_download/images/other/azure-foundry.png){style="width: 1286px"}

3.  No menu de navegação sob **Recursos compartilhados**, selecione **Implantações**. O nome da implantação (`Azure_OpenAI_Deployment_Name`) é exibido.

### Preparar o Jitterbit Cloud Datastore {: #prepare-jitterbit-cloud-datastore }

[Crie dois armazenamentos de chave](/pt/management-console/cloud-datastore/#key-storages) no Jitterbit Cloud Datastore, `Bot_Authorized_Users` e `askjb_sales_q_and_a`, cujos campos têm os nomes e tipos listados nas tabelas abaixo.

Ao adicionar campos personalizados, use as tabelas abaixo para determinar se cada um deve ser alternado para **Obrigatório** na interface do usuário do Cloud Datastore. Os campos `AlternativeKey` e `Value` são campos padrão que não podem ser removidos ou alternados.

Após adicionar campos personalizados, [adicione um registro de armazenamento de chave](/pt/management-console/cloud-datastore/#key-storage-registers) para cada usuário que será autorizado a usar o bot do agente de IA. Você deve definir manualmente os valores marcados nas tabelas abaixo. Você pode deixar em branco os valores dos campos cujos valores são preenchidos automaticamente ou não são utilizados.

#### Bot_Authorized_Users {: #bot_authorized_users }

Este armazenamento de chave contém a lista de usuários autorizados e suas sessões. Você deve inserir manualmente os endereços de email dos usuários que estão autorizados a acessar o bot do agente de IA.

| Nome             | Tipo | Obrigatório | Definição do valor | Descrição                                                                                                                                                                                                                                     |
| ---------------- | ---- | ----------- | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Key`            | Texto | Sim         | Inserir manualmente | O endereço de email do usuário autorizado a interagir com o agente de IA via o bot do Slack. Este valor é inserido manualmente.                                                                                                           |
| `AlternativeKey` | Texto | Não         | Preenchido automaticamente | A sessão do usuário será gerada automaticamente durante a execução. Nenhuma entrada manual é necessária.                                                                                                                                                  |
| `Value`          | Texto | Não         | Inserir manualmente | O endereço de email do usuário autorizado a interagir com o agente de IA via o bot do Slack. Este valor é inserido manualmente. Embora não seja marcado como um campo obrigatório por padrão, fornecer um valor é necessário para o funcionamento do agente de IA. |

#### askjb_sales_q_and_a {: #askjb_sales_q_and_a }

Este armazenamento de chave retém o histórico de chat de um bot para fornecer contexto de memória para o LLM. É utilizado pela integração para armazenar o histórico de perguntas e respostas. Todos os dados são inseridos automaticamente durante a execução da interação.

| Nome                      | Tipo     | Obrigatório | Definição do valor | Descrição                                                                                   |
| ------------------------- | -------- | ----------- | ------------------ | --------------------------------------------------------------------------------------------- |
| `Key`                     | Texto    | Sim         | Preenchido automaticamente | Especifica o identificador único atribuído a uma mensagem pelo sistema.                          |
| `AlternativeKey`          | Texto    | Não         | Preenchido automaticamente | Especifica o identificador único atribuído a uma sessão de chat pelo sistema.                     |
| `Value`                   | Texto    | Não         | Não utilizado      | Não utilizado.                                                                                     |
| `slackChannel`            | Texto    | Sim         | Preenchido automaticamente | O ID do canal Slack de onde a mensagem é enviada.                                          |
| `User`                    | Texto    | Sim         | Preenchido automaticamente | O nome de usuário do Slack do usuário que envia a mensagem.                                         |
| `FirstName`               | Texto    | Não         | Preenchido automaticamente | Primeiro nome do usuário que envia a mensagem.                                                 |
| `LastName`                | Texto    | Não         | Preenchido automaticamente | Último nome do usuário que envia a mensagem.                                                  |
| `Email`                   | Texto    | Sim         | Preenchido automaticamente | Endereço de email do usuário que envia a mensagem.                                              |
| `MessageTimestampText`    | Texto    | Sim         | Preenchido automaticamente | O texto do timestamp da mensagem.                                                            |
| `UserQuestion`            | Texto Grande | Sim     | Preenchido automaticamente | A pergunta ou mensagem submetida pelo usuário ao agente de IA.                                |
| `AIAnswer`                | Texto Grande | Sim     | Preenchido automaticamente | A resposta gerada pelo agente de IA à pergunta do usuário.                                |
| `ai_reformulate_question` | Texto Grande | Não     | Preenchido automaticamente | A pergunta do usuário após ser reformulada ou reescrita pela IA para melhorar a compreensão. |

### Configurar variáveis do projeto {: #configure-project-variables }

No projeto do Integration Studio instalado anteriormente via Marketplace, é necessário definir valores para as seguintes [variáveis do projeto](/pt/integration-studio/design/variables/project/).

Isso pode ser feito usando o menu de ações <span class="icon-more"></span> do projeto para selecionar **Variáveis do Projeto** e abrir um painel na parte inferior da página onde é possível revisar e definir os valores.

#### Salesforce {: #salesforce }

| Nome da variável       | Descrição                                                                                                                                                                                     |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `SF_Login_URL`        | **Servidor Host** na [conexão Salesforce](/pt/integration-studio/design/connectors/salesforce/salesforce-connector-configuration/salesforce-connection/#configure-a-salesforce-connection)    |
| `SF_Password`         | **Senha** na [conexão Salesforce](/pt/integration-studio/design/connectors/salesforce/salesforce-connector-configuration/salesforce-connection/#configure-a-salesforce-connection)       |
| `SF_Security_Token`   | **Token de segurança** na [conexão Salesforce](/pt/integration-studio/design/connectors/salesforce/salesforce-connector-configuration/salesforce-connection/#configure-a-salesforce-connection) |
| `SF_User_Name`        | **Nome de usuário** na [conexão Salesforce](/pt/integration-studio/design/connectors/salesforce/salesforce-connector-configuration/salesforce-connection/#configure-a-salesforce-connection)       |

#### NetSuite {: #netsuite }



| Nome da variável              | Descrição                                                                                                                                                                            |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `NetSuite_Account`           | **Conta** na [conexão NetSuite](/pt/integration-studio/design/connectors/netsuite/netsuite-connector-configuration/netsuite-connection/#configure-a-netsuite-connection)         |
| `NetSuite_Consumer_Key`      | **Chave do consumidor** na [conexão NetSuite](/pt/integration-studio/design/connectors/netsuite/netsuite-connector-configuration/netsuite-connection/#configure-a-netsuite-connection)    |
| `NetSuite_Consumer_Secret`   | **Segredo do consumidor** na [conexão NetSuite](/pt/integration-studio/design/connectors/netsuite/netsuite-connector-configuration/netsuite-connection/#configure-a-netsuite-connection) |
| `NetSuite_Base_URL`          | URL base do NetSuite, como `https://{{NetSuite_Account}}.suitetalk.api.netsuite.com`.                                                                                                  |
| `NetSuite_Token_Key`         | **Chave do token** na [conexão NetSuite](/pt/integration-studio/design/connectors/netsuite/netsuite-connector-configuration/netsuite-connection/#configure-a-netsuite-connection)       |
| `NetSuite_Token_Secret`      | **Segredo do token** na [conexão NetSuite](/pt/integration-studio/design/connectors/netsuite/netsuite-connector-configuration/netsuite-connection/#configure-a-netsuite-connection)    |



#### Azure Blob Storage {: #azure-blob-storage }

| Nome da variável                      | Descrição                                                                          |
| ------------------------------------- | ------------------------------------------------------------------------------------ |
| `Azure_Customer_Details_Container`   | O nome do contêiner Azure Blob para armazenar informações de clientes de formulários de pedido. |
| `azure_customer_detail_blob_sig`      | Assinatura da URL SAS para `Azure_Customer_Details_Container`.                            |
| `azure_blob_base_url`                 | URL base do serviço de contêiner Azure para `Azure_Customer_Details_Container`.             |



!!! tip "Dica"
    Esses valores podem ser derivados da URL SAS, que está no formato de `{{azure_blob_base_url}}`/`{{Azure_Customer_Details_Container}}`?`{{azure_customer_detail_blob_sig}}`.



#### Azure AI Search {: #azure-ai-search }

| Nome da variável                      | Descrição                                                                                                                    |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `customer_search_index_name`          | O nome do índice Azure que armazena informações de clientes de formulários de pedido.                                                 |
| `Azure_SalesOrders_Customer_Indexer`  | O nome do indexador Azure que indexa dados de `Azure_Customer_Details_Container` para o índice `customer_search_index_name`. |
| `azure_ai_search_url`                 | URL base do serviço de busca AI da Azure.                                                                                              |
| `azure_ai_search_api_key`             | Chave de API para o serviço de busca AI da Azure.                                                                                           |

#### Azure OpenAI {: #azure-openai }

| Nome da variável                    | Descrição                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Max_Output_Tokens`                 | O número máximo de tokens que o LLM pode gerar em uma resposta. [GPT-4.1](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/concepts/models?tabs=global-standard%2Cstandard-chat-completions#gpt-41-series) suporta até 32768 tokens, enquanto [GPT-4o](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/concepts/models?tabs=global-standard%2Cstandard-chat-completions#gpt-4o-and-gpt-4-turbo) suporta até 16384. |
| `Azure_OpenAI_Deployment_Name`      | O nome da implantação para LLM no Azure OpenAI.                                                                                                                                                                                                                                                                                                                                                                                           |
| `azure_openai_base_url`             | URL base do serviço Azure OpenAI.                                                                                                                                                                                                                                                                                                                                                                                                            |
| `azure_openai_api_key`              | Chave de API para o serviço Azure OpenAI.                                                                                                                                                                                                                                                                                                                                                                                                         |

#### Slack {: #slack }

| Nome da variável                | Descrição                                                                                                                                                                                                                  |
| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `salesorder_slack_bot_token` | O token do bot do Slack que é obtido após [criar o aplicativo Slack](#create-the-slack-app), usado para o **token de acesso OAuth do usuário Bot** na [conexão do Slack](/pt/integration-studio/design/connectors/slack/connection/). |

!!! note "Nota"
    O aplicativo Slack é criado em uma etapa posterior. Por enquanto, você pode deixar esta variável em branco.

#### Comum {: #common }

| Nome da variável                    | Descrição                                                                                                                                                                             |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Authorized_User_Admin`          | Nome/email do contato exibido na resposta enviada ao usuário quando ocorre um erro.                                                                                                         |
| `Customer_LastOrder_DefaultDate` | A data padrão (`mm/dd/yyyy`) a partir da qual os pedidos são extraídos do NetSuite durante a primeira execução ou uma execução histórica quando `incrementalRun` está definido como `false`. Por exemplo: `06/01/2004`. |
| `Default_Last_Sync_Date`         | Data da última sincronização padrão a ser usada se o valor do cache não estiver disponível.                                                                                                                      |
| `incrementalRun`                 | Quando `true`, apenas pedidos incrementais (novos ou atualizados) são extraídos do NetSuite. Quando `false` ou em branco, um histórico completo de pedidos é recuperado a partir da data padrão.                     |
| `Only_Unexpired_Orders`          | Quando `true`, apenas os pedidos com `nextbilldate` maior que a data de hoje serão extraídos do NetSuite.                                                                                |

### Testar conexões {: #test-connections }

[Teste](/pt/integration-studio/design/connectors/connector-basics/#connectorbasics-connection-testing) as configurações de endpoint para verificar a conectividade usando os valores de variáveis de projeto definidos.

Isso pode ser feito na aba **Endpoints e conectores do projeto** <span class="icon-new-connection"></span> do painel de componentes de design, passando o mouse sobre cada endpoint e clicando em <span class="icon-test"></span> **Testar**.

### Implantar o projeto {: #deploy-the-project }

[Implante](/pt/integration-studio/design/projects/deployment/) o projeto do Integration Studio. Isso pode ser feito usando o menu de ações <span class="icon-more"></span> do projeto para selecionar **Implantar**.

### Criar a API personalizada do Jitterbit {: #create-the-jitterbit-custom-api }

[Criar uma API personalizada](/pt/api-manager/api-manager-reference/api-configuration/custom-api/) usando o API Manager para um dos seguintes:

-   [Manipulador de solicitações da API do bot Slack](#create-the-slack-bot-api-request-handler): Necessário se estiver usando a notificação do Slack incluída no design deste agente de IA.
-   [Manipulador de solicitações da API genérica](#generic-api-request-handler): Opcional. Use para manipular solicitações de API de qualquer aplicativo.

#### Criar o manipulador de solicitações da API do bot Slack {: #create-the-slack-bot-api-request-handler }

Esta API personalizada do Jitterbit acionará a operação `Manipulador de Solicitações da API do Bot Slack`. Configure e publique a API personalizada com as seguintes configurações:

-   **Serviço da API:** `Manipulador de Solicitações da API do Bot Slack`
-   **Caminho:** `/`
-   **Projeto:** Selecione o projeto do Integration Studio criado a partir do `Agente de Vendas Jitterbit` no Marketplace
-   **Operação a Acionar:** `Manipulador de Solicitações da API do Bot Slack`
-   **Método:** `POST`
-   **Tipo de Resposta:** `Variável do Sistema`

Mantenha a URL do serviço da API publicada para uso na criação do aplicativo Slack. A URL do serviço pode ser encontrada na [gaveta de detalhes da API](/pt/api-manager/api-manager-user-interface/apis/#api-details-drawer) na aba **Serviços**, passando o mouse sobre a coluna **Ações** do serviço e clicando em <span class="icon-copy"></span> **Copiar URL do serviço da API**.

#### Manipulador de solicitações da API genérica {: #generic-api-request-handler }

Esta API personalizada do Jitterbit acionará a operação `Generic API request Handler`. Não é obrigatório. Crie esta API se você estiver usando outros aplicativos para processar solicitações de API HTTP. Configure e publique a API personalizada com as seguintes configurações:

-   **Nome do serviço:** `Generic API request Handler`
-   **Projeto:** Selecione o projeto do Integration Studio criado a partir do `Jitterbit Sales Agent` no Marketplace
-   **Operação:** `Generic API request Handler`
-   **Método:** `POST`
-   **Tipo de resposta:** `System Variable`

!!! tip "Dica"
    Você também pode adicionar um [perfil de segurança](/pt/api-manager/api-manager-user-interface/security-profiles/) para autenticação.

``` title="Corpo da solicitação"
{
    "username": "abc@abc.com",
    "sessionId": "123608",
    "prompt": "Order Forms details for xyz"
}

Resposta

{
   "message": "Based on order forms, here are the complete order details: ...",
   "status_code": 200
}

Crie o aplicativo Slack, teste a conexão e reimplante o projeto

Para criar a interface de chat do Sales Agent no Slack, crie um aplicativo Slack usando o arquivo de manifesto do aplicativo Slack fornecido com os arquivos de personalização deste agente de IA. Ou, crie-o do zero.

Se estiver usando o arquivo de manifesto do aplicativo Slack fornecido (slack_app_manifest.json), você deve substituir os seguintes marcadores de posição pelos seus próprios valores de configuração:

Marcador de posição	Descrição
`{{Substitua pelo nome do bot Slack}}`	O nome que você deseja que seu bot Slack tenha, conforme exibido para os usuários. Existem dois locais no manifesto onde você deve substituir este valor.
`{{Substitua pela URL da API Jitterbit}}`	A URL do serviço da API personalizada do Jitterbit que você criou em Crie o manipulador de solicitações da API do bot Slack.

Após instalar o aplicativo Slack, obtenha seu token de bot.

Reabra a configuração das variáveis do projeto e insira o token de bot no valor da variável do projeto salesorder_slack_bot_token.

Uma vez que o token de bot esteja configurado, teste a conexão com o Slack e reimplante o projeto.

Acionar os fluxos de trabalho do projeto

Para o carregador de dados inicial, execute a operação no primeiro fluxo de trabalho, Utility-Upload Customer Order Forms to Azure. Isso pode ser feito usando a opção Executar da operação, que é exibida ao passar o mouse sobre a operação. Você precisará executar a operação novamente no futuro se seus dados forem atualizados.

Dica

Você pode querer colocar essa operação em um cronograma para obter dados atualizados regularmente. Isso pode ser feito no menu de ações da operação em Configurações > Cronogramas.

Os outros dois principais fluxos de trabalho são acionados pelas APIs personalizadas do Jitterbit:

Main Entry - Slack API Request Handler: Este fluxo de trabalho é acionado a partir do Slack via a API personalizada Slack Bot API Request Handler. Enviar uma mensagem direta para o aplicativo Slack iniciará o acionamento da API personalizada.
Generic API Request Handler: Este fluxo de trabalho é acionado a partir de outro aplicativo via a API personalizada Generic API Request Handler. Enviar uma solicitação para a API configurada iniciará o acionamento da API personalizada.

Todos os outros fluxos de trabalho são acionados por outras operações e estão a jusante das listadas acima. Eles não são destinados a serem executados sozinhos.

Solução de Problemas

Revise os logs da API e os logs da operação para obter informações detalhadas sobre solução de problemas.

Para assistência adicional, entre em contato com o suporte do Jitterbit.