Créez un assistant vocal IA avec Cartesia et Bright Data

Dans cet article de blog, vous découvrirez :

Ce qu’est Cartesia et ce qu’il offre pour le développement d’agents vocaux IA.
Pourquoi les agents vocaux (comme tout autre agent) ont besoin d’un accès au Web pour être efficaces et véritablement fiables.
Comment doter un agent vocal IA Cartesia de la capacité de rechercher et d’extraire des informations sur le Web grâce à l’intégration de Bright Data.

C’est parti !

Qu’est-ce que Cartesia ?

Cartesia est une plateforme axée sur les développeurs, destinée à la création d’agents vocaux IA en temps réel. Elle combine des modèles vocaux à faible latence avec une pile complète de développement d’agents, fournissant tout ce dont vous avez besoin pour passer d’une idée à un agent vocal prêt à être mis en production.

La plateforme est conçue pour une itération rapide, permettant aux développeurs de prototyper, déployer et affiner des agents conversationnels avec un minimum de friction. Elle gère la parole, le raisonnement, le déploiement et les tests au sein d’un écosystème unique et unifié.

La pile vocale de Cartesia s’appuie sur deux modèles maison clés :

Sonic: un modèle de synthèse vocale en continu (TTS) optimisé pour une latence ultra-faible et un rendu très expressif. Il peut rire, exprimer des émotions et produire un discours naturel, semblable à celui d’un humain, dans plus de 40 langues.
Ink: un modèle de reconnaissance vocale (STT) rapide et précis, conçu pour les conversations du monde réel, capable de gérer le bruit, les accents et les hésitations tout en conservant une vitesse de transcription quasi en temps réel.

Pour créer des agents, Cartesia propose à la fois un générateur d’agents Web intégré et Line, son SDK open source. Le SDK Cartesia prend en charge les modèles, l’intégration d’outils, l’orchestration multi-agents, et bien plus encore. Vous disposez ainsi de tout ce dont vous avez besoin pour créer des agents vocaux intelligents et prêts à l’emploi.

Pourquoi les agents vocaux ont besoin d’un accès Web

Cartesia est sans aucun doute une solution riche en fonctionnalités pour la création d’agents vocaux IA, prenant en charge plus de 100 LLM via LiteLLM. Cependant, malgré ce large choix, tous les LLM partagent la même limitation inhérente : leurs connaissances sont figées à un moment précis. Cela peut entraîner des réponses obsolètes, des hallucinations ou des lacunes lorsque les agents doivent gérer des tâches réelles et actuelles.

De plus, les LLM ne peuvent pas accéder au Web de manière native ni interagir avec des systèmes externes. Par conséquent, les workflows standard des agents restent limités par les contraintes des modèles. Pour surmonter cela, l’intégration avec des services externes via des outils personnalisés est essentielle.

C’est là que Bright Data entre en jeu. En connectant Cartesia à Bright Data, vos agents peuvent accéder à des informations en temps réel, à des résultats de recherche et à des données structurées provenant de n’importe quel site web.

L’infrastructure de niveau entreprise de Bright Data comprend l’un des plus grands réseaux de Proxies au monde, avec plus de 400 millions d’adresses IP réparties dans 195 pays, permettant un accès sécurisé, fiable et évolutif au contenu Web en direct.

Les principaux produits Bright Data dont vous pouvez équiper les agents vocaux Cartesia sont les suivants :

API SERP: collectez les résultats des moteurs de recherche tels que Google, Bing et bien d’autres pour alimenter des réponses éclairées.
API Web Unlocker: accédez au contenu de n’importe quel site au format HTML brut ou Markdown, en contournant les CAPTCHA et les protections anti-bot.
API Scraper: extrayez des données structurées de plateformes telles qu’Amazon, LinkedIn et Instagram.
API Crawl: transformez des sites web entiers en ensembles de jeux de données structurés pour les workflows d’IA en aval.

