Integre ChatGPT da OpenAI com Twilio Voz Programável e Functions

Tempo de leitura: 13 minutos

April 03, 2023

Escrito por

Michael Carpenter

Twilion

Gabriel Bolzi

Twilion

Revisado por

Dhruv Patel

Twilion

Integre ChatGPT da OpenAI com Twilio Voz Programável e Functions

Por que conversar com um robô quando você pode conversar com três?

Usar o ChatGPT para alimentar um chatbot de voz interativa não é apenas uma novidade, pode ser uma maneira de obter informações úteis de inteligência de negócios, reservando agentes humanos dedicados, caros e de thread único para conversas que apenas os humanos podem ajudar. Nos dias de hoje, as pessoas falam, ouvem e colaboram com robôs o tempo todo, mas você sabe o que é mais legal do que interagir com um robô? Interagir com três!

Neste post, mostraremos como usar o reconhecimento de fala nativo da Twilio e as capacidades de texto para fala neural da Amazon Polly com o ChatGPT para criar um chatbot ativado por voz, hospedado inteiramente no ambiente de funções em cloud da Twilio. Você também usará a API de eventos de chamada para analisar o que os chamadores estão perguntando e visualizar as respostas do bot, o que nos permite desbloquear os ricos dados de primeira parte capturados nessas interações e enviar os dados para plataformas de engajamento do cliente como o Segment, onde você pode usá-los para construir perfis de clientes, entender preferências de clientes e criar experiências personalizadas que os clientes esperam.

Quer experimentar uma demonstração antes de se aprofundar? Ligue para 1-989-4OPENAI (467-3624) para testá-lo!

Robô #1: Decodificando a voz humana usando reconhecimento de fala

O reconhecimento de fala da Twilio usando o verbo TwiML <Gather> é uma ferramenta poderosa que converte palavras faladas em uma chamada telefônica em texto. Ele oferece excelente precisão, baixa latência e suporte a inúmeros idiomas e dialetos. Historicamente, os desenvolvedores da Twilio usaram o reconhecimento de fala como uma maneira de navegar em respostas de voz interativas (IVRs) e outros fluxos de trabalho de automação de autoatendimento, mas com o lançamento de novos modelos de fala experimentais, o único limite é ✨ sua imaginação ✨.

Recurso #2: Dando uma voz ao seu robô com as Vozes Neurais da Amazon Polly

Com o verbo TwiML <Say>, o Twilio fornece uma função de texto para fala (TTS) que usa vozes da Amazon Polly que aproveitam o aprendizado profundo para sintetizar uma fala semelhante à humana. As vozes neurais da Polly oferecem um som mais natural e realista, proporcionando uma experiência auditiva envolvente para os usuários. Com suporte para vários idiomas, uma ampla gama de vozes e suporte SSML, o texto para fala da Twilio permite personalizar a voz do chatbot para corresponder à identidade da marca.

Recurso #3: Companheiro de conversação ChatGPT da OpenAI

O ChatGPT é um modelo de linguagem avançado desenvolvido pela OpenAI, capaz de gerar texto semelhante ao humano com base na entrada fornecida. Ele pode entender o contexto, fornecer respostas relevantes e até mesmo realizar tarefas criativas, como escrever histórias ou poemas. Ao alavancar a API da OpenAI, os desenvolvedores podem integrar essa IA diretamente em suas aplicações, oferecendo aos usuários uma experiência mais interativa e envolvente.

Twilio Functions

Como você fará com que esses três robôs conversem entre si e com seus chamadores? Usando as Twilio Functions. Além de dar a você a capacidade de colocar uma prova de conceito em funcionamento sem precisar iniciar seu próprio servidor, as Twilio Functions fornecem recursos de dimensionamento automático, segurança aprimorada e redução de latência, executando seu código dentro da Twilio. É claro que, se você tiver seu próprio servidor em algum lugar, pode fazer algumas pequenas edições no JavaScript e ele será executado em seu ambiente Node.js.

Agora que você tem os ingredientes, vamos conferir a receita em dois sabores: CLI e GUI.

Prepare-se antes de começar

