Come creare un assistente vocale IA: IA vocale in linea con il brand

Immagina di chiamare un negozio per chiedere un rimborso, essere accolto da un'IA simile a un essere umano e ricevere il denaro sul tuo conto bancario in pochi minuti. Ogni interazione avviene senza problemi, senza bisogno di personale umano per l'assistenza. Un tempo considerati fantascienza, gli assistenti vocali basati sull'IA in grado di gestire casi d'uso complessi sono oggi una realtà. 

Sempre più aziende scelgono gli assistenti vocali IA per le applicazioni rivolte ai clienti. Basati su agenti vocali all'avanguardia e IA generativa, questi assistenti supportano il riconoscimento dell'intento, risposte a bassa latenza e integrazioni funzionali in diversi casi d'uso. 

Con strumenti come ElevenAgents, integrare gli assistenti vocali nei workflow di assistenza clienti è più facile che mai. Per creare un assistente vocale IA, definisci il compito che deve svolgere, quindi collega Speech to Text, un LLM e Text to Speech in un'unica pipeline in tempo reale. Aggiungi la tua knowledge base e gli strumenti aziendali, scrivi istruzioni di sistema e regole di fallback, verifica latenza e sicurezza e misura i risultati dopo il lancio.

Questa guida mostra come creare un assistente vocale IA strettamente in linea con il tuo brand. 

In sintesi

• Un assistente vocale IA collega Speech to Text, un LLM e Text to Speech per creare un'IA conversazionale in grado di agire. 
• Mantieni il tempo di risposta completo sotto i 500 ms con il rilevamento dell'attività vocale (VAD), così l'IA vocale suona naturale e riduce l'abbandono delle chiamate.
• Integra la knowledge base interna e gli strumenti per offrire risposte IA contestuali, accurate e utili nei diversi scenari.
• Applica misure di sicurezza che richiedono una conferma verbale esplicita e trasferisci a un operatore umano quando gestisci richieste emotivamente delicate o complesse.
• Usa ElevenAPI per accedere a modelli vocali e audio interattivi ad alta precisione progettati per interazioni dal vivo. 

Cos'è un assistente vocale IA? 

Un assistente vocale IA è un software che comprende il linguaggio parlato e consente agli utenti di interagire con sistemi connessi. Combina Speech to Text, modelli IA e tecnologie Text to Speech per trasformare le conversazioni in azioni. 

Oltre a trascrivere il parlato, gli assistenti vocali IA possono svolgere attività come avviare un'app, recuperare dati e controllare macchinari. A seconda del modello vocale usato, alcuni assistenti IA possono risultare praticamente indistinguibili da registrazioni umane.

Gli assistenti vocali IA, tuttavia, non sono una tecnologia nuova. Molti consumatori usano Siri, Alexa e Google Assistant, assistenti vocali commerciali che rispondono a comandi semplici. Ma con l'evoluzione delle tecnologie IA, sempre più organizzazioni creano assistenti vocali IA per workflow aziendali più complessi. 

Ad esempio, Admiral, una compagnia assicurativa, ha creato un assistente vocale IA per supportare milioni di clienti. L'assistente IA risponde alle richieste, recupera documenti e libera gli operatori umani dalle attività ripetitive. 

Se stai pianificando di creare un assistente vocale IA per workflow commerciali o industriali, continua a leggere. Ti guideremo nella sua creazione usando un esempio di assistente vocale IA in Python per evidenziare i principali dettagli di implementazione. 

Come creare un assistente vocale IA: definisci il compito del tuo agente vocale IA 

L'IA vocale automatizza comunemente l'assistenza clienti nei call center. Tuttavia, date le ampie capacità di un agente vocale IA, puoi creare un assistente vocale IA per quasi qualsiasi caso d'uso, tra cui vendite, prodotto e risorse umane. 

Indipendentemente dall'applicazione del tuo agente vocale, assicurati che sia in linea con la logica aziendale. Per creare un assistente vocale ad alte prestazioni, consulta gli esperti di dominio sulle sfide più comuni degli utenti finali. Quindi, mappa il percorso di interazione del cliente e definisci indicatori misurabili. 

Ad esempio, se applichi l'IA vocale a un funnel di vendita, l'agente deve poter porre domande di prequalificazione. 