Grâce à Bright Data, les agents Cartesia ne sont plus limités à des connaissances pré-entraînées. Ils peuvent explorer, récupérer et raisonner à partir de données web en temps réel et fiables. Cela leur permet de fournir des réponses plus précises, contextuelles et exploitables.

Comment créer un agent vocal IA Cartesia optimisé par la récupération de données Web de Bright Data

Dans cette section étape par étape, vous apprendrez à créer un agent vocal IA avec Cartesia. L’agent sera enrichi de capacités de recherche et de Scraping web grâce à Bright Data.

Plus précisément, l’agent vocal IA simulera la génération d’un bref rapport de type journal télévisé que vous pourrez écouter sur un sujet donné. Vous pourrez également discuter avec l’agent pour lui poser des questions complémentaires et approfondir le sujet.

Remarque: il ne s’agit là que d’une implémentation possible d’un agent vocal IA. L’intégration de Bright Data prend en charge de nombreux autres cas d’utilisation.

Plus précisément, vous intégrerez deux des produits de Bright Data compatibles avec l’IA :

L’API Web Unlocker pour permettre à l’agent d’extraire des données à partir de n’importe quelle URL.
l’API SERP pour permettre à l’agent d’effectuer des recherches sur le Web.

Ensemble, ces outils permettent à l’agent IA d’appliquer le modèle de recherche et d’extraction. C’est idéal pour l’ancrage des données et la découverte sur le Web.

Pour bénéficier d’un contrôle plus programmatique lors de la création de l’agent, nous utiliserons Line (c’est-à-dire le SDK Cartesia). En effet, l’Agent Builder est excellent pour le prototypage, mais ses fonctionnalités sont quelque peu limitées.

Suivez les instructions ci-dessous !

Prérequis

Pour suivre ce tutoriel, assurez-vous de disposer des éléments suivants :

Un système d’exploitation basé sur Unix (Linux, macOS ou WSL sous Windows).
Python 3.9+ installé localement.
uv installé localement.
Une clé API provenant de l’un des fournisseurs LLM pris en charge par Cartesia (ici, nous utiliserons une clé API Gemini).
Un compte Bright Data avec une API Web Unlocker et une API SERP configurées, ainsi qu’une clé API.
Un compte Cartesia avec une clé API configurée.

Ne vous inquiétez pas pour la configuration des comptes Bright Data et Cartesia pour l’instant, car vous serez guidé tout au long des sous-chapitres dédiés.

Étape n° 1 : Initialiser un projet Cartesia

Commencez par créer un dossier pour votre projet à l’aide de uv (c’est l’approche recommandée dans le guide de démarrage rapide de Cartesia) :

uv init cartesia-bright-data-voice-agent

Accédez au dossier du projet :

cd cartesia-bright-data-voice-agent

Vous devriez voir une structure de dossiers comme celle-ci :

cartesia-bright-data-voice-agent/
├── .git/
├── .gitignore
├── .python-version
├── README.md
├── main.py
└── pyproject.toml

C’est le résultat de la commande uv init.

Concentrez-vous sur le fichier main.py. C’est là que vous ajouterez votre logique Cartesia pour concevoir un agent vocal IA doté de capacités de récupération et de recherche de données Web à l’aide de Bright Data.

Ensuite, installez les dépendances du projet avec :

uv add cartesia-line requests

Les deux bibliothèques requises sont :

cartesia-line: le SDK Cartesia Line permettant de créer des agents vocaux intelligents à faible latence.
requests: le célèbre client HTTP Python, qui sera utilisé pour appeler les API de Bright Data dans les outils Cartesia personnalisés.

Ces bibliothèques seront automatiquement installées dans un environnement virtuel.venv par uv. Vous pouvez désormais ouvrir le projet directement dans votre IDE Python préféré.

Bravo ! Votre projet Cartesia vierge est prêt à être utilisé.

Étape n° 2 : Démarrer avec la CLI Cartesia