Antes de entrar no processo de integração, você precisará dos seguintes itens:

Uma conta na Twilio - Inscreva-se gratuitamente usando este link e receba $10 de crédito quando atualizar sua conta.
Um número de telefone Twilio - Clique aqui para saber como obter o seu primeiro número Twilio com sua conta de teste.
Uma chave de API da OpenAI em um plano premium ou com créditos disponíveis.

O CLI da Twilio com a ferramenta Serverless instalada.

Função do próximo dia

Primeiro, vamos organizar nosso backend. Você começará criando um novo projeto Serverless. Como você instalou o incrível Serverless Toolkit de código aberto, pode fazer isso em uma linha passando o comando para o seu terminal:

twilio serverless:init <project-name>

Substitua <nome-do-projeto> por um nome de sua preferência. Eu estou nomeando o meu como "three-robot-rhumba".

Terminal window showing the initialization of a Twilio Serverless project

Vá em frente e acesse o diretório do seu projeto e vamos atualizar o arquivo .env para fornecer seu token de autenticação da Twilio como AUTH_TOKEN e sua chave de API OpenAI como OPENAI_API_KEY. O SID da sua conta Twilio deve ser preenchido automaticamente. Certifique-se de que seu arquivo .env fique assim (com os espaços reservados XXXXX substituídos por suas respectivas chaves):

ACCOUNT_SID=XXXXX
AUTH_TOKEN=XXXXX
OPENAI_API_KEY=XXXXX

Já que as Funções (Functions) da Twilio Serverless são apenas aplicativos Node.js, você pode adicionar dependências usando qualquer gerenciador de pacotes que escreva em package.json; estou usando o npm porque é básico. Volte ao seu terminal e digite o seguinte para instalar o pacote OpenAI NPM:

npm install openai

Com suas variáveis de ambiente definidas e suas dependências adicionadas, você pode começar a trabalhar. Você vai criar duas Funções (Functions): uma função /transcribe que usa o reconhecimento de fala da Twilio para transformar suas palavras faladas em texto que o ChatGPT pode entender usando o verbo <Gather> do TwiML e uma função /respond que pega o texto gerado pelo reconhecimento de fala, envia-o para a API da OpenAI e passa a resposta para o mecanismo de texto para fala da Twilio, que é alimentado pela tecnologia de voz neural da Amazon Polly, usando o verbo <Say> do TwiML.

Para criar uma nova Função, abra a pasta de funções no diretório do seu projeto e crie um arquivo JavaScript. Crie as funções /transcribe e /respond criando um arquivo transcribe.js e respond.js na pasta.

Perdido na Transcrição

Agora abra o arquivo transcribe.js e adicione o seguinte código:

exports.handler = function(context, event, callback) {
    // Create a TwiML Voice Response object to build the response
    const twiml = new Twilio.twiml.VoiceResponse();

    // If no previous conversation is present, or if the conversation is empty, start the conversation
    if (!event.request.cookies.convo) {
        // Greet the user with a message using AWS Polly Neural voice
        twiml.say({
                voice: 'Polly.Joanna-Neural',
            },
            "Hey! I'm Joanna, a chatbot created using Twilio and ChatGPT. What would you like to talk about today?"
        );
    }

    // Listen to the user's speech and pass the input to the /respond Function
    twiml.gather({
        speechTimeout: 'auto', // Automatically determine the end of user speech
        speechModel: 'experimental_conversations', // Use the conversation-based speech recognition model
        input: 'speech', // Specify speech as the input type
        action: '/respond', // Send the collected input to /respond 
    });

    // Create a Twilio Response object
    const response = new Twilio.Response();

    // Set the response content type to XML (TwiML)
    response.appendHeader('Content-Type', 'application/xml');

    // Set the response body to the generated TwiML
    response.setBody(twiml.toString());

    // If no conversation cookie is present, set an empty conversation cookie
    if (!event.request.cookies.convo) {
        response.setCookie('convo', '', ['Path=/']); 
    }

    // Return the response to Twilio
    return callback(null, response);
};

