---
title: "Używaj ThunderPhone z Pipecat"
description: "Uruchom głosowego agenta ThunderPhone jako usługę mowa-mowa w pipeline Pipecat, korzystając z własnego transportu i telefonii."
---

[Pipecat](https://github.com/pipecat-ai/pipecat) to otwartoźródłowy framework
do tworzenia agentów głosowych z komponowalnych usług. ThunderPhone integruje się jako
**usługa LLM speech-to-speech**: Pipecat wysyła dźwięk rozmówcy, ThunderPhone
zwraca głos agenta, transkrypcje i wywołania funkcji, a transport Pipecat
(Daily, LiveKit, Twilio, WebRTC, lokalny mikrofon) przesyła
dźwięk. Rozpoznawanie mowy, model językowy, głos, rozpoznawanie zmian tury, 62
języki i narzędzia działają w ThunderPhone.

Połączenia realizowane w ten sposób pojawiają się w [historii połączeń](/api-reference/calls) i są
rozliczane jak każde inne połączenie w czasie rzeczywistym ([cennik](/pl/guides/pricing)). Nie
wymagają subskrypcji ani numeru telefonu ThunderPhone.

## Instalacja

```bash
pip install pipecat-thunderphone
export THUNDERPHONE_API_KEY=sk_live_...   # a secret API key
```

Pakiet opakowuje usługę OpenAI Realtime w Pipecat, ponieważ [Realtime WebSocket](/api-reference/realtime)
ThunderPhone korzysta z tego samego protokołu. Wymaga `pipecat-ai` 1.8 lub nowszego.

## Uruchom zapisanego agenta

Wszystko, co robi agent (prompt, głos, silnik, języki, narzędzia, powitanie,
sprawdzanie ciszy), jest konfigurowane w ThunderPhone. Pipeline jedynie przesyła dźwięk.
Utwórz agenta w panelu lub zleć jego konfigurację Zeusowi (agentowi AI, który tworzy, testuje
i dostraja agentów ThunderPhone), a następnie przekaż tutaj jego identyfikator. Zmiany wdrożone
w ThunderPhone zostaną zastosowane przy następnym połączeniu bez modyfikowania pipeline'u.

```python
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.worker import PipelineParams, PipelineWorker
from pipecat.processors.aggregators.llm_context import LLMContext
from pipecat.processors.aggregators.llm_response_universal import LLMContextAggregatorPair
from pipecat_thunderphone import ThunderPhoneRealtimeLLMService

llm = ThunderPhoneRealtimeLLMService(agent_id=12)

context = LLMContext()
aggregators = LLMContextAggregatorPair(context)
pipeline = Pipeline([
    transport.input(),
    aggregators.user(),
    llm,
    aggregators.assistant(),
    transport.output(),
])
worker = PipelineWorker(pipeline, params=PipelineParams(allow_interruptions=True))
```

Zapisany agent rozpoczyna połączenie zgodnie z własnym harmonogramem, więc usługa nie
żąda od Pipecat odpowiedzi otwierającej. Przekaż `greet_on_connect=True`, jeśli
mimo to chcesz ją uzyskać.

## Skonfiguruj sesję bezpośrednio w kodzie

Bez `agent_id` instrukcje i narzędzia pochodzą z kontekstu Pipecat, tak
jak w przypadku OpenAI. `product` wybiera silnik, a `voice` wybiera głos
ThunderPhone.

```python
from pipecat.adapters.schemas.function_schema import FunctionSchema
from pipecat.adapters.schemas.tools_schema import ToolsSchema
from pipecat.services.llm_service import FunctionCallParams

llm = ThunderPhoneRealtimeLLMService(product="bolt", voice="olivia", language="es")

async def check_availability(params: FunctionCallParams):
    slots = await calendar.free_slots(params.arguments["date"])
    await params.result_callback({"slots": slots})

llm.register_function("check_availability", check_availability)

context = LLMContext(
    messages=[{"role": "system", "content": "You are Acme Dental's receptionist."}],
    tools=ToolsSchema(standard_tools=[
        FunctionSchema(
            name="check_availability",
            description="Free appointment slots on a date",
            properties={"date": {"type": "string"}},
            required=["date"],
        )
    ]),
)
```

Sesje konfigurowane bezpośrednio w kodzie są sterowane przez klienta: agent
mówi pierwszy, ponieważ Pipecat żąda odpowiedzi po otrzymaniu kontekstu, i pozostaje
cichy podczas ciszy, chyba że dodasz wiadomość lub zażądasz kolejnej odpowiedzi.

## Opcje

| Argument | Znaczenie |
|---|---|
| `api_key` | Tajny klucz (`sk_live_...`). Domyślnie używany jest `THUNDERPHONE_API_KEY`. |
| `agent_id` | Uruchom zapisanego agenta. Wzajemnie wykluczające się z `product` i `voice`. |
| `product` | Silnik dla sesji wbudowanych: `bolt` (starsze `spark` i `storm` są nadal obsługiwane). |
| `voice` | Nazwa głosu ThunderPhone dla sesji wbudowanych. |
| `language` | Wskazówka dotycząca głównego języka dla sesji wbudowanych, np. `es`. |
| `from_number`, `to_number` | Numery do zarejestrowania w połączeniu, gdy potok obsługuje linię telefoniczną. |
| `live_transcripts` | Przesyłaj fragmenty transkrypcji rozmówcy w trakcie wypowiedzi (dodatkowo płatne). |
| `greet_on_connect` | Zażądaj pierwszej odpowiedzi, gdy tylko sesja będzie gotowa. |
| `end_task_on_call_ended` | Wyślij `EndWorkerFrame`, gdy ThunderPhone zakończy połączenie (domyślnie włączone). |

## Zdarzenia

ThunderPhone dodaje zdarzenia platformy do protokołu czasu rzeczywistego. Usługa
przekazuje je do procedur obsługi:

```python
@llm.event_handler("on_call_ended")
async def on_call_ended(service, event):
    print("call ended:", event["reason"], "call id:", service.call_id)
```

`service.call_id` jest ustawiane, gdy sesja jest aktywna. Użyj go z
[`GET /v1/calls/{call_id}`](/api-reference/calls), aby pobrać nagranie,
transkrypcję i ocenę po połączeniu.

## Limity

- Wykrywanie tur odbywa się po stronie serwera i jest zawsze włączone; tury
  sterowane przez Pipecat (`turn_detection=False`) nie są obsługiwane.
- Funkcje zarejestrowane w usłudze działają tylko w sesjach inline. Zapisany
  agent uruchamia własne narzędzia w ThunderPhone.
- Dźwięk to 16-bitowy monofoniczny PCM o częstotliwości 24 kHz w obu kierunkach.
- Klatki wideo są ignorowane.

<Note>
Tworzysz rozwiązanie na podstawie LiveKit Agents? Zobacz
[Używanie ThunderPhone z LiveKit Agents](/pl/guides/use-with-livekit).
</Note>