Pour tester un agent Cartesia en local, vous devez installer la CLI Cartesia et vous y connecter. Pour l’authentification, vous avez besoin d’une clé API Cartesia, alors commençons par la préparer !

Si vous n’avez pas encore de compte, créez un nouveau compte Cartesia. Sinon, connectez-vous. Une fois connecté, vous accéderez au tableau de bord :
The Cartesia dashboard

Rendez-vous maintenant sur la page « API Keys » et cliquez sur le bouton « New » :
Pressing the “New” button

Donnez un nom à votre clé API (par exemple, « Agent vocal optimisé par Bright Data »), cliquez sur « Créer », et la clé API s’affichera dans une fenêtre contextuelle.
Getting your Cartesia API key
Copiez le jeton API et conservez-le en lieu sûr, car vous en aurez besoin sous peu.

Dans votre terminal Unix, installez la CLI Cartesia à l’aide de la commande suivante :

curl -fsSL https://cartesia.sh | sh

Une fois l’installation terminée, redémarrez votre shell afin de pouvoir utiliser la commande cartesia depuis n’importe où.

Pour vous authentifier dans la CLI, exécutez :

cartesia auth login

Vous serez invité à saisir votre clé API Cartesia. Collez-la et appuyez sur Entrée. Si l’opération réussit, vous devriez voir un message comme celui-ci :
The authentication success message

Remarque: dans cet exemple, « Writech » est le nom de l’organisation Cartesia. Dans votre cas, vous verrez un message personnalisé pour votre organisation.

Parfait ! Il est temps de configurer votre compte Bright Data pour remplir les conditions préalables initiales.

Étape n° 3 : Configurer un compte Bright Data

Pour connecter l’API SERP et Web Unlocker dans Cartesia, vous devez d’abord disposer d’un compte Bright Data sur lequel une zone API SERP et une zone API Web Unlocker sont configurées, ainsi qu’une clé API.

Si vous n’avez pas de compte Bright Data, créez-en un. Si vous avez déjà un compte, connectez-vous. Accédez à votre panneau de configuration, rendez-vous sur la page « Proxies & Scraping » et consultez le tableau « My Zones » :
Note the “web_unlocker” Web Unlocker API zone and “serp_api” SERP API zone
Si le tableau répertorie déjà une zone API Web Unlocker (par exemple, web_unlocker) et une zone API SERP (par exemple, serp_api), tout est prêt. Ces deux zones seront utilisées pour appeler les services API Web Unlocker et SERP via des outils personnalisés.

Si l’une des zones manque, créez-la. Faites défiler jusqu’aux cartes « Unblocker API » et « API SERP », puis cliquez sur « Créer une zone ». Suivez l’assistant pour ajouter les deux zones :
Note the “Create zone” buttons

Pour obtenir des instructions détaillées, consultez ces pages de documentation :

Notez bien les noms que vous attribuez à ces deux zones, car vous en aurez besoin à l’étape suivante. Enfin, générez votre clé API Bright Data et conservez-la en lieu sûr.

Parfait ! Bright Data est désormais prêt à être intégré à Cartesia.

Étape n° 4 : Configurer la lecture des variables d’environnement

Ce workflow d’agent vocal IA repose sur quelques secrets : un fournisseur LLM (Gemini, dans ce cas) et Bright Data (clé API + noms de zones). Le codage en dur de ces secrets dans votre code représente un risque de sécurité ; il est donc préférable de les stocker dans des variables d’environnement.

La CLI Cartesia lit automatiquement un fichier .env en arrière-plan à l’aide de python-dotenv, vous pouvez donc y stocker tous vos secrets. Commencez par ajouter un fichier .env à votre répertoire de projet :

cartesia-bright-data-voice-agent/
├── .git/
├── .env # <-----------
├── .gitignore
├── .python-version
├── README.md
├── main.py
└── pyproject.toml