Se você é novo em Functions, deixe-me explicar o que está acontecendo aqui. A Função /transcribe cria uma resposta de voz geradora de TwiML com base na biblioteca auxiliar Node.js da Twilio, inicia uma conversa se nenhuma existir, ouve a entrada do usuário e passa essa entrada juntamente com o histórico da conversa para o endpoint /respond para processamento adicional.

Na linha 6, o aplicativo verifica se um cookie chamado "convo" existe. Se ele não existir ou se existir, mas estiver vazio, você pode entender que a conversa ainda não começou, portanto, iniciará uma saudação inicial usando o verbo TwiML <Say>.

Em seguida, o método twiml.gatheré usado para capturar a entrada do usuário. Os parâmetros para gather são:

speechTimeout: 'auto': Determina automaticamente quando o usuário parou de falar, pode ser definido como um número inteiro positivo, mas 'auto' é melhor para esse caso de uso.
speechModel: "experimental_conversations": Usa um modelo de reconhecimento de fala otimizado para casos de uso conversacionais
input: 'speech': Define o tipo de entrada como fala e ignora quaisquer pressionamentos de tecla (DTMF)
action: '/respond': Passa a entrada de fala do usuário juntamente com o histórico da conversa para o endpoint /respond

Agora, você precisa criar uma maneira de criar o cookie convo para que a Função /respond tenha um lugar para armazenar o histórico da conversa que será passado entre a API da OpenAI e nossas vozes neurais Polly, o que significa que o aplicativo precisa inicializar um objeto Twilio.Response(); na linha 25.

Você não pode passar tanto o Twilio.twiml.VoiceResponse(); quanto o Twilio.Response(); de volta para o manipulador, portanto, precisará usar a resposta que acabou de criar para anexar um cabeçalho às nossas solicitações e definir o TwiML que você gerou via <Gather> para o corpo nas linhas 28 e 31, respectivamente.

Depois disso, você pode definir o cookie usando response.setCookie(); na linha 35 antes de passar a resposta de volta para o manipulador para execução por nossa infraestrutura Serverless na linha 39. Vá em frente e salve este arquivo e feche-o.

Chamada e Resposta

Em seguida, abra respond.js e adicione o seguinte código:

// Import required modules
const { Configuration, OpenAIApi } = require("openai");

