Criando um agente de voz com IA capaz de pesquisar na web com Cartesia e Bright Data

Nesta postagem do blog, você descobrirá:

• O que é a Cartesia e o que ela oferece para o desenvolvimento de agentes de voz com IA.
• Por que os agentes de voz (como qualquer outro agente) precisam de acesso à web para serem eficazes e verdadeiramente confiáveis.
• Como dar a um agente de voz com IA da Cartesia a capacidade de pesquisar e extrair informações da web usando a integração com a Bright Data.

Vamos começar!

O que é a Cartesia?

A Cartesia é uma plataforma voltada para desenvolvedores para a criação de agentes de voz com IA em tempo real. Ela combina modelos de fala de baixa latência com uma pilha completa de desenvolvimento de agentes, fornecendo tudo o que você precisa para passar da ideia a um agente de voz pronto para produção.

A plataforma foi projetada para iteração rápida, permitindo que os desenvolvedores criem protótipos, implantem e refinem agentes conversacionais com o mínimo de atrito. Ela lida com fala, raciocínio, implantação e testes dentro de um único ecossistema unificado.

A pilha de voz da Cartesia é alimentada por dois modelos internos principais:

• Sonic: Um modelo de conversão de texto para fala (TTS) em streaming otimizado para latência ultrabaixa e saída altamente expressiva. Ele pode rir, demonstrar emoções e produzir uma fala natural e semelhante à humana em mais de 40 idiomas.
• Ink: Um modelo rápido e preciso de conversão de fala em texto (STT) projetado para conversas do mundo real, lidando com ruídos, sotaques e disfluências enquanto mantém uma velocidade de transcrição quase em tempo real.

Para criar agentes, a Cartesia oferece tanto um Agent Builder integrado à web quanto o Line, seu SDK de código aberto. O SDK da Cartesia suporta modelos, integração de ferramentas, orquestração de múltiplos agentes e muito mais. Isso oferece tudo o que você precisa para criar agentes de voz inteligentes e prontos para produção.

Por que os agentes de voz precisam de acesso à web

A Cartesia é, sem dúvida, uma solução rica em recursos para a criação de agentes de voz com IA, com suporte para mais de 100 LLMs via LiteLLM. No entanto, mesmo com essa ampla seleção, todos os LLMs compartilham a mesma limitação inerente: seu conhecimento está congelado em um momento específico no tempo. Isso pode levar a respostas desatualizadas, alucinações ou lacunas quando os agentes precisam lidar com tarefas do mundo real e atualizadas.

Além disso, os LLMs não podem acessar a web nativamente nem interagir com sistemas externos. Como resultado, os fluxos de trabalho padrão dos agentes permanecem restritos pelas limitações dos modelos. Para superar isso, a integração com serviços externos por meio de ferramentas personalizadas é essencial.

É aqui que a Bright Data entra em cena. Ao conectar o Cartesia à Bright Data, seus agentes podem acessar informações em tempo real, resultados de pesquisa e dados estruturados de qualquer site.

A infraestrutura de nível empresarial da Bright Data conta com uma das maiores redes de Proxies do mundo, com mais de 400 milhões de IPs em 195 países, permitindo acesso seguro, confiável e escalável a conteúdo da web em tempo real.

Os principais produtos da Bright Data que você pode equipar aos agentes de voz da Cartesia incluem:

• API SERP: Colete resultados de mecanismos de busca do Google, Bing e outros para alimentar respostas bem informadas.
• Web Unlocker API: acesse conteúdo de qualquer site em HTML bruto ou Markdown, contornando CAPTCHAs e proteções anti-bot.
• Web Scraper APIs: Extraia dados estruturados de plataformas como Amazon, LinkedIn e Instagram.
• API Crawl: Transforme sites inteiros em Conjuntos de dados estruturados para fluxos de trabalho de IA posteriores.

Com a Bright Data, os agentes da Cartesia não estão mais limitados a conhecimentos pré-treinados. Eles podem explorar, recuperar e raciocinar com dados da web em tempo real e confiáveis. Isso permite que eles forneçam respostas mais precisas, sensíveis ao contexto e acionáveis.

Como criar um agente de voz de IA da Cartesia com tecnologia de recuperação de dados da web da Bright Data

Nesta seção passo a passo, você aprenderá como criar um agente de voz com IA usando o Cartesia. O agente será aprimorado com recursos de pesquisa na web e Scraping de dados usando o Bright Data.