Ensuite, remplissez-le avec vos secrets :

GEMINI_API_KEY="<VOTRE_CLÉ_API_GEMINI>"
BRIGHT_DATA_API_KEY="<VOTRE_CLÉ_API_BRIGHT_DATA>"
BRIGHT_DATA_WEB_UNLOCKER_ZONE="<VOTRE_BRIGHT_DATA_WEB_UNLOCKER_ZONE>" # par ex., "web_unlocker"
BRIGHT_DATA_SERP_API_ZONE="<VOTRE_BRIGHT_DATA_SERP_API_ZONE>" # par ex., "serp_api"

Remplacez tous les espaces réservés par vos valeurs réelles. Étant donné que le workflow ne doit pas démarrer tant que tous ces secrets ne sont pas définis, ajoutez la logique suivante à main.py:

import os

GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
if not GEMINI_API_KEY:
    raise EnvironmentError("Variable d'environnement manquante : GEMINI_API_KEY")

BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")
if not BRIGHT_DATA_API_KEY:
    raise EnvironmentError("Variable d'environnement manquante : BRIGHT_DATA_API_KEY")

BRIGHT_DATA_SERP_API_ZONE = os.getenv("BRIGHT_DATA_SERP_API_ZONE")
if not BRIGHT_DATA_SERP_API_ZONE:
    raise EnvironmentError("Variable d'environnement manquante : BRIGHT_DATA_SERP_API_ZONE")

BRIGHT_DATA_WEB_UNLOCKER_ZONE = os.getenv("BRIGHT_DATA_WEB_UNLOCKER_ZONE")
if not BRIGHT_DATA_WEB_UNLOCKER_ZONE:
    raise EnvironmentError("Variable d'environnement manquante : BRIGHT_DATA_WEB_UNLOCKER_ZONE")

Notez qu’il n’est pas obligatoire d’utiliser un fichier .env. Vous pouvez également définir les variables d’environnement directement dans votre terminal à l’aide de :

export GEMINI_API_KEY="<VOTRE_CLÉ_API_GEMINI>" BRIGHT_DATA_API_KEY="<VOTRE_CLÉ_API_BRIGHT_DATA>" BRIGHT_DATA_WEB_UNLOCKER_ZONE="<VOTRE_ZONE_WEB_UNLOCKER_BRIGHT_DATA>" BRIGHT_DATA_SERP_API_ZONE="<VOTRE_ZONE_API_SERP_BRIGHT_DATA>"

Parfait ! Vos variables d’environnement sont désormais correctement configurées. Prochaine étape : implémentation des outils Bright Data pour le Scraping web et la recherche.

Étape n° 5 : Définir l’outil Web Unlocker pour le Scraping web

Par défaut, un agent vocal Cartesia IA ne peut pas accéder au Web externe. Pour l’activer, vous devez l’équiper d’outils personnalisés que l’agent peut appeler. Ici, vous allez définir un outil pour vous connecter à l’API Web Unlocker de Bright Data pour le Scraping web.

Dans Cartesia, un outil n’est rien d’autre qu’une fonction annotée avec l’un des décorateurs d’outils disponibles. Voici comment créer un outil de Scraping web Cartesia se connectant à l’API Web Unlocker :

@loopback_tool
def bright_data_web_unlocker(
    ctx,
    page_url: Annotated[str, "L'URL de la page à extraire"]
) -> str:
    """
    Récupérer le contenu d'une page Web à l'aide de l'API Web Unlocker de Bright Data
    """

    url = "https://api.brightdata.com/request"
    data = {
        "Zone": BRIGHT_DATA_WEB_UNLOCKER_ZONE,
        "url": page_url,
        "format": "raw",
        "data_format": "markdown"
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}",
        "Content-Type": "application/json"
    }
    # Envoyer une requête à l'API Bright Data Web Unlocker
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