// Define the main function for handling requests
exports.handler = async function(context, event, callback) {
    // Set up the OpenAI API with the API key
    const configuration = new Configuration({ apiKey: context.OPENAI_API_KEY });
    const openai = new OpenAIApi(configuration);

    // Set up the Twilio VoiceResponse object to generate the TwiML
    const twiml = new Twilio.twiml.VoiceResponse();

    // Initiate the Twilio Response object to handle updating the cookie with the chat history
    const response = new Twilio.Response();

    // Parse the cookie value if it exists
    const cookieValue = event.request.cookies.convo;
    const cookieData = cookieValue ?
        JSON.parse(decodeURIComponent(cookieValue)) :
        null;

    // Get the user's voice input from the event
    let voiceInput = event.SpeechResult;

    // Create a conversation variable to store the dialog and the user's input to the conversation history
    const conversation = cookieData?.conversation || [];
    conversation.push(`user: ${voiceInput}`);

    // Get the AI's response based on the conversation history
    const aiResponse = await generateAIResponse(conversation.join(";"));

    // For some reason the OpenAI API loves to prepend the name or role in its responses, so let's remove 'assistant:' 'Joanna:', or 'user:' from the AI response if it's the first word
    const cleanedAiResponse = aiResponse.replace(/^\w+:\s*/i, "").trim();

    // Add the AI's response to the conversation history
    conversation.push(`assistant: ${aiResponse}`);

    // Limit the conversation history to the last 10 messages; you can increase this if you want but keeping things short for this demonstration improves performance
    while (conversation.length > 10) {
        conversation.shift();
    }

    // Generate some <Say> TwiML using the cleaned up AI response
    twiml.say({
            voice: "Polly.Joanna-Neural",
        },
        cleanedAiResponse
    );

    // Redirect to the Function where the <Gather> is capturing the caller's speech
    twiml.redirect({
            method: "POST",
        },
        `/transcribe`
    );

    // Since we're using the response object to handle cookies we can't just pass the TwiML straight back to the callback, we need to set the appropriate header and return the TwiML in the body of the response
    response.appendHeader("Content-Type", "application/xml");
    response.setBody(twiml.toString());

    // Update the conversation history cookie with the response from the OpenAI API
    const newCookieValue = encodeURIComponent(
        JSON.stringify({
            conversation,
        })
    );
    response.setCookie("convo", newCookieValue, ["Path=/"]);

    // Return the response to the handler
    return callback(null, response);

    // Function to generate the AI response based on the conversation history
    async function generateAIResponse(conversation) {
        const messages = formatConversation(conversation);
        return await createChatCompletion(messages);
    }

    // Function to create a chat completion using the OpenAI API
    async function createChatCompletion(messages) {
        try {
            const completion = await openai.createChatCompletion({
                model: "gpt-3.5-turbo",
                messages: messages,
                temperature: 0.8, // Controls the randomness of the generated responses. Higher values (e.g., 1.0) make the output more random and creative, while lower values (e.g., 0.2) make it more focused and deterministic. You can adjust the temperature based on your desired level of creativity and exploration.
                max_tokens: 100, //You can adjust this number to control the length of the generated responses. Keep in mind that setting max_tokens too low might result in responses that are cut off and don't make sense.
                // top_p: 0.9, Set the top_p value to around 0.9 to keep the generated responses focused on the most probable tokens without completely eliminating creativity. Adjust the value based on the desired level of exploration.
                // n: 1, Specifies the number of completions you want the model to generate. Generating multiple completions will increase the time it takes to receive the responses.
            });
            // Check if the response has a status code of 500
            if (completion.status === 500) {
                console.error("Error: OpenAI API returned a 500 status code."); // Log an error message indicating that the OpenAI API returned a 500 status code
                twiml.say({
                        // Create a TwiML say element to provide an error message to the user
                        voice: "Polly.Joanna-Neural",
                    },
                    "Oops, looks like I got an error from the OpenAI API on that request. Let's try that again."
                );
                twiml.redirect({
                        // Create a TwiML redirect element to redirect the user to the /transcribe endpoint
                        method: "POST",
                    },
                    `/transcribe`
                );
                response.appendHeader("Content-Type", "application/xml"); // Set the Content-Type header of the response to "application/xml"
                response.setBody(twiml.toString()); // Set the body of the response to the XML string representation of the TwiML response
                return callback(null, response); // Return the response to the callback function
            }
            return completion.data.choices[0].message.content;
        } catch (error) {
            // Check if the error is a timeout error
            if (error.code === "ETIMEDOUT" || error.code === "ESOCKETTIMEDOUT") {
                console.error("Error: OpenAI API request timed out."); // Log an error message indicating that the OpenAI API request timed out
                twiml.say({
                        // Create a TwiML say element to provide an error message to the user
                        voice: "Polly.Joanna-Neural",
                    },
                    "I'm sorry, but it's taking me a little bit too long to respond. Let's try that again, one more time."
                );
                twiml.redirect({
                        // Create a TwiML redirect element to redirect the user to the /transcribe endpoint
                        method: "POST",
                    },
                    `/transcribe`
                );
                response.appendHeader("Content-Type", "application/xml"); // Set the Content-Type header of the response to "application/xml"
                response.setBody(twiml.toString()); // Set the body of the response to the XML string representation of the TwiML response
                return callback(null, response); // Return the response to the callback function
            } else {
                console.error("Error during OpenAI API request:", error);
                throw error;
            }
        }
    }

    // Function to format the conversation history into a format that the OpenAI API can understand
    function formatConversation(conversation) {
        let isAI = true;
        const messages = [{
                role: "system",
                content: "You are a creative, funny, friendly and amusing AI assistant named Joanna. Please provide engaging but concise responses.",
            },
            {
                role: "user",
                content: "We are having a casual conversation over the telephone so please provide engaging but concise responses.",
            },
        ];

        // Iterate through the conversation history and alternate between 'assistant' and 'user' roles
        for (const message of conversation.split(";")) {
            const role = isAI ? "assistant" : "user";
            messages.push({
                role: role,
                content: message,
            });
            isAI = !isAI;
        }
        return messages;
    }
};