Especificamente, o agente de voz com IA simulará a geração de um breve relatório no estilo de notícias sobre um determinado tópico, que você poderá ouvir. Você também poderá conversar com o agente para fazer perguntas complementares e explorar o tópico mais a fundo.

Observação: esta é apenas uma das possíveis implementações de um agente de voz com IA. A integração da Bright Data oferece suporte a muitos outros casos de uso.

Especificamente, você integrará dois produtos da Bright Data prontos para IA:

• A API Web Unlocker para dar ao agente a capacidade de extrair dados de qualquer URL.
• A API SERP para permitir que o agente pesquise na web.

Juntas, essas ferramentas dão ao agente de IA a capacidade de aplicar o padrão de pesquisa e extração. Isso é ideal para fundamentação de dados e descoberta na web.

Para obter mais controle programático ao construir o agente, utilizaremos o Line (ou seja, o SDK da Cartesia). Isso porque o Agent Builder é ótimo para prototipagem, mas um pouco limitado.

Siga as instruções abaixo!

Pré-requisitos

Para acompanhar este tutorial, certifique-se de ter o seguinte:

• Um sistema operacional baseado em Unix (Linux, macOS ou WSL no Windows).
• Python 3.9+ instalado localmente.
• uv instalado localmente.
• Uma chave de API de um dos provedores de LLM compatíveis com o Cartesia (aqui, usaremos uma chave de API do Gemini).
• Uma conta Bright Data com as APIs Web Unlocker e API SERP configuradas, juntamente com uma chave de API.
• Uma conta Cartesia com uma chave de API configurada.

Não se preocupe em configurar as contas da Bright Data e da Cartesia ainda, pois você será orientado nos subcapítulos dedicados.

Passo 1: Inicialize um projeto Cartesia

Comece criando uma pasta para o seu projeto usando o uv (essa é a abordagem recomendada no guia de início rápido do Cartesia):

uv init cartesia-bright-data-voice-agent

Entre na pasta do projeto:

cd cartesia-bright-data-voice-agent

Você deverá ver uma estrutura de pastas como esta:

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

Este é o resultado do comando uv init.

Concentre-se no arquivo main.py. É nele que você adicionará sua lógica Cartesia para projetar um agente de voz com IA, ampliado com recursos de recuperação e pesquisa de dados da web usando o Bright Data.

Em seguida, instale as dependências do projeto com:

uv add cartesia-line requests

As duas bibliotecas necessárias são:

• cartesia-line: O SDK Cartesia Line para a criação de agentes de voz inteligentes e de baixa latência.
• requests: O popular cliente HTTP para Python, que será usado para chamar as APIs da Bright Data em ferramentas Cartesia personalizadas.

Essas bibliotecas serão instaladas automaticamente em um ambiente virtual.venv pelo uv. Agora você pode abrir o projeto diretamente em seu IDE Python favorito.

Muito bem! Seu projeto Cartesia em branco está pronto para uso.

Passo 2: Comece a usar a CLI do Cartesia

Para testar um agente Cartesia localmente, você precisa instalar e fazer login na CLI da Cartesia. Para a autenticação, você precisa de uma chave de API da Cartesia, então vamos preparar isso primeiro!

Se você ainda não tem uma conta, crie uma nova conta Cartesia. Caso contrário, faça login. Após o login, você chegará ao painel:

Agora, vá para a página “Chaves de API” e clique no botão “Novo”:

Dê um nome à sua chave API (por exemplo, “Agente de voz com tecnologia Bright Data”), clique em “Criar” e você verá a chave API em uma janela modal.

Copie o token da API e guarde-o em local seguro, pois você precisará dele em breve.

No seu terminal baseado em Unix, instale a CLI da Cartesia com:

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

Após a instalação, reinicie seu shell para poder usar o comando cartesia de qualquer lugar.

Para se autenticar na CLI, execute:

cartesia auth login

Será solicitado que você insira sua chave API do Cartesia. Cole-a e pressione Enter. Se for bem-sucedido, você deverá ver uma mensagem como esta:

Observação: Neste exemplo, “Writech” é o nome da organização Cartesia. No seu caso, você verá uma mensagem personalizada para a sua organização.

Perfeito! É hora de configurar sua conta Bright Data para concluir os pré-requisitos iniciais.

Etapa 3: Configure uma conta Bright Data

Para conectar a API SERP e o Web Unlocker no Cartesia, você primeiro precisa de uma conta Bright Data com uma zona de API SERP e uma zona de API Web Unlocker configuradas, além de uma chave de API.