Notez que le SDK Cartesia utilise la chaîne de documentation de la fonction comme description de l’outil et les annotations de type pour ses paramètres. De plus, le premier paramètre de chaque outil doit être ctx, qui représente le contexte de l’outil. Cela permet d’accéder à l’état de la conversation et garantit la compatibilité ascendante.

La fonction bright_data_web_unlocker() s’appuie sur le client HTTP Requests pour envoyer une requête POST à votre zone API Bright Data Web Unlocker. Cela renvoie la version Markdown de la page Web spécifiée dans l’argument page_url. Pour plus de détails sur les paramètres et options disponibles, consultez la documentation Bright Data.

Notez que l’argument data_format est défini sur « markdown ». Cela permet à la fonctionnalité «Scrape as Markdown »d’obtenir le contenu extrait dans un format Markdown optimisé pour l’IA,idéal pour l’ingestion LLM. L’argument format est défini sur « raw » afin que l’API renvoie le contenu Markdown extrait tel quel, plutôt que de l’encapsuler dans du JSON.

Parfait ! Votre application Cartesia IA comprend désormais un outil permettant de réaliser du Scraping web efficace sur n’importe quel site web à l’aide de Bright Data.

Étape n° 6 : Définir l’outil API SERP pour la recherche Web

De la même manière, définissez un outil de fonction personnalisée pour appeler l’API SERP :

@loopback_tool
def bright_data_serp_api(
    ctx,
    query: Annotated[str, "La requête de recherche Google"]
) -> str:
    """
    Effectuer une recherche sur le Web pour un terme spécifique à l'aide de l'API SERP de Bright Data.
    """

    url = "https://api.brightdata.com/request"
    data = {
        "Zone": BRIGHT_DATA_SERP_API_ZONE,
        "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&brd_json=1",
        "format": "raw"
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}",
        "Content-Type": "application/json"
    }

    # Envoyer une requête à l'API SERP de Bright Data
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

Cette fonction envoie une requête POST à votre zone API SERP. Elle envoie une requête à Google et récupère les résultats de recherche analysés via Bright Data. Pour plus de détails, consultez la documentation de l’API SERP de Bright Data.

Parfait ! Votre application Cartesia inclut désormais les outils requis alimentés par Bright Data.

Étape n° 7 : Définir l’agent vocal Cartesia

À ce stade, vous disposez de tous les éléments nécessaires pour définir votre agent Cartesia. L’approche recommandée consiste à utiliser la classe LlmAgent intégrée, qui prend en charge plus de 100 fournisseurs LLM via LiteLLM.

Pour définir l’agent vocal, fournissez à la classe :

Le modèle LLM et la clé API.
Les outils qu’il peut utiliser.
Une invite système décrivant ce que l’agent doit faire.
Un message initial.

Voici comment assembler le tout :

from line.llm_agent import LlmAgent, LlmConfig, end_call
from line.voice_agent_app import VoiceAgentApp

async def get_agent(env, call_request):
    # Définir l'agent vocal IA
    SYSTEM_PROMPT = """
    Vous êtes un assistant serviable capable d'effectuer des recherches sur le Web pour récupérer des informations contextuelles à jour.
    Répondez d'un ton clair, informatif, à la manière d'un journal télévisé.
    """

    return LlmAgent(
        model="gemini/gemini-3-flash-preview",
        api_key=GEMINI_API_KEY,
        tools=[
            end_call,
            bright_data_web_unlocker,
            bright_data_serp_api
        ],
        config=LlmConfig(
            system_prompt=SYSTEM_PROMPT,
            introduction="Bonjour ! Comment puis-je vous aider aujourd'hui ?",
        ),
    )

Quelques points à noter :

Le tableau tools comprend les deux outils Bright Data personnalisés définis précédemment (bright_data_web_unlocker et bright_data_serp_api).
L’outil end_call intégré est nécessaire pour que l’agent puisse mettre fin à une conversation en douceur.
Le modèle LLM configuré est Gemini 3 Flash, mais n’importe quel autre modèle Gemini fera l’affaire.

Enfin, enregistrez l’agent dans la classe VoiceAgentApp et exécutez-le :

app = VoiceAgentApp(get_agent=get_agent)

if __name__ == "__main__":
    app.run()

Mission accomplie ! Vous avez créé un agent vocal IA capable de fournir des réponses de type actualités. Cet agent est capable de rechercher et de récupérer des informations en temps réel sur le Web pour fournir des réponses plus précises et à jour.

Étape n° 8 : Code final

Voici ce que le fichier main.py devrait désormais contenir :

# uv add cartesia-line requests

import os
from line.llm_agent import loopback_tool
from typing import Annotated
import requests
import urllib
from line.llm_agent import LlmAgent, LlmConfig, end_call
from line.voice_agent_app import VoiceAgentApp

# Lecture des secrets requis dans l'environnement
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
if not GEMINI_API_KEY:
    raise EnvironmentError("Variable d'environnement manquante : GEMINI_API_KEY")

BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")
if not BRIGHT_DATA_API_KEY:
    raise EnvironmentError("Variable d'environnement manquante : BRIGHT_DATA_API_KEY")

BRIGHT_DATA_SERP_API_ZONE = os.getenv("BRIGHT_DATA_SERP_API_ZONE")
if not BRIGHT_DATA_SERP_API_ZONE:
    raise EnvironmentError("Variable d'environnement manquante : BRIGHT_DATA_SERP_API_ZONE")

BRIGHT_DATA_WEB_UNLOCKER_ZONE = os.getenv("BRIGHT_DATA_WEB_UNLOCKER_ZONE")
if not BRIGHT_DATA_WEB_UNLOCKER_ZONE:
    raise EnvironmentError("Variable d'environnement manquante : BRIGHT_DATA_WEB_UNLOCKER_ZONE")

@loopback_tool
def bright_data_web_unlocker(
    ctx,
    page_url: Annotated[str, "L'URL de la page à extraire"]
) -> str:
    """
    Récupère le contenu d'une page web à l'aide de l'API Bright Data Web Unlocker
    """

    url = "https://api.brightdata.com/request"
    data = {
        "Zone": BRIGHT_DATA_WEB_UNLOCKER_ZONE,
        "url": page_url,
        "format": "raw",
        "data_format": "markdown"
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}",
        "Content-Type": "application/json"
    }

    # Envoyer une requête à l'API Bright Data Web Unlocker
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

@loopback_tool
def bright_data_serp_api(
    ctx,
    query: Annotated[str, "La requête de recherche Google"]
) -> str:
    """
    Effectue une recherche sur le Web pour un terme spécifique à l'aide de l'API SERP de Bright Data.
    """

    url = "https://api.brightdata.com/request"
    data = {
        "zone": BRIGHT_DATA_SERP_API_ZONE,
        "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&brd_json=1",
        "format": "raw"
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}",
        "Content-Type": "application/json"
    }

    # Envoyer une requête à l'API SERP de Bright Data
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

async def get_agent(env, call_request):
    # Définir l'agent vocal IA
    SYSTEM_PROMPT = """
    Vous êtes un assistant utile capable d'effectuer des recherches sur le Web pour récupérer des informations contextuelles à jour.
    Répondez d'un ton clair, informatif et digne d'un journal télévisé.
    """

    return LlmAgent(
        model="gemini/gemini-2.5-flash",
        api_key=GEMINI_API_KEY,
        tools=[
            end_call,
            bright_data_web_unlocker,
            bright_data_serp_api
        ],
        config=LlmConfig(
            system_prompt=SYSTEM_PROMPT,
            introduction="Bonjour ! Comment puis-je vous aider aujourd'hui ?",
        ),
    )

app = VoiceAgentApp(get_agent=get_agent)

if __name__ == "__main__":
    app.run()

Super ! En une centaine de lignes de code Python, vous avez réussi à créer un puissant agent IA vocal doté de capacités de découverte de données Web.

Étape n° 9 : Tester l’agent vocal

Assurez-vous d’avoir défini toutes les variables d’environnement requises (soit dans un fichier .env, soit via une commande export ). Lancez ensuite l’agent avec :

PORT=8000 uv run python main.py

Cela démarre l’application Cartesia localement sur http://localhost:8000, comme indiqué dans les journaux :
The command's log

Dans un autre terminal, interagissez avec votre agent en exécutant :

cartesia chat 8000

L’expérience Cartesia Chat s’ouvrira directement dans votre terminal :
The Cartesia Chat TUI
Cette configuration vous permet de simuler des conversations via le chat plutôt que par voix, ce qui simplifie considérablement les tests.

Essayez une commande comme celle-ci :

Recherchez la requête « US inflation news » sur le Web, sélectionnez 3 à 5 articles spécifiques (pas de pages d'actualités), extrayez leur contenu, puis utilisez ces informations pour produire un podcast d'environ 3 minutes résumant les points clés, en citant les sources.

Voici ce qui devrait se passer :
The AI voice agent run on the given prompt

Remarquez comment l’agent appelle d’abord l’outil bright_data_serp_api avec la requête « US inflation news ». Dans l’autre terminal, vous verrez les journaux contenant les résultats JSON renvoyés par l’API SERP de Bright Data. À partir de ces résultats, l’agent sélectionne 3 URL d’articles pertinents :
Note the URLs selection from the agent

Ensuite, il extrait le contenu de chaque page à l’aide de l’outil bright_data_web_unlocker et produit un résumé étayé par des sources :
The output produced by the agent
Remarquez comment le ton de la réponse ressemble à celui d’un journaliste, correspondant à l’invite système que vous avez définie précédemment.

Et voilà ! Vous avez réussi à créer un agent vocal capable de rechercher et de récupérer activement des informations sur le Web, ce qui permet d’obtenir des réponses plus précises et mieux adaptées au contexte. Cela n’aurait pas été possible sans l’intégration des outils de recherche et de scraping de Bright Data.

Prochaines étapes

Maintenant que vous disposez d’un agent vocal IA opérationnel, l’étape suivante consiste à le déployer sur Cartesia et à l’appeler depuis votre téléphone. Pour affiner et personnaliser davantage votre agent en fonction de vos besoins, consultez la documentation.

Enfin, gardez à l’esprit que, comme nous l’avons montré dans ce tutoriel, vous pouvez intégrer d’autres produits Bright Data basés sur des API. Cela permettra d’étendre les capacités de votre agent.

N’oubliez pas que Cartesia prend en charge de nombreuses intégrations, notamment LiveKit (une autre technologie permettant de créer des agents vocaux IA). Pour plus d’informations, découvrez comment intégrer Bright Data à LiveKit.

Conclusion

Dans cet article, vous avez découvert ce qu’est Cartesia et ce qu’il apporte au développement d’agents vocaux IA. Vous avez également vu ses limites et comment les contourner grâce aux intégrations Bright Data.

En ajoutant deux outils spécialisés à vos agents vocaux, vous leur avez donné la capacité de rechercher sur le Web et d’extraire des données à partir de pages Web. Cela a été rendu possible en connectant vos agents à des outils personnalisés alimentés par les API SERP et Web Unlocker de Bright Data.

Pour étendre encore davantage les fonctionnalités, par exemple en accédant à des flux Web en direct ou en automatisant les interactions Web, intégrez les agents vocaux Cartesia à la suite complète de services Bright Data pour l’IA.

Créez gratuitement un compte Bright Data dès aujourd’hui et commencez à intégrer des solutions de données Web compatibles avec l’IA à vos agents !

Contacter Ventes Essai gratuit

Créer un assistant vocal IA capable d’effectuer des recherches sur le Web avec Cartesia et Bright Data