Assim como acima, aqui está um passeio guiado sobre o que exatamente está acontecendo neste código. Ele começa importando os módulos necessários (linha 2) e definindo a função principal para lidar com solicitações (linha 5).

As linhas 7-8 configuram a API da OpenAI com a chave da API, enquanto a linha 11 cria o objeto Twilio Voice Response que gerará TwiML para transformar as respostas do ChatGPT em fala para os chamadores. A linha 14 inicia o objeto de resposta da Twilio para atualizar o cookie do histórico da conversa e definir os cabeçalhos e o corpo para que o TwiML seja passado na resposta.

As linhas 17-20 analisam o valor do cookie, se existir, e a linha 23 recupera a entrada de voz do usuário do evento SpeechResult recebido da função /transcribe. As linhas 26-27 criam uma variável de conversação para armazenar o diálogo e adicionam a entrada do usuário ao histórico da conversa.

A linha 30 gera a resposta da AI com base no histórico da conversa e a linha 33 limpa a resposta da AI removendo quaisquer nomes de função desnecessários (assistente, Joanna, usuário). A linha adiciona a resposta da AI limpa ao histórico da conversa.

As linhas 39-41 limitam o histórico da conversa às últimas 10 mensagens para melhorar o desempenho e manter o cookie em um tamanho razoável, ao mesmo tempo em que dão ao chatbot contexto suficiente para fornecer respostas úteis. Você pode aumentar (ou diminuir) isso se quiser, mas lembre-se de que o histórico armazenado está sendo passado para a API da OpenAI em cada solicitação, então quanto maior isso ficar, mais tokens sua aplicação estará consumindo. As linhas 44-48 geram o TwiML <Say> usando a resposta da AI limpa e as linhas 51-55 redirecionam a chamada para a função /transcribe, onde o <Gather> está capturando a fala do chamador.

Assim como com /transcribe, precisamos usar a resposta para fornecer o TwiML e as linhas 58-59 definem o cabeçalho apropriado e retornam o TwiML no corpo da resposta. As linhas 62-67 atualizam o cookie do histórico da conversa com a resposta da API da OpenAI e a linha 70 retorna a resposta ao manipulador.

A função generateAIResponse (linhas 73-76) formata a conversa e cria uma conclusão do chat usando a API da OpenAI. A função createChatCompletion (linhas 81-88) envia uma solicitação à API da OpenAI para gerar uma resposta usando o modelo GPT-3.5-turbo e parâmetros especificados. Se recebermos um erro 500 da API da OpenAI, não queremos simplesmente encerrar a conversa, então lidaremos com um erro da API com <Say> e redirecionando a conversa de volta para a função /transcribe nas linhas 90-107.

Também é possível que a solicitação para a OpenAI simplesmente demore demais para ser respondida, então um tratamento de exceção foi adicionado entre as linhas 109-131 para lidar com o tempo limite de forma elegante, redirecionando para /transcribe para tentar novamente.

Finalmente, a função formatConversation (linhas 136-158) formata o histórico de conversa em um formato que a API da OpenAI possa entender, alternando entre os papéis de assistente e usuário.

Agora que seu código foi atualizado, suas dependências configuradas e suas variáveis de ambiente configuradas, você está pronto para implantar. Com o Twilio Serverless, não poderia ser mais fácil ... é apenas um único comando!

twilio serverless:deploy

Assim que a implantação terminar, você poderá usar as Funções (Functions) que criou para capturar a entrada falada de um chamador, convertê-la em texto, enviá-la para a API do ChatGPT e reproduzir a resposta de volta para o chamador na forma de fala gerada por IA. Três robôs, trabalhando juntos, apenas para você!

Electronic music band Kraftwerk performing live

O Modelo