Il nostro sales development representative (SDR) IA, Dom, lo ha fatto, raggiungendo il 92% di accuratezza nella qualificazione. 

Scegli metriche di successo, canali e percorsi di escalation

Quando viene distribuito in un ambiente aziendale, l'agente deve offrire prestazioni costanti rispetto a obiettivi specifici. Più l'obiettivo è circoscritto, più è facile valutare e ottimizzare l'agente.

Perciò, poni domande come queste nelle prime fasi dello sviluppo:

• Qual è la latenza di risposta tollerabile? 
• Qual è il tasso di contenimento previsto? 
• L'agente deve conversare in più lingue? 
• L'assistente IA può gestire richieste di base dall'inizio alla fine senza intervento umano?
• In quali circostanze l'agente dovrebbe passare all'assistenza umana? 

Sviluppare con API raw o usare ElevenAgents?

Prima di scrivere codice, decidi quale parte dello stack vocale vuoi gestire direttamente. Puoi collegare autonomamente Speech to Text, un LLM e Text to Speech tramite ElevenAPI, oppure usare ElevenAgents, una piattaforma gestita che riunisce questi componenti.

Sviluppare con API raw ti offre il pieno controllo di ogni livello. Scegli l'LLM, scrivi il codice di orchestrazione e gestisci turn-taking, interruzioni, telefonia e monitoraggio. Questo approccio è adatto ai team con requisiti architetturali specifici ed è quello seguito dalla guida Python di questo articolo.

ElevenAgents riunisce modelli, strumenti, una knowledge base e workflow in un'unica dashboard. Si collega a provider di telefonia, come Twilio e Amazon Connect, e a strumenti aziendali come Salesforce, Zendesk e HubSpot. Include inoltre simulazioni e test automatizzati prima del lancio, oltre ad analisi su tasso di successo, CSAT e trascrizioni successive.

Usa queste domande per scegliere:

• Velocità: ElevenAgents consente a un team di configurare e lanciare un agente da una dashboard, mentre le API raw richiedono di creare e mantenere l'intera pipeline.
• Controllo: le API raw consentono di personalizzare ogni fase nel codice, mentre ElevenAgents copre le esigenze comuni tramite configurazione.
• Operatività: ElevenAgents include test e analisi, mentre con le API raw devi creare il tuo monitoraggio.
• Team: ElevenAgents è adatto a team misti di prodotto, assistenza e operatività, mentre le API raw sono più indicate per team con ingegneri dedicati.

Un approccio pratico consiste nel convalidare prima il caso d'uso in ElevenAgents, quindi spostare livelli specifici su codice personalizzato solo dove serve maggiore controllo.

Mappa l'architettura dell'assistente vocale IA 

Dopo aver definito l'obiettivo aziendale, associa le funzioni dell'agente alle tecnologie giuste. Un assistente vocale IA si basa su diversi componenti chiave che collaborano per trasformare il parlato in testo, attivare azioni e fornire una risposta coerente. 

• Un modello Speech to Text acquisisce gli enunciati verbali, identifica i fonemi e produce trascrizioni della conversazione. 
• Un motore IA, che può spaziare da un semplice algoritmo basato su regole o una libreria di elaborazione del linguaggio naturale a un large language model (LLM), agisce da cervello dell'assistente vocale. 
• Un modello Text to Speech sintetizza risposte conversazionali con voci simili a quelle umane e rispetta le linee guida del brand. 

ElevenLabs offre modelli vocali e audio Speech to Text e Text to Dialogue che aiutano i team di prodotto e ingegneria a progettare i propri assistenti vocali IA. I nostri modelli supportano intonazione ricca di sfumature, consapevolezza emotiva e risposte a bassa latenza. Puoi accedere ai modelli vocali tramite ElevenAPI. 

Per i modelli IA, la scelta dipende in larga misura dagli obiettivi e dai requisiti dell'assistente vocale. Sebbene gli LLM, come i modelli GPT di OpenAI, Gemini e Claude, eccellano nel ragionamento, richiedono ulteriore fine-tuning per soddisfare esigenze specifiche di dominio. Talvolta è più pratico usare una rete neurale più semplice o un parser basato su regole. 

