Automatizzare la raccolta dati telefonica con AI4Call: una guida all’integrazione multicanale

30 Ottobre 2024

Se il vostro sistema multicanale già gestisce efficacemente la raccolta dati via web e WhatsApp, ma le chiamate telefoniche richiedono ancora l’intervento umano, AI4Call offre una soluzione per automatizzare anche questo canale. Vediamo come integrare AI4Call nel vostro sistema esistente con un esempio pratico e dettagliato.

Obiettivi dell’Integrazione

Identificare automaticamente il chiamante dal numero di telefono
Verificare la presenza di contatori associati al cliente
Guidare l’utente passo-passo nella fornitura dei dati necessari
Integrarsi seamlessly con il vostro sistema API esistente

Implementazione

Ecco un esempio di codice Node.js che illustra come implementare questa integrazione:

    
const express = require('express');
const bodyParser = require('body-parser');
const axios = require('axios');

const app = express();
app.use(bodyParser.json());

// Simula un database clienti e contatori
const customerDB = {
    // ... (aggiungi qui i tuoi clienti di esempio)
};

// Endpoint iniziale chiamato da AI4Call
app.post('/incoming-call', async (req, res) => {
    const { callerNumber } = req.body;

    // Identifica il chiamante e cerca contatori associati
    const customer = await identifyCustomer(callerNumber);
    const meters = await getMetersForCustomer(customer.id);

    if (customer) {
        if (meters.length > 0) {
            // Cliente identificato con contatori
            res.json({
                text: `Benvenuto ${customer.name}. Abbiamo ${meters.length} contatori associati al suo account. Desidera fornire una lettura o richiedere assistenza? Dica 'lettura' o 'assistenza'.`,
                action: "ASR_command",
                key: "initial_choice",
                next_url: "https://your-server.com/handle-initial-choice",
                accepted_commands: ["lettura", "assistenza"]
            });
        } else {
            // Cliente identificato senza contatori
            res.json({
                text: `Benvenuto ${customer.name}. Non abbiamo contatori associati al suo account. Desidera registrare un nuovo contatore o parlare con un operatore? Dica 'registrare' o 'operatore'.`,
                action: "ASR_command",
                key: "new_customer_choice",
                next_url: "https://your-server.com/handle-new-customer",
                accepted_commands: ["registrare", "operatore"]
            });
        }
    } else {
        // Cliente non identificato
        res.json({
            text: "Benvenuto nel nostro sistema automatico. Non abbiamo riconosciuto il suo numero. Per favore, dica il suo codice cliente.",
            action: "ASR_string",
            key: "customer_code",
            next_url: "https://your-server.com/identify-customer"
        });
    }
});

// Gestisce la scelta iniziale del cliente
app.post('/handle-initial-choice', async (req, res) => {
    const { initial_choice, callerNumber } = req.body;
    const customer = await identifyCustomer(callerNumber);
    const meters = await getMetersForCustomer(customer.id);

    if (initial_choice === "lettura") {
        if (meters.length === 1) {
            // Se c'è solo un contatore, chiedi direttamente la lettura
            res.json({
                text: `Per favore, fornisca la lettura attuale del suo contatore ${meters[0].id}.`,
                action: "ASR_number",
                key: "meter_reading",
                next_url: "https://your-server.com/submit-reading"
            });
        } else {
            // Se ci sono più contatori, chiedi quale
            let meterList = meters.map((meter, index) => `${index + 1} per il contatore ${meter.id}`).join(", ");
            res.json({
                text: `Quale contatore vuole leggere? Dica ${meterList}.`,
                action: "ASR_DTMF",
                key: "meter_choice",
                next_url: "https://your-server.com/choose-meter",
                min_length: 1,
                max_length: meters.length.toString().length
            });
        }
    } else if (initial_choice === "assistenza") {
        res.json({
            text: "La connetto con un operatore. Attenda in linea, per favore.",
            action: "redirect",
            extension: "support_line_extension" // Sostituire con l'estensione reale del supporto
        });
    }
});

