Como incluir informações vinda do DialogFlow em um chatbot?

Olá João.
Tudo bem?
Para buscar informações no Dialogflow e gravar em um banco, você precisa integrar o Dialogflow com sua aplicação backend. No fluxo básico, quando o usuário envia uma mensagem para o bot, o Dialogflow processa a requisição e retorna uma resposta com base na intenção ou entidade correspondentes. Em seguida, no código da sua aplicação (como um servidor Node.js, Python, etc.), você captura a resposta do Dialogflow e, dependendo das informações necessárias, realiza uma conexão com o banco de dados (como MySQL, PostgreSQL, MongoDB, etc.).
Você pode usar bibliotecas específicas de acesso ao banco, como Sequelize ou Mongoose, para inserir ou atualizar os dados no banco após a resposta do Dialogflow.
Para isso, é importante configurar um webhook no Dialogflow, que vai direcionar a comunicação entre o Dialogflow e seu backend.
No backend, você valida os dados e faz a inserção no banco conforme necessário.
Qualquer duvida comente ai .
Bons estudos.

Você teria um passo a passo ou um curso referente acima:

Olá amigo.
Vamos dividir esse processo em etapas para te ajudar a implementar um sistema básico de integração entre o Dialogflow, backend e um banco de dados.
Vou te guiar por cada uma das partes: configuração do Dialogflow, criação do backend e integração com o banco de dados.

1. Configuração do Dialogflow

1.1 Criar um agente no Dialogflow

• Primeiramente, crie um agente no Dialogflow (caso ainda não tenha).
• Vá para o Dialogflow Console e crie um novo agente.
• Depois, defina as intenções e entidades que o bot irá identificar (como "informações de usuário", "consulta de dados", etc.).

1.2 Criar um webhook no Dialogflow

• No Dialogflow, o webhook é o endpoint da sua aplicação backend que vai ser chamado quando o Dialogflow precisar executar uma ação (como acessar um banco de dados).
• Vá para a aba Fulfillment no Dialogflow e habilite o Webhook.
• Defina a URL para o seu endpoint (essa URL vai ser do seu servidor backend, onde você vai processar a lógica e comunicar-se com o banco).

2. Configuração do Backend

Agora que o Dialogflow está configurado, precisamos criar o servidor backend para processar as requisições.

2.1 Criando um servidor com Node.js (Express)

Vou te passar um exemplo básico de como criar um servidor usando Node.js e o framework Express para receber as requisições do Dialogflow e interagir com o banco de dados.

1. Inicie um novo projeto Node.js:

   npm init -y
   

2. Instale as dependências necessárias:

   npm install express body-parser axios sequelize mysql2
   

Crie um arquivo chamado index.js e adicione o seguinte código:

const express = require('express');
const bodyParser = require('body-parser');
const axios = require('axios');
const { Sequelize, DataTypes } = require('sequelize');

// Criando a instância do Express
const app = express();
const port = 3000;

// Configurando o BodyParser
app.use(bodyParser.json());

// Configurando a conexão com o banco de dados (MySQL no exemplo)
const sequelize = new Sequelize('mysql://user:password@localhost:3306/db_name');

// Definindo o modelo do banco de dados
const User = sequelize.define('User', {
  name: {
    type: DataTypes.STRING,
    allowNull: false
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false
  },
});

// Testando a conexão com o banco
sequelize.authenticate().then(() => {
  console.log('Conexão com o banco de dados estabelecida com sucesso!');
}).catch((err) => {
  console.error('Erro ao conectar ao banco de dados:', err);
});

// Endpoint para receber dados do Dialogflow
app.post('/webhook', async (req, res) => {
  const { queryResult } = req.body;

  // Aqui, você pode tratar a intenção que foi identificada pelo Dialogflow
  const intent = queryResult.intent.displayName;
  const parameters = queryResult.parameters;

  if (intent === 'Cadastrar Usuário') {
    const { name, email } = parameters;
    
    // Inserir no banco de dados
    try {
      await User.create({ name, email });
      res.json({
        fulfillmentText: `Usuário ${name} cadastrado com sucesso!`
      });
    } catch (error) {
      res.json({
        fulfillmentText: 'Ocorreu um erro ao cadastrar o usuário.'
      });
    }
  } else {
    res.json({
      fulfillmentText: 'Desculpe, não entendi sua solicitação.'
    });
  }
});

