TTS API डेमो: लाइव अनुरोध और प्रतिक्रिया उदाहरण

कुछ भी चलाने से पहले

उन सभी के लिए एक स्पष्ट चेतावनी जो बस 'प्ले' बटन दबाकर आवाज़ सुनना चाहते हैं: यह tts API डेमो कोई आवाज़ नहीं देता। सेवा uncensored मॉडल से टेक्स्ट लौटाती है, POST /v1/chat/completions के माध्यम से। एक दूसरा एंडपॉइंट, GET /v1/models, उपलब्ध विकल्पों की सूची प्राप्त करने के लिए है। ऑडियो, छवियाँ या एम्बेडिंग्स कोई नहीं लौटते।

फिर डेमो क्यों? क्योंकि कई स्पीच प्रोजेक्ट्स को बिल्कुल इसी हिस्से की आवश्यकता होती है: एक पाठ लेखक, एक पाठ शुद्धकर्ता, एक विभाजक जो यह तय करता है कि कौन क्या बोल रहा है। नीचे दिए गए उदाहरण उन कार्यों को दिखाते हैं, और आउटपुट प्रारूप वह है जिसे आपकी स्पीच कोड पार्स करेगी।

आपको एक कुंजी की ज़रूरत है। Google या ईमेल और पासवर्ड से API कुंजी पेज पर साइन अप करें, फिर एक क्लिक से $0.50 का मुफ़्त ट्रायल क्रेडिट क्लेम करें। यह 7 दिनों के लिए मान्य है और कार्ड की ज़रूरत नहीं है। कुंजी को एक्सपोर्ट करें ताकि नीचे दिए गए कमांड इसे पढ़ सकें:

Copyexport XTTS_API_KEY="paste-your-key-here"
curl -s https://api.xtts.cc/v1/models -H "Authorization: Bearer $XTTS_API_KEY" | grep uncensored

यदि वह कॉल एक JSON सूची लौटाती है जिसमें uncensored शामिल है, तो कुंजी काम कर रही है और आप आगे बढ़ सकते हैं।

डेमो 1: एक साधारण अनुरोध

सबसे छोटा उपयोगी कॉल एक छोटे, बोलने के शैली वाले पैराग्राफ के लिए पूछता है:

Copycurl -s https://api.xtts.cc/v1/chat/completions \
  -H "Authorization: Bearer $XTTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You write short lines for a voice actor. No stage directions."},
      {"role": "user", "content": "Welcome listeners to a show about lighthouses. Two sentences."}
    ],
    "temperature": 0.7,
    "max_tokens": 120
  }'

जवाब नीचे दिए गए नमूने जैसा दिखता है। content के अंदर का टेक्स्ट हर रन पर अलग होगा, इसलिए इसे संरचना का एक उदाहरण मानें, रिकॉर्डेड आउटपुट नहीं।

Copy{
  "id": "chatcmpl-example",
  "object": "chat.completion",
  "model": "uncensored",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Welcome to the show. Tonight we climb the stairs of the world's loneliest lighthouses."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {"prompt_tokens": 38, "completion_tokens": 21, "total_tokens": 59}
}

आपका स्पीच कोड choices[0].message.content पढ़ता है। finish_reason बताता है कि जनरेशन क्यों समाप्त हुआ: stop प्राकृतिक अंत के लिए, length यदि max_tokens इसे बीच में काट दे। यदि आप max_tokens छोड़ देते हैं, तो पूर्णता 100,000-टोकन विंडो के शेष हिस्से का उपयोग कर सकती है, जो प्रॉम्प्ट और पूर्णता दोनों को कवर करती है।

हेडर्स आपको क्या बताते हैं

curl कमांड में -i जोड़ें और आप X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests और X-RateLimit-Limit-Concurrency देखेंगे। बैलेंस हेडर डेमो में उपयोगी है क्योंकि आप हर कॉल के बाद इसके गिरने की नज़र रख सकते हैं। इस अनुरोध के लिए ऊपर बताई गई उपयोग मात्रा 38 x $0.15 / 1,000,000 जमा 21 x $0.50 / 1,000,000 के बराबर है, जो $0.0000057 जमा $0.0000105 है, लगभग $0.0000162।