// Gestisce la scelta del contatore e richiede la lettura
app.post('/choose-meter', async (req, res) => {
    const { meter_choice, callerNumber } = req.body;
    const customer = await identifyCustomer(callerNumber);
    const meters = await getMetersForCustomer(customer.id);
    
    const chosenMeter = meters[parseInt(meter_choice) - 1];
    
    res.json({
        text: `Per favore, fornisca la lettura attuale del contatore ${chosenMeter.id}.`,
        action: "ASR_number",
        key: "meter_reading",
        next_url: "https://your-server.com/submit-reading"
    });
});

// Gestisce la sottomissione della lettura
app.post('/submit-reading', async (req, res) => {
    const { meter_reading, callerNumber } = req.body;
    const customer = await identifyCustomer(callerNumber);
    
    // Qui dovresti implementare la logica per salvare la lettura nel tuo sistema
    await saveReading(customer.id, meter_reading);
    
    res.json({
        text: `Grazie. Abbiamo registrato la lettura di ${meter_reading}. C'è altro in cui posso aiutarla?`,
        action: "ASR_command",
        key: "further_assistance",
        next_url: "https://your-server.com/further-assistance",
        accepted_commands: ["sì", "no"]
    });
});

// Funzioni di supporto (da implementare con la tua logica specifica)
async function identifyCustomer(phoneNumber) {
    // Implementa la logica per identificare il cliente dal numero di telefono
}

async function getMetersForCustomer(customerId) {
    // Implementa la logica per ottenere i contatori associati al cliente
}

async function saveReading(customerId, reading) {
    // Implementa la logica per salvare la lettura nel tuo sistema
}

app.listen(3000, () => console.log('Server running on port 3000'));

Spiegazione del Codice

Questo codice implementa un server Express che gestisce le chiamate inoltrate da AI4Call. Ecco i punti chiave:

Identificazione del Cliente: Usa il numero di telefono per identificare automaticamente il cliente.
Verifica dei Contatori: Controlla se ci sono contatori associati al cliente.
Gestione delle Opzioni: Offre diverse opzioni basate sul profilo del cliente (con o senza contatori).
Raccolta delle Letture: Guida il cliente nel processo di fornire le letture dei contatori.
Flessibilità: Gestisce scenari multipli, inclusi clienti non identificati e richieste di assistenza.

Implementazione Pratica

Per implementare questo sistema nel vostro ambiente:

Sostituite le funzioni di supporto (identifyCustomer, getMetersForCustomer, saveReading) con chiamate alle vostre API o al vostro database.
Assicuratevi che gli URL nelle risposte (next_url) puntino correttamente ai vostri endpoint.
Implementate la gestione degli errori e la validazione degli input per una maggiore robustezza.
Aggiungete logica per gestire scenari più complessi, come la verifica della plausibilità delle letture fornite.
Integrate questo flusso con il vostro sistema di CRM esistente per una visione unificata delle interazioni dei clienti su tutti i canali.

Vantaggi dell’Integrazione

Efficienza Operativa: Riduce il carico di lavoro manuale per le attività di routine.
Coerenza Multicanale: Offre un’esperienza uniforme su tutti i canali di comunicazione.
Disponibilità 24/7: Permette ai clienti di fornire letture in qualsiasi momento.
Scalabilità: Gestisce facilmente picchi di chiamate senza aumentare il personale.
Dati in Tempo Reale: Aggiorna immediatamente il vostro sistema con le nuove letture.

Conclusione

Integrando AI4Call nel vostro sistema multicanale, potete automatizzare efficacemente la raccolta di dati telefonici, allineandola con i vostri processi web e WhatsApp esistenti. Questo approccio non solo migliora l’efficienza operativa, ma anche l’esperienza del cliente, offrendo un servizio coerente e sempre disponibile su tutti i canali.

Ricordate di testare approfonditamente il sistema e di raffinare continuamente il flusso di conversazione per garantire un’esperienza utente ottimale e una raccolta dati accurata.