---
title: "Utilizați ThunderPhone din Pipecat"
description: "Rulați un agent vocal ThunderPhone ca serviciu de vorbire-la-vorbire într-un flux Pipecat, cu propriul transport și propria telefonie."
---

[Pipecat](https://github.com/pipecat-ai/pipecat) este un cadru open-source
pentru construirea de agenți vocali din servicii modulare. ThunderPhone se integrează ca
un **serviciu LLM speech-to-speech**: Pipecat trimite sunetul apelantului, ThunderPhone
returnează vocea agentului, transcrierile și apelurile de funcții, iar
transportul Pipecat (Daily, LiveKit, Twilio, WebRTC, un microfon local) transmite
sunetul. Recunoașterea vorbirii, modelul lingvistic, vocea, gestionarea turelor de vorbire, 62 de
limbi și instrumentele rulează toate pe ThunderPhone.

Apelurile efectuate astfel apar în [istoricul apelurilor](/api-reference/calls) și sunt
facturate ca orice alt apel în timp real ([tarife](/ro/guides/pricing)). Nu
este implicat niciun abonament și niciun număr de telefon ThunderPhone.

## Instalare

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

Pachetul împachetează serviciul OpenAI Realtime din Pipecat, deoarece
[Realtime WebSocket](/api-reference/realtime) de la ThunderPhone utilizează același protocol. Acesta
necesită `pipecat-ai` 1.8 sau o versiune mai nouă.

## Rulați un agent salvat

Tot ce face agentul (promptul, vocea, motorul, limbile, instrumentele, mesajul de întâmpinare, verificările perioadelor de liniște) se configurează în ThunderPhone. Fluxul procesează doar sunetul. Creați agentul în tabloul de bord sau solicitați-i lui Zeus (agentul AI care creează, testează și ajustează agenții ThunderPhone) să îl configureze, apoi transmiteți aici ID-ul acestuia. Modificările implementate în ThunderPhone se aplică la următorul apel fără a modifica fluxul dumneavoastră.

```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))
```

Un agent salvat inițiază apelul conform propriului program, astfel încât serviciul nu
solicită un răspuns de deschidere de la Pipecat. Transmiteți `greet_on_connect=True` dacă
doriți totuși unul.

## Configurați sesiunea inline

Fără `agent_id`, instrucțiunile și instrumentele provin din contextul Pipecat,
la fel ca pentru OpenAI. `product` selectează motorul, iar `voice` selectează vocea
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"],
        )
    ]),
)
```

Sesiunile inline sunt controlate de client: agentul vorbește primul deoarece Pipecat
solicită un răspuns când contextul ajunge și rămâne silențios în timpul tăcerii,
cu excepția cazului în care adăugați un mesaj sau solicitați un alt răspuns.

## Opțiuni

| Argument | Semnificație |
|---|---|
| `api_key` | Cheie secretă (`sk_live_...`). Valoarea implicită este `THUNDERPHONE_API_KEY`. |
| `agent_id` | Rulați un agent salvat. Se exclude reciproc cu `product` și `voice`. |
| `product` | Motor pentru sesiuni inline: `bolt` (versiunile mai vechi `spark` și `storm` sunt încă acceptate). |
| `voice` | Numele vocii ThunderPhone pentru sesiuni inline. |
| `language` | Indiciu privind limba principală pentru sesiuni inline, de exemplu `es`. |
| `from_number`, `to_number` | Numere de înregistrat în apel când pipeline-ul deservește o linie telefonică. |
| `live_transcripts` | Transmiteți fragmente din transcrierea apelantului în timpul rostirii (facturat suplimentar). |
| `greet_on_connect` | Solicitați un prim răspuns imediat ce sesiunea este gata. |
| `end_task_on_call_ended` | Trimiteți `EndWorkerFrame` când ThunderPhone încheie apelul (activat implicit). |

## Evenimente

ThunderPhone adaugă evenimente de platformă peste protocolul în timp real. Serviciul
le transmite către handlere:

```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` este setat după ce sesiunea devine activă. Folosiți-l cu
[`GET /v1/calls/{call_id}`](/api-reference/calls) pentru a obține înregistrarea,
transcrierea și evaluarea după apel.

## Limitări

- Detectarea tururilor este realizată pe server și este mereu activă; tururile controlate de Pipecat
  (`turn_detection=False`) nu sunt acceptate.
- Funcțiile înregistrate în serviciu rulează numai pentru sesiuni inline. Un agent
  salvat își execută propriile instrumente în ThunderPhone.
- Sunetul este PCM mono pe 16 biți la 24 kHz în ambele direcții.
- Cadrele video sunt ignorate.

<Note>
Folosiți în schimb LiveKit Agents? Consultați
[Utilizați ThunderPhone din LiveKit Agents](/ro/guides/use-with-livekit).
</Note>