डेमो 2: स्क्रिप्ट को स्ट्रीम करना

ऑडियो के लिए आप अक्सर पूरे टेक्स्ट का इंतज़ार नहीं करना चाहते। "stream": true जोड़ें और API सर्वर-सेंट इवेंट्स भेजता है, एक बार में एक छोटा टेक्स्ट टुकड़ा। नीचे दिया गया Node उदाहरण आने वाले टेक्स्ट को प्रिंट करता है, जहाँ आप एक वाक्य कतार (queue) भेज सकते हैं।

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.xtts.cc/v1",
  apiKey: process.env.XTTS_API_KEY,
});

const stream = await client.chat.completions.create({
  model: "uncensored",
  stream: true,
  messages: [
    { role: "user", content: "Read a four-line weather report for a coastal town." },
  ],
});

for await (const chunk of stream) {
  const piece = chunk.choices[0]?.delta?.content ?? "";
  process.stdout.write(piece);
}
process.stdout.write("\n");

इसे ES मॉड्यूल के रूप में चलाएँ (demo.mjs के रूप में सेव करें और npm install openai के बाद node demo.mjs चलाएँ)। वायर पर हर इवेंट एक लाइन होती है जो data: से शुरू होती है, उसके बाद JSON आता है, और स्ट्रीम एक अंतिम मार्कर के साथ बंद होती है। स्ट्रीम के अंत में टोकन उपयोग की रिपोर्ट की जाती है। योजना बनाने के लिए एक बात मायने रखती है: एक स्ट्रीम किए गए अनुरोध में कन्करेंसी स्लॉट तब तक बना रहता है जब तक स्ट्रीम ख़त्म न हो जाए, इसलिए एक धीमा कन्ज़्यूमर आपके अगले अनुरोध को ब्लॉक कर सकता है।

डेमो 3: टूल कॉलिंग को स्पीच राउटर के रूप में उपयोग करना

टूल कॉलिंग मॉडल को प्रॉज़ के बजाय एक संरचित निर्देश वापस करने देती है। एक वॉयस प्रोजेक्ट में यह एक साफ़ तरीका है लाइन-दर-लाइन डिलीवरी शैली चुनने का। आप say नाम का एक फ़ंक्शन परिभाषित करते हैं, और मॉडल उसके आर्गुमेंट्स भरता है। आपकी कोड फिर तय करती है कि उनसे क्या करना है। मॉडल स्वयं कुछ भी नहीं चलाता।

Copyimport json
import os
from openai import OpenAI

client = OpenAI(base_url="https://api.xtts.cc/v1", api_key=os.environ["XTTS_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "say",
        "description": "Queue one line for the voice engine.",
        "parameters": {
            "type": "object",
            "properties": {
                "text": {"type": "string"},
                "style": {"type": "string", "enum": ["calm", "urgent", "whisper"]},
            },
            "required": ["text", "style"],
        },
    },
}]

messages = [
    {"role": "system", "content": "Always answer by calling say, once per line."},
    {"role": "user", "content": "The alarm sounds. The guard tells everyone to leave."},
]

r = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = r.choices[0].message
for call in msg.tool_calls or []:
    args = json.loads(call.function.arguments)
    print(args["style"], "->", args["text"])

आर्गुमेंट्स एक JSON स्ट्रिंग के रूप में आते हैं, इसलिए उपयोग से पहले उन्हें पार्स और वैलिडेट करें। मॉडल्स आपके एन्यूम के बाहर एक स्टाइल उत्पन्न कर सकते हैं या कोई फ़ील्ड छोड़ सकते हैं, और एक अनचेक किए गए मान को कभी भी आपके इंजन तक नहीं पहुँचना चाहिए। यदि आप बातचीत जारी रखना चाहते हैं, तो असिस्टेंट मैसेज और role: "tool" और मिलते-जुलते tool_call_id के साथ एक रिप्लाई ऐपेंड करें, फिर API को फिर से कॉल करें।

स्ट्रीमिंग के दौरान, टूल कॉल टुकड़ों में आते हैं। फ़ंक्शन का नाम पहले आता है और आर्गुमेंट स्ट्रिंग चंक्स के बीच बनती जाती है, इसलिए फ़्रैगमेंट्स को इंडेक्स द्वारा इकट्ठा करें और स्ट्रीम खत्म होने पर एक बार में पार्स करें।

डेमो 4: कास्ट लिस्ट के लिए JSON मोड

यदि आप टूल डिफ़िनिशंस को छोड़ना पसंद करते हैं, तो JSON मोड मैसेज कंटेंट में वैध JSON देता है। यह एक कच्चे दृश्य को स्पीकर-दर-लाइन में बदलने के लिए एक अच्छा विकल्प है।

Copycurl -s https://api.xtts.cc/v1/chat/completions \
  -H "Authorization: Bearer $XTTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "response_format": {"type": "json_object"},
    "temperature": 0.2,
    "messages": [
      {"role": "system", "content": "Return JSON: {\"lines\": [{\"speaker\": string, \"text\": string}]}"},
      {"role": "user", "content": "Ana asks Ben to hold the ladder. Ben agrees reluctantly."}
    ]
  }'

JSON मोड यह गारंटी देता है कि आउटपुट पार्स हो जाएगा, यह नहीं कि यह आपकी शैली से मेल खाएगा। शैली को प्रॉम्प्ट में वर्णित करें, जैसा कि ऊपर बताया गया है, और कोड में कीज़ की जाँच करें। कम टेम्परेचर संरचना को स्थिर रखता है।

डेमो 5: एक ही अनुरोध में एक लंबा दस्तावेज़

कॉन्टेक्स्ट विंडो 100,000 टोकन की है, जो प्रॉम्प्ट और पूर्णता दोनों के लिए साझा है। यह एक लंबे ट्रांसक्रिप्ट या एक पूरी छोटी कहानी भेजने और ऑडियो के लिए लिखे गए संस्करण का अनुरोध करने के लिए पर्याप्त है। अनुरोध बॉडी 8 MB तक हो सकती है, इसलिए आकार दुर्लभ ही सीमा होती है; टोकन गणना सीमा होती है।

यहाँ एक भारी कॉल की लागत है। मान लीजिए आप 80,000 टोकन भेजते हैं और 2,000 वापस पाते हैं। इनपुट: 80,000 x $0.15 / 1,000,000 = $0.012। आउटपुट: 2,000 x $0.50 / 1,000,000 = $0.001। कुल $0.013 है, इसलिए $0.50 का ट्रायल इस जैसी लगभग 38 कॉल को कवर कर सकता है। लंबे इनपुट की लागत लंबे आउटपुट की तुलना में सस्ती है, इसलिए बड़े टेक्स्ट के सारांश और रीराइट्स सस्ते हैं जबकि एक ही बार में एक पूरी नॉवेल जनरेट करना महंगा है।

लंबे इनपुट के लिए एक व्यावहारिक टिप: अपने निर्देशों को पहले रखें और अंत में मुख्य नियम दोहराएं। मॉडल्स सबसे हालिया निर्देश का सबसे अच्छा पालन करने की प्रवृत्ति रखते हैं, और 80,000 टोकन के स्रोत टेक्स्ट के बाद एक लाइन का रिमाइंडर लगभग मुफ़्त पड़ता है।

डेमो में त्रुटियों को पढ़ना

बाद में इसे पहचानने के लिए एक बार जानबूझकर कुछ तोड़ें। एक गलत कुंजी के साथ अनुरोध भेजें और आपको कंप्लीशन के बजाय एक ऑथेंटिकेशन एरर मिलेगा। एक ट्रायल कुंजी से एक ही समय में दस अनुरोध भेजें और कुछ HTTP 429 के साथ वापस आते हैं।

