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

मुख्य बिंदु
- एक चैट कॉल एक कच्चे विचार को एक पूर्ण प्रॉम्प्ट में बदल देती है; मॉडल ID uncensored है।
- JSON मोड उन फ़ील्ड्स को लौटाता है जिन्हें आपका स्क्रिप्ट स्टोर और खोज सकता है।
- एक पूर्ण कुंजी एक साथ 8 अनुरोध और प्रति मिनट 300 चलाती है; Retry-After का उपयोग करके 429 त्रुटियों को पुनः प्रयास करें।
- API केवल पाठ लिखती है; आप प्रॉम्प्ट को अपने वीडियो या इमेज टूल में पेस्ट करते हैं।
एक LLM API प्रॉम्प्ट वर्क के लिए क्या करता है
एक LLM API जो प्रॉम्प्ट्स के लिए है, प्रॉम्प्ट वर्क के उस हिस्से में अच्छा है जो लोगों को थका देता है: तीन शब्दों के विचार को एक पूर्ण विवरण में बदलना, उसी दृश्य के दस विकल्प लिखना, या एक प्रॉम्प्ट को फिर से लिखना ताकि वह एक ब्रांड स्टाइल का पालन करे। आप एक कच्चा विचार और नियमों का सेट भेजते हैं, और आपको तैयार प्रॉम्प्ट टेक्स्ट वापस मिलता है। क्योंकि एंडपॉइंट OpenAI-कम्पैटिबल है, कोड वही चैट कॉल है जिसे आप किसी अन्य मॉडल के लिए लिखते।
पहले एक सीमा। यह सेवा केवल टेक्स्ट लौटाती है। यह वीडियो, छवियों या ऑडियो रेंडर नहीं करती है। यदि आपका अंतिम लक्ष्य एक टेक्स्ट-टू-वीडियो टूल से क्लिप बनाना है, तो API प्रॉम्प्ट लिखता है, और आप उस प्रॉम्प्ट को किसी भी जनरेटर में पेस्ट या पाइप करते हैं। यह विभाजन अपने आप में उपयोगी है, क्योंकि प्रॉम्प्ट लिखना धीमा, दोहराया जाने वाला कदम है, और टेक्स्ट टोकन सस्ते हैं।
मॉडल एक ओपन-वेट मॉडल है जिसे कानूनी वयस्कों के उपयोग के लिए बिना सेंसर जवाब देने के लिए ट्यून्ड किया गया है, इसलिए एक डार्क थ्रिलर सीन या हिंसक फंतासी बैटल के बारे में प्रॉम्प्ट-राइटिंग जॉब लेक्चर के साथ वापस बौंस नहीं होती। एक कठोर सीमा यह है कि यौन सामग्री में नाबालिगों से जुड़ा कुछ भी उत्पादित नहीं किया जाएगा।
पायथन में पहली प्रॉम्प्ट-राइटर कॉल
SDK को pip install openai के साथ इंस्टॉल करें और इसे बेस यूआरएल पर पॉइंट करें। मॉडल आईडी uncensored है, और कुंजी एक Bearer टोकन के रूप में जाती है, जिसे SDK आपके लिए संभालता है।
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
SYSTEM = (
"You write prompts for a text-to-video tool. "
"Given a rough idea, reply with one prompt of 60 to 90 words. "
"Name the subject, the camera movement, the lighting and the mood. "
"Reply with the prompt only, no preamble."
)
def expand(idea: str) -> str:
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": SYSTEM},
{"role": "user", "content": idea},
],
temperature=0.8,
max_tokens=300,
)
return resp.choices[0].message.content.strip()
print(expand("a lighthouse during a storm, seen from a drone"))
तीन विवरण इसे एक पहली कोशिश की तुलना में बेहतर बनाते हैं। सिस्टम संदेश लंबाई और उन तत्वों को परिभाषित करता है जिसे हर प्रॉम्प्ट में नामित करना चाहिए, ताकि आउटपुट तुलनीय रहें। temperature को 0.8 के आसपास सेट करने से रन के बीच विविधता मिलती है, विचार से भटकते हुए नहीं। और max_tokens यहाँ वैकल्पिक है, लेकिन 300 की सीमा एक बातूनी प्रतिक्रिया को इससे अधिक खर्च होने से रोकती है। यदि आप इसे छोड़ देते हैं, तो पूर्णता 100,000-टोकन विंडो में बचे हुए कुछ भी उपयोग कर सकती है।
यदि आप एक विचार पर दस संस्करण चाहते हैं, तो समान सेटिंग्स के साथ दस बार लूप न करें और उम्मीद न करें। या तो तापमान बढ़ाएं और हर कॉल के लिए एक अलग seed पास करें, या एक जवाब में दस नंबर वाले प्रॉम्प्ट मांगें और उन्हें कोड में विभाजित करें। दूसरा विकल्प सस्ता है क्योंकि निर्देश एक बार भेजे जाते हैं।
JSON मोड के साथ संरचित प्रॉम्प्ट लौटाएं
फ्री टेक्स्ट एक इंसान के लिए ठीक है। एक बार जब एक स्क्रिप्ट आउटपुट का उपभोग कर लेती है, तो आपको फ़ील्ड्स चाहिए। JSON मोड प्रतिक्रिया को एक वैध JSON ऑब्जेक्ट बनाता है, ताकि आप बिना एक भंगुर पार्सर लिखे प्रॉम्प्ट, उन तत्वों जिन्हें आप छोड़ना चाहते हैं और कुछ टैग पढ़ सकें। सिस्टम संदेश में JSON शब्द और आपकी अपेक्षित कुंजियाँ उल्लेख करें, और response_format सेट करें।
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{
"role": "system",
"content": (
"Return a JSON object with the keys prompt (string), "
"avoid (string) and tags (list of at most five short strings)."
),
},
{"role": "user", "content": "a night market in the rain, handheld camera"},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["prompt"])
print(data["tags"])
केवल टेक्स्ट नहीं, ऑब्जेक्ट को स्टोर करें। विचार, अंतिम प्रॉम्प्ट, टैग और तारीख के लिए कॉलम वाला एक टेबल आपको बाद में अपने इतिहास में खोजने देता है, और यह देखना आसान बनाता है कि किस निर्देशों ने उन प्रॉम्प्ट्स को उत्पादित किया जिन्हें आपने रखा।
जब आउटपुट को एक ऐसे प्रारूप का पालन करना हो जिसे JSON कैप्चर नहीं करता, जैसे लेबल वाली लाइनों का एक निश्चित क्रम, तो सिस्टम संदेश के अंदर एक ठोस उदाहरण के साथ ऐसा कहें। मॉडल अमूर्त विवरणों का पालन करने की तुलना में उदाहरणों को अधिक विश्वसनीय रूप से कॉपी करते हैं।
इंटरैक्टिव टूल्स के लिए परिणाम को स्ट्रीम करें
यदि कोई व्यक्ति परिणाम का इंतजार कर रहा है, उदाहरण के लिए एक आंतरिक प्रॉम्प्ट टूल या चैट पैनल में, तो जवाब को स्ट्रीम करें ताकि पहले शब्द तुरंत दिखाई दें। stream: true सेट करें; जवाब सर्वर-सेंट इवेंट्स के रूप में आता है, और उपयोग स्ट्रीम के अंत में रिपोर्ट किया जाता है।
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
stream = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Rewrite the user's prompt to be more specific about camera and light."},
{"role": "user", "content": "a man walking through a foggy forest"},
],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
याद रखें कि एक स्ट्रीमिंग अनुरोध स्ट्रीम समाप्त होने तक अपनी समवर्तीता स्लॉट को पकड़े रखता है। एक पूर्ण कुंजी एक साथ 8 अनुरोधों की अनुमति देती है, इसलिए आठ उपयोगकर्ता जो धीमी स्ट्रीम को एक ही समय में पढ़ रहे हैं, एक नवें को ब्लॉक कर देंगे। एक छोटे आंतरिक टूल के लिए यह पर्याप्त है। किसी भी सार्वजनिक चीज़ के लिए, अपने पक्ष पर अनुरोधों को क्यू में रखें।
रेट लिमिट के अंदर एक बैच चलाएं
सबसे अधिक समय बचाने वाले प्रॉम्प्ट-राइटिंग कार्य बैच होते हैं: 500 उत्पाद शॉट्स, एक स्क्रिप्ट से 200 दृश्य विचार, एक पूरी स्प्रेडशीट कच्ची लाइनों की। एक पूर्ण कुंजी 8 समवर्ती अनुरोधों और प्रति मिनट 300 अनुरोधों की अनुमति देती है, और एक ट्रायल कुंजी 2 और 60 की अनुमति देती है। कुंजी के बराबर थ्रेड पूल दोनों संख्याओं के भीतर रहने का सबसे सरल तरीका है।
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError
SYSTEM = "Turn the idea into one 60 to 90 word video prompt. Reply with the prompt only."
def expand(idea: str) -> str:
for attempt in range(4):
try:
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": SYSTEM},
{"role": "user", "content": idea},
],
max_tokens=300,
)
return resp.choices[0].message.content.strip()
except RateLimitError as err:
wait = int(err.response.headers.get("Retry-After", "5"))
time.sleep(wait)
raise RuntimeError("gave up on: " + idea)
ideas = ["a paper boat in a gutter", "a train crossing a salt flat", "a chef plating dessert"]
with ThreadPoolExecutor(max_workers=8) as pool:
prompts = list(pool.map(expand, ideas))
for idea, prompt in zip(ideas, prompts):
print(idea, "->", prompt[:80])
एक 429 दो चीजों का मतलब हो सकता है। एरर कोड rate_limited का मतलब है कि आपने प्रति मिनट अनुरोध सीमा पार कर ली; concurrency का मतलब है कि एक साथ बहुत सारे अनुरोध चल रहे थे। अस्थायी ओवरलोड भी एक Retry-After: 5 हेडर के साथ 429 लौटाता है। ऊपर का लूप हेडर द्वारा कहे गए समय तक इंतजार करता है और फिर से कोशिश करता है। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए एक रीट्राई लागत को दोगुना नहीं करता।
जैसे-जैसे आगे बढ़ें, परिणामों को डिस्क पर लिखें, हर पूरे प्रॉम्प्ट के लिए एक लाइन। एक JSON-लाइन्स फ़ाइल अच्छी तरह काम करती है: एक ऑब्जेक्ट प्रति लाइन जिसमें विचार, प्रॉम्प्ट और समय होता है, ताकि एक क्रैशेड रन शुरू करने पर पहले से किए गए काम को छोड़ सके। कुछ हजार कॉल्स का एक बैच अंततः एक खराब नेटवर्क मोमेंट से टकराएगा, और आप शीर्ष से फिर से शुरू नहीं करना चाहेंगे।
अपनी शैली गाइड 100k कॉन्टेक्स्ट विंडो में डालें
जब मॉडल आपके नियमों को जानता है तो प्रॉम्प्ट बेहतर हो जाते हैं। एक 100,000-टोकन विंडो के साथ, प्रॉम्प्ट और पूर्णता, आप सिस्टम संदेश में बहुत कुछ डाल सकते हैं: एक शैली गाइड, एक प्रतिबंधित वाक्यांशों की सूची, बीस अनुमोदित उदाहरण प्रॉम्प्ट्स, और एक ग्लोसरी कि आपकी टीम कैमरा मूव्स को कैसे नाम देती है।
उस स्थान का इरादे से उपयोग करें, और एक नियम को ध्यान में रखें: मॉडल जो लिखा गया है उसका पालन करता है, इसलिए नियमों को इस तरह लिखें जैसे आप एक नए सहकर्मी को ब्रीफ़ कर रहे हों। पांच उत्कृष्ट उदाहरणों की एक छोटी सूची पचास मिश्रितों से बेहतर है, क्योंकि मॉडल जो देखता है उसका औसत निकालता है। उदाहरणों को उसी प्रारूप में डालें जिसे आप वापस चाहते हैं। यदि एक प्रोजेक्ट में एक दोहराव वाला किरदार है, तो किरदार शीट एक बार लिखें, बाल, कपड़े और उम्र (केवल वयस्क किरदार) को निश्चित शब्दों में वर्णित करें, और मॉडल को उन शब्दों को हर प्रॉम्प्ट में शब्दशः कॉपी करने के लिए कहें। यह सबसे सस्ता कंसिस्टेंसी ट्रिक उपलब्ध है: हर प्रॉम्प्ट में वही वाक्यांश आता है, इसलिए डाउनस्ट्रीम जनरेटर हर बार वही विवरण देखता है।
लंबे निर्देशों को प्रत्येक कॉल के साथ फिर से भेजा जाता है, इसलिए उन्हें प्रत्येक कॉल के लिए बिल किया जाता है। प्रति मिलियन इनपुट टोकन $0.15 पर, एक 3,000-टोकन स्टाइल गाइड का खर्च केवल इनपुट के लिए प्रति अनुरोध $0.00045 है। यह छोटा है, लेकिन 10,000 अनुरोधों के पार यह $4.50 है, इसलिए जब गाइड काम कर ले तो उसे कम करें। मूल्य निर्धारण पृष्ठ पर पूर्ण दरें हैं यदि आप अपने खुद के नंबर चलाना चाहते हैं।
सामान्य समस्याएँ और उन्हें ठीक करने के तरीके
प्रॉम्प्ट-राइटिंग पाइपलाइनों में कुछ गलतियां बार-बार दिखाई देती हैं।
- आउटपुट में प्रस्तावना। "Here is your prompt:" से शुरू होने वाली प्रतिक्रियाएँ जनरेटर के अंदर आ जाती हैं। सिस्टम संदेश को "Reply with the prompt only" के साथ समाप्त करें और परिणाम को स्ट्रिप करें।
- बहुत लंबे प्रॉम्प्ट। अधिक शब्द हमेशा बेहतर वीडियो या छवियां नहीं देते। निर्देशों में शब्द सीमा सेट करें और कोड में उसकी जांच करें।
- एक ही विचार, एक ही आउटपुट। यदि आप
seedस्थिर मान के साथ पास करते हैं, तो रन दोहराए जाते हैं। विविधता चाहते हैं तो प्रति आइटम सीड बदलें या इसे छोड़ दें। - भूमिकाओं का मिश्रण। नियमों को सिस्टम संदेश में रखें और विचार को यूजर संदेश में। दोनों को एक ब्लॉक में डालने से मॉडल आपके नियमों को फिर से लिखने के लिए सामग्री मान लेता है।
- लंबे बैच में गुणवत्ता में कमी। जब एक ही निर्देशों को हजारों बार चलाया जाता है, तो गुणवत्ता खिसक सकती है। रन की शुरुआत, मध्य और अंत से आइटम की स्पॉट-चेक करें, और सिस्टम संदेश को संस्करण नियंत्रण के अंतर्गत रखें ताकि आप यह बता सकें कि किस वर्डिंग ने कौन सा बैच बनाया।
- कोई समीक्षा चरण नहीं। महंगे डाउनस्ट्रीम टूल को प्रॉम्प्ट भेजने से पहले हर बैच का नमूना पढ़ें। दस मिनट की पढ़ाई बहुत सारी बर्बाद रेंडरिंग से बचाती है।
शुरू करने के लिए, एक खाता बनाएं, API कुंजी पृष्ठ पर $0.50 का मुफ़्त ट्रायल क्रेडिट क्लेम करें और ऊपर दिया गया स्क्रिप्ट चलाएं। ट्रायल एक व्यक्ति के लिए एक बार क्लेम किया जा सकता है, 7 दिनों तक चलता है और कार्ड की आवश्यकता नहीं है। दस्तावेज़ीकरण में उन सभी पैरामीटरों की सूची है जो पास किए जाते हैं, जिनमें top_p, stop और पेनल्टीज़ शामिल हैं।
अधिक गाइड
प्रश्न और उत्तर
क्या यह API वीडियो स्वयं जनरेट कर सकता है?
नहीं। यह केवल टेक्स्ट जनरेट करता है। प्रॉम्प्ट लिखने के लिए इसका उपयोग करें, फिर उस प्रॉम्प्ट को अपनी पसंद के वीडियो टूल को दें।
मैं प्रति मिनट कितने प्रॉम्प्ट लिख सकता हूं?
एक पूर्ण कुंजी प्रति मिनट 300 अनुरोध और एक साथ 8 की अनुमति देती है। एक ट्रायल कुंजी प्रति मिनट 60 और एक साथ 2 की अनुमति देती है।
यदि आप बहुत सारे अनुरोध भेजते हैं तो क्या होता है?
आपको HTTP 429 कोड rate_limited या concurrency के साथ मिलता है। Retry-After मान के लिए प्रतीक्षा करें, फिर अनुरोध फिर से भेजें।
क्या मेरे प्रॉम्प्ट प्रशिक्षण के लिए उपयोग किए जाते हैं?
नहीं। प्रॉम्प्ट प्रशिक्षण के लिए उपयोग नहीं किए जाते हैं।
आपकी कुंजी बस एक फ़ॉर्म दूर है
एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।