// Iniciar o servidor
app.listen(port, () => {
  console.log(`Servidor rodando na porta ${port}`);
});

2.2 Explicando o código

• Conexão com o banco: Estamos usando o Sequelize para se conectar a um banco MySQL. O modelo User foi definido para armazenar name e email.
• Webhook: O servidor recebe as requisições POST do Dialogflow no endpoint /webhook. A partir disso, ele verifica a intenção (intent) e os parâmetros enviados.
• Inserção no banco: Quando a intenção for Cadastrar Usuário, os parâmetros name e email são extraídos e salvos no banco de dados.

2.3 Testando o servidor

• Inicie o servidor com o comando:

  node index.js
  

• Agora, no Dialogflow, defina o Webhook URL para o endereço do seu servidor (ex: http://localhost:3000/webhook).

continua...

3. Testar o Fluxo de Trabalho

Agora, quando o Dialogflow identificar a intenção correta (por exemplo, "Cadastrar Usuário"), ele vai chamar seu webhook.
O servidor backend processa a requisição e insere as informações no banco de dados, enviando uma resposta de volta para o Dialogflow, que por sua vez, envia essa resposta ao usuário.

4. Ajustes e Melhorias

• Validação de Dados: Verifique os dados antes de inserir no banco, para garantir que o email ou nome estejam no formato correto.
• Segurança: Em produção, use validações e segurança nas comunicações, como autenticação, SSL e sanitização de dados.
• Resposta ao usuário: Melhore a resposta que é retornada ao usuário, com mais interatividade ou informações relevantes.

5. Conclusão

Esse é o fluxo básico de integração entre o Dialogflow, seu backend e o banco de dados.
O Dialogflow processa a entrada do usuário, o backend recebe a requisição e faz a manipulação do banco conforme necessário.
Analisa o texto acima faça as implementações e avise qualquer duvida.
Bons estudos.

Bom dia!

Excelente trabalho.

Fiz tudo que foi pedido acima só que na hora da integração com o webhook não esta fazendo.

veja aonde estou erando:

minha url e esta: https://rotaservicos.com.br/contatos/

no webhook eu fiz assim:

mas não grava no banco mysql
Será que você pode me ajudar?

Olá amigo.
Vamos tentar e ver o que acontece.
Pela imagem, o Dialogflow está com o webhook configurado para https://rotaservicos.com.br/contatos/, mas o problema é que essa URL precisa apontar exatamente para o endpoint do seu backend, e esse endpoint deve estar preparado para receber requisições POST no formato que o Dialogflow envia.
Vamos fazer uma checagem passo a passo pra entender onde pode estar o erro
No seu código Node.js, o endpoint precisa ser exatamente o mesmo que o configurado no Dialogflow:

app.post('/contatos', async (req, res) => {
  const { queryResult } = req.body;

  const intent = queryResult.intent.displayName;
  const parameters = queryResult.parameters;

  if (intent === 'Cadastrar Usuário') {
    const { name, email } = parameters;

    try {
      await User.create({ name, email });
      res.json({
        fulfillmentText: `Usuário ${name} cadastrado com sucesso!`
      });
    } catch (error) {
      console.error(error);
      res.json({
        fulfillmentText: 'Ocorreu um erro ao cadastrar o usuário.'
      });
    }
  } else {
    res.json({
      fulfillmentText: 'Desculpe, não entendi sua solicitação.'
    });
  }
});

Isso significa que:

• Se a URL pública é https://rotaservicos.com.br/contatos/,
  então o servidor precisa estar rodando com um endpoint POST em /contatos.

Se no seu código estiver /webhook, o Dialogflow não vai encontrar esse caminho.
Você pode testar se o endpoint realmente responde enviando uma requisição POST via Postman ou curl:

curl -X POST https://rotaservicos.com.br/contatos/ \
     -H "Content-Type: application/json" \
     -d '{"queryResult": {"intent": {"displayName": "Cadastrar Usuário"}, "parameters": {"name": "João", "email": "joao@email.com"}}}'

Se o servidor estiver certo, ele deve retornar:

{
  "fulfillmentText": "Usuário João cadastrado com sucesso!"
}

Se der erro de timeout ou 404:

• O servidor não está rodando;
• A rota não existe (/contatos ≠ /webhook);
• Ou o servidor não está acessível externamente (por exemplo, se está apenas no localhost).

Se o backend estiver rodando localmente (ex: localhost:3000), o Dialogflow não consegue acessá-lo.
Para resolver, use um túnel como:

npx ngrok http 3000

O ngrok vai gerar uma URL do tipo:

https://abcd1234.ngrok.io/webhook

Aí sim, você coloca essa URL no Dialogflow.
O Dialogflow envia os dados dentro de req.body.queryResult.
Garanta que você está usando app.use(bodyParser.json()) no Express, como no exemplo.

• Teste a conexão Sequelize:

sequelize.authenticate()

• E veja se a tabela Users foi criada (sequelize.sync() pode ajudar).
• Se não criou, adicione antes do app.listen():

sequelize.sync({ alter: true });

Teste ai e me avise.
Qualquer problema me envia o index.js para eu analisar.
Bons estudos.

Executei no Pòstman:

Minha Intent e está:

Meu DialogFlow Webhhok:

Aqui faço o e
teste teria que gravar no banco.

No hostgator esta confirado assim: https://rotaservicos.com.br/contatos/

Mas não gravar.

Olá João.
O Dialogflow envia o corpo (body) em um formato JSON específico, e seu backend precisa tratar esse formato corretamente.
O erro mais comum é:
O código espera req.body.queryResult.parameters,
mas o servidor está recebendo o JSON “cru” (ou está fora da estrutura esperada).
Além disso, se o nome da intenção no Dialogflow não bater exatamente com o nome no backend, o código não entra no if (intent === 'Cadastrar Usuário').
Abra o arquivo /public_html/contatos/index.js e use este código revisado:

const express = require('express');
const bodyParser = require('body-parser');
const { Sequelize, DataTypes } = require('sequelize');

// Inicializando o Express
const app = express();
const port = 3000;

// Middleware para interpretar JSON
app.use(bodyParser.json());

// Conexão com o banco MySQL
const sequelize = new Sequelize('rotase97_nodezeus', 'rotase97_older', 'Skca@1954', {
  host: 'localhost',
  dialect: 'mysql'
});

// Modelo do banco
const Contato = sequelize.define('Contato', {
  nome: {
    type: DataTypes.STRING,
    allowNull: false
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false
  },
  telefone: {
    type: DataTypes.STRING,
    allowNull: false
  },
  cpf: {
    type: DataTypes.STRING,
    allowNull: false
  }
});

// Sincroniza o modelo com o banco
sequelize.sync();

// Rota Webhook que o Dialogflow chama
app.post('/contatos', async (req, res) => {
  console.log('Requisição recebida do Dialogflow:');
  console.log(JSON.stringify(req.body, null, 2));

  // Garante que o corpo contém os dados esperados
  if (!req.body.queryResult) {
    return res.json({ fulfillmentText: 'Formato de dados inválido recebido.' });
  }

  const intent = req.body.queryResult.intent.displayName;
  const params = req.body.queryResult.parameters;

  if (intent === 'cadastrar-contato') {
    const { nome, email, telefone, cpf } = params;

    try {
      await Contato.create({ nome, email, telefone, cpf });
      res.json({
        fulfillmentText: `Contato ${nome} cadastrado com sucesso!`
      });
    } catch (error) {
      console.error('Erro ao salvar no banco:', error);
      res.json({
        fulfillmentText: 'Ocorreu um erro ao salvar o contato.'
      });
    }
  } else {
    res.json({
      fulfillmentText: 'Intenção não reconhecida pelo servidor.'
    });
  }
});

// Inicializa o servidor
app.listen(port, () => {
  console.log(`Servidor rodando na porta ${port}`);
});

No seu Dialogflow a intenção está com o nome cadastrar-contato,
então o código precisa verificar exatamente esse nome:

if (intent === 'cadastrar-contato') {

Se estiver diferente (ex: "Cadastrar Usuário"), o backend não executará a inserção.
Use este corpo JSON no Postman:

{
  "queryResult": {
    "intent": {
      "displayName": "cadastrar-contato"
    },
    "parameters": {
      "nome": "João Cruz",
      "email": "cruz.jasc@gmail.com",
      "telefone": "27997119905",
      "cpf": "32783177520"
    }
  }
}

Deve retornar:

{
  "fulfillmentText": "Contato João Cruz cadastrado com sucesso!"
}

E verificar se o dado foi inserido na tabela do MySQL.
No phpMyAdmin, confira se existe a tabela Contatos (ou contatos) e se as colunas nome, email, telefone, cpf estão lá.
Se a tabela ainda não existir, o Sequelize cria automaticamente com o comando sequelize.sync().
Agora volte ao Dialogflow, abra o chatbot e envie:

• “Quero cadastrar um contato”
  E vá preenchendo os parâmetros.
  Ao final, ele deve responder:
• “Contato João Cruz cadastrado com sucesso!”
  E o dado deve aparecer no banco .
  Teste ai mais uma vez com as mudanças sugeridas.
  Avise qualquer duvida e envie um feedback.
  Bons estudos.

Bom dia!

Demorei para dar um retorno devido uma cirurgia que eu tive que fazer nos olhos.
Já me recuperei e estou bem.

Consegui resolver o problema com o webhook, esta funcionando.
Obrigado.

Estou com outro problema, se você puder me ajudar eu agradeço.

Estou tentando enviar o documento via Dialogflow, veja abaixo minha arte.

É possível enviar por aqui ou vou ter que enviar para um site?

Olá amigo.
Fico feliz que está se recuperando bem de sua cirurgia.
Esse nosso post já se tornou uma consultoria.
Vaou tentar lhe auxiliar com sua duvida.
É possível enviar documentos diretamente pelo Dialogflow?
NÃO.
O Dialogflow não envia arquivos diretamente pela interface padrão.
Ele só recebe texto, números, entidades e dispara webhooks.
Para enviar um documento, você precisa passar por uma camada externa, como:

• Seu servidor (via webhook)
  Você pode:

• hospedar o arquivo no seu servidor
• gerar um link
• retornar esse link para o usuário

• Plataforma onde o chatbot está rodando**
  O Dialogflow não envia arquivos, mas:

Como normalmente se faz

Fluxo correto

1. Usuário aciona o intent → nome, telefone etc.

2. Dialogflow chama seu webhook (Fulfillment).

3. Seu servidor responde com:

   • mensagem de texto + link para o arquivo, ou
   • requisição externa para enviar o arquivo (ex: API do WhatsApp / Telegram)

Exemplo de webhook (Node.js) enviando link

agent.add("Aqui está o documento que você pediu:");
agent.add("https://seusite.com/documentos/contrato.pdf");

Exemplo enviando arquivo pelo WhatsApp Cloud API

curl -X POST \
  https://graph.facebook.com/v18.0/YOUR_PHONE_ID/messages \
  -H 'Authorization: Bearer YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "messaging_product": "whatsapp",
    "to": "55XXXXXXXXX",
    "type": "document",
    "document": {
      "link": "https://seusite.com/documentos/contrato.pdf",
      "filename": "Contrato.pdf"
    }
}'

Resumo final

• Você não envia arquivos diretamente no Dialogflow
• Você precisa de um servidor ou API externa
• O arquivo pode ser enviado pela plataforma do chatbot (WhatsApp, Telegram, etc.)
• No caso de site, você só envia link, nunca arquivo diretamente

Faça os testes ai e as alterações necessarias.
Vai precisar fazer algumas adaptações em seu código.
Avisa alguma duvida e envia o feedback com os resultados.
Boa sorte com seu projeto.
Até...

Bom dia!

Obrigado, consegui concluir o projeto. Sua ajuda foi primordial.

Olá João.
Tudo bem ?
Fico feliz que tenha concluído seu projeto.
Peço apenas que encerre este tópico e marque como solucionado.
Muito sucesso para você!
Bons estudos.