429 का तीन कारण हैं, और त्रुटि कोड उन्हें अलग-अलग बताता है:

• rate_limited का अर्थ है एक मिनट में बहुत अधिक अनुरोध: ट्रायल कुंजी पर 60, पूर्ण कुंजी पर 300।
• concurrency का अर्थ है एक ही समय में उड़ान में बहुत अधिक अनुरोध: ट्रायल कुंजी पर 2, पूर्ण कुंजी पर 8।
• Retry-After: 5 हेडर के साथ 429 का अर्थ है कि सेवा क्षणिक रूप से ओवरलोड थी। पाँच सेकंड प्रतीक्षा करें और इसे फिर से भेजें।

असफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए एरर्स की कोई लागत नहीं है। यह देखने के लिए कि आपकी कुंजी के पास कौन से लिमिट हैं, किसी भी सामान्य रिस्पॉन्स पर X-RateLimit-Limit-Requests और X-RateLimit-Limit-Concurrency पढ़ें। एक छोटा रीट्राई लूप जो Retry-After मान के लिए सोता है, या जब यह गायब हो तो पाँच सेकंड के लिए, एक डेमो स्क्रिप्ट को चाहिए होता है।

अगला क्या आज़माना है

जब ये चार कॉल काम कर जाएं, तो आपके पास एक स्क्रिप्ट पाइपलाइन के टुकड़े हो जाते हैं। सादे अनुरोध को एक फ़ंक्शन में लपेटें, स्ट्रीमिंग लूप को एक कतार (queue) में चलाएं, और कतार को अपनी पसंद के स्पीच इंजन से कनेक्ट करें। इंजन कीमत, लाइसेंस और गुणवत्ता में अलग-अलग होते हैं, इसलिए उनकी वर्तमान शर्तें पढ़ें। यह सेवा एक नहीं प्रदान करती और उनके बारे में कुछ भी नहीं बताती।

प्रयोग करते समय लागत छोटी रहती है। प्रति मिलियन इनपुट टोकन $0.15 और प्रति मिलियन आउटपुट टोकन $0.50 पर, एक सामान्य डेमो कॉल की लागत एक सेंट का अंश होती है, और $0.50 का ट्रायल सैकड़ों को कवर करता है। $20 से $500 तक टॉप-अप और 5% से 15% तक बोनस के लिए प्राइसिंग पेज देखें, जो क्रिप्टो से भुगतान योग्य हैं। docs में पूर्ण पैरामीटर सूची, रेट लिमिट्स (एक पूर्ण कुंजी पर 8 कन्करेंट और प्रति मिनट 300) और एरर कोड शामिल हैं। प्रॉम्प्ट्स को ट्रेनिंग के लिए उपयोग नहीं किया जाता है।

पहले दोपहर के लिए एक उचित क्रम: टोन सही होने तक सादे अनुरोध को चलाएं, स्ट्रीमिंग पर स्विच करें और वाक्यों को पूरा होने पर प्रिंट करें, फिर या तो टूल कॉल या JSON मोड जोड़ें, जो आपके स्पीच कोड के इनपुट के तरीके से मेल खाता हो। हर प्रॉम्प्ट को वर्जन कंट्रोल के तहत एक फ़ाइल में रखें। जब अंतिम ऑडियो में कोई लाइन गलत लगती है, तो आप उसे उस सटीक निर्देश तक वापस ट्रैस कर सकते हैं जिसने इसे उत्पन्न किया था और एक समय में एक चीज़ बदल सकते हैं।

अधिक गाइड

• TTS API Python: SDK का उपयोग करके स्पीच के लिए टेक्स्ट तैयार करें
• TTS API मुफ़्त: $0.50 ट्रायल क्या कवर करता है (केवल टेक्स्ट)
• वॉइस क्लोनिंग API: OpenAI कम्पैटिबल TTS