Se você não tem uma conta Bright Data, crie uma nova. Se já tem uma conta, faça login. Acesse seu painel de controle, navegue até a página “Proxies & Scraping” e verifique a tabela “My Zones”:

Se a tabela já listar uma zona de API do Web Unlocker (por exemplo, web_unlocker) e uma zona de API SERP (por exemplo, serp_api), você está pronto. Essas duas zonas serão usadas para chamar os serviços da API do Web Unlocker e da API SERP por meio de ferramentas personalizadas.

Se alguma das zonas estiver faltando, crie-a. Role até os cartões “API do Unblocker” e “API SERP” e clique em “Criar zona”. Siga o assistente para adicionar ambas as zonas:

Para obter orientações detalhadas, consulte estas páginas da documentação:

• Como começar a usar a API SERP
• Guia de Início Rápido para a API Web Unlocker da Bright Data

Lembre-se dos nomes que você atribuiu a ambas as zonas, pois precisará deles na próxima etapa. Por fim, gere sua chave de API da Bright Data e guarde-a em local seguro.

Ótimo! A Bright Data agora está pronta para ser integrada ao Cartesia.

Etapa 4: Configurar a leitura de variáveis de ambiente

Este fluxo de trabalho do agente de voz com IA depende de alguns segredos: um provedor de LLM (Gemini, neste caso) e a Bright Data (chave de API + nomes de zona). Codificar esses segredos diretamente no seu código é um risco à segurança, portanto, é melhor armazená-los em variáveis de ambiente.

A CLI do Cartesia lê automaticamente um arquivo .env em segundo plano usando o python-dotenv, então você pode armazenar todos os seus segredos lá. Comece adicionando um arquivo .env ao diretório do seu projeto:

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

Em seguida, preencha-o com suas chaves secretas:

GEMINI_API_KEY="<SUA_CHAVE_API_GEMINI>"
BRIGHT_DATA_API_KEY="<SUA_CHAVE_API_BRIGHT_DATA>"
BRIGHT_DATA_WEB_UNLOCKER_ZONE="<SUA_ZONA_DO_BRIGHT_DATA_WEB_UNLOCKER>" # por exemplo, "web_unlocker"
BRIGHT_DATA_SERP_API_ZONE="<SUA_ZONA_DO_BRIGHT_DATA_SERP_API>" # por exemplo, "serp_api"

Substitua todos os espaços reservados pelos seus valores reais. Como o fluxo de trabalho não deve iniciar a menos que todos esses segredos estejam definidos, adicione a seguinte lógica ao main.py:

import os

GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
if not GEMINI_API_KEY:
    raise EnvironmentError("Variável de ambiente ausente: GEMINI_API_KEY")

BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")
if not BRIGHT_DATA_API_KEY:
    raise EnvironmentError("Variável de ambiente ausente: 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("Variável de ambiente ausente: 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("Variável de ambiente ausente: BRIGHT_DATA_WEB_UNLOCKER_ZONE")

Lembre-se de que não é necessário usar um arquivo .env. Você também pode definir as variáveis de ambiente diretamente no terminal com:

export GEMINI_API_KEY="<SUA_CHAVE_API_GEMINI>" BRIGHT_DATA_API_KEY="<SUA_CHAVE_API_BRIGHT_DATA>" BRIGHT_DATA_WEB_UNLOCKER_ZONE="<SUA_ZONA_DE_DESBLOQUEIO_WEB_BRIGHT_DATA>" BRIGHT_DATA_SERP_API_ZONE="<SUA_ZONA_API_SERP_BRIGHT_DATA>"

Excelente! Suas variáveis de ambiente agora estão configuradas com segurança. Próximo passo: implementar as ferramentas da Bright Data para Scraping de dados e pesquisa.

Etapa 5: Defina a ferramenta Web Unlocker para Scraping de dados

Por padrão, um agente de voz da Cartesia IA não pode acessar a web externa. Para habilitar isso, você deve equipá-lo com ferramentas personalizadas que o agente possa chamar. Aqui, você definirá uma ferramenta para se conectar à API do Web Unlocker da Bright Data para Scraping de dados.

No Cartesia, uma ferramenta nada mais é do que uma função anotada com um dos decoradores de ferramenta disponíveis. Veja abaixo como criar uma ferramenta de Scraping de dados do Cartesia conectada à API Web Unlocker:

@loopback_tool
def bright_data_web_unlocker(
    ctx,
    page_url: Annotated[str, "A URL da página a ser extraída"]
) -> str:
    """
    Recupera o conteúdo da página da web usando a API Web Unlocker da Bright Data
    """

    url = "https://api.brightdata.com/request"
    data = {
        "zone": BRIGHT_DATA_WEB_UNLOCKER_ZONA,
        "url": page_url,
        "format": "raw",
        "data_format": "markdown"
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}",
        "Content-Type": "application/json"
    }
    # Enviar uma solicitação à API do Bright Data Web Unlocker
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

