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

AI의 도움으로 지원 상담원의 역량을 강화하는 대화형 고객 서비스 지원 애플리케이션 구축에 대한 2부 시리즈의 두 번째 이야기로 돌아왔습니다. 목표는 벡터 검색을 사용하여 현재 미해결 질문에 대해 이전에 해결된 답변을 빠르고 직관적으로 활용함으로써 상담원들의 중요한 업무를 향상시키는 것입니다.

tl;dr 구현으로 바로 건너뛰고 싶은 경우, 이 애플리케이션의 전체 작동 예제를 다음에서 찾을 수 있습니다. GitHub 자세한 README 지침과 함께.

1부에서는 를 포함하여 애플리케이션에 필요한 모든 서비스를 설정했습니다:

- 카우치베이스 카펠라
- Vonage 메시지 API
- OpenAI 임베딩 API

실제 활용 중인 AI: 일자리를 대체하는 것이 아니라 향상시키는 것

또한 애플리케이션의 백엔드를 Ruby on Rails로 스캐폴딩했습니다. 이제 이 세 가지 서비스를 연결하고 이를 통합하여 WhatsApp을 통해 사용자 문의에 응답하는 고객 서비스 상담원의 업무를 지원하는 코드를 작성해 보겠습니다.

먼저 애플리케이션의 비즈니스 로직을 정의해 보겠습니다.

애플리케이션 비즈니스 로직 정의

루비 온 레일즈의 아름다운 점 중 하나는 구성에 대한 관습이라는 개념입니다. 즉, 애플리케이션의 비즈니스 로직을 어디에 배치할지 고민할 필요가 없습니다. 이제 우리가 빌드하는 것은 단순화된 버전이 될 것입니다. 이 자습서에는 모든 애플리케이션 코드가 표시되지는 않지만 처음에 언급했듯이 전체 코드베이스는 로컬에서 복제할 수 있습니다. GitHub.

간단히 말해, 모델 및 컨트롤러 파일에 로직을 정의할 것입니다.

애플리케이션에는 세 가지 모델이 있습니다:

- 티켓
- 사용자
- 에이전트

또한 애플리케이션에는 두 개의 컨트롤러가 있습니다:

- 메시지 컨트롤러
- 대시보드 컨트롤러

구성해야 하는 애플리케이션의 다른 부분에는 Vonage, OpenAI 및 Couchbase 이니셜라이저가 포함됩니다. config/초기화자에서 애플리케이션의 경로를 config/routes.rb. 이 모든 것은 GitHub에서 볼 수 있으며 거기에서 자신의 코드베이스에 직접 복사할 수 있습니다.

모델부터 시작하겠습니다.

모델 만들기

고전적으로 Rails는 즉시 SQL 데이터베이스와 함께 작동하는 것이 사실입니다. Rails의 장점과 Couchbase와 같은 JSON 문서 데이터베이스의 장점을 결합하고 싶다면 어떻게 해야 할까요? 이제 간소화된 방식으로 그렇게 할 수 있습니다. Couchbase와 함께 작업하기 위해 Rails의 많은 ActiveRecord 기능을 사용할 수 있게 해주는 Couchbase Ruby ORM 덕분에 가능합니다. 각 모델은 다음에서 상속됩니다. CouchbaseOrm::Base 를 사용하여 ORM의 메소드를 사용할 수 있도록 합니다.

티켓 모델

애플리케이션의 티켓에는 쿼리, 현재 상태, 질문한 사람, 최종 해결 방법 요약 및 해당 해결 방법의 벡터 임베딩에 대한 정보가 포함되어야 합니다. 이러한 각 정보를 속성으로 정의할 수 있습니다:

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 }

OPEN = 'open'

해결됨 = '해결됨'

belongs_to :사용자

belongs_to :에이전트, 선택 사항: true

속성 :쿼리, :문자열

속성 :상태, :문자열, 기본값: OPEN

속성 :요약, :문자열

속성 :임베딩, :배열, 유형: :float, 기본값: []

속성 :created_at, :날짜 시간, 기본값: -> { 시간.지금 }

속성 :updated_at, :날짜 시간, 기본값: -> { 시간.지금 }

위에서 볼 수 있듯이 두 개의 상수도 정의되어 있습니다, OPEN 그리고 해결되었습니다, 티켓이 있을 수 있는 두 가지 상태 상태입니다. 또한 선택 사항으로 티켓과 사용자 및 상담원과의 관계도 만들 수 있습니다.

