Download do pipecat - Download do código fonte pipecat

pipecat

Outro código-fonte

v0.0.49

Baixar

O PiCecat é uma estrutura Python de código aberto para criar voz e agentes de conversação multimodal. Ele lida com a complexa orquestração de serviços de IA, transporte de rede, processamento de áudio e interações multimodais, permitindo que você se concentre na criação de experiências envolventes.

O que você pode construir

Assistentes de voz : conversas naturais e em tempo real com IA
Agentes interativos : treinadores pessoais e assistentes de reunião
Aplicativos multimodais : combine voz, vídeo, imagens e texto
Ferramentas criativas : experiências de contar histórias e companheiros sociais
Soluções de negócios : fluxos de entrada do cliente e bots de suporte
Fluxos de conversação complexos : consulte os fluxos de Pipecat para aprender mais

Veja em ação

Principais recursos

Design de voz primeiro : reconhecimento de fala interno, TTS e manuseio de conversas
Integração flexível : trabalha com serviços de IA populares (Openai, Elevenlabs, etc.)
Arquitetura de pipeline : construir aplicativos complexos a partir de componentes simples e reutilizáveis
Processamento em tempo real : arquitetura de pipeline baseada em quadros para interações fluidas
Produção pronta : WebRTC e suporte da WebSocket de classe corporativa e WebSocket

Procurando construir conversas estruturadas? Confira os fluxos de Pipecat para gerenciar estados e transições de conversação complexas.

Começando

Você pode começar com o Pipecat funcionando em sua máquina local e mover o seu agente processa para a nuvem quando estiver pronto. Você também pode adicionar um? Número de telefone ,? Saída de imagem, entrada de vídeo, use LLMs diferentes e muito mais.

 # Install the module
pip install pipecat-ai

# Set up your environment
cp dot-env.template .env

Para manter as coisas leves, apenas a estrutura principal é incluída por padrão. Se você precisar de suporte para serviços de IA de terceiros, poderá adicionar as dependências necessárias com:

pip install " pipecat-ai[option,...] "

As opções disponíveis incluem:

Categoria	Serviços	Instalar exemplo de comando
Fala para texto	Assemblyai, Azure, Deepgram, Gladia, Whisper	`pip install "pipecat-ai[deepgram]"`
Llms	Antrópico, Azure, Fireworks AI, Gêmeos, Ollama, Openai, juntos ai	`pip install "pipecat-ai[openai]"`
Texto para fala	AWS, Azure, Cartesia, Deepgram, Elevenlabs, Google, LMNT, OpenAi, Playht, Rime, XTTs	`pip install "pipecat-ai[cartesia]"`
Fala a fala	Openai em tempo real	`pip install "pipecat-ai[openai]"`
Transporte	Diariamente (webrtc), webSocket, local	`pip install "pipecat-ai[daily]"`
Vídeo	Tavus	`pip install "pipecat-ai[tavus]"`
Visão e imagem	Moondream, Fal	`pip install "pipecat-ai[moondream]"`
Processamento de áudio	Silero Vad, Krisp, Noisneduce	`pip install "pipecat-ai[silero]"`
Análise e métricas	AI canônica, sentinela	`pip install "pipecat-ai[canonical]"`

Visualizar documentação completa de serviços →

Exemplos de código

Fundamental - pequenos trechos que se desenvolvem, introduzindo um ou dois conceitos de cada vez
Exemplo de aplicativos - Aplicativos completos que você pode usar como pontos de partida para desenvolvimento

Um simples agente de voz executando localmente

Aqui está um BOT PIPECAT muito básico que cumprimenta um usuário quando eles ingressam em uma sessão em tempo real. Usaremos diariamente para transporte de mídia em tempo real e cartesia para falar em fala em fala.

 import asyncio

from pipecat . frames . frames import EndFrame , TextFrame
from pipecat . pipeline . pipeline import Pipeline
from pipecat . pipeline . task import PipelineTask
from pipecat . pipeline . runner import PipelineRunner
from pipecat . services . cartesia import CartesiaTTSService
from pipecat . transports . services . daily import DailyParams , DailyTransport

