---
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)ದಲ್ಲಿ ಕಾಣಿಸುತ್ತವೆ ಮತ್ತು ಇತರ ಯಾವುದೇ ನೈಜ-ಸಮಯದ ಕರೆಯಂತೆ ಬಿಲ್ ಮಾಡಲಾಗುತ್ತದೆ ([ಬೆಲೆ ನಿಗದಿ](/kn/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 ಬಳಸಿ](/kn/guides/use-with-livekit).
</Note>
