Integrazioni

Sintesi vocale KugelAudio per Pipecat

KugelAudio offre un servizio TTS ufficiale per Pipecat. Inserite KugelAudioTTSService nella fase TTS della vostra pipeline e il resto del bot rimane invariato.

Prova gratuitaLeggete la guida completa

Come funziona

Cosa fa l'integrazione

  • Un TTSService pronto da inserire

    Emette i frame standard di Pipecat, quindi si adatta a qualsiasi pipeline basata su Pipecat 0.x o 1.x.

  • Connessione riutilizzata

    Chiamate prewarm() nella configurazione asincrona e il servizio riusa un unico WebSocket per tutti i turni, riconnettendosi se cade.

  • Metriche incluse

    Il TTFB di Pipecat e l'uso dei caratteri vengono riportati in automatico. KugelAudioEnhanceFilter rimuove il rumore di fondo in ingresso.

Codice

Un bot vocale locale

Microfono in ingresso, STT Deepgram, LLM OpenAI, TTS KugelAudio, altoparlante in uscita. Impostate KUGELAUDIO_API_KEY, DEEPGRAM_API_KEY e OPENAI_API_KEY, poi eseguite python bot.py.

Install
pip install "kugelaudio[pipecat]" "pipecat-ai[deepgram,local,openai,silero]"
bot.py
import asyncio
import os

from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.frames.frames import TTSSpeakFrame
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineTask
from pipecat.processors.aggregators.llm_context import LLMContext
from pipecat.processors.aggregators.llm_response_universal import (
    LLMContextAggregatorPair,
)
from pipecat.services.deepgram.stt import DeepgramSTTService
from pipecat.services.openai.llm import OpenAILLMService
from pipecat.transports.local.audio import (
    LocalAudioTransport,
    LocalAudioTransportParams,
)

from kugelaudio.pipecat import KugelAudioTTSService


async def main():
    transport = LocalAudioTransport(
        LocalAudioTransportParams(
            audio_in_enabled=True,
            audio_out_enabled=True,
            audio_out_sample_rate=24000,
            vad_enabled=True,
            vad_analyzer=SileroVADAnalyzer(),
        )
    )
    stt = DeepgramSTTService(api_key=os.environ["DEEPGRAM_API_KEY"])
    llm = OpenAILLMService(
        api_key=os.environ["OPENAI_API_KEY"],
        settings=OpenAILLMService.Settings(
            model="gpt-4o-mini",
            system_instruction="You are a helpful voice assistant. Keep answers short.",
        ),
    )
    tts = KugelAudioTTSService(
        model="kugel-3.5",
        voice_id=1071,
        sample_rate=24000,  # must match the transport's output rate
        language="en",      # normalization language (default: the voice's)
    )
    tts.prewarm()  # needs the running event loop, so call it inside main()

    context_aggregator = LLMContextAggregatorPair(LLMContext())
    pipeline = Pipeline(
        [
            transport.input(),
            stt,
            context_aggregator.user(),
            llm,
            tts,
            transport.output(),
            context_aggregator.assistant(),
        ]
    )

    task = PipelineTask(pipeline)
    await task.queue_frames([TTSSpeakFrame("Hi! How can I help you?")])
    await PipelineRunner().run(task)


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

Copiato dalla documentazione in docs.kugelaudio.com/integrations/pipecat. Leggete la guida completa

Integrazioni

Altre integrazioni

Tutte le integrazioni

Date al vostro agente una voce KugelAudio

Create un account, copiate una chiave API dalla dashboard e scegliete una voce. Tutte le integrazioni di questa pagina usano la stessa API.

Prova gratuita