---
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) ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ ਅਤੇ ਕਿਸੇ ਵੀ ਹੋਰ ਰੀਅਲਟਾਈਮ ਕਾਲ ਵਾਂਗ ਬਿਲ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ([ਕੀਮਤਾਂ](/pa/guides/pricing))। ਇਸ ਵਿੱਚ ਕੋਈ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਜਾਂ ThunderPhone ਫ਼ੋਨ ਨੰਬਰ ਸ਼ਾਮਲ ਨਹੀਂ ਹੁੰਦਾ।

## ਇੰਸਟਾਲ ਕਰੋ

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

ਪੈਕੇਜ Pipecat ਦੀ OpenAI Realtime ਸੇਵਾ ਨੂੰ ਰੈਪ ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ ThunderPhone ਦਾ
[Realtime WebSocket](/api-reference/realtime) ਉਹੀ ਪ੍ਰੋਟੋਕੋਲ ਬੋਲਦਾ ਹੈ। ਇਸ ਲਈ
`pipecat-ai` 1.8 ਜਾਂ ਇਸ ਤੋਂ ਨਵਾਂ ਵਰਜਨ ਚਾਹੀਦਾ ਹੈ।

## ਸੇਵ ਕੀਤਾ ਏਜੰਟ ਚਲਾਓ

ਏਜੰਟ ਜੋ ਕੁਝ ਵੀ ਕਰਦਾ ਹੈ (prompt, ਆਵਾਜ਼, ਇੰਜਣ, ਭਾਸ਼ਾਵਾਂ, ਟੂਲ, ਸਵਾਗਤ,
ਚੁੱਪੀ ਚੈੱਕ-ਇਨ) ThunderPhone ਵਿੱਚ ਕਨਫਿਗਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਪਾਈਪਲਾਈਨ ਸਿਰਫ਼ ਆਡੀਓ ਭੇਜਦੀ ਹੈ।
ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਏਜੰਟ ਬਣਾਓ, ਜਾਂ Zeus ਤੋਂ (ਉਹ AI ਏਜੰਟ ਜੋ ThunderPhone ਏਜੰਟ ਬਣਾਉਂਦਾ, ਟੈਸਟ ਕਰਦਾ
ਅਤੇ ਟਿਊਨ ਕਰਦਾ ਹੈ) ਇਸਨੂੰ ਸੈੱਟ ਕਰਵਾਓ, ਫਿਰ ਇਸਦੀ 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` ਤੋਂ ਬਿਨਾਂ, ਹਦਾਇਤਾਂ ਅਤੇ ਟੂਲ Pipecat ਕੌਂਟੈਕਸਟ ਤੋਂ ਆਉਂਦੇ ਹਨ, ਬਿਲਕੁਲ
ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ OpenAI ਲਈ ਆਉਂਦੇ ਹਨ। `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 ਵਰਤੋ](/pa/guides/use-with-livekit)।
</Note>