속성을 정의하는 것 외에도 애플리케이션에서 액세스할 수 있는 몇 가지 메서드를 티켓에 만들고자 합니다. 이와 같이 티켓의 상태를 확인하는 데 사용할 수 있는 헬퍼 메서드를 만들고자 합니다:

  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 self.열기_티켓

어디(상태: OPEN).에_a

끝

def self.해결됨_티켓

어디(상태: 해결됨).에_a

끝

def 열기?

상태 == OPEN

끝

def 해결됨?

상태 == 해결됨

끝

def mark_as_resolved!

업데이트!(상태: 해결됨)

끝

티켓 모델은 추가 유효성 검사를 포함하여 전체적으로 다음과 같은 모양이 됩니다:

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

클래스 티켓 < 카우치베이스오름::기본

OPEN = 'open'

해결됨 = '해결됨'

belongs_to :사용자

belongs_to :에이전트, 선택 사항: true

속성 :쿼리, :문자열

속성 :상태, :문자열, 기본값: OPEN

속성 :요약, :문자열

속성 :임베딩, :배열, 유형: :float, 기본값: []

속성 :created_at, :날짜 시간, 기본값: -> { 시간.지금 }

속성 :updated_at, :날짜 시간, 기본값: -> { 시간.지금 }

보장_디자인_문서!

유효성 검사 :쿼리, 존재감: true

before_save :set_타임스탬프

def self.열기_티켓

어디(상태: OPEN).에_a

끝

def self.해결됨_티켓

어디(상태: 해결됨).에_a

끝

def 열기?

상태 == OPEN

끝

def 해결됨?

상태 == 해결됨

끝

def mark_as_resolved!

업데이트!(상태: 해결됨)

끝

비공개

def set_타임스탬프

self.updated_at = 시간.지금

끝

사용자 모델에 대해서도 비슷한 길을 따라가 보겠습니다.

사용자 모델

애플리케이션의 사용자는 고객이 지원을 요청하는 여러 문제를 처리할 수 있으므로 많은 티켓을 보유할 수 있어야 합니다.

또한 WhatsApp 번호로 사용자를 쉽게 찾을 수 있도록 하려면 모델에 이를 위한 헬퍼 메서드도 만들어야 합니다. 이 헬퍼 메서드에서는 번호로 사용자를 찾거나, 그렇지 않은 경우 새 사용자를 생성하고 번호의 일부를 사용하여 이름 필드를 채웁니다.

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

클래스 사용자 < 카우치베이스오름::기본

has_many :티켓

속성 :whatsapp_number, :문자열

속성 :이름, :문자열

속성 :created_at, :날짜 시간, 기본값: -> { 시간.지금 }

속성 :updated_at, :날짜 시간, 기본값: -> { 시간.지금 }

유효성 검사 :whatsapp_number, 존재감: true

유효성 검사 :이름, 존재감: true

before_save :set_타임스탬프

비공개

def set_타임스탬프

self.updated_at = 시간.지금

끝

def self.찾기_또는_생성_사용자_by_whatsapp_번호(whatsapp_number)

사용자 = 사용자.find_by(whatsapp_number: whatsapp_number)

아니면 사용자

사용자 = 사용자.create!(whatsapp_number: whatsapp_number, 이름: "User #{whatsapp_number[-4..-1]}")

끝

사용자

끝

마지막으로 생성할 모델은 에이전트 모델입니다.

에이전트 모델

상담원 모델은 많은 티켓을 보유하고 있다는 점에서 여러 면에서 사용자 모델과 유사합니다. 한 가지 중요한 차이점은 상담원이 애플리케이션에서 자신의 WhatsApp 번호를 사용하여 커뮤니케이션하지 않는다는 점입니다. 그 대신 애플리케이션 대시보드를 통해 사용자와 소통하며 Vonage 메시지 API가 프로그래밍 방식으로 사용자의 WhatsApp 받은 편지함으로 메시지를 보냅니다.

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

require 'couchbase-orm'

클래스 에이전트 < 카우치베이스오름::기본

has_many :티켓

속성 :이름, :문자열

속성 :이메일, :문자열

속성 :created_at, :날짜 시간, 기본값: -> { 시간.지금 }

속성 :updated_at, :날짜 시간, 기본값: -> { 시간.지금 }

유효성 검사 :이메일, 존재감: true, 고유성: true

유효성 검사 :이름, 존재감: true

before_save :set_타임스탬프

비공개

def set_타임스탬프

self.updated_at = 시간.지금

끝

이 시점에서 우리는 모델을 만들었습니다. 이제 컨트롤러를 정의할 때가 아닙니다.

