Fala pessoal, tudo bem? Douglas Falsarella na área e hoje vamos embarcar em uma jornada incrível para criar um bot de atendimento ao cliente usando algumas das tecnologias mais avançadas em inteligência artificial. Se você, assim como eu, é apaixonado por IA e sempre quis saber como implementar um sistema completo que usa Dialogflow, PyTorch, SpaCy, GPT-3 e ainda integra tudo isso com o WhatsApp via Twilio, você está no lugar certo!

A ideia aqui é transformar a maneira como você interage com seus clientes, proporcionando um atendimento automatizado, dinâmico e eficiente. E o melhor de tudo? Vamos fazer isso passo a passo, de uma maneira bem didática, para que você possa replicar esse processo na sua própria aplicação.

Prepare-se para mergulhar em conceitos avançados, mas não se preocupe – vou te guiar por cada etapa do caminho. Vamos explorar desde a configuração inicial do Dialogflow, passando pelo treinamento de modelos de linguagem com PyTorch, extração de intenções com SpaCy, até a geração de respostas dinâmicas usando GPT-3.

E claro, para fechar com chave de ouro, vamos integrar tudo isso com o WhatsApp via Twilio, garantindo que seu bot esteja acessível onde seus clientes mais precisam. Então, sem mais delongas, vamos arregaçar as mangas e colocar a mão na massa. Pronto para começar essa aventura? Vamos lá!

Bot

Um bot de atendimento ao cliente é um projeto muito útil e com várias aplicações. Vamos passar pelas etapas principais para montar esse projeto.

Etapa 1: Definir o Escopo e Objetivo

Objetivo: Criar um bot de atendimento ao cliente que possa responder a perguntas frequentes e ajudar os usuários com suas dúvidas.

Funcionalidades: o Responder a perguntas frequentes.

• Transferir para um atendente humano, se necessário.
• Coletar feedback dos usuários.
• Suportar múltiplos canais de comunicação (site, WhatsApp, Telegram,
  etc.).

Etapa 2: Coleta e Preparação dos Dados

Fontes de Dados:

• Histórico de conversas com clientes.
• Perguntas frequentes (FAQs).
• Documentação e guias de produto/serviço.

Estruturação dos Dados:

• Organize as perguntas e respostas em um formato estruturado (por
  exemplo, CSV ou JSON).
• Categorize as perguntas por tópicos.

Etapa 3: Usando o DiagFlow e Sapcy

Etapa 4: Desenvolvimento do Bot

1. Processamento de Linguagem Natural (PLN):

• Use uma biblioteca Spacy para processar e entender as perguntas dos
  usuários.

2. Modelo de Resposta:

• Crie um modelo básico que mapeia perguntas frequentes para respostas
  pré-definidas.
• Para um bot mais avançado, use o GPT-3 para gerar respostas mais
  dinâmicas.

3. Treinamento do Modelo:

• Use seus dados históricos para treinar o modelo.
• Avalie a precisão do modelo e faça ajustes conforme necessário.

Etapa 5: Integração e Testes com o Bot

Integração com Canais de Comunicação:

• Conecte o bot ao WhatsApp.
• Testes:
• Realize testes com usuários reais para garantir que o bot responde
  corretamente e melhora continuamente com o feedback.

Etapa 6: Monitoramento e Manutenção

Monitoramento:

• Monitore as interações para identificar áreas de melhoria.
• Use métricas como tempo de resposta, satisfação do cliente, e taxa de
  transferência para humanos.

Manutenção:

• Atualize regularmente a base de dados de perguntas e respostas.
• Ajuste o modelo conforme novas necessidades surgem.

Vamos utilizar o Dialogflow para criar o seu bot de atendimento. Aqui está um guia passo a passo para te ajudar:

Passo 1: Configurar o Dialogflow

1. Criar uma Conta no Google Cloud:

• Se você ainda não tem, crie uma conta no Google Cloud.
• Acesse o Dialogflow e faça login com sua conta Google.

2. Criar um Novo Projeto no Dialogflow:

• No console do Dialogflow, clique em “Create Agent”
• Dê um nome ao seu agente (por exemplo, “AtendimentoBot”).
• Escolha o idioma e a região.
• Clique em “Create”

Passo 2: Definir Intenções (Intents)

1. Adicionar Intenções Básicas:

• No menu à esquerda, vá para “Intents” e clique em “Create Intent“.
• Dê um nome à intenção (por exemplo, “Saudação”).
• Adicione exemplos de frases de usuários que acionariam essa intenção (por exemplo, “Olá”, “Oi”, “Bom dia”).
• Adicione uma resposta que o bot deve dar (por exemplo, “Olá! Como posso ajudar você hoje?”).
• Clique em “Save“.

2. Adicionar Mais Intenções:

• Crie outras intenções para diferentes tipos de perguntas e respostas que
  você espera que o bot lide. Exemplo:
  “FAQ_Pedidos” para perguntas sobre status de pedidos.
  “FAQ_HorárioFuncionamento” para perguntas sobre horários de funcionamento

Passo 3: Treinar e Testar o Bot

1. Treinar o Agente:

• No topo da página, clique em “Train” para treinar o agente com as intenções que você definiu.

2. Testar o Agente:

• Use o painel de teste à direita para interagir com o bot e verificar se ele
  está respondendo corretamente às suas intenções.

Passo 4: Integração com Canais de Comunicação

1. Escolher o Canal de Comunicação:

• No menu à esquerda, vá para “Integrations“.
• Escolha o canal que você deseja integrar (por exemplo, Web, Telegram,
  Facebook Messenger).

2. Configurar a Integração:

• Siga as instruções para configurar a integração. Para Web, você pode
  gerar um código embed e colocá-lo no seu site. Para Telegram, você
  precisará do token de bot do Telegram, etc.

Passo 5: Monitorar e Melhorar o Bot

1. Analisar Conversas do Bot:

• No menu à esquerda, vá para “Analytics” para ver as interações dos usuários e identificar possíveis melhorias.

2. Melhorar Intenções do Bot:

• Baseado no feedback e nas interações, ajuste as intenções e respostas do bot para melhorar a precisão e a satisfação do usuário.

Exemplos de Intenções:

Aqui estão alguns exemplos de intenções para começar:

1. Intenção de Saudação do Bot:

• Exemplos de Usuário: “Olá”, “Oi”, “Bom dia”
• Resposta do Bot: “Olá! Como posso ajudar você hoje?”

2. Intenção de FAQ_Pedidos:

• Exemplos de Usuário: “Qual o status do meu pedido?”, “Meu pedido já foi enviado?”
• Resposta do Bot: “Para verificar o status do seu pedido, por favor, forneça o número do pedido.”

3. Intenção de FAQ_HorárioFuncionamento:

• Exemplos de Usuário: “Qual o horário de funcionamento?”, “Vocês estão abertos aos finais de semana?”
• Resposta do Bot: “Nosso horário de funcionamento é de segunda a sexta, das 9h às 18h.”

Agora, vamos integrar o PyTorch com o Dialogflow para criar um bot de atendimento ao cliente mais robusto e inteligente.

Passo a Passo para Integrar PyTorch com Dialogflow

Passo 1: Configuração do Ambiente

Instalar PyTorch:

Se você ainda não tem o PyTorch instalado, pode fazer isso usando pip:

pip install torch torchvision

Instalar Outras Dependências:

Vamos precisar do transformers para modelos de linguagem pré-treinados, como BERT ou GPT-2.

pip install transformers

Passo 2: Treinamento do Modelo de IA com PyTorch

1. Preparar Dados:

Organize seus dados de perguntas e respostas em um formato estruturado. Por exemplo, um arquivo CSV com duas colunas: Pergunta e Resposta.

2. Treinar um Modelo de Linguagem com PyTorch:

Aqui está um exemplo de como você pode usar o BERT para treinar um modelo de classificação de intenções. Vamos usar o Hugging Face Transformers para simplificar o processo.

import torch
from transformers import BertTokenizer, BertForSequenceClassification
from torch.utils.data import DataLoader, Dataset
import pandas as pd