Observe que o SDK da Cartesia usa a string de documentação da função como descrição da ferramenta e as anotações de tipo para seus parâmetros. Além disso, o primeiro parâmetro de todas as ferramentas deve ser ctx, que representa o contexto da ferramenta. Isso fornece acesso ao estado da conversa e garante compatibilidade futura.

A função bright_data_web_unlocker() utiliza o cliente HTTP Requests para fazer uma solicitação POST à sua zona da API do Bright Data Web Unlocker. Isso retorna a versão Markdown da página da web especificada no argumento page_url. Para mais detalhes sobre os parâmetros e opções disponíveis, consulte a documentação do Bright Data.

Observe que o argumento data_format está definido como “markdown”. Isso habilita o recurso“Scrape as Markdown”para obter o conteúdo extraído em um formato Markdown otimizado para IA —ideal para ingestão de LLM. O argumento format está definido como “raw” para que a API responda com o conteúdo Markdown extraído em formato simples, em vez de envolvê-lo em JSON.

Ótimo! Seu aplicativo Cartesia IA agora inclui uma ferramenta para o Scraping de dados bem-sucedido de qualquer site usando o Bright Data.

Passo 6: Defina a ferramenta API SERP para pesquisa na web

Da mesma forma, defina uma ferramenta de função personalizada para chamar a API SERP:

@loopback_tool
def bright_data_serp_api(
    ctx,
    query: Annotated[str, "A consulta de pesquisa do Google"]
) -> str:
    """
    Consulte a web por um termo específico usando a API SERP da 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"
    }

    # Envie uma solicitação para a API SERP da Bright Data
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

Esta função faz uma solicitação POST à sua zona da API SERP. Ela envia uma consulta ao Google e recupera os resultados de pesquisa analisados por meio da Bright Data. Para mais detalhes, consulte a documentação da API SERP da Bright Data.

Ótimo! Seu aplicativo Cartesia agora inclui as ferramentas necessárias com tecnologia Bright Data.

Etapa 7: Defina o Agente de Voz Cartesia

Neste ponto, você tem todos os componentes necessários para definir seu agente Cartesia. A abordagem recomendada é usar a classe LlmAgent integrada, que oferece suporte a mais de 100 provedores de LLM via LiteLLM.

Para definir o agente de voz, forneça à classe:

• O modelo LLM e a chave da API.
• As ferramentas que ele pode usar.
• Um prompt do sistema descrevendo o que o agente deve fazer.
• Uma mensagem inicial.

Veja como montar tudo:

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

async def get_agent(env, call_request):
    # Defina o agente de voz com IA
    SYSTEM_PROMPT = """
    Você é um assistente prestativo capaz de pesquisar na web para recuperar informações atualizadas.
    Responda em um tom claro, informativo e no estilo de notícias.
    """

    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="Olá! Em que posso ajudar hoje?",
        ),
    )

Algumas observações:

• A matriz de ferramentas inclui as duas ferramentas personalizadas da Bright Data definidas anteriormente (bright_data_web_unlocker e bright_data_serp_api).
• A ferramenta end_call integrada é necessária para que o agente possa encerrar uma conversa de maneira adequada.
• O modelo LLM configurado é o Gemini 3 Flash, mas qualquer outro modelo Gemini serve.

Por fim, registre o agente na classe VoiceAgentApp e execute-o:

app = VoiceAgentApp(get_agent=get_agent)

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

Missão cumprida! Você criou um agente de voz com IA para respostas no estilo noticiário. Esse agente é capaz de pesquisar e recuperar informações em tempo real da web para fornecer respostas mais precisas e atualizadas.

Passo 8: Código final

Isto é o que o arquivo main.py deve conter agora:

# 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

# Ler os segredos necessários do ambiente
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
if not GEMINI_API_KEY:
    raise EnvironmentError("Variável de ambiente ausente: GEMINI_API_KEY")

BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")
if not BRIGHT_DATA_API_KEY:
    raise EnvironmentError("Variável de ambiente ausente: 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("Variável de ambiente ausente: 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("Variável de ambiente ausente: BRIGHT_DATA_WEB_UNLOCKER_ZONE")

@loopback_tool
def bright_data_web_unlocker(
    ctx,
    page_url: Annotated[str, "A URL da página a ser rastreada"]
) -> str:
    """
    Recupera o conteúdo da página da web usando a API do Bright Data Web Unlocker
    """

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

    # Enviar uma solicitação à API do 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, "A consulta de pesquisa do Google"]
) -> str:
    """
    Pesquise na web por um termo específico usando a API SERP da 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"
    }

    # Envie uma solicitação à API SERP da Bright Data
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