O exemplo acima usa o modelo gpt-3.5-turbo da OpenAI. Este é um bom (e barato!) modelo para fins de desenvolvimento e provas de conceito, mas você pode achar que outros modelos são melhores para casos de uso específicos. O GPT-4 foi lançado em beta limitado e mesmo aqui na Twilio ainda não tivemos a chance de realmente testá-lo, mas com base na transmissão ao vivo para desenvolvedores publicada com o anúncio, parece ser uma atualização significativa em relação à versão 3.5 que tem impressionado as pessoas nos últimos meses.

Uma consideração adicional é que o GPT-3 é superado pelo 3.5 (e naturalmente pelo 4), mas os modelos do GPT-3 expõem recursos de ajuste fino que os modelos mais avançados não têm no momento da escrita. Por exemplo, mesmo que os dados de treinamento sejam mais antigos, você pode obter respostas mais rápidas usando o Curie e pode empregar coisas como análise de sentimento e estilos de resposta. Escolha sua própria aventura.

Rikki Não Perca Esse Número

Agora que você tem sua Função implantada e pronta para funcionar, pode testá-la fazendo uma ligação, mas primeiro precisará configurar um número de telefone para usar as Funções (Functions) que acabou de criar, e a CLI fornece uma maneira rápida e fácil de fazê-lo. Digite o seguinte no seu terminal para listar os números de telefone da sua conta (estamos assumindo que você seguiu o pré-requisito e adquiriu um número antes).

twilio phone-numbers:list

Você receberá uma lista dos SIDs de números de telefone, números de telefone e nomes amigáveis em sua conta. Você pode usar tanto o SID quanto o número de telefone formatado em E.164 completo para sua solicitação:

twilio phone-numbers:update <PN SID> –voice-url=<The URL for the /transcribe Function>

Ooey-GUI

Obi-wan Kenobi from the movie Star Wars saying that he's never used a command line interface and R2-D2 responding with sad beeps.

Se as interfaces de linha de comando não forem a sua praia, você pode fazer todas as coisas que descrevemos acima diretamente no Console da Twilio. Primeiro, na barra de navegação esquerda na guia Develop, vá para a seção Functions and Assets e clique em Services. Clique em Create Service.

Dê um nome para o seu Serviço, eu vou chamar o meu de voice-chatgpt-demo e clique em Next.

Você verá agora a visualização do Console para o seu Serviço, com Funções (Functions), Ativos (Assets), Variáveis de Ambiente (Environment Variables) e Dependências (Dependencies) no menu à esquerda, e um editor de texto e console para editar seu código e monitorar os logs. A primeira coisa que você vai querer fazer é configurar suas variáveis de ambiente, então clique em Variáveis de Ambiente no canto inferior direito.

As variáveis de ambiente da sua conta Twilio SID e token de autenticação estão pré-preenchidas, então tudo o que você precisa fazer é adicionar sua chave da API OpenAI; o código de exemplo se referirá a ela como OPENAI_API_KEY, então se você estiver procurando por uma experiência de copiar/colar sem editar, certifique-se de nomeá-la da mesma maneira. Clique em "Add" quando terminar.

Depois, você precisará atualizar as dependências para incluir o módulo npm OpenAI, para que você possa fazer solicitações à API OpenAI. Clique em Dependencies e digite openai no campo Module e latest no campo Version. Não se esqueça de clicar em Add.

Depois de inserir os inputs, clique em add

Agora você pode começar a criar as funções. Você vai criar duas: /transcribe que fará todo o trabalho pesado do reconhecimento de fala e /respond que passará o texto transcrito para a API do ChatGPT e lerá a resposta para o chamador usando uma voz de síntese neural de texto Amazon Polly.

Clique no botão Add e selecione Add Function no menu suspenso para criar uma nova função e nomeie-a como /transcribe.

Substitua o conteúdo da nova função com o trecho de código aqui e clique em Salvar. Sua nova função deve ficar assim quando concluída:

Em seguida, crie outra função e chame-a de /respond. Substitua o conteúdo desta nova função com o trecho de código aqui e clique em Salvar novamente. Se você quiser um tour guiado sobre o que está acontecendo nestes exemplos, confira a seção CLI deste post, onde percorremos o código com mais detalhes.

