Integrationen

KugelAudio Text-to-Speech für Pipecat

KugelAudio stellt einen offiziellen TTS-Service für Pipecat bereit. Setzen Sie KugelAudioTTSService an die Stelle der TTS-Stufe Ihrer Pipeline, der Rest des Bots bleibt unverändert.

Kostenlos startenZur vollständigen Anleitung

So funktioniert es

Was die Integration leistet

  • Ein TTSService zum Einsetzen

    Er erzeugt die üblichen Pipecat-Frames und passt damit in jede Pipeline auf Basis von Pipecat 0.x oder 1.x.

  • Wiederverwendete Verbindung

    Rufen Sie prewarm() in Ihrem asynchronen Setup auf. Der Service nutzt eine WebSocket-Verbindung über alle Gesprächszüge und verbindet sich bei Abbruch neu.

  • Metriken inklusive

    Pipecat-TTFB und Zeichenverbrauch werden automatisch gemeldet. KugelAudioEnhanceFilter entfernt Hintergrundgeräusche am Eingang.

Code

Ein lokaler Voice Bot

Mikrofon rein, Deepgram STT, OpenAI LLM, KugelAudio TTS, Lautsprecher raus. Setzen Sie KUGELAUDIO_API_KEY, DEEPGRAM_API_KEY und OPENAI_API_KEY und starten Sie 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())

Übernommen aus der Dokumentation unter docs.kugelaudio.com/integrations/pipecat. Zur vollständigen Anleitung

Integrationen

Weitere Integrationen

Alle Integrationen

Geben Sie Ihrem Agenten eine KugelAudio-Stimme

Konto anlegen, API-Schlüssel im Dashboard kopieren, Stimme auswählen. Alle Integrationen auf dieser Seite nutzen dieselbe API.

Kostenlos starten