async def get_agent(env, call_request):
    # Defina o agente de voz com IA
    SYSTEM_PROMPT = """
    Você é um assistente útil capaz de pesquisar na web para recuperar informações atualizadas.
    Responda em um tom claro, informativo e no estilo de notícias.
    """

    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="Olá! Em que posso ajudá-lo hoje?",
        ),
    )

app = VoiceAgentApp(get_agent=get_agent)

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

Legal! Com cerca de 100 linhas de código Python, você conseguiu criar um poderoso agente de IA de voz com recursos de descoberta de dados na web.

Passo 9: Teste o agente de voz

Certifique-se de ter definido todas as variáveis de ambiente necessárias (seja em um arquivo .env ou por meio de um comando export ). Em seguida, inicie o agente com:

PORT=8000 uv run python main.py

Isso inicia o aplicativo Cartesia localmente em http://localhost:8000, conforme mostrado nos logs:

Em um terminal separado, interaja com seu agente executando:

cartesia chat 8000

A experiência do Cartesia Chat será iniciada diretamente no seu terminal:

Essa configuração permite simular conversas por chat em vez de voz, tornando os testes muito mais simples.

Tente um prompt como este:

Pesquise a consulta “notícias sobre inflação nos EUA” na web, selecione 3 a 5 artigos específicos (não páginas de notícias), extraia o conteúdo deles e use essas informações para produzir um podcast de cerca de 3 minutos resumindo os principais insights, citando as fontes.

Veja abaixo o que deve acontecer:

Observe como o agente primeiro chama a ferramenta bright_data_serp_api com a consulta “notícias sobre inflação nos EUA”. No outro terminal, você verá logs com os resultados em JSON retornados pela API SERP da Bright Data. A partir desses resultados, o agente seleciona 3 URLs de artigos relevantes:

Em seguida, ele extrai cada página usando a ferramenta bright_data_web_unlocker e produz um resumo com base nas fontes:

Observe como o tom da resposta se assemelha ao de um jornalista, correspondendo ao prompt do sistema que você definiu anteriormente.

Et voilà! Você criou com sucesso um agente de voz capaz de pesquisar e recuperar informações da web de forma ativa, resultando em respostas mais precisas e sensíveis ao contexto. Isso não seria possível sem a integração das ferramentas de pesquisa e scraping da Bright Data.

Próximos passos

Agora que você tem um agente de voz com IA em funcionamento, o próximo passo é implantá-lo no Cartesia e chamá-lo pelo seu celular. Para refinar e personalizar ainda mais seu agente de acordo com suas necessidades, explore a documentação.

Por fim, lembre-se de que — assim como mostramos neste tutorial — você pode integrar outros produtos da Bright Data baseados em API. Isso ampliará as capacidades do seu agente.

Lembre-se de que o Cartesia oferece suporte a muitas integrações, incluindo o LiveKit (outra tecnologia para a criação de agentes de voz com IA). Para obter mais informações, veja como integrar a Bright Data ao LiveKit.

Conclusão

Nesta postagem do blog, você aprendeu o que é o Cartesia e o que ele oferece para o desenvolvimento de agentes de voz com IA. Você também viu onde ele apresenta limitações e como contorná-las usando as integrações da Bright Data.

Ao adicionar duas ferramentas especializadas aos seus agentes de voz, você lhes deu a capacidade de pesquisar na web e extrair dados de páginas da web. Isso foi possível conectando seus agentes a ferramentas personalizadas alimentadas pelas APIs SERP e Web Unlocker da Bright Data.

Para ampliar ainda mais a funcionalidade — como acessar feeds da web em tempo real ou automatizar interações na web — integre os agentes de voz da Cartesia com o conjunto completo de serviços da Bright Data para IA.

Crie hoje mesmo uma conta gratuita na Bright Data e comece a integrar soluções de dados da web preparadas para IA em seus agentes!