---
title: "Pipecat నుండి ThunderPhone ఉపయోగించండి"
description: "మీ స్వంత ట్రాన్స్‌పోర్ట్ మరియు టెలిఫోనీతో, Pipecat పైప్‌లైన్‌లో స్పీచ్-టు-స్పీచ్ సేవగా ThunderPhone వాయిస్ ఏజెంట్‌ను నడపండి."
---

[Pipecat](https://github.com/pipecat-ai/pipecat) అనేది కాంపోజ్ చేయగల సేవలతో వాయిస్ ఏజెంట్లను రూపొందించడానికి ఓపెన్-సోర్స్ ఫ్రేమ్‌వర్క్. ThunderPhone ఒక **స్పీచ్-టు-స్పీచ్ LLM సేవ**గా అనుసంధానమవుతుంది: Pipecat కాలర్ ఆడియోను పంపుతుంది, ThunderPhone ఏజెంట్ వాయిస్, ట్రాన్స్‌క్రిప్ట్‌లు, ఫంక్షన్ కాల్‌లను తిరిగి అందిస్తుంది, మరియు Pipecat ట్రాన్స్‌పోర్ట్‌ (Daily, LiveKit, Twilio, WebRTC, స్థానిక మైక్రోఫోన్) ఆడియోను నిర్వహిస్తుంది. స్పీచ్ రికగ్నిషన్, లాంగ్వేజ్ మోడల్, వాయిస్, టర్న్-టేకింగ్, 62 భాషలు మరియు టూల్స్ అన్నీ ThunderPhoneలోనే నడుస్తాయి.

ఈ విధంగా చేసిన కాల్‌లు [కాల్ చరిత్రలో](/api-reference/calls) కనిపిస్తాయి మరియు ఇతర రియల్‌టైమ్ కాల్‌ల మాదిరిగానే బిల్ చేయబడతాయి ([ధరలు](/te/guides/pricing)). ఇందులో ఎలాంటి సబ్‌స్క్రిప్షన్ లేదా ThunderPhone ఫోన్ నంబర్ ఉండదు.

## ఇన్‌స్టాల్ చేయండి

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

ThunderPhone యొక్క [Realtime WebSocket](/api-reference/realtime) అదే ప్రోటోకాల్‌ను ఉపయోగిస్తున్నందున, ఈ ప్యాకేజ్ Pipecat యొక్క OpenAI Realtime సేవను ర్యాప్ చేస్తుంది. దీనికి `pipecat-ai` 1.8 లేదా అంతకంటే కొత్త వెర్షన్ అవసరం.

## సేవ్ చేసిన ఏజెంట్‌ను అమలు చేయండి

ఏజెంట్ చేసే ప్రతిదీ (prompt, వాయిస్, ఇంజిన్, భాషలు, టూల్స్, అభివాదం,
నిశ్శబ్ద తనిఖీలు) ThunderPhoneలో కాన్ఫిగర్ చేయబడుతుంది. పైప్‌లైన్ ఆడియోను మాత్రమే తరలిస్తుంది.
డ్యాష్‌బోర్డ్‌లో ఏజెంట్‌ను రూపొందించండి లేదా ThunderPhone ఏజెంట్‌లను రూపొందించి, పరీక్షించి, ట్యూన్ చేసే AI ఏజెంట్ అయిన Zeusతో దాన్ని సెటప్ చేయించండి, ఆపై దాని IDని ఇక్కడ పాస్ చేయండి. మీరు ThunderPhoneలో డిప్లాయ్ చేసే మార్పులు మీ పైప్‌లైన్‌ను మార్చాల్సిన అవసరం లేకుండానే తదుపరి కాల్‌కు వర్తిస్తాయి.

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

సేవ్ చేసిన ఏజెంట్ తన సొంత షెడ్యూల్ ప్రకారం కాల్‌ను ప్రారంభిస్తుంది, కాబట్టి ఈ సేవ Pipecat నుండి ప్రారంభ ప్రతిస్పందనను అభ్యర్థించదు. అయినప్పటికీ మీకు అది కావాలంటే `greet_on_connect=True`ను పంపండి.

## సెషన్‌ను ఇన్‌లైన్‌లో కాన్ఫిగర్ చేయండి

`agent_id` లేకుండా, OpenAI కోసం చేసినట్లే సూచనలు మరియు టూల్స్ Pipecat కాంటెక్స్ట్ నుండి వస్తాయి. `product` ఇంజిన్‌ను ఎంచుకుంటుంది, `voice` 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"],
        )
    ]),
)
```

ఇన్‌లైన్ సెషన్‌లు క్లయింట్-నియంత్రితమైనవి: కాంటెక్స్ట్ వచ్చినప్పుడు Pipecat ప్రతిస్పందనను అభ్యర్థిస్తుంది కాబట్టి ఏజెంట్ ముందుగా మాట్లాడుతుంది; మీరు సందేశాన్ని జోడించే వరకు లేదా మరొక ప్రతిస్పందనను అభ్యర్థించే వరకు నిశ్శబ్ద సమయంలో మౌనంగా ఉంటుంది.

## ఎంపికలు

| ఆర్గ్యుమెంట్ | అర్థం |
|---|---|
| `api_key` | రహస్య కీ (`sk_live_...`). డిఫాల్ట్‌గా `THUNDERPHONE_API_KEY`ను ఉపయోగిస్తుంది. |
| `agent_id` | సేవ్ చేసిన ఏజెంట్‌ను అమలు చేయండి. `product`, `voice`తో పరస్పర విరుద్ధం. |
| `product` | ఇన్‌లైన్ సెషన్ల కోసం ఇంజిన్: `bolt` (పాత `spark`, `storm` ఇప్పటికీ ఆమోదించబడతాయి). |
| `voice` | ఇన్‌లైన్ సెషన్ల కోసం ThunderPhone వాయిస్ పేరు. |
| `language` | ఇన్‌లైన్ సెషన్ల కోసం ప్రాథమిక భాష సూచన, ఉదాహరణకు `es`. |
| `from_number`, `to_number` | పైప్‌లైన్ ఫోన్ లైన్‌కు ముందు ఉన్నప్పుడు కాల్‌లో నమోదు చేయాల్సిన నంబర్లు. |
| `live_transcripts` | పలుకుబడి మధ్యలో కాలర్ ట్రాన్స్‌క్రిప్ట్ భాగాలను స్ట్రీమ్ చేయండి (అదనపు బిల్లింగ్ ఉంటుంది). |
| `greet_on_connect` | సెషన్ సిద్ధమైన వెంటనే మొదటి ప్రతిస్పందనను అభ్యర్థించండి. |
| `end_task_on_call_ended` | ThunderPhone కాల్‌ను ముగించినప్పుడు `EndWorkerFrame`ను పంపండి (డిఫాల్ట్‌గా ఆన్‌లో ఉంటుంది). |

## ఈవెంట్‌లు

ThunderPhone రియల్‌టైమ్ ప్రోటోకాల్‌కు అదనంగా ప్లాట్‌ఫార్మ్ ఈవెంట్‌లను జోడిస్తుంది. సేవ వాటిని హ్యాండ్లర్‌లకు అందిస్తుంది:

```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` సెట్ అవుతుంది. కాల్ తర్వాత రికార్డింగ్,
ట్రాన్స్‌క్రిప్ట్ మరియు గ్రేడ్‌ను పొందడానికి దీన్ని
[`GET /v1/calls/{call_id}`](/api-reference/calls)తో ఉపయోగించండి.

## పరిమితులు

- టర్న్ డిటెక్షన్ సర్వర్-సైడ్‌లో ఉంటుంది మరియు ఎల్లప్పుడూ ఆన్‌లో ఉంటుంది; Pipecat ఆధారిత టర్న్‌లు
  (`turn_detection=False`)కు మద్దతు లేదు.
- సేవపై రిజిస్టర్ చేసిన ఫంక్షన్‌లు ఇన్‌లైన్ సెషన్‌లకే అమలవుతాయి. సేవ్ చేసిన
  ఏజెంట్ ThunderPhoneలో దాని స్వంత టూల్స్‌ను అమలు చేస్తుంది.
- ఆడియో రెండు దిశల్లోనూ 24 kHz వద్ద 16-బిట్ మోనో PCMగా ఉంటుంది.
- వీడియో ఫ్రేమ్‌లు విస్మరించబడతాయి.

<Note>
బదులుగా LiveKit Agentsతో నిర్మిస్తున్నారా? చూడండి
[LiveKit Agents నుండి ThunderPhone ఉపయోగించండి](/te/guides/use-with-livekit).
</Note>