# Carregar dados
data = pd.read_csv('faq_data.csv')

# Definir Dataset personalizado
class FAQDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_len = max_len

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        text = self.texts[idx]
        label = self.labels[idx]
        encoding = self.tokenizer.encode_plus(
            text,
            add_special_tokens=True,
            max_length=self.max_len,
            return_token_type_ids=False,
            padding='max_length',
            truncation=True,
            return_attention_mask=True,
            return_tensors='pt',
        )
        return {
            'text': text,
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'label': torch.tensor(label, dtype=torch.long)
        }

# Inicializar o Tokenizer e o Modelo
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

# Preparar DataLoader
MAX_LEN = 32
dataset = FAQDataset(
    texts=data['Pergunta'].to_numpy(),
    labels=data['Resposta'].to_numpy(),
    tokenizer=tokenizer,
    max_len=MAX_LEN
)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)

# Treinamento (exemplo simplificado)
optimizer = torch.optim.Adam(model.parameters(), lr=2e-5)
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)

for epoch in range(3):
    model.train()
    for batch in dataloader:
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['label'].to(device)
        
        outputs = model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

print("Treinamento concluído!")

Passo 3: Integração com Dialogflow

1. Implementar Endpoint de Webhook:

Para que o Dialogflow possa usar seu modelo PyTorch, você precisa criar um servidor que atenda às requisições de webhook do Dialogflow.

from flask import Flask, request, jsonify
import torch

app = Flask(__name__)

# Carregar modelo treinado
model.eval()

@app.route('/webhook', methods=['POST'])
def webhook():
    req = request.get_json(silent=True, force=True)
    query_text = req['queryResult']['queryText']
    
    inputs = tokenizer.encode_plus(query_text, return_tensors='pt', max_length=MAX_LEN, truncation=True, padding='max_length')
    input_ids = inputs['input_ids'].to(device)
    attention_mask = inputs['attention_mask'].to(device)
    
    with torch.no_grad():
        outputs = model(input_ids, attention_mask=attention_mask)
        predicted_label = torch.argmax(outputs.logits, dim=1).item()

    response_text = data['Resposta'][predicted_label]
    
    response = {
        'fulfillmentText': response_text
    }
    
    return jsonify(response)

if __name__ == '__main__':
    app.run(port=5000, debug=True)

def extract_intent_and_entities(text):
    doc = nlp(text)
    entities = [(ent.text, ent.label_) for ent in doc.ents]
    return doc.cats, entities

from flask import Flask, request, jsonify
import spacy

app = Flask(__name__)

# Carregar o modelo SpaCy
nlp = spacy.load('en_core_web_sm')

def extract_intent_and_entities(text):
    doc = nlp(text)
    entities = [(ent.text, ent.label_) for ent in doc.ents]
    return entities

@app.route('/webhook', methods=['POST'])
def webhook():
    req = request.get_json(silent=True, force=True)
    query_text = req['queryResult']['queryText']
    
    entities = extract_intent_and_entities(query_text)
    
    # Adicionar lógica para determinar a resposta com base nas entidades extraídas
    response_text = f"Entidades encontradas: {entities}"

    response = {
        'fulfillmentText': response_text
    }
    
    return jsonify(response)

if __name__ == '__main__':
    app.run(port=5000, debug=True)

from flask import Flask, request, jsonify
import spacy

app = Flask(__name__)

# Carregar o modelo SpaCy
nlp = spacy.load('en_core_web_sm')

def extract_intent_and_entities(text):
    doc = nlp(text)
    entities = [(ent.text, ent.label_) for ent in doc.ents]
    return entities

@app.route('/webhook', methods=['POST'])
def webhook():
    req = request.get_json(silent=True, force=True)
    query_text = req['queryResult']['queryText']
    
    entities = extract_intent_and_entities(query_text)
    
    # Adicionar lógica para determinar a resposta com base nas entidades extraídas
    if 'DATE' in [entity[1] for entity in entities]:
        response_text = "Parece que você está perguntando sobre uma data."
    else:
        response_text = f"Entidades encontradas: {entities}"

    response = {
        'fulfillmentText': response_text
    }
    
    return jsonify(response)

if __name__ == '__main__':
    app.run(port=5000, debug=True)

pip install openai

Configurar a API Key da OpenAI:

Você precisará de uma chave de API da OpenAI. Se ainda não tem, registre-se na OpenAI e obtenha a sua chave.

Defina a chave de API em seu ambiente:

openai.api_key = 'sua-api-key-aqui'

Passo 2: Implementação do Webhook com GPT-3

Criar um Endpoint de Webhook com Flask:

Vamos criar um servidor Flask que receberá as requisições do Dialogflow e usará o GPT-3 para gerar respostas.

from flask import Flask, request, jsonify
import openai

app = Flask(__name__)

# Configurar a chave da API OpenAI
openai.api_key = 'sua-api-key-aqui'

def generate_response(prompt):
    response = openai.Completion.create(
        engine="text-davinci-003",  # ou outro modelo GPT-3 de sua escolha
        prompt=prompt,
        max_tokens=150,
        n=1,
        stop=None,
        temperature=0.7
    )
    message = response.choices[0].text.strip()
    return message

@app.route('/webhook', methods=['POST'])
def webhook():
    req = request.get_json(silent=True, force=True)
    query_text = req['queryResult']['queryText']
    
    # Gerar resposta usando GPT-3
    response_text = generate_response(query_text)

    response = {
        'fulfillmentText': response_text
    }
    
    return jsonify(response)

if __name__ == '__main__':
    app.run(port=5000, debug=True)

Configurar o Webhook no Dialogflow:

No console do Dialogflow, vá para a seção de Fulfillment e ative o webhook.

Adicione o URL do seu servidor (por exemplo, https://meuservidor.com/webhook).

Passo 3: Testar e Ajustar

Testar no Dialogflow:

Use o console do Dialogflow para testar as interações com seu bot e verificar se as respostas do GPT-3 estão coerentes e relevantes.

Ajustar o Prompt:

Ajuste o prompt enviado ao GPT-3 para melhorar a qualidade das respostas. Por exemplo, você pode incluir mais contexto ou instruções específicas.

Exemplo Completo de Código Flask com GPT-3

Aqui está o exemplo completo do servidor Flask integrado com GPT-3:

from flask import Flask, request, jsonify
import openai

app = Flask(__name__)

# Configurar a chave da API OpenAI
openai.api_key = 'sua-api-key-aqui'

def generate_response(prompt):
    response = openai.Completion.create(
        engine="text-davinci-003",  # ou outro modelo GPT-3 de sua 
escolha
        prompt=prompt,
        max_tokens=150,
        n=1,
        stop=None,
        temperature=0.7
    )
    message = response.choices[0].text.strip()
    return message

@app.route('/webhook', methods=['POST'])
def webhook():
    req = request.get_json(silent=True, force=True)
    query_text = req['queryResult']['queryText']
    
    # Gerar resposta usando GPT-3
    response_text = generate_response(query_text)

    response = {
        'fulfillmentText': response_text
    }
    
    return jsonify(response)

if __name__ == '__main__':
    app.run(port=5000, debug=True)

Próximos Passos

Melhorar o Prompt:

Você pode ajustar o prompt enviado ao GPT-3 para melhorar a qualidade das respostas. Por exemplo:

def generate_response(query_text):
    prompt = f"Um cliente perguntou: '{query_text}' Responda de maneira clara e detalhada."
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=prompt,
        max_tokens=150,
        n=1,
        stop=None,
        temperature=0.7
    )
    message = response.choices[0].text.strip()
    return message

Deploy:

Faça o deploy do seu servidor de webhook em uma plataforma confiável (Google Cloud, AWS, Heroku, etc.).

Manutenção:

Monitore as interações e continue ajustando o prompt e a lógica para melhorar a precisão e a satisfação do usuário.

pip install twilio

from flask import Flask, request, jsonify
import openai
import os
from twilio.twiml.messaging_response import MessagingResponse

app = Flask(__name__)

# Configurar a chave da API OpenAI
openai.api_key = os.environ.get('OPENAI_API_KEY')

def generate_response(prompt):
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=prompt,
        max_tokens=150,
        n=1,
        stop=None,
        temperature=0.7
    )
    message = response.choices[0].text.strip()
    return message
from flask import Flask, request, jsonify

import openai

import os

from twilio.twiml.messaging_response import MessagingResponse



app = Flask(__name__)



# Configurar a chave da API OpenAI

openai.api_key = os.environ.get('OPENAI_API_KEY')



def generate_response(prompt):

    response = openai.Completion.create(

        engine="text-davinci-003",

        prompt=prompt,

        max_tokens=150,

        n=1,

        stop=None,

        temperature=0.7

    )

    message = response.choices[0].text.strip()

    return message



@app.route('/webhook', me
@app.route('/webhook', methods=['POST'])
def webhook():
    req = request.get_json(silent=True, force=True)
    query_text = req['queryResult']['queryText']
    
    # Gerar resposta usando GPT-3
    response_text = generate_response(query_text)

    response = {
        'fulfillmentText': response_text
    }
    
    return jsonify(response)

@app.route('/whatsapp', methods=['POST'])
def whatsapp():
    incoming_msg = request.values.get('Body', '').strip()
    response_text = generate_response(incoming_msg)
    
    resp = MessagingResponse()
    msg = resp.message()
    msg.body(response_text)
    
    return str(resp)

if __name__ == '__main__':
    app.run(port=5000, debug=True)

export OPENAI_API_KEY='sua-api-key-aqui'

python app.py

Passo 3: Configurar Twilio para Chamar seu Webhook

Configurar o Webhook do Twilio:

No console do Twilio, vá para Messaging > Services e selecione seu serviço de mensagens.

Em Inbound Settings, defina a URL do webhook para apontar para o seu endpoint /whatsapp:

https://seuservidor.com/whatsapp

Testar a Integração:

Envie uma mensagem para o número do WhatsApp sandbox configurado no Twilio e verifique se você recebe uma resposta gerada pelo GPT-3.

Passo 4: Fazer Deploy do Servidor Flask

Escolher uma Plataforma de Deploy:

Escolha uma plataforma para fazer o deploy do seu servidor Flask, como Heroku, AWS, Google Cloud, etc.

Configurar e Fazer Deploy:

Siga as instruções específicas da plataforma escolhida para configurar e fazer o deploy do seu servidor Flask.

Exemplo Completo de Código Flask

from flask import Flask, request, jsonify
import openai
import os
from twilio.twiml.messaging_response import MessagingResponse

app = Flask(__name__)

# Configurar a chave da API OpenAI
openai.api_key = os.environ.get('OPENAI_API_KEY')

def generate_response(prompt):
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=prompt,
        max_tokens=150,
        n=1,
        stop=None,
        temperature=0.7
    )
    message = response.choices[0].text.strip()
    return message

@app.route('/webhook', methods=['POST'])
def webhook():
    req = request.get_json(silent=True, force=True)
    query_text = req['queryResult']['queryText']
    
    # Gerar resposta usando GPT-3
    response_text = generate_response(query_text)

    response = {
        'fulfillmentText': response_text
    }
    
    return jsonify(response)

@app.route('/whatsapp', methods=['POST'])
def whatsapp():
    incoming_msg = request.values.get('Body', '').strip()
    response_text = generate_response(incoming_msg)
    
    resp = MessagingResponse()
    msg = resp.message()
    msg.body(response_text)
    
    return str(resp)

if __name__ == '__main__':
    app.run(port=5000, debug=True)

Grand Finale

Agora você tem um bot de atendimento ao cliente que usa GPT-3 para gerar respostas dinâmicas e está integrado com o WhatsApp via Twilio. Certifique-se de monitorar as interações e ajustar o prompt e a lógica de resposta conforme necessário para melhorar a precisão e a satisfação do usuário. 

Leia também:

Criando um ChatBot em menos de 5 minutos? Sim, é possível!

Como os chatbots entendem cada vez mais os humanos? Graças ao Linguista Computacional