컨트롤러 만들기

애플리케이션에는 사이트의 각 경로 내에서 일어나는 일을 정의하는 두 개의 컨트롤러가 있습니다. 즉 대시보드_컨트롤러 대시보드의 기능을 감독하는 대시보드와 메시지_컨트롤러 메시징 기능을 감독합니다.

먼저 대시보드부터 시작하겠습니다.

대시보드 컨트롤러

그리고 색인 그리고 show 보기는 모두 대시보드 컨트롤러에 정의되며, 이전에 해결된 티켓의 벡터 유사성을 가져오는 헬퍼 메서드와 함께 상담원이 현재 티켓으로 작업할 수 있도록 지원합니다.

Couchbase Ruby SDK에는 Couchbase의 기능과의 상호 작용을 보다 간소화하기 위한 유용한 추상화가 많이 포함되어 있습니다. 여기에는 다음을 사용하여 새 벡터 검색을 만드는 것이 포함됩니다. 카우치베이스::벡터서치.new 새로운 인스턴스화 내부의 인수를 정의하는 것은 벡터서치 객체와 같은 것입니다:

    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)
      )
    )

요청 = 카우치베이스::검색 요청.new(

카우치베이스::벡터서치.new(

[

카우치베이스::벡터 쿼리.new('임베딩', 임베딩) do |q|

q.num_candidates = 2

q.boost = 0.3

끝

카우치베이스::옵션::벡터서치.new(벡터_쿼리_조합: :그리고)

)

먼저 벡터서치 의 새 인스턴스 안에 래핑됩니다. Couchbase::SearchRequest와 같이 벡터서치 는 검색 요청의 한 유형입니다. 그런 다음 새로운 카우치베이스::벡터 쿼리 인스턴스가 벡터서치 객체에서 검색할 필드를 지정합니다(예 임베딩), 고객 쿼리는 두 번째 인수로 자체 임베딩으로 변환됩니다.

루비 SDK를 사용하여 벡터 검색을 만드는 방법을 염두에 두고 전체 대시보드 컨트롤러 코드를 살펴보겠습니다:

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

클래스 대시보드 컨트롤러 < 애플리케이션 컨트롤러

def 색인

@오픈 티켓 = 티켓.어디(상태: 'open').to_a.정렬_by { |티켓| 티켓.생성_에서 }.역방향

@해결됨_티켓 = 티켓.모두.to_a.선택 { |티켓| 티켓.상태 == 티켓::해결됨 }.to_a.정렬_by { |티켓| 티켓.업데이트_에서 }.역방향

끝

def show

@티켓 = 찾기_티켓

@사용자 = 찾기_사용자

@제안 = 찾기_제안

끝

비공개

def 찾기_티켓

티켓.찾기(매개변수[:id])

끝

def 찾기_사용자

찾기_티켓.사용자

끝

def 찾기_제안

검색_유사_티켓(찾기_티켓.쿼리)

끝

def 검색_유사_티켓(쿼리)

임베딩 = OPENAI_CLIENT.임베딩(

매개변수: {

모델: "text-embedding-ada-002",

입력: 쿼리

}

)['데이터'][0]['임베딩']

클러스터 = 카우치베이스::클러스터.연결(

환경['카우치베이스_연결_스트링'],

환경['couchbase_username'],

환경['couchbase_password']

)

버킷 = 클러스터.버킷(환경['카우치베이스_버킷'])

범위 = 버킷.범위('_default')

요청 = 카우치베이스::검색 요청.new(

카우치베이스::벡터서치.new(

[

카우치베이스::벡터 쿼리.new('임베딩', 임베딩) do |q|

q.num_candidates = 2

q.boost = 0.3

끝

카우치베이스::옵션::벡터서치.new(벡터_쿼리_조합: :그리고)

)

결과 = 범위.검색('whatsapp_support_index', 요청)

결과.행.지도 do |행|

문서 = 버킷.기본_컬렉션.get(행.id)

{

id: 행.id,

점수: 행.점수,

요약: 문서.콘텐츠['요약']

}

끝

이 코드를 사용하여 기본 대시보드 보기와 대시보드의 각 개별 티켓 보기 모두에 대한 기능 로직을 정의했습니다.

프런트엔드 코드는 다음에서 찾을 수 있습니다. GitHub 를 사용하며, 코드베이스에 직접 복사하거나 필요에 따라 편집할 수 있습니다.

메시지 컨트롤러

이제 WhatsApp을 통해 애플리케이션을 통해 수신 및 전송되는 모든 메시지에 대한 로직을 정의해야 합니다. 메시지 컨트롤러는 사용자가 처음으로 메시지를 보낼 때 새 티켓과 사용자가 생성되도록 하는 역할도 담당하게 됩니다.

나중에 애플리케이션을 반복할 때 이 기능 중 일부를 코드베이스의 다른 영역으로 이동하여 분리할 수 있지만, 지금은 단순화를 위해 모든 기능을 메시지 컨트롤러에 유지하겠습니다.

Rails의 가장 큰 장점 중 하나는 JavaScript를 사용하지 않고도 브라우저 창에 새 콘텐츠를 동적으로 삽입할 수 있다는 점입니다. 이는 다음을 통해 수행됩니다. 액션케이블의 핵심 기능입니다. 또한 액션케이블을 사용하여 대시보드의 개별 티켓 보기를 Vonage 메시지 API로 주고받은 최신 메시지로 업데이트할 예정입니다.

에서 언급했듯이 보니지 메시지 API 사용 섹션에서 개발 목적으로 API 샌드박스를 사용하여 빌드하고 있으므로 메시지를 전송하기 위한 API 호출은 HTTP POST 요청으로 수동으로 빌드됩니다. Vonage 문서에 설명된 필수 단계를 완료하여 메타 WhatsApp 비즈니스 계정을 획득한 후에는 Vonage Ruby SDK를 사용하여 이러한 HTTP 요청을 추상화할 수 있습니다.

컨트롤러의 코드는 다음과 같습니다:

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

클래스 메시지 컨트롤러 < 애플리케이션 컨트롤러

skip_before_action :확인_인증_토큰

def 인바운드

whatsapp_number = 매개변수[:에서]

텍스트 = 매개변수[:텍스트]

@답글 = { 발신자: '사용자', body: 텍스트, created_at: 시간.현재 }

@사용자 = 사용자.find_by(whatsapp_number: whatsapp_number)

만약 @사용자

오픈_티켓 = 티켓.find_by(user_id: @사용자.id, 상태: 티켓::OPEN)

만약 오픈_티켓.nil?

티켓.create!(user_id: @사용자.id, 쿼리: "쿼리 대기 중", 상태: 티켓::OPEN)

보내기_메시지(에: whatsapp_number, 텍스트: "메시지를 보내주셔서 감사합니다. 지원 문의 사항을 설명해 주세요.")

elsif 오픈_티켓.쿼리 == "쿼리 대기 중"

오픈_티켓.업데이트!(쿼리: 텍스트)

액션케이블.서버.방송 "messages_#{@user.id}", { 답글: @답글, 티켓: 열기_티켓 }

else

액션케이블.서버.방송 "messages_#{@user.id}", { 답글: @답글, 티켓: 열기_티켓 }

끝

else

@사용자 = 사용자.create!(whatsapp_number: whatsapp_number, 이름: "User #{whatsapp_number[-4..-1]}")

보내기_메시지(에: whatsapp_number, 텍스트: "메시지를 보내주셔서 감사합니다. 지원 문의 사항을 설명해 주세요.")

티켓.create!(user_id: @사용자.id, 쿼리: "쿼리 대기 중", 상태: 티켓::OPEN)

끝

응답 대상 do |형식|

형식.터보_스트림 { 렌더링 터보 스트림: 터보 스트림.추가("messages_#{@user.id}", 부분: "메시지/댓글", 현지인: { 답글: @답글 }) }

끝

def 답글

@ticket_id = 매개변수[:ticket_id]

@메시지 = 매개변수[:메시지]

@해결됨 = 매개변수[:mark_as_resolved] == "1"

@티켓 = 티켓.찾기(@ticket_id)

@사용자 = @티켓.사용자

@답글 = { 발신자: '에이전트', body: @메시지, created_at: 시간.현재 }

액션케이블.서버.방송 "messages_#{@user.id}", { 답글: @답글, 티켓: @티켓 }

만약 @해결됨

임베딩 = OPENAI_CLIENT.임베딩(

매개변수: {

모델: "text-embedding-ada-002",

입력: @메시지

}

)['데이터'][0]['임베딩']

@티켓.업데이트!(요약: @메시지, 상태: 티켓::해결됨, 임베딩: 임베딩)

보내기_메시지(

에: @사용자.whatsapp_number,

텍스트: @메시지

)

응답 대상 do |형식|

형식.html { redirect_to 요청.참조자, 공지사항: "티켓이 해결됨으로 표시되었습니다." }

끝

else

보내기_메시지(

에: @사용자.whatsapp_number,

텍스트: @메시지

)

응답 대상 do |형식|

형식.터보_스트림 { 렌더링 터보 스트림: 터보 스트림.추가("messages_#{@user.id}", 부분: "메시지/댓글", 현지인: { 답글: @답글 }) }

끝

def 상태

head :확인

끝

비공개

def 보내기_메시지(에:, 텍스트:)

require 'net/http'

require 'uri'

require 'json'

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

요청 = Net::HTTP::게시물.new(uri)

요청.기본_인증(환경['vonage_api_key'], 환경['vonage_api_secret'])

요청.content_type = 'application/json'

요청['수락'] = 'application/json'

요청.body = {

에서: 환경['vonage_from_number'],

에: 에,

메시지 유형: 'text',

텍스트: 텍스트,

채널: 'whatsapp'

}.에_json

http = Net::HTTP.new(uri.호스트, uri.포트)

http.use_ssl = true

응답 = http.요청(요청)

풋 "응답 코드: #{response.code}"

풋 "응답 본문: #{response.body}"

끝

메시지 컨트롤러를 만들면서 애플리케이션에 필요한 거의 모든 기능을 정의했습니다.

아직 파악하지 못한 내용은 다음에서 완전히 완성되고 작동하는 예제 애플리케이션을 통해 쉽게 확인할 수 있습니다. GitHub.

이제 남은 일은 애플리케이션을 실행하는 것뿐입니다!

애플리케이션 실행

애플리케이션을 사용하려면 터미널 창을 열고 다음을 실행하세요. bin/dev 를 클릭합니다. 이렇게 하면 애플리케이션의 개발 환경이 시작됩니다. 이제 별도의 터미널 창에서 위에서 설명한 대로 로컬 호스트 환경을 외부에서 액세스할 수 있도록 하기 위해 ngrok을 사용하는 경우 다음을 실행하여 ngrok을 시작합니다. ngrok http 3000.

두 명령을 모두 완료하면 브라우저에서 열 수 있습니다. http://localhost:3000. 티켓이 없는 빈 대시보드가 표시됩니다. 아직 티켓을 만들지 않았기 때문입니다!

Vonage 메시지 API 샌드박스에서 제공된 WhatsApp 번호로 메시지를 보내세요. 애플리케이션에서 지원 문의 사항을 설명하라는 메시지가 표시됩니다. 설명을 마치면 브라우저의 대시보드에 새 티켓이 표시됩니다. 그런 다음 티켓을 열려면 보기 를 클릭하고 상호 작용을 시작하세요.

티켓이 해결됨으로 표시되기 시작하면 향후 티켓에 다음과 같은 메시지가 표시됩니다. 추천 솔루션 섹션으로 이동합니다. 제안된 각 솔루션은 현재 지원 질문과의 유사성에 따라 순위가 매겨집니다.

이러한 방식으로 저희는 팀원들의 업무를 대체하는 것이 아니라 팀원들의 업무 역량을 강화하는 AI 활용 애플리케이션을 만들었습니다.

마무리

카우치베이스, 보니지, OpenAI를 통합하여 상담원이 관련 정보에 빠르게 액세스하여 효율성을 개선하고 우수한 고객 서비스를 제공하는 데 집중할 수 있는 애플리케이션을 구축했습니다. 이 프로젝트는 기술을 활용하여 직장에서 인간의 역할을 지원하고 향상시켜 직원과 고객 모두에게 더 나은 결과를 가져올 수 있는 방법을 보여줍니다. 이제 그 가능성을 확인했으니 이제 이러한 개념을 자신의 프로젝트에 적용하여 혁신을 이어가야 할 때입니다.

- 파트 1 - 실제 활용 중인 AI: 일자리를 대체하는 것이 아니라 향상시키는 것
- 지금 바로 카우치베이스 카펠라를 시작하세요, 무료로 가입하기

벤 그린버그, 수석 개발자 에반젤리스트

이 문서 공유하기

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

2부 - 실제로 구현되는 AI: 일자리를 대체하지 않고 향상시키기

애플리케이션 비즈니스 로직 정의

모델 만들기

티켓 모델

사용자 모델

에이전트 모델

컨트롤러 만들기

대시보드 컨트롤러

메시지 컨트롤러

애플리케이션 실행

마무리

받은 편지함에서 카우치베이스 블로그 업데이트 받기

작성자

게시자 벤 그린버그, 수석 개발자 에반젤리스트

댓글 남기기 응답 취소

카우치베이스 카펠라를 시작할 준비가 되셨나요?

구축 시작

카펠라 무료 사용

연락하기