Integre o ChatGPT da OpenAI ao Programmable Voice e Functions da Twilio

Tempo de leitura: 13 minutos

March 23, 2023
Escrito por
Michael Carpenter
Twilion
Revisado por
Dhruv Patel
Twilion

Por que falar com um robô se você pode falar com três?

T-800 do filme Exterminador do Futuro 2: O Julgamento Final explicando que sua CPU é um processador de rede neural, um computador de aprendizado, e que aprende com os humanos tendo contato com eles enquanto John Connor coloca a mão no rosto sem acreditar.

Usar o ChatGPT para acionar um chatbot de voz interativo não é só uma novidade, mas pode ser uma maneira de obter informações úteis sobre business intelligence ao reservar agentes humanos exclusivos, caros e de thread único para conversas com as quais apenas humanos podem ajudar. Hoje em dia, 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 artigo, mostraremos como usar o reconhecimento de fala nativo da Twilio e os recursos de conversão de texto em fala do Amazon Polly Neural com o ChatGPT para criar um chatbot ativado por voz, tudo hospedado inteiramente no ambiente do Functions sem servidor da Twilio. Você também usará a API Call Event para analisar o que os autores da chamada estão perguntando e visualizar as respostas do bot, o que nos permitirá desbloquear os ricos first-party data capturados nessas interações e enviá-los para plataformas de engajamento com o cliente, como a Segment, que você pode usar para criar perfis de clientes, entender suas preferências e criar as experiências personalizadas que eles esperam.

Quer dar uma olhada na demonstração antes de começar? Ligue para 1-989-4OPENAI (467-3624) para fazer um teste!

Robô nº 1: Decodificação da voz humana por meio do reconhecimento de fala

O reconhecimento de fala da Twilio por meio do verbo TwiML <Gather> é uma ferramenta poderosa que transforma palavras faladas em uma chamada telefônica em texto. Ele oferece excelente precisão e baixa latência, além de ser compatível com vários idiomas e dialetos. Historicamente, os desenvolvedores da Twilio usaram o reconhecimento de fala como uma forma de navegar pela unidade de resposta audível (URA) e outros fluxos de trabalho de automação self-service, mas, com o lançamento de novos modelos de fala experimentais, o único limite é a ✨sua imaginação ✨.

Robô nº 2: Como dar ao seu robô uma voz com as vozes neurais do Amazon Polly

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

Robô nº 3: Companheiro de conversação do ChatGPT da OpenAI

O ChatGPT é um modelo de linguagem avançada desenvolvido pela OpenAI que gera texto semelhante ao de um ser humano com base em determinada entrada. Ele consegue entender o contexto, fornecer respostas pertinentes e até mesmo se envolver em tarefas criativas, como escrever histórias ou poemas. Ao aproveitar a API da OpenAI, os desenvolvedores podem integrar essa IA diretamente em seus aplicativos, oferecendo aos usuários uma experiência mais interativa e envolvente.

Molho secreto: Twilio Functions

Como fazer com que esses três robôs conversem entre si e com seus autores da chamada? Usando o Twilio Functions. Além de simplesmente oferecer a capacidade de colocar uma prova de conceito em funcionamento sem precisar criar um servidor, o Functions fornece recursos de escalonamento automático, segurança aprimorada e latência reduzida ao executar seu código dentro da Twilio. Claro, se tiver seu próprio servidor em algum lugar, você poderá fazer algumas pequenas edições no Javascript, e ele será executado em seu ambiente node.js sem problemas.

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

Robôs dançando e Herbie Hancock cantando no videoclipe da música Rockit.

Faça uma pré-solicitação antes da destruição

Antes de mergulhar no processo de integração, você precisará do seguinte:

Função do dia seguinte

Primeiro, vamos colocar nosso backend em ordem. Você começará criando um novo projeto sem servidor. Como você instalou o incrível kit de ferramentas sem servidor open source, é possível fazer isso em uma linha passando o comando para o terminal:

twilio serverless:init <project-name>

Substitua <project-name> por um nome de sua preferência; o meu é three-robot-rhumba.

Janela de terminal mostrando a inicialização de um projeto do Twilio Serverless

Vá em frente e digite cd no diretório do seu projeto para atualizarmos o arquivo .env e fornecer seu token de autenticação Twilio como AUTH_TOKEN e sua chave de API da OpenAI como OPENAI_API_KEY. A SID da sua conta Twilio deve ser preenchida automaticamente. Verifique se o arquivo .env tem a seguinte aparência (com os espaços reservados XXXXX substituídos por suas respectivas chaves):

ACCOUNT_SID=XXXXX
AUTH_TOKEN=XXXXX
OPENAI_API_KEY=XXXXX

Como o Functions do Twilio Serverless são só aplicativos Node.js, você pode adicionar dependências usando qualquer gerenciador de pacotes que grava no package.json; eu uso npm porque gosto do básico. Retorne ao seu terminal e insira o seguinte para instalar o pacote OpenAI NPM:

npm install openai@3.3.0

Com as variáveis de ambiente definidas e as dependências adicionadas, já dá para trabalhar. Você vai criar duas funções: uma de /transcribe, que usa o reconhecimento de fala da Twilio para transformar palavras faladas em texto que o ChatGPT consiga compreender por meio do verbo TwiML <Gather>, e outra de /respond, que envia o texto gerado pelo reconhecimento de fala para a API da OpenAI e envia a resposta para o mecanismo de conversão de texto em fala neural desenvolvido pelo Amazon Polly da Twilio por meio do verbo TwiML <Say>.

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

Perdido na transcrição

Agora vamos abrir o transcribe.js e adicionar 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);
};

Caso ainda não conheça o Functions, vou explicar o que acontece aqui. A função /transcribe cria uma resposta de voz gerada pelo TwiML com base na biblioteca auxiliar Node.js da Twilio, inicia uma conversa se não houver nenhuma, ouve a entrada do usuário e envia essa entrada com o histórico da conversa para o endpoint /respond para processamento posterior.

Na linha 6, o aplicativo verifica se existe um cookie chamado convo. Caso isso não aconteça, ou aconteça, mas esteja vazio, será um indicativo de que a conversa ainda não começou, então poderá usar uma saudação inicial com o verbo TwiML <Say>.

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

  • speechTimeout: 'auto': determina automaticamente quando o usuário parou de falar, pode ser definido como um número inteiro positivo, mas o auto é melhor para este caso de uso
  • speechModel: "experimental_conversations": usa um modelo de reconhecimento de fala otimizado para casos de uso ocasionais
  • input: 'speech': define o tipo de entrada para fala e ignora qualquer pressionamento de teclas (DTMF)
  • action: '/respond': envia a entrada de voz do usuário com o histórico de conversa para o endpoint /respond

Agora, você precisa criar uma maneira de criar o cookie do convo para que a função /respond tenha um local para armazenar o histórico da conversa que será transmitido entre a API da OpenAI e o Polly Neural Voices, e isso significa que o aplicativo precisa inicializar um objeto Twilio.Response(); e faz isso na linha 25.

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

Em seguida, poderá definir o cookie usando response.setCookie(); na linha 35 antes de devolver a resposta ao manipulador para execução por nossa infraestrutura sem servidor na linha 39. Vá em frente, salve o arquivo e feche-o.

Chamada e resposta

Em seguida, vamos abrir respond.js e adicionar o seguinte código:

// Import the OpenAI module
const { OpenAI } = 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 from your environment variables
   const openai = new OpenAI({
    apiKey: context.OPENAI_API_KEY, 
  });


  // 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 object to store the dialog and the user's input to the conversation history
  const conversation = cookieData?.conversation || [];
  conversation.push({role: 'user', content: voiceInput});

  // Get the AI's response based on the conversation history
  const aiResponse = await createChatCompletion(conversation);


  // Add the AI's response to the conversation history
  conversation.push(aiResponse);

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

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

  // 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 {
        // Define system messages to model the AI
        const systemMessages = [{
                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.'
            },
        ];
        messages = systemMessages.concat(messages);

        const chatCompletion = await openai.chat.completions.create({
            messages: messages,
            model: 'gpt-4',
            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.
        });

          return chatCompletion.choices[0].message.content;

      } catch (error) {
          console.error("Error during OpenAI API request:", error);
          throw error;
      }
  }
}

Assim como acima, temos aqui um tour guiado sobre o que exatamente ocorre 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 e 8 definem a API da OpenAI com a chave de API, ao passo que a linha 11 cria o objeto Twilio Voice Response, que gerará um TwiML para transformar as respostas do ChatGPT em fala para os autores da chamada. A linha 14 inicia o objeto Twilio Response para atualizar o cookie do histórico de conversas e definir os cabeçalhos e o corpo para que o TwiML seja enviado na resposta.

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

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

As linhas 39 a 41 limitam o histórico da conversa às últimas 10 mensagens para melhorar o desempenho e manter o cookie em tamanho razoável, ao mesmo tempo em que dão ao chatbot contexto suficiente para fornecer respostas úteis. Caso deseje, é possível aumentar (ou diminuir), mas lembre-se de que o histórico armazenado está sendo enviado para a API da OpenAI a cada solicitação, de modo que, quanto maior for, mais tokens seu aplicativo estará processando. As linhas 44 a 48 geram o TwiML <Say> usando a resposta limpa da IA, e as linhas 51 a 55 redirecionam a chamada para a função /transcribe em que <Gather> está capturando a fala do autor da chamada.

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

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

Também é possível que a solicitação para a OpenAI simplesmente se esgote, de modo que foi adicionada uma captura entre as linhas 109-131 para lidar com os tempos limite de forma elegante e redirecionar para /transcribe para tentar novamente.

Por fim, a função formatConversation (linhas 136 a 158) formata o histórico da conversa em um formato que a API da OpenAI consiga entender, alternando entre os papéis de assistant e user.

Agora que o código está atualizado, as dependências, definidas, e as variáveis de ambiente, configuradas, você está pronto para a implantação. Com o Twilio Serverless, não poderia ser mais fácil, é apenas um comando!

twilio serverless:deploy

Concluída a implantação, você poderá usar as funções criadas para capturar a entrada falada de um autor da chamada, convertê-la em texto, que é enviado à API do ChatGPT, e reproduzir a resposta ao autor da chamada em forma de fala gerada por IA. Três robôs trabalhando juntos só para você!

Apresentação ao vivo da banda de música eletrônica Kraftwerk

O modelo

O exemplo acima usa o modelo gpt-3.5-turbo da OpenAI. É um modelo bom (e barato!) para fins de desenvolvimento e proof of concept (prova de conceito), mas talvez você perceba que outros modelos são melhores para casos de uso específicos. O GPT-4 acaba de ser lançado em versão beta limitada e, mesmo aqui na Twilio, ainda não tivemos a chance de experimentá-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 dois meses.

Uma consideração adicional: o GPT-3 foi substituído pelo 3.5 (e, naturalmente, pelo 4), mas os modelos do GPT-3 apresentam recursos de ajuste fino que os modelos mais avançados não têm no momento em que este artigo foi escrito. Por exemplo, mesmo que os dados de treinamento sejam mais antigos, você pode obter respostas mais rápidas usando o curie e pode implantar coisas como análise de sentimentos e estilos de resposta. Escolha sua própria aventura.

Rikki, não perca esse número

Com a função implantada e pronta para uso, você pode testá-la fazendo uma chamada, mas primeiro deverá configurar um número de telefone para usar as funções que acabou de criar, e a CLI oferece uma maneira rápida e fácil de fazer isso. Para listar os números de telefone em sua conta, digite o seguinte no terminal (presumimos que tenha seguido a pré-solicitação e adquirido um número antecipadamente).

twilio phone-numbers:list

Você receberá de volta uma lista de números de telefone SIDs, números de telefone e nomes conhecidos em sua conta. Para sua solicitação, use o SID ou o número de telefone completo formatado em E.164:

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

Oooey-GUI

Obi-wan Kenobi, do filme Star Wars, dizendo que nunca usou uma interface de linha de comando, e R2-D2 respondendo com bipes tristes.

Se as CLIs não passarem na verificação de validação, você poderá fazer tudo o que descrevemos acima diretamente no Console da Twilio. Primeiro, na navegação à esquerda da guia Desenvolver, vá para a seção Functions e Assets e clique em Serviços. Clique em Criar serviço.

Demonstração do Twilio Voice ChatGPT Criar serviço

Dê um nome ao seu Serviço (o do meu será voice-chatgpt-demo) e clique em Avançar.

Demonstração do Twilio Voice ChatGPT Nomear serviço

Agora você verá a visualização Console do seu Serviço, com Functions, Assets, Variáveis de ambiente e Dependências no navegador à 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 será configurar as variáveis de ambiente, então clique em Variáveis de ambiente no canto inferior direito.

Demonstração do Twilio Voice ChatGPT Configurar serviço

O SID e o token de autenticação da sua conta Twilio são pré-preenchidos como variáveis de ambiente, então basta adicionar sua chave de API da OpenAI; o código de exemplo se referirá a ele como OPENAI_API_KEY, então, caso esteja procurando uma experiência de copiar/colar com edição zero, certifique-se de nomeá-lo da mesma forma. Quando terminar, clique em Adicionar.

Demonstração do Twilio Voice ChatGPT Adicionar variáveis ambientais

Em seguida, atualize nossas dependências para incluir o módulo npm da OpenAI para fazer solicitações à API da OpenAPI. Clique em Dependências e digite openai na caixa de texto Módulo e 3.3.0 na caixa de texto Versão. Não se esqueça de clicar em Adicionar.

Agora você pode começar a criar as Functions. Você criará duas: /transcribe, que fará todo o trabalho pesado de uma perspetiva de reconhecimento de fala, e /respond, que enviará o texto transcrito para a API do ChatGPT e lerá a resposta ao autor da chamada usando uma voz de conversão de texto em fala neural do Amazon Polly.

Clique no botão Adicionar e selecione Adicionar função no menu suspenso para criar uma nova função e nomeá-la para /transcribe.

Demonstração do Twilio Voice ChatGPT Adicionar função

Substitua o conteúdo da nova função pelo trecho de código aqui e pressione Salvar. Sua Function de fábrica deve ter a seguinte aparência quando concluída:

Demonstração do Twilio Voice ChatGPT Transcrever função

Em seguida, crie outra Function e chame-a de /respond. Substitua o conteúdo dessa nova função pelo trecho de código aqui e pressione Salvar novamente. Caso deseje fazer um tour guiado para saber o que está acontecendo exatamente nesses exemplos, consulte a seção CLI deste post, na qual abordaremos o código em mais detalhes.

Em seguida, clique no botão Implantar para implantar suas funções salvas e poder usá-las na configuração do número de telefone recebido. Clique nos três pontos na vertical ao lado de /transcribe para Copiar URL. Precisaremos disso em um segundo.

Demonstração do Twilio Voice ChatGPT Configurar número de telefone

Na guia Desenvolver, navegue até a seção Phone Numbers e, em seguida, Gerenciar e selecione Números ativos. Depois de encontrar um número que deseja usar, role para baixo até a seção Voz e fax e, em Chamada recebida, selecione Function. Para Serviço, selecione o serviço de Function que acabou de criar, denominado voice-chatgpt-demo. Em seguida, selecione ui para Ambiente e, por fim, /transcribe para o Caminho da Function, pois é para onde a chamada telefônica deve ser encaminhada primeiro.