Oltre ai modelli vocali e IA, ti serve anche un software personalizzato che estragga entità specifiche dalle conversazioni o dalle richieste degli utenti. Ad esempio, quando chi chiama dice: “Voglio parlare con il reparto vendite”, il tuo codice deve identificare “reparto vendite” e attivare l'azione appropriata.

Crea chiavi API e collega Speech to Text, un LLM, strumenti e Text to Speech

Prima di collegarti ai modelli vocali e linguistici. Analogamente, ti servono chiavi API per effettuare richieste API quando integri strumenti di servizi esterni nel tuo assistente vocale. 

• Per creare una chiave API ElevenLabs, clicca qui. 
• Per usare un LLM OpenAI, ottieni qui la tua chiave. 
• Se ti colleghi a CRM, ERP e altri strumenti di terze parti, consulta la documentazione ufficiale per creare una chiave API e trovare le API supportate. 

Dopo aver ottenuto le chiavi API, salvale nel tuo ambiente di sviluppo. 

Quindi, inizializzi e accedi agli strumenti, all'LLM e ai modelli audio passando gli argomenti corretti all'API. 

1. Per prima cosa, collegati a ElevenLabs Scribe v2 Realtime per eseguire il riconoscimento vocale automatico. ElevenLabs Scribe v2 Realtime ti consente di creare agenti vocali a bassa latenza che trasformano le conversazioni in testo in meno di 150 ms, esclusi i tempi di rete e dell'applicazione. 

Di seguito trovi uno snippet di codice Python che acquisisce la registrazione del microfono con ElevenLabs Scribe v2 Realtime.

async def run(
    self,
    audio_queue: asyncio.Queue[bytes],
    on_partial: Callable[[str], None],
    on_committed: TranscriptHandler,
) -> None:
    audio_format = AudioFormat(f"pcm_{self.settings.audio_sample_rate}")
    connection = await self.client.speech_to_text.realtime.connect(
        RealtimeAudioOptions(
            model_id="scribe_v2_realtime",
            audio_format=audio_format,
            sample_rate=self.settings.audio_sample_rate,
            commit_strategy=CommitStrategy.VAD,
            vad_silence_threshold_secs=0.45,
            min_speech_duration_ms=120,
        )
    )

2. Successivamente, invia la trascrizione a un LLM con solide capacità di ragionamento per generare una risposta. In questo esempio usiamo OpenAI GPT-4o mini. 

Ecco come inviare una trascrizione a un LLM nel tuo codice Python. 

async def _stream_completion(self) -> tuple[str, list[dict[str, str]]]:
    response = await self.client.chat.completions.create(
        model=self.settings.openai_model,
        messages=[self.messages[0], *self.messages[-12:]],
        tools=TOOLS,
        tool_choice="auto",
        parallel_tool_calls=False,
        temperature=0.4,
        stream=True,
    )

3. Dopo aver ricevuto l'output dell'LLM, trasformalo in una risposta vocale realistica con ElevenLabs v4 Turbo. Il nostro modello Text to Speech è altamente espressivo, progettato per l'interazione in tempo reale e offre una latenza ultra-bassa di circa 100 ms (si riferisce solo al tempo di inferenza del modello. La latenza end-to-end effettiva varia in base a fattori quali la tua posizione e il tipo di endpoint utilizzato).

Il codice seguente mostra l'agente che usa un WebSocket per trasmettere risposte vocali in streaming con l'API ElevenLabs Text to Dialogue.

async def stream(self, text: str) -> AsyncIterator[bytes]:
    query = urlencode(
        {
            "model_id": self.settings.elevenlabs_tts_model_id,
            "output_format": "pcm_24000",
        }
    )
    url = f"wss://api.elevenlabs.io/v1/text-to-dialogue/stream-input?{query}"
    voice_id = self.settings.elevenlabs_voice_id


    async with websockets.connect(url, max_size=2**20, ping_interval=20) as socket:
        await socket.send(
            json.dumps(
                {
                    "voices": [voice_id],
                    "xi_api_key": self.settings.elevenlabs_api_key,
                }
            )
        )
        await socket.send(
            json.dumps(
                {
                    "inputs": [
                        {"text": text, "voice_id": voice_id, "new_turn": False}
                    ]
                }
            )
        )
        await socket.send(json.dumps({"close_socket": True}))

Il tuo agente di riconoscimento vocale automatico dovrebbe gestire agevolmente conversazioni con più turni. Per farlo, ti serve un agente vocale in grado di sapere quando il parlato inizia e finisce. 

Progetta conversazioni naturali e focalizzate  

I sistemi convenzionali di risposta vocale interattiva (IVR) non operano oltre gli scenari per cui sono programmati. Quando viene chiesto loro di risolvere problemi non definiti nelle loro regole, questi IVR non riescono a fornire risposte soddisfacenti. Inoltre, non sempre suonano naturali, compromettendo l'esperienza del cliente.

Con modelli IA e vocali avanzati, un assistente vocale può rispondere in modo più naturale e gestire i casi limite. Puoi progettare diversi scenari che l'agente deve prevedere e un percorso di escalation per i casi che non riesce a risolvere. Ad esempio, alcuni clienti chiamano per chiedere lo stato della spedizione, mentre altri possono essere frustrati da prodotti difettosi e insistere per parlare con un responsabile CX. 

Scrivi istruzioni di sistema, regole di turn-taking e risposte di fallback

Per gestire scenari diversi, crei codici specifici per la gestione della logica e system prompt nell'applicazione dell'agente vocale IA. 

Ad esempio, il system prompt seguente rileva la frustrazione e indica all'LLM di rispondere con maggiore empatia. 

SYSTEM_PROMPT = ""You are a calm, empathetic voice assistant for customer support.
Speak naturally in short, clear sentences that are easy to hear. Answer from
retrieved company information when relevant; say when the answer is uncertain
rather than inventing a policy. Use tools for customer lookup and support
requests. Before creating a ticket or transferring a caller, request explicit
verbal confirmation through the tool flow and wait for a clear yes. Never ask
for passwords, full payment card numbers, or authentication codes. Do not claim
a ticket was created, a contact was found, or a transfer completed unless the
tool confirms it. Keep responses concise and avoid markdown when speaking.
"""

Le conversazioni IA non dovrebbero mai sembrare affrettate né interrotte. Il modello vocale deve rilevare quando l'utente ha smesso di parlare e rispondere al momento giusto. ElevenLabs Scribe v2 Realtime ti consente di attivare il VAD durante l'ascolto dell'input del microfono. A differenza del VAD convenzionale, che si basa esclusivamente sulla durata del silenzio, ElevenLabs Scribe v2 Realtime usa algoritmi di deep learning per stabilire se il cliente ha terminato di parlare. 

Per attivare il VAD, imposta il parametro nel tuo codice quando interagisci con la API Speech to Text. 

commit_strategy=CommitStrategy.VAD,

Poi, fornisci risposte di fallback cortesi e rispettose se l'agente non riesce a rispondere in modo soddisfacente alla richiesta del cliente. Analogamente, un agente IA potrebbe riscontrare un errore durante la trascrizione delle conversazioni. Il tuo codice dovrebbe gestire le difficoltà tecniche e comunicarle apertamente ai clienti. 

Per fornire risposte di fallback, usa la logica condizionale nel tuo codice. Ad esempio, lo snippet seguente acquisisce lo stato di errore dall'API Speech to Text e attiva le risposte appropriate. 

connection.on(RealtimeEvents.ERROR, handle_error)
connection.on(RealtimeEvents.AUTH_ERROR, handle_error)
connection.on(RealtimeEvents.CLOSE, stopped.set)

Crea il livello di knowledge base e strumenti per risposte affidabili 

Gli LLM offrono solide capacità di ragionamento, che consentono a un assistente vocale IA di rispondere naturalmente. Una risposta conversazionale, tuttavia, non implica sempre accuratezza. Senza dati di grounding, gli LLM possono avere allucinazioni, portando l'agente vocale a fornire risposte plausibili ma inaccurate. 

Ad esempio, quando chiedi a GPT-4o mini informazioni su un prodotto lanciato di recente, non può fornire una risposta con sicurezza. Per farlo, devi collegare l'LLM alla tua knowledge base interna con un sistema di retrieval-augmented generation (RAG). RAG consente all'LLM di fare riferimento alle guide interne sui prodotti e produrre una risposta accurata. 

Aggiungi retrieval, azioni API, autorizzazioni e passaggi a operatori umani

Per usare RAG, devi creare un database vettoriale. Un database vettoriale archivia documenti come rappresentazioni numeriche in uno spazio multidimensionale. Lo snippet di codice seguente mostra come l'agente vocale recupera documenti pertinenti dal vector store prima di interrogare l'LLM. 

def search(self, query: str, top_k: int = 3) -> list[dict[str, str | float]]:
    query_vector = _vectorize(query)
    ranked = sorted(
        (
            (_cosine(query_vector, chunk.vector), chunk)
            for chunk in self.chunks
        ),
        key=lambda item: item[0],
        reverse=True,
    )
    return [
        {"source": chunk.source, "text": chunk.text, "score": score}
        for score, chunk in ranked[: max(0, top_k)]
        if score > 0

Oltre a RAG, il tuo assistente vocale IA avrà probabilmente bisogno di accedere a CRM, ERP e altri sistemi aziendali. Ciò consente all'agente vocale di recuperare informazioni necessarie, come dati dei clienti, transazioni storiche e tendenze di mercato, da usare come contesto nella formulazione delle risposte.

Ad esempio, puoi integrare ElevenLabs con HubSpot usando le API. In questo modo puoi risolvere problemi comuni usando la knowledge base del CRM, creare ticket e passare il caso all'assistenza con il contesto completo della conversazione. 

Ecco uno snippet di codice che consente all'agente vocale di creare un ticket di assistenza in HubSpot.

esponse = await self.client.post(
    "/crm/v3/objects/tickets",
    json={
        "properties": {
            "subject": title,
            "content": description,
            "hs_pipeline": "0",
            "hs_pipeline_stage": "1",
        }
    },
)
response.raise_for_status()
ticket = response.json()
if contact_email:
    contact_response = await self.search_contact(contact_email)
    results = contact_response.get("results", [])
    if results:
        await self.client.put(
            f"/crm/v4/objects/tickets/{ticket['id']}/associations/contacts/{results[0]['id']}",
            json=[{"associationCategory": "HUBSPOT_DEFINED", "associationTypeId": 16}],
        )
return {"mode": "live", "id": ticket.get("id"), "title": title}

Sebbene gli agenti vocali IA possano velocizzare la risoluzione dei problemi, i clienti devono conoscere le proprie opzioni, soprattutto quando le modifiche potrebbero incidere significativamente sui loro account. A differenza dei chatbot basati su testo, elencare verbalmente le opzioni richiede maggiori misure di sicurezza. Una volta effettuata una scelta, può essere difficile annullarla durante una chiamata.

In questo caso, consigliamo di autenticare chi chiama e richiedere una conferma verbale. Ad esempio, se il cliente vuole annullare un acquisto, il tuo agente vocale deve chiedere esplicitamente: “Sei sicuro di voler annullare l'ordine?” e attendere una risposta. 

Di seguito mostriamo un esempio. 

def request(self, name: str, arguments: dict[str, Any]) -> str:
    self.pending = PendingAction(name=name, arguments=arguments)
    if name == "create_support_ticket":
        return "I can create that support ticket. Would you like me to submit it?"
    return "I can transfer you to a human support agent. Should I start the transfer?"

def resolve(self, text: str) -> tuple[ConfirmationState, PendingAction | None]:
    if self.pending is None:
        return ConfirmationState.NONE, None

    answer = re.sub(r"[^a-z']+", " ", text.lower()).strip()
    if answer in {
        "yes", "yes please", "yeah", "yeah please", "yep", "sure",
        "please do", "confirm", "do it",
    }:
        action, self.pending = self.pending, None
        return ConfirmationState.CONFIRMED, action
    if answer in {"no", "nope", "dont", "do not", "cancel", "stop"}:
        self.pending = None
        return ConfirmationState.DECLINED, None
    return ConfirmationState.PENDING, None

Come verificare l'identità di chi chiama con un agente vocale IA

Prima che un agente vocale IA condivida dettagli dell'account o modifichi un account, dovrebbe confermare con chi sta parlando. Il numero di telefono di chi chiama è un segnale utile, ma non prova l'identità. Combinalo con altre verifiche:

• Abbina il numero di chi chiama a un record cliente nel tuo CRM.
• Chiedi dettagli che solo il titolare dell'account conoscerebbe, come la data di un ordine recente.
• Convalida le risposte tramite una tool call rispetto ai tuoi record e non affidarti mai all'LLM per stabilire se sono corrette.
• Limita le azioni disponibili a chi chiama non è verificato, ad esempio consentendo di controllare lo stato dell'ordine ma non di annullarlo.

Tieni password, numeri completi delle carte di pagamento e codici di autenticazione fuori dalla conversazione, come indicato dal system prompt precedente.

Agente vocale IA con trasferimento della chiamata e escalation in tempo reale

Un trasferimento in tempo reale passa il chiamante a un operatore umano senza costringerlo a ripetere le informazioni. In un passaggio assistito, l'agente vocale invia la trascrizione e il contesto all'operatore prima di collegare la chiamata. I trigger più comuni includono:

• Chi chiama chiede di parlare con una persona.
• Chi chiama sembra frustrato o la conversazione diventa emotivamente delicata.
• L'agente non riesce a risolvere la richiesta dopo le sue risposte di fallback.
• La richiesta necessita di un'azione che richiede l'approvazione umana.

In alcuni casi, l'agente IA deve trasferire la chiamata a un agente umano. Spesso, l'agente vocale rileva intenti che indicano frustrazione o parole specifiche che attivano il trasferimento. Nel tuo codice, il trasferimento di chiamata deve avvenire senza interruzioni ed essere trasparente per i clienti. 

Prima del passaggio, trasmetti la trascrizione, i dettagli del cliente e altro contesto di supporto al servizio di assistenza in tempo reale. ElevenLabs offre uno strumento di trasferimento a numero che instrada le chiamate gestite dagli agenti IA a un trunk SIP o a un numero di telefono Twilio.

Lo snippet di codice seguente mostra un passaggio tramite conferenza Twilio. 

account = self.settings.twilio_account_sid
call_sid = self.settings.twilio_call_sid
conference = f"support-{call_sid}"
room = xml.sax.saxutils.escape(conference)
twiml = f"<Response><Dial><Conference>{room}</Conference></Dial></Response>"
api = f"https://api.twilio.com/2010-04-01/Accounts/{account}"
auth = (account, self.settings.twilio_auth_token)
async with httpx.AsyncClient(timeout=15.0, auth=auth) as client:
    agent_call = await client.post(
        f"{api}/Calls.json",
        data={
            "To": self.settings.handoff_number,
            "From": self.settings.twilio_from_number,
            "Twiml": twiml,
        },
    )
    agent_call.raise_for_status()
    caller_call = await client.post(
        f"{api}/Calls/{call_sid}.json",
        data={"Twiml": twiml},
    )
    caller_call.raise_for_status()

Crea un assistente vocale IA senza codice in ElevenAgents

Se non ti serve codice personalizzato, puoi lanciare lo stesso assistente in ElevenAgents. I passaggi rispecchiano l'architettura descritta sopra, ma configuri ogni livello in una dashboard invece di scrivere codice.

1. Crea un agente e descrivine il compito nel system prompt, inclusi tono, ambito e quando eseguire l'escalation.
2. Scegli una voce dalla Voice Library, oppure progettane o clonane una tua, e imposta le lingue che l'agente deve parlare.
3. Aggiungi la tua knowledge base affinché l'agente possa rispondere usando i tuoi documenti.
4. Collega strumenti e integrazioni, come il tuo CRM o help desk, affinché l'agente possa agire.
5. Configura il trasferimento a un operatore umano per le chiamate che l'assistente non riesce a risolvere.
6. Esegui simulazioni e test automatizzati per verificare il comportamento prima del lancio.
7. Distribuisci l'agente su un numero di telefono o un canale, quindi esamina tassi di successo, CSAT e trascrizioni.

Le indicazioni su test e misurazione nelle sezioni seguenti si applicano sia che tu sviluppi con codice sia senza.

Come creare un assistente vocale IA adatto al tuo brand 

Le organizzazioni possono adattare la voce dell'agente IA al proprio brand. Un tono coerente durante tutta la conversazione aiuta a creare fiducia. Con ElevenLabs, hai diversi modi per personalizzare la voce del tuo agente IA. 

• ElevenLabs Voice Library offre oltre 20.000 voci IA parlate naturalmente in più di 90 lingue. Da energica a calma e sicura, puoi esplorarle e usarne una adatta al tono del tuo brand. 
• ElevenLabs Voice Design ti permette di creare un'impronta vocale unica con un prompt testuale. Descrivi ritmo, tono, emozione e altre caratteristiche vocali per ottenere la voce che desideri. 
• Clonazione Vocale IA di ElevenLabs crea una replica digitale della tua voce analizzando un campione delle tue registrazioni vocali. 

Oltre a rendere correttamente emozione e sfumature, è importante verificare la pronuncia della voce IA, soprattutto per i nomi particolari. Se necessario, crea un dizionario di pronuncia a cui il tuo modello vocale possa fare riferimento. 

Testa latenza, interruzioni, accuratezza e sicurezza prima del lancio 

Prima del lancio, testa rigorosamente il tuo agente vocale IA per assicurarti che funzioni in modo affidabile in scenari diversi. 

• Test di latenza: un agente che impiega più di 700 ms a rispondere sembrerà innaturale ai clienti. A seconda della configurazione, la velocità di rete, l'LLM, i modelli vocali e le API di terze parti possono influire sulla latenza. Idealmente, mantieni la latenza conversazionale sotto i 500 ms. 
• Test delle interruzioni: verifica se l'agente gestisce le interruzioni a metà conversazione. Nello specifico, l'agente dovrebbe scartare i frame audio in output, interrompere il TTS e riprendere l'acquisizione dell'input vocale senza perdere il contesto. 
• Test del turn-taking: quando l'utente smette di parlare, l'agente dovrebbe intervenire in modo naturale. Valuta se l'agente interviene al momento giusto e se interrompe l'utente a metà frase. Per una guida dettagliata, leggi come ElevenLabs gestisce il turn-taking. 
• Test di accuratezza: qualsiasi imprecisione nel livello STT si propaga a valle. Assicurati che l'assistente vocale comprenda il parlato anche in ambienti rumorosi. Inoltre, il modello vocale deve trascrivere con accuratezza e coerenza discorsi con accenti diversi. 
• Test di sicurezza: assicurati che i guardrail prevengano comportamenti del sistema che violano le policy del brand. Se un'interazione diventa emotivamente delicata, l'agente deve facilitare un warm handover a un operatore umano secondo linee guida preimpostate.

Misura i risultati e migliora lo sviluppo del tuo assistente vocale 

Superare i criteri di test interni prepara il tuo agente vocale IA alla distribuzione nel mondo reale. Tuttavia, non è l'obiettivo finale del ciclo di sviluppo. Anche l'iterazione dopo la distribuzione è essenziale per garantire che il tuo agente vocale IA continui a risolvere le richieste dei clienti.

Usa il feedback delle metriche di IA conversazionale per identificare le lacune nel tuo assistente IA. Quindi, perfeziona gradualmente la logica dell'applicazione, le integrazioni API, le scelte dei modelli e altri componenti dello stack tecnologico per migliorare le prestazioni dell'IA conversazionale.

Monitora contenimento, risoluzione, soddisfazione dei clienti e modalità di errore

Misura continuamente il tuo assistente IA rispetto ai benchmark del settore. Alcune metriche da monitorare includono: 

• Contenimento: misura quante conversazioni vengono risolte con successo dall'agente IA. 
• Tasso di escalation: misura le chiamate che richiedono infine l'intervento umano. 
• Tasso di errore delle parole: un benchmark di accuratezza che indica quanto precisamente l'IA trascrive l'audio. 
• Tasso di allucinazioni: evidenzia i casi in cui gli LLM generano risposte inaccurate ma plausibili. 
• CSAT: feedback dei clienti che indica quanto sono soddisfatti dell'agente vocale IA. 

Scopri di più sulle metriche dell'IA conversazionale.

Inizia con ElevenAPI per gli assistenti vocali IA 

ElevenAPI semplifica lo sviluppo di assistenti vocali IA. Con modelli leader di Text to Speech e Speech to Text, puoi creare agenti IA conversazionali contestuali che si integrano perfettamente nel tuo workflow aziendale. I nostri modelli vocali e audio offrono costantemente alta accuratezza e bassa latenza, garantendo un'esperienza cliente naturale. 

Ottieni qui la tua chiave API ElevenAPI ed esplora la nostra documentazione ufficiale per iniziare a sviluppare. 

FAQ: creare un assistente vocale IA