Tutorial completo sobre como construir agentes de voz com LiveKit…

INEMA

integração telefônica (voz real com número). * Criar agentes múltiplos conectados entre si. * Implementar RAG (busca + IA). * Automatizar fluxos com Docker e MCP Catalog.

. Aqui está o passo a passo completo e direto para criar seu primeiro agente de voz com o LiveKit, conforme explicado no vídeo:

1. Instalar e preparar o ambiente⌗

Tenha o Python 3.10+ instalado.
No terminal, instale o LiveKit SDK:

pip install livekit 3. Instale também as bibliotecas necessárias (TTS, STT, etc.):

pip install openai deepgram-sdk 4. Crie uma conta gratuita em *https://cloud.livekit.io*. 5. Instale o CLI do LiveKit:

Windows:

winget install livekit * macOS/Linux:

brew install livekit 6. Autentique no LiveKit Cloud:

lk cloud auth

2. Configurar as chaves e variáveis⌗

Crie um arquivo .env com suas credenciais:

OPENAI_API_KEY=chave_da_openai DEEPGRAM_API_KEY=chave_da_deepgram LIVEKIT_API_KEY=chave_da_livekit LIVEKIT_API_SECRET=segredo_da_livekit

Essas chaves serão usadas para:

OpenAI → respostas do agente (LLM).
Deepgram → transcrição e voz.
LiveKit → autenticação e nuvem.

3. Criar o arquivo principal⌗

Crie um arquivo chamado basic_agent.py e copie a estrutura base:

```from livekit import cli from livekit.agents import Agent

class Assistant(Agent): def init(self): super().init( system_prompt="Você é um assistente de voz útil e amigável." )

async def entrypoint(self):
    session = await self.create_session(
        speech_to_text="deepgram",
        language_model="gpt-4o-mini",
        text_to_speech="cartesia"
    )
    await session.say("Olá! Como posso te ajudar hoje?")

if name == "main": cli.run_app(Assistant)```

4. Testar o agente localmente⌗

Execute no terminal:

python basic_agent.py console

O agente vai iniciar e cumprimentar com voz. Exemplo de diálogo:

Agente: Olá! Como posso te ajudar hoje? Usuário: Diga em cinco palavras por que o LiveKit é incrível. Agente: Escalável, rápido, aberto, confiável e gratuito.

5. Adicionar ferramentas (tools)⌗

Você pode ensinar o agente a executar funções Python. Exemplo – mostrar hora atual:

```from livekit.agents import function_tool from datetime import datetime

class Assistant(Agent): ...

@function_tool
def get_current_time(self):
    """Use esta ferramenta para informar a hora atual."""
    return datetime.now().strftime("%H:%M")```

Depois, se você perguntar:

Qual é a hora atual?

Ele responderá com base na função.

6. Criar um exemplo prático⌗

Exemplo de agente que busca e reserva Airbnbs (dados simulados):

```@function_tool def search_airbnbs(city: str): """Procure Airbnbs disponíveis na cidade informada.""" return [ {"nome": "Loft aconchegante", "preço": "R$750/noite"}, {"nome": "Apartamento central", "preço": "R$980/noite"}, ]

@function_tool def book_airbnb(nome: str, checkin: str, checkout: str): """Reserve um Airbnb com as datas informadas.""" return f"Reserva confirmada para {nome} de {checkin} a {checkout}."```

7. Integrar APIs reais com MCP⌗

Execute o Docker MCP Gateway (porta 8089).
No código, adicione:

session = await self.create_session( mcp_servers=["http://localhost:8089"] ) 3. Assim o agente pode se conectar a APIs reais (ex: Airbnb, Google, etc.) usando o protocolo MCP.

8. Implantar na nuvem⌗

Configure variáveis de ambiente:

lk app env 2. Inicie o agente local:

lk start 3. Crie e envie para a nuvem:

lk agent create 4. O agente será criado no LiveKit Cloud Dashboard.

9. Testar no navegador⌗

Acesse o Playground LiveKit: https://cloud.livekit.io/playground
Escolha sua organização e agente.
Converse diretamente pelo navegador (voz e texto).

10. Próximos passos⌗

Adicionar

youtube.com/watch ↗

construir agentes de voz sem depender de plataformas pagas.

Resumo, organizada de forma didática, direta e completa, ideal para quem quer entender a estrutura e o potencial do LiveKit passo a passo:

1. Contexto e Problema⌗

Plataformas como Vappy, Synthflow e Bland.ai facilitam a criação de agentes de voz, mas apresentam limitações:

Infraestrutura fechada e não controlável.
Chamadas lentas e custos altos por minuto.
Difícil personalização e dependência total do provedor.

Empresas têm migrado para soluções próprias em busca de performance, economia e liberdade.

2. A Solução: LiveKit⌗

LiveKit é um framework Python open source para construir agentes de voz personalizados com total controle. Principais vantagens:

Código aberto e gratuito.
Personalização completa da lógica de conversa.
Integrações diretas com ferramentas, APIs e servidores MCP.
Suporte a self-hosting ou implantação na nuvem (LiveKit Cloud).
Alta velocidade, estabilidade e escalabilidade.

3. Estrutura Básica de um Agente⌗

O vídeo ensina a criar um agente funcional em 52 linhas de código. Etapas principais:

Importar dependências do LiveKit.
Criar uma classe Assistant.
Definir o prompt do sistema (instruções iniciais do agente).
Criar a sessão do agente (entry point) conectando:

Modelo de Speech-to-Text (STT).
Modelo LLM (ex: OpenAI).
Modelo Text-to-Speech (TTS). 5. Iniciar o agente e gerar uma saudação automática.

Esse pipeline converte voz → texto → resposta → fala novamente, criando uma experiência interativa.

4. Personalização com Ferramentas (Tools)⌗

Para adicionar funções ao agente:

Cria-se uma função Python dentro da classe e adiciona-se o decorator @function_tool.
O docstring da função explica ao LLM quando e como usá-la. Exemplo:
get_current_time() → informa data e hora atual.
Pode-se criar quantas funções forem necessárias, como cálculo, busca, API externa, etc.

5. Exemplo Prático: Agente tipo Airbnb⌗

O tutorial demonstra um assistente de viagens que:

Busca e reserva Airbnbs (dados simulados).
Pergunta informações complementares ao usuário.
Usa funções:
search_airbnbs(city)
book_airbnb(name, checkin, checkout)
Mostra como o LLM entende parâmetros e executa as funções certas no fluxo da conversa.

6. Integração Real com MCP Servers⌗

O vídeo evolui o agente para usar dados reais da API do Airbnb. Passos:

Rodar o Docker MCP Gateway (porta 8089).
Conectar o LiveKit ao MCP via streamable HTTP.
Inserir a URL do servidor MCP no código.

Assim, o agente passa a buscar resultados reais sem depender de mocks.

7. Eventos e Lógica Avançada⌗

O LiveKit permite controlar eventos e fluxos customizados, como:

Quando o usuário começa ou termina de falar.
Inserção de lógicas personalizadas durante o diálogo. Isso amplia o controle e diferencia o LiveKit de plataformas comerciais engessadas.

8. Implantação na Nuvem⌗

O tutorial ensina a subir o agente para o LiveKit Cloud:

Instalar o CLI do LiveKit (winget install livekit).
Autenticar: lk cloud auth.
Configurar variáveis de ambiente (chaves da OpenAI e Deepgram).
Iniciar o projeto:

lk app env → define variáveis.
lk start → prepara o ambiente.
lk agent create → cria e publica o agente. 5. Testar no Playground do LiveKit diretamente no navegador.

Tudo gratuito, exceto o custo da API OpenAI.

9. Extensões Possíveis⌗

O autor menciona recursos adicionais:

Integração telefônica (agente com número de telefone real).
Multi-agentes dentro do LiveKit.
Integração RAG e Docker MCP Catalog (em próximos tutoriais).

10. Conclusão⌗

O LiveKit oferece um ambiente aberto, gratuito e poderoso para criar agentes de voz com controle total. Resumo dos diferenciais:

Total liberdade de personalização.
Integração com qualquer modelo (STT, LLM, TTS).
Código limpo e 100% Python.
Escalável e pronto para produção.
Ideal para quem quer

Repositório do GitHub agentes de voz do LiveKit: https://github.com/coleam00/ottomator...

GitHub dos Agentes do LiveKit: https://github.com/livekit/agents/tre...

Guia para implantação do agente de voz: https://docs.livekit.io/agents/start/...

Nuvem do LiveKit: https://cloud.livekit.io/

Agente do LiveKit Playground: https://agents-playground.livekit.io/

LiveKit - Opensource

chatgpt.com ↗