Agora ligue para o seu número de telefone recém-configurado para testar tudo!

Não desmontar

Número 5, personagem do filme Short Circuit: O Incrível Robô, dizendo

Uma coisa particularmente boa 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 é enviado 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 business intelligence e, mesmo que essas funções estejam em execução no ambiente do Twilio Serverless, você ainda pode obter o conteúdo da conversa usando a API Call Events. Saiba como obter os detalhes usando a CLI da Twilio:

twilio api:core:calls:events:list --call-sid <The call SID you are interested in> -o json

Usando essa API, você pode recuperar as solicitações, as respostas e os parâmetros associados e inseri-los diretamente em seus sistemas internos para fazer coisas como fornecer aos agentes um aviso sobre o que o autor da chamada estava perguntando antes de ser conectado ou usar os dados para decorar os perfis de seus clientes em uma plataforma de dados de clientes como a Segment.

Robot Rock

Daft Punk tocando baixo e bateria no videoclipe da música Get Lucky

Revistas como McKinsey e Forbes já estão opinando sobre como tecnologias de IA generativa, como o ChatGPT, podem ser usadas para solucionar problemas de negócios. Então, agora com três robôs trabalhando para você, o que poderia realmente fazer com uma integração assim? Que tal um agente de suporte de desktop de TI na frontline? Faça com que o ChatGPT pesquise no Google para que o seu caro departamento de TI não precise fazer isso e, caso o autor da chamada e o ChatGPT não consigam resolver o problema, conecte a chamada aos seus agentes. Enfrentando longos tempos de espera para contatar seus profissionais de saúde? Em vez de tocar jazz suave para quem está ligando, ofereça a eles a sabedoria do ChatGPT para doenças comuns não críticas enquanto esperam.

Conclusão

Então é isso: com a ajuda do reconhecimento de fala da Twilio, do Twilio Functions, das vozes neurais do Amazon Polly e da API da OpenAI, você criou seu próprio chatbot de voz interativo. Definitivamente, fique de olho neste espaço e atento aos avanços em IA conversacional e recursos de chatbot que você pode aproveitar usando a Twilio.

Michael Carpenter (também conhecido como MC) é um especialista em API de telecomunicações que faz telefones tocarem com software desde 2001. Como gerente de produto para o Programmable Voice na Twilio, o diagrama de Venn de seus interesses é a interseção de APIs, SIP, WebRTC e SDKs móveis. Ele também conhece muito sobre o Depeche Mode. Fale com ele pelo e-mail mc (arroba) twilio.com ou LinkedIn.

Tenho uma enorme gratidão a Dhruv Patel por seu post positivamente preventivo e sobre Como ligar para um amigo de IA usando o GPT-3 com o Twilio Voice e o Functions. Dhruv também forneceu uma revisão técnica do código neste post. Dhruv Patel é desenvolvedor na equipe do Developer Voices da Twilio e você pode encontrá-lo trabalhando em uma cafeteria com um copo de café gelado, ou você pode entrar em contato pelo e-mail dhrpatel [at] twilio.com ou pelo LinkedIn.

Publicações relacionadas

Recursos relacionados

A newspaper article

Twilio Docs

De APIs a SDKs e aplicativos de amostra

Documentação de referência de API, SDKs, bibliotecas auxiliares, guias de início rápido e tutoriais para sua linguagem e plataforma.
An Open book

Centro de Recursos

Os mais recentes e-books, relatórios do setor e webinars

Aprenda com especialistas em engajamento do cliente para melhorar sua própria comunicação.
User group reactions

Ahoy

Centro da comunidade de desenvolvedores da Twilio

Melhores práticas, exemplos de código e inspiração para criar comunicações e experiências de engajamento digital.