Em seguida, clique no botão Deploy e suas funções salvas serão implantadas e agora podem ser usadas em sua configuração de número de telefone de entrada. Clique nos três pontos verticais ao lado de /transcribe para Copiar URL. Vamos precisar disso em um segundo.

Na guia Develop, navegue até a seção Phone Numbers, depois Manage e escolha Active Numbers. Depois de encontrar um número que deseja usar, role para baixo até a seção Voice & Fax e, em A call comes in, selecione Function. Para Service, selecione o serviço de função que acabou de criar e nomeou como voice-chatgpt-demo. Em seguida, escolha ui para o ambiente e, por último, escolha /transcribe para o caminho da função, já que é aqui que sua chamada telefônica deve ser encaminhada primeiro.

Agora, faça uma ligação para o número de telefone recém-configurado para testar tudo!

Não desmontar

Uma coisa particularmente ótima sobre essa integração é que tanto as entradas quanto as respostas estão disponíveis para você como desenvolvedor; o texto de reconhecimento de fala da pessoa na forma do parâmetro SpeechResult que é passado para a Função /respond, e as respostas derivadas do ChatGPT na forma do TwiML <Say> que é executado nas chamadas. Isso significa que essas conversas não são caixas fechadas de inteligência empresarial e, mesmo que essas Funções (Functions) estejam sendo executadas no ambiente Serverless da Twilio, você ainda pode colocar as mãos no conteúdo da conversa usando a API de Eventos de Chamadas. Aqui está como obter os detalhes usando o CLI da Twilio:

twilio api:core:calls:events:list --call-sid <o SID da chamada que você está interessado> -o json

Usando essa API, você pode recuperar as solicitações, respostas e parâmetros associados e enviá-los diretamente para seus sistemas internos para fazer coisas como fornecer aos agentes uma prévia sobre o que o chamador estava perguntando antes de ser conectado, ou usar os dados para decorar seus perfis de cliente em uma plataforma de dados do cliente como o Segment.

Robôs são incríveis

Publicações como McKinsey e Forbes já estão opinando sobre como tecnologias de inteligência artificial generativa como o ChatGPT podem ser usadas para resolver problemas de negócios, então agora que você tem três robôs trabalhando para você, o que você pode realmente fazer com uma integração como essa? Que tal um agente de suporte técnico de primeira linha? Faça o ChatGPT pesquisar no Google para que seu caro departamento de TI não precise fazer isso, e no caso em que seu chamador e o ChatGPT não conseguirem resolver, conecte a chamada aos seus agentes. Tempos de espera longos para seus especialistas em saúde? Em vez de tocar jazz suave para os chamadores, ofereça a eles a sabedoria do ChatGPT para doenças comuns não críticas enquanto esperam.

Concluindo

Agora você tem um chatbot de voz interativo próprio com a ajuda do reconhecimento de fala da Twilio, Funções (Functions) da Twilio, vozes neurais da Amazon Polly e a API da OpenAI. Definitivamente, fique de olho neste espaço e esteja atento aos avanços nas capacidades de inteligência artificial conversacional e chatbot que você pode aproveitar usando a Twilio.

Michael Carpenter (também conhecido como MC) é um veterano de API de telecomunicações que vem fazendo telefones tocarem com software desde 2001. Como Gerente de Produto para Voice Programável na Twilio, o Diagrama de Venn de seus interesses é a intersecção de APIs, SIP, WebRTC e SDKs móveis. Ele também sabe muito sobre Depeche Mode. Entre em contato com ele em mc (at) twilio.com ou LinkedIn.

Uma enorme dívida de gratidão a postagem positivamente perspicaz de Dhruv Patel sobre Como Chamar um Amigo de IA Usando GPT-3 com Twilio Voice e Funções. Dhruv também forneceu uma revisão técnica do código neste post. Dhruv Patel é um Desenvolvedor da equipe Developer Voices da Twilio e você pode encontrá-lo trabalhando em uma cafeteria com um copo de cold brew, ou ele pode ser contatado no LinkedIn.