async def main ():
  # Use Daily as a real-time media transport (WebRTC)
  transport = DailyTransport (
    room_url = ...,
    token = "" , # leave empty. Note: token is _not_ your api key
    bot_name = "Bot Name" ,
    params = DailyParams ( audio_out_enabled = True ))

  # Use Cartesia for Text-to-Speech
  tts = CartesiaTTSService (
    api_key = ...,
    voice_id = ...
  )

  # Simple pipeline that will process text to speech and output the result
  pipeline = Pipeline ([ tts , transport . output ()])

  # Create Pipecat processor that can run one or more pipelines tasks
  runner = PipelineRunner ()

  # Assign the task callable to run the pipeline
  task = PipelineTask ( pipeline )

  # Register an event handler to play audio when a
  # participant joins the transport WebRTC session
  @ transport . event_handler ( "on_first_participant_joined" )
  async def on_first_participant_joined ( transport , participant ):
    participant_name = participant . get ( "info" , {}). get ( "userName" , "" )
    # Queue a TextFrame that will get spoken by the TTS service (Cartesia)
    await task . queue_frame ( TextFrame ( f"Hello there, { participant_name } !" ))

  # Register an event handler to exit the application when the user leaves.
  @ transport . event_handler ( "on_participant_left" )
  async def on_participant_left ( transport , participant , reason ):
    await task . queue_frame ( EndFrame ())

  # Run the pipeline task
  await runner . run ( task )

if __name__ == "__main__" :
  asyncio . run ( main ())

Execute -o com:

python app.py

O Daily fornece uma interface de usuário do WebRTC pré -construída. Enquanto o aplicativo estiver em execução, você pode visitar em https://<yourdomain>.daily.co/<room_url> e ouvir o bot dizer olá!

WebRTC para uso da produção

Os websockets são bons para comunicação servidor a server ou para o desenvolvimento inicial. Mas, para uso da produção, você precisará de áudio cliente-servidor para usar um protocolo projetado para transporte de mídia em tempo real. (Para uma explicação da diferença entre Websockets e WebRTC, consulte este post.)

Uma maneira de subir e funcionar rapidamente com o WebRTC é se inscrever em uma conta diária de desenvolvedor. O Daily oferece SDKs e infraestrutura global para roteamento de áudio (e vídeo). Cada conta recebe 10.000 minutos de áudio/vídeo/transcrição grátis a cada mês.

Inscreva -se aqui e crie uma sala no painel do desenvolvedor.

Hacking na própria estrutura

Observe que pode ser necessário configurar um ambiente virtual antes de seguir as instruções abaixo. Por exemplo, pode ser necessário executar o seguinte a partir da raiz do repo:

python3 -m venv venv
source venv/bin/activate

Da raiz deste repositório, execute o seguinte:

pip install -r dev-requirements.txt
python -m build

Isso constrói o pacote. Para usar o pacote localmente (por exemplo, executar arquivos de amostra), execute

pip install --editable " .[option,...] "

Se você deseja usar este pacote de outro diretório, poderá executar:

pip install " path_to_this_repo[option,...] "

Testes de execução

No diretório raiz, execute:

pytest --doctest-modules --ignore-glob= " *to_be_updated* " --ignore-glob= * pipeline_source * src tests

Configurando seu editor

Este projeto usa a formatação rígida pep 8 via Ruff.

Emacs

Você pode usar o package de uso para instalar o pacote Emacs-Lazy-Ruff e configurar argumentos ruff :

( use-package lazy-ruff
  :ensure t
  :hook (( python-mode . lazy-ruff-mode))
  :config
  ( setq lazy-ruff-format-command " ruff format " )
  ( setq lazy-ruff-only-format-block t )
  ( setq lazy-ruff-only-format-region t )
  ( setq lazy-ruff-only-format-buffer t ))

ruff foi instalado no ambiente venv descrito anteriormente, para que você possa usar o PyvenV-AUTO para carregar automaticamente esse ambiente dentro do EMACS.

( use-package pyvenv-auto
  :ensure t
  :defer t
  :hook (( python-mode . pyvenv-auto-run)))

Código do Visual Studio

Instale a extensão RUFF. Em seguida, edite as configurações do usuário ( Ctrl-Shift-P Open User Settings (JSON) ) e defina-o como o formatador Python padrão e ative a formatação no Salvar:

 "[python]" : {
    "editor.defaultFormatter" : " charliermarsh.ruff " ,
    "editor.formatOnSave" : true
}

Contribuindo

Congratulamo -nos com contribuições da comunidade! Esteja você corrigindo bugs, melhorando a documentação ou adicionando novos recursos, veja como você pode ajudar: