Part 2 - AI in Action: Enhancing and Not Replacing Jobs

Bem-vindo de volta à segunda parte de nossa série de duas partes sobre a criação de um aplicativo interativo de suporte ao atendimento ao cliente que capacita os agentes de suporte com a ajuda da IA. O objetivo é aprimorar o importante trabalho deles, aproveitando respostas resolvidas anteriormente para perguntas abertas atuais de forma rápida e intuitiva usando a pesquisa vetorial.

tl;dr Caso queira pular direto para a implementação, você pode encontrar um exemplo totalmente funcional desse aplicativo em GitHub juntamente com instruções detalhadas do README.

Na primeira parte, configuramos todos os serviços necessários para nosso aplicativo, incluindo:

- Couchbase Capella
- API de mensagens da Vonage
- API de incorporação da OpenAI

IA em ação: Aprimorando e não substituindo empregos

Também montamos o back-end do nosso aplicativo com o Ruby on Rails. Agora, vamos escrever o código que conectará esses três serviços e os reunirá para dar suporte ao trabalho dos agentes de atendimento ao cliente que respondem às consultas dos usuários via WhatsApp.

Primeiro, vamos definir a lógica comercial do nosso aplicativo.

Definição da lógica comercial do aplicativo

Uma das coisas boas do Ruby on Rails é sua noção de convenção sobre configuração. Isso significa que não precisamos reinventar a roda para saber onde colocar a lógica comercial do nosso aplicativo. O que criaremos agora será uma versão simplificada. Todo o código do aplicativo não será mostrado neste tutorial, mas, conforme mencionado no início, toda a base de código está disponível para clonagem localmente em GitHub.

Em resumo, definiremos nossa lógica nos arquivos de modelo e controlador.

O aplicativo terá três modelos:

- Bilhete
- Usuário
- Agente

O aplicativo também terá dois controladores:

- Controlador de mensagens
- Controlador do painel

Outras partes do aplicativo que precisarão ser configuradas incluem os inicializadores Vonage, OpenAI e Couchbase em config/initializadorese as rotas para o aplicativo em config/routes.rb. Todos eles podem ser visualizados no GitHub e copiados diretamente de lá para sua própria base de código.

Vamos começar com os modelos.

Criar modelos

É verdade que, classicamente, o Rails trabalha com bancos de dados SQL imediatamente. E se você quiser combinar o melhor do Rails com o melhor de um banco de dados de documentos JSON como o Couchbase? Agora é possível fazer isso de forma simplificada graças ao Couchbase Ruby ORM, que disponibiliza muitas das funcionalidades do ActiveRecord no Rails para trabalhar com o Couchbase. Cada um de nossos modelos herdará de CouchbaseOrm::Base para tornar os métodos do ORM disponíveis para ele.

O modelo Ticket

Um tíquete no aplicativo precisa conter informações sobre a consulta, seu status atual, quem a solicitou, o resumo da eventual resolução e a incorporação vetorial dessa resolução. Podemos definir cada uma dessas informações como atributos:

OPEN = 'open'
RESOLVED = 'resolved'

belongs_to :user
belongs_to :agent, optional: true

attribute :query, :string
attribute :status, :string, default: OPEN
attribute :summary, :string
attribute :embedding, :array, type: :float, default: []
attribute :created_at, :datetime, default: -> { Time.now }
attribute :updated_at, :datetime, default: -> { Time.now }

ABERTO = "aberto

RESOLVIDO = "resolvido

pertence_a :usuário

pertence_a :agente, opcional: verdadeiro

atributo :consulta, :string

atributo :status, :string, padrão: ABERTO

atributo :resumo, :string

atributo :incorporação, :matriz, tipo: :flutuante, padrão: []

atributo :created_at, :data e hora, padrão: -> { Tempo.agora }

atributo :updated_at, :data e hora, padrão: -> { Tempo.agora }

Como você pode ver acima, também definimos duas constantes, ABERTO e RESOLVIDO, que são os dois estados de status possíveis em que um ticket pode estar. Também criamos o relacionamento de um ticket com um usuário e com um agente, opcionalmente.

Além de definir os atributos, também queremos criar alguns métodos no tíquete que possam ser acessados em nosso aplicativo. Queremos criar métodos auxiliares que possam ser usados para verificar o status de um tíquete como este:

  def self.open_tickets
    where(status: OPEN).to_a
  end

  def self.resolved_tickets
    where(status: RESOLVED).to_a
  end

  def open?
    status == OPEN
  end

  def resolved?
    status == RESOLVED
  end

  def mark_as_resolved!
    update!(status: RESOLVED)
  end

def autônomo.aberto_ingressos

onde(status: ABERTO).para_a

final

def autônomo.resolvido_ingressos

onde(status: RESOLVIDO).para_a

final

def aberto?

status == ABERTO

final

def resolvido?

status == RESOLVIDO

final

def mark_as_resolved!

atualização!(status: RESOLVIDO)

final

Em conjunto, o modelo de ticket terá a seguinte aparência, incluindo validações adicionais:

class Ticket < CouchbaseOrm::Base
  OPEN = 'open'
  RESOLVED = 'resolved'

  belongs_to :user
  belongs_to :agent, optional: true

  attribute :query, :string
  attribute :status, :string, default: OPEN
  attribute :summary, :string
  attribute :embedding, :array, type: :float, default: []
  attribute :created_at, :datetime, default: -> { Time.now }
  attribute :updated_at, :datetime, default: -> { Time.now }

  ensure_design_document!

  validates :query, presence: true

  before_save :set_timestamps
  def self.open_tickets
    where(status: OPEN).to_a
  end

  def self.resolved_tickets
    where(status: RESOLVED).to_a
  end

  def open?
    status == OPEN
  end

  def resolved?
    status == RESOLVED
  end

  def mark_as_resolved!
    update!(status: RESOLVED)
  end

  private

  def set_timestamps
    self.updated_at = Time.now
  end
end

classe Bilhete < CouchbaseOrm::Base

ABERTO = "aberto

RESOLVIDO = "resolvido

pertence_a :usuário

pertence_a :agente, opcional: verdadeiro

atributo :consulta, :string

atributo :status, :string, padrão: ABERTO

atributo :resumo, :string

atributo :incorporação, :matriz, tipo: :flutuante, padrão: []

atributo :created_at, :data e hora, padrão: -> { Tempo.agora }

atributo :updated_at, :data e hora, padrão: -> { Tempo.agora }

garantir_documento_de_design!

valida :consulta, presença: verdadeiro

antes_de_salvar :definir_registros de data e hora

def autônomo.aberto_ingressos

onde(status: ABERTO).para_a

final

def autônomo.resolvido_ingressos

onde(status: RESOLVIDO).para_a

final

def aberto?

status == ABERTO

final

def resolvido?

status == RESOLVIDO

final

def mark_as_resolved!

atualização!(status: RESOLVIDO)

final

privado

def definir_registros de data e hora

autônomo.updated_at = Tempo.agora

final

Vamos seguir um caminho semelhante para o modelo de usuário.

O modelo do usuário

Um usuário no aplicativo precisa ter muitos tíquetes, pois é possível que um cliente esteja lidando com vários problemas para os quais está buscando suporte.

Também queremos garantir que possamos encontrar facilmente um usuário pelo número do WhatsApp, portanto, criaremos um método auxiliar no modelo para isso também. Nesse método auxiliar, um usuário será encontrado pelo número ou, caso contrário, um novo usuário será criado e uma parte do número será usada para preencher o campo de nome.

class User < CouchbaseOrm::Base
  has_many :tickets

  attribute :whatsapp_number, :string
  attribute :name, :string
  attribute :created_at, :datetime, default: -> { Time.now }
  attribute :updated_at, :datetime, default: -> { Time.now }

  validates :whatsapp_number, presence: true
  validates :name, presence: true

  before_save :set_timestamps

  private

  def set_timestamps
    self.updated_at = Time.now
  end

  def self.find_or_create_user_by_whatsapp_number(whatsapp_number)
    user = User.find_by(whatsapp_number: whatsapp_number)
    unless user
      user = User.create!(whatsapp_number: whatsapp_number, name: "User #{whatsapp_number[-4..-1]}")
    end
    user
  end
end

classe Usuário < CouchbaseOrm::Base

has_many :ingressos

atributo :número do whatsapp, :string

atributo :nome, :string

atributo :created_at, :data e hora, padrão: -> { Tempo.agora }

atributo :updated_at, :data e hora, padrão: -> { Tempo.agora }

valida :número do whatsapp, presença: verdadeiro

valida :nome, presença: verdadeiro

antes_de_salvar :definir_registros de data e hora

privado

def definir_registros de data e hora

autônomo.updated_at = Tempo.agora

final

def autônomo.localizar_ou_criar_usuário_por_número_do_whatsapp(número do whatsapp)

usuário = Usuário.encontrar_por(número do whatsapp: número do whatsapp)

a menos que usuário

usuário = Usuário.criar!(número do whatsapp: número do whatsapp, nome: "User #{whatsapp_number[-4..-1]}")

final

usuário

final

O último modelo que criaremos é o modelo Agent, vamos fazer isso.

O modelo de agente

De muitas maneiras, o modelo de agente é semelhante ao modelo de usuário, pois ambos têm muitos tíquetes. Uma distinção importante é que o agente não usa seu próprio número do WhatsApp para se comunicar no aplicativo. Em vez disso, ele se comunica com os usuários por meio do painel do aplicativo e a API Vonage Messages envia programaticamente suas mensagens para a caixa de entrada do WhatsApp do usuário.

require 'couchbase-orm'

class Agent < CouchbaseOrm::Base
  has_many :tickets

  attribute :name, :string
  attribute :email, :string
  attribute :created_at, :datetime, default: -> { Time.now }
  attribute :updated_at, :datetime, default: -> { Time.now }

  validates :email, presence: true, uniqueness: true
  validates :name, presence: true

  before_save :set_timestamps

  private

  def set_timestamps
    self.updated_at = Time.now
  end
end

exigir 'couchbase-orm'

classe Agente < CouchbaseOrm::Base

has_many :ingressos

atributo :nome, :string

atributo :e-mail, :string

atributo :created_at, :data e hora, padrão: -> { Tempo.agora }

atributo :updated_at, :data e hora, padrão: -> { Tempo.agora }

valida :e-mail, presença: verdadeiro, exclusividade: verdadeiro

valida :nome, presença: verdadeiro

antes_de_salvar :definir_registros de data e hora

privado

def definir_registros de data e hora

autônomo.updated_at = Tempo.agora

final

Neste ponto, já criamos nossos modelos. Não é hora de definir os controladores.

Criar controladores

O aplicativo terá dois controladores que definem o que acontece em cada rota do site. Ou seja, um controlador de painel que supervisiona a funcionalidade do Dashboard, e um controlador_de_mensagens que supervisiona a funcionalidade de mensagens.

Começaremos com o Dashboard primeiro.

O controlador Dashboard

O índice e show serão definidas no controlador do painel, juntamente com métodos auxiliares para buscar a similaridade vetorial de tickets resolvidos anteriormente para os agentes de suporte em seu trabalho com os tickets atuais.

O Couchbase Ruby SDK inclui muitas abstrações úteis para tornar a interação com a funcionalidade do Couchbase mais simplificada. Isso inclui a criação de uma nova pesquisa vetorial usando Couchbase::VectorSearch.new definindo os argumentos dentro da instanciação de um novo VectorSearch objeto como esse:

    request = Couchbase::SearchRequest.new(
      Couchbase::VectorSearch.new(
        [
          Couchbase::VectorQuery.new('embedding', embedding) do |q|
            q.num_candidates = 2
            q.boost = 0.3
          end
        ],
        Couchbase::Options::VectorSearch.new(vector_query_combination: :and)
      )
    )

solicitação = Couchbase::Solicitação de pesquisa.novo(

Couchbase::VectorSearch.novo(

[

Couchbase::VectorQuery.novo("incorporação, incorporação) fazer |q|

q.num_candidatos = 2

q.impulso = 0.3

final

Couchbase::Opções::VectorSearch.novo(vector_query_combination: :e)

)

Primeiro, o VectorSearch é agrupado em uma nova instância de Couchbase::SearchRequest, como o VectorSearch é um tipo de solicitação de pesquisa. Em seguida, uma nova Couchbase::VectorQuery é passada para a instância VectorSearch especificando o campo a ser pesquisado (ou seja, o objeto incorporação) e a consulta do cliente convertida em sua própria incorporação como o segundo argumento.

Tendo isso em mente sobre como criar uma pesquisa vetorial usando o Ruby SDK, vamos dar uma olhada no código completo do controlador do painel:

class DashboardController < ApplicationController
  def index
    @open_tickets = Ticket.where(status: 'open').to_a.sort_by { |ticket| ticket.created_at }.reverse
    @resolved_tickets = Ticket.all.to_a.select { |ticket| ticket.status == Ticket::RESOLVED }.to_a.sort_by { |ticket| ticket.updated_at }.reverse
  end

  def show
    @ticket = find_ticket
    @user = find_user
    @suggestions = find_suggestions
  end

  private
  def find_ticket
    Ticket.find(params[:id])
  end

  def find_user
    find_ticket.user
  end

  def find_suggestions
    search_similar_tickets(find_ticket.query)
  end

  def search_similar_tickets(query)
    embedding = OPENAI_CLIENT.embeddings(
      parameters: {
        model: "text-embedding-ada-002",
        input: query
      }
    )['data'][0]['embedding']

    cluster = Couchbase::Cluster.connect(
      ENV['COUCHBASE_CONNECTION_STRING'],
      ENV['COUCHBASE_USERNAME'],
      ENV['COUCHBASE_PASSWORD']
    )

    bucket = cluster.bucket(ENV['COUCHBASE_BUCKET'])

    scope = bucket.scope('_default')

    request = Couchbase::SearchRequest.new(
      Couchbase::VectorSearch.new(
        [
          Couchbase::VectorQuery.new('embedding', embedding) do |q|
            q.num_candidates = 2
            q.boost = 0.3
          end
        ],
        Couchbase::Options::VectorSearch.new(vector_query_combination: :and)
      )
    )

    result = scope.search('whatsapp_support_index', request)

    result.rows.map do |row|
      document = bucket.default_collection.get(row.id)
      {
        id: row.id,
        score: row.score,
        summary: document.content['summary']
      }
    end
  end
end

classe Controlador do painel < Controlador de aplicativos

def índice

@open_tickets = Bilhete.onde(status: "aberto).para_a.classificar_por { |ingresso| ingresso.criado_em }.reverso

@bilhetes_resolvidos = Bilhete.todos.para_a.selecionar { |ingresso| ingresso.status == Bilhete::RESOLVIDO }.para_a.classificar_por { |ingresso| ingresso.atualizado_em }.reverso

final

def show

@ingresso = encontrar_ingresso

@usuário = encontrar_usuário

@sugestões = encontrar_sugestões

final

privado

def encontrar_ingresso

Bilhete.encontrar(parâmetros[:id])

final

def encontrar_usuário

find_ticket.usuário

final

def encontrar_sugestões

search_similar_tickets(find_ticket.consulta)

final

def search_similar_tickets(consulta)

incorporação = OPENAI_CLIENT.incorporações(

parâmetros: {

modelo: "text-embedding-ada-002",

entrada: consulta

}

)["dados][0]["incorporação]

agrupamento = Couchbase::Aglomerado.conectar(

ENV['COUCHBASE_CONNECTION_STRING'],

ENV['COUCHBASE_USERNAME'],

ENV['COUCHBASE_PASSWORD']

)

balde = agrupamento.balde(ENV['COUCHBASE_BUCKET'])

escopo = balde.escopo('_default')

solicitação = Couchbase::Solicitação de pesquisa.novo(

Couchbase::VectorSearch.novo(

[

Couchbase::VectorQuery.novo("incorporação, incorporação) fazer |q|

q.num_candidatos = 2

q.impulso = 0.3

final

Couchbase::Opções::VectorSearch.novo(vector_query_combination: :e)

)

resultado = escopo.pesquisa('whatsapp_support_index', solicitação)

resultado.linhas.mapa fazer |fila|

documento = balde.default_collection.obter(fila.id)

{

id: fila.id,

pontuação: fila.pontuação,

resumo: documento.conteúdo['resumo']

}

final

Com esse código, definimos a lógica funcional tanto para a visualização do painel principal quanto para a visualização de cada tíquete individual no painel.

O código de front-end pode ser encontrado em GitHub para essas duas visualizações e podem ser copiadas diretamente para sua base de código ou editadas de acordo com suas necessidades específicas.

O controlador de mensagens

Agora precisamos definir a lógica de todas as mensagens que serão recebidas e enviadas pelo aplicativo via WhatsApp. O controlador de mensagens também será responsável por garantir que novos tíquetes e usuários sejam criados quando um usuário enviar uma mensagem pela primeira vez.

É possível que, em uma iteração posterior do aplicativo, algumas dessas funcionalidades possam ser movidas e separadas em diferentes áreas da base de código, mas, para simplificar, manteremos tudo no controlador de mensagens por enquanto.

Um dos grandes aspectos do Rails é a capacidade de injetar dinamicamente novo conteúdo na janela do navegador sem a necessidade de usar JavaScript. Isso é feito com o ActionCableum recurso essencial do Rails. Também usaremos o ActionCable para atualizar a exibição de tíquete individual do painel com as mensagens mais recentes enviadas e recebidas com a API de mensagens da Vonage.

Conforme mencionado no Usando a API de mensagens da Vonage seção, para fins de desenvolvimento, estamos construindo com a sandbox da API, portanto, como resultado, nossa chamada de API para enviar mensagens será construída manualmente como uma solicitação HTTP POST. Depois de concluir as etapas necessárias descritas na documentação da Vonage para obter uma conta comercial do Meta WhatsApp, você poderá usar o Ruby SDK da Vonage para abstrair essas solicitações HTTP para você.

Aqui está o código do controlador:

class MessagesController < ApplicationController
  skip_before_action :verify_authenticity_token

  def inbound
    whatsapp_number = params[:from]
    text = params[:text]
    @reply = { sender: 'User', body: text, created_at: Time.current }
    @user = User.find_by(whatsapp_number: whatsapp_number)

    if @user
      open_ticket = Ticket.find_by(user_id: @user.id, status: Ticket::OPEN)

      if open_ticket.nil?
        Ticket.create!(user_id: @user.id, query: "Awaiting query", status: Ticket::OPEN)
        send_message(to: whatsapp_number, text: "Thank you for your message. Please describe your support query.")
      elsif open_ticket.query == "Awaiting query"
        open_ticket.update!(query: text)
        ActionCable.server.broadcast "messages_#{@user.id}", { reply: @reply, ticket: open_ticket }
      else
        ActionCable.server.broadcast "messages_#{@user.id}", { reply: @reply, ticket: open_ticket }
      end
    else
      @user = User.create!(whatsapp_number: whatsapp_number, name: "User #{whatsapp_number[-4..-1]}")
      send_message(to: whatsapp_number, text: "Thank you for your message. Please describe your support query.")
      Ticket.create!(user_id: @user.id, query: "Awaiting query", status: Ticket::OPEN)
    end

    respond_to do |format|
      format.turbo_stream { render turbo_stream: turbo_stream.append("messages_#{@user.id}", partial: "messages/reply", locals: { reply: @reply }) }
    end
  end

  def reply
    @ticket_id = params[:ticket_id]
    @message = params[:message]
    @resolved = params[:mark_as_resolved] == "1"

    @ticket = Ticket.find(@ticket_id)
    @user = @ticket.user

    @reply = { sender: 'Agent', body: @message, created_at: Time.current }

    ActionCable.server.broadcast "messages_#{@user.id}", { reply: @reply, ticket: @ticket }

    if @resolved
      embedding = OPENAI_CLIENT.embeddings(
        parameters: {
          model: "text-embedding-ada-002",
          input: @message
        }
      )['data'][0]['embedding']

      @ticket.update!(summary: @message, status: Ticket::RESOLVED, embedding: embedding)

      send_message(
        to: @user.whatsapp_number,
        text: @message
      )

      respond_to do |format|
        format.html { redirect_to request.referrer, notice: "Ticket marked as resolved." }
      end
    else
      send_message(
        to: @user.whatsapp_number,
        text: @message
      )

      respond_to do |format|
        format.turbo_stream { render turbo_stream: turbo_stream.append("messages_#{@user.id}", partial: "messages/reply", locals: { reply: @reply }) }
      end
    end
  end

  def status
    head :ok
  end

  private

  def send_message(to:, text:)
    require 'net/http'
    require 'uri'
    require 'json'

    uri = URI.parse("https://messages-sandbox.nexmo.com/v1/messages")

    request = Net::HTTP::Post.new(uri)
    request.basic_auth(ENV['VONAGE_API_KEY'], ENV['VONAGE_API_SECRET'])
    request.content_type = 'application/json'
    request['Accept'] = 'application/json'

    request.body = {
      from: ENV['VONAGE_FROM_NUMBER'],
      to: to,
      message_type: 'text',
      text: text,
      channel: 'whatsapp'
    }.to_json

    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    response = http.request(request)

    puts "Response Code: #{response.code}"
    puts "Response Body: #{response.body}"
  end
end

100

101

102

103

104

105

106

107

108

109

classe MessagesController < Controlador de aplicativos

skip_before_action :verify_authenticity_token

def de entrada

número do whatsapp = parâmetros[:de]

texto = parâmetros[:texto]

@resposta = { remetente: 'Usuário', corpo: texto, created_at: Tempo.atual }

@usuário = Usuário.encontrar_por(número do whatsapp: número do whatsapp)

se @usuário

open_ticket = Bilhete.encontrar_por(user_id: @usuário.id, status: Bilhete::ABERTO)

se open_ticket.nulo?

Bilhete.criar!(user_id: @usuário.id, consulta: "Aguardando consulta", status: Bilhete::ABERTO)

send_message(para: número do whatsapp, texto: "Obrigado por sua mensagem. Por favor, descreva sua consulta de suporte.")

se open_ticket.consulta == "Aguardando consulta"

open_ticket.atualização!(consulta: texto)

ActionCable.servidor.transmissão "messages_#{@user.id}", { resposta: @resposta, ingresso: aberto_ingresso }

mais

ActionCable.servidor.transmissão "messages_#{@user.id}", { resposta: @resposta, ingresso: aberto_ingresso }

final

mais

@usuário = Usuário.criar!(número do whatsapp: número do whatsapp, nome: "User #{whatsapp_number[-4..-1]}")

send_message(para: número do whatsapp, texto: "Obrigado por sua mensagem. Por favor, descreva sua consulta de suporte.")

Bilhete.criar!(user_id: @usuário.id, consulta: "Aguardando consulta", status: Bilhete::ABERTO)

final

responder_a fazer |formato|

formato.turbo_fluxo { renderizar turbo_stream: turbo_stream.anexar("messages_#{@user.id}", parcial: "messages/reply", locais: { resposta: @resposta }) }

final

def resposta

@ticket_id = parâmetros[:ticket_id]

@mensagem = parâmetros[:mensagem]

@resolvido = parâmetros[:mark_as_resolved] == "1"

@ingresso = Bilhete.encontrar(@ticket_id)

@usuário = @ingresso.usuário

@resposta = { remetente: "Agente, corpo: @mensagem, created_at: Tempo.atual }

ActionCable.servidor.transmissão "messages_#{@user.id}", { resposta: @resposta, ingresso: @ingresso }

se @resolvido

incorporação = OPENAI_CLIENT.incorporações(

parâmetros: {

modelo: "text-embedding-ada-002",

entrada: @mensagem

}

)["dados][0]["incorporação]

@ingresso.atualização!(resumo: @mensagem, status: Bilhete::RESOLVIDO, incorporação: incorporação)

send_message(

para: @usuário.número do whatsapp,

texto: @mensagem

)

responder_a fazer |formato|

formato.html { redirect_to solicitação.referenciador, aviso: "Ticket marcado como resolvido". }

final

mais

send_message(

para: @usuário.número do whatsapp,

texto: @mensagem

)

responder_a fazer |formato|

formato.turbo_fluxo { renderizar turbo_stream: turbo_stream.anexar("messages_#{@user.id}", parcial: "messages/reply", locais: { resposta: @resposta }) }

final

def status

cabeça :ok

final

privado

def send_message(para:, texto:)

exigir 'net/http'

exigir 'uri'

exigir 'json'

uri = URI.analisar("https://messages-sandbox.nexmo.com/v1/messages")

solicitação = Líquido::HTTP::Postar.novo(uri)

solicitação.basic_auth(ENV['VONAGE_API_KEY'], ENV['VONAGE_API_SECRET'])

solicitação.tipo de conteúdo = 'application/json'

solicitação['Aceitar'] = 'application/json'

solicitação.corpo = {

de: ENV['VONAGE_FROM_NUMBER'],

para: para,

message_type: 'texto',

texto: texto,

canal: 'whatsapp'

}.para_json

http = Líquido::HTTP.novo(uri.hospedeiro, uri.porto)

http.use_ssl = verdadeiro

resposta = http.solicitação(solicitação)

coloca "Código de resposta: #{response.code}"

coloca "Corpo da resposta: #{response.body}"

final

Com a criação do controlador de mensagens, definimos praticamente toda a funcionalidade de que precisamos em nosso aplicativo.

Qualquer coisa que você ainda esteja tentando descobrir está prontamente disponível no aplicativo de exemplo totalmente completo e funcional em GitHub.

Tudo o que falta fazer agora é executar nosso aplicativo!

Executar o aplicativo

Para usar o aplicativo, abra uma janela de terminal e execute bin/dev dentro da pasta do aplicativo. Isso iniciará um ambiente de desenvolvimento do aplicativo. Agora, em uma janela de terminal separada, inicie o ngrok, se estiver usando o ngrok conforme descrito acima para tornar seu ambiente localhost acessível externamente, executando ngrok http 3000.

Depois de executar os dois comandos, você poderá abrir no navegador http://localhost:3000. Você verá um painel vazio, sem tickets. Isso é porque você ainda não criou um!

Vá em frente e envie uma mensagem para o número do WhatsApp fornecido a você na sandbox da API do Vonage Messages. O aplicativo responderá pedindo que você explique sua pergunta de suporte. Depois disso, o painel em seu navegador será preenchido com o novo tíquete. Você pode então abrir o tíquete clicando em Ver e começar a interagir com ele.

Quando você começar a ter tickets marcados como resolvidos, os tickets futuros serão preenchidos com um Soluções sugeridas como pode ser visto na captura de tela acima. Cada solução sugerida será classificada por sua similaridade com a pergunta de suporte atual.

Dessa forma, criamos um aplicativo utilizando IA que capacita os membros da equipe em seu trabalho e não busca substituí-los em suas funções.

Concluindo

Ao integrar Couchbase, Vonage e OpenAI, criamos um aplicativo que capacita os agentes com acesso rápido a informações relevantes, melhorando sua eficiência e permitindo que eles se concentrem em oferecer um excelente atendimento ao cliente. Esse projeto mostra como a tecnologia pode ser aproveitada para apoiar e elevar as funções humanas no local de trabalho, levando a melhores resultados para funcionários e clientes. Agora que você já viu o potencial, é hora de aplicar esses conceitos em seus próprios projetos e continuar inovando.

- Parte 1 - IA em ação: Aprimorando e não substituindo empregos
- Comece a usar o Couchbase Capella hoje mesmo, Registre-se gratuitamente

Ben Greenberg, desenvolvedor sênior evangelista

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todas as publicações

Parte 2 - IA em ação: Aprimorando e não substituindo empregos

Definição da lógica comercial do aplicativo

Criar modelos

O modelo Ticket

O modelo do usuário

O modelo de agente

Criar controladores

O controlador Dashboard

O controlador de mensagens

Executar o aplicativo

Concluindo

Autor

Postado por Ben Greenberg, desenvolvedor sênior evangelista

Deixar uma resposta Cancelar resposta