सेटअप और पहला कॉल
यह एक स्वतंत्र OpenAI-संगत सेवा है, OpenAI की अपनी Codex API नहीं। इसका एकल मॉडल ओपन-वेट है, केवल टेक्स्ट के लिए है, और कोड जनरेशन, व्याख्या और रिफैक्टोरिंग जैसे कार्यों के लिए पर्याप्त रूप से अच्छा काम करता है, जिन्हें आपको अभी भी समीक्षा करना चाहिए। यदि आप पहले पृष्ठभूमि जानना चाहते हैं, तो OpenAI Codex API वाला पेज बताता है कि दोनों कैसे संबंधित हैं।
SDK को pip install openai से इंस्टॉल करें, API कुंजी पृष्ठ पर एक कुंजी बनाएं और निम्नलिखित चलाएं:
# pip install openai
from openai import OpenAI
client = OpenAI(base_url="https://api.getcodexapi.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a senior Python developer. Reply with code only, no commentary."},
{"role": "user", "content": "Write a function that parses an ISO 8601 date string and returns a datetime."},
],
temperature=0.2,
)
print(resp.choices[0].message.content)नए उपयोगकर्ताओं का $0.50 का मुफ़्त ट्रायल क्रेडिट इसी तरह के हजारों छोटे अनुरोधों को कवर करता है। तापमान 0.2 है क्योंकि कोड में कम यादृच्छिकता की आवश्यकता होती है। यदि आप उत्तर के चारों ओर एक markdown फेंस देखते हैं, तो कोड में इसे हटा दें या सिस्टम संदेश में कच्चा पाठ मांगें। बेस URL पेज, Codex API base URL, सटीक पता फिर से सूचीबद्ध करता है।
कोड के लिए प्रॉम्प्टिंग जो चलाया जा सके
कुछ आदतें किसी भी पैरामीटर से अधिक आउटपुट को बेहतर बनाती हैं।
- भाषा और संस्करण बताएं। "Python 3.11, केवल स्टैंडर्ड लाइब्रेरी" अनुमान लगाने की बहुत सी बातें हटा देता है।
- सिग्नेचर दें। फ़ंक्शन हेडर और एक डॉकस्ट्रिंग पेस्ट करें, और मॉडल से बॉडी भरने को कहें।
- एक उदाहरण इनपुट और आउटपुट दिखाएं। यह पाठ की तुलना में एज केस को बेहतर तरीके से तय करता है।
- एक ही चीज़ मांगें। फ़ंक्शन जनरेट करें, फिर दूसरे अनुरोध में टेस्ट मांगें।
- संपादन के लिए diff माँगें। पूरे फ़ाइल के रीराइट करने पर आउटपुट टोकन जलते हैं, जो इनपुट से अधिक खर्च होते हैं।
कॉन्टेक्स्ट विंडो 100,000 टोकन की है, और max_tokens वैकल्पिक है। एक कोड टास्क के लिए आप कई मॉड्यूल पेस्ट कर सकते हैं और फिर भी जवाब के लिए जगह रख सकते हैं। max_tokens सेट करना अनियंत्रित आउटपुट के खिलाफ एक सुरक्षा नेट के रूप में ही उपयोगी है।
संरचित परिणामों के लिए JSON मोड
जब कोड उत्तर का उपभोग करता है, तो JSON मोड का उपयोग करें। यह आउटपुट को वैध JSON बनाता है; यह आपका स्कीमा लागू नहीं करता है, इसलिए प्रॉम्प्ट में कुंजियों के नाम दें और उन्हें जांचें।
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.getcodexapi.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Return JSON with keys: name, args (list of strings), returns."},
{"role": "user", "content": "Describe the signature of: def clamp(x, lo, hi)."},
],
temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["name"], data["args"])इसे try/except के साथ json.loads के चारों ओर और एक अकेले पुनः प्रयास के साथ जोड़ें जो पार्स त्रुटि वापस भेजता है। व्यावहारिक रूप से यह दुर्लभ खराब प्रारूप वाली प्रतिक्रिया को संभालता है। तापमान 0 का उपयोग करें ताकि दोहराए गए चलाए जाने वाले समान हों।
टूल कॉलिंग
टूल्स के साथ आप फ़ंक्शन का वर्णन करते हैं और मॉडल तय करता है कि कब उन्हें कॉल करना है। आप फ़ंक्शन चलाते हैं, फिर tool रोल के साथ आउटपुट वापस भेजते हैं। यह हर कोडिंग एजेंट की नींव है।
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.getcodexapi.com/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "run_tests",
"description": "Run the project's test suite and return the output.",
"parameters": {
"type": "object",
"properties": {"path": {"type": "string"}},
"required": ["path"],
},
},
}]
messages = [{"role": "user", "content": "Run the tests in tests/unit and tell me what failed."}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, tool_choice="auto")
msg = first.choices[0].message
if msg.tool_calls:
call = msg.tool_calls[0]
args = json.loads(call.function.arguments)
output = "2 passed, 1 failed: test_parse_empty" # replace with a real runner
messages.append(msg)
messages.append({"role": "tool", "tool_call_id": call.id, "content": output})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)उत्पन्न कोड का परीक्षण किसी भी अन्य योगदान की तरह करें: इसे चलाएं, लिन्ट करें, और ज्ञात-अच्छे आउटपुट वाले प्रॉम्प्ट का एक छोटा सेट रखें ताकि आपको पता चले कि प्रॉम्प्ट बदलने से परिणाम खराब हो रहे हैं। संस्करणों की तुलना करते समय seed और तापमान को पिन् करें।
नोट: टूल विवरण छोटे और शाब्दिक रखें, कुछ भी चलाने से पहले तर्कों की सत्यापन करें, और मॉडल आउटपुट को सीधे शैल में न भेजें। एक लूप के लिए, tool_calls मौजूद रहने तक कॉल दोहराएं और अधिकतम कदमों की संख्या के बाद रुक जाएं। हर कदम इतिहास को फिर से भेजता है, इसलिए एक दस-कदम का रन लगभग दस गुना संदर्भ के लिए भुगतान करता है।
स्ट्रीमिंग और 429 पर रीट्राई
इंटरैक्टिव टूल्स के लिए, टोकन को आने पर स्ट्रीम करें। उपयोग स्ट्रीम के अंत में आता है, जिससे लागत लॉगिंग आसान हो जाती है।
import time
from openai import OpenAI, RateLimitError
client = OpenAI(base_url="https://api.getcodexapi.com/v1", api_key="YOUR_KEY", max_retries=0)
def ask(prompt, tries=4):
for attempt in range(tries):
try:
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
stream=True,
stream_options={"include_usage": True},
)
text = []
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
text.append(piece)
print(piece, end="", flush=True)
if chunk.usage:
print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
return "".join(text)
except RateLimitError:
time.sleep(5 * (attempt + 1))
raise RuntimeError("still rate limited")
ask("Explain Python generators in four sentences.")उस retry loop के पीछे की सीमाएँ: एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 की अनुमति देती है, और एक trial key 2 और 60 की। सीमा से अधिक होने पर आपको HTTP 429 मिलता है कोड rate_limited या concurrency के साथ। अस्थिर overload भी 429 देता है Retry-After: 5 header के साथ। उदाहरण क्लाइंट पर max_retries=0 सेट करता है ताकि आपका अपना loop wait को नियंत्रित करे। एक streamed request अपनी concurrency slot को stream खत्म होने तक पकड़े रखता है, इसलिए हमेशा stream को consume या close करें।
एक साथ कई अनुरोध चलाना
Batch jobs जैसे कि सौ फ़ंक्शन्स के लिए tests जनरेट करने के लिए एक concurrency cap की आवश्यकता होती है। एक thread pool का उपयोग करें जिसमें अधिकतम 8 workers हों एक पूर्ण key पर।
एक सरल पैटर्न ThreadPoolExecutor(max_workers=6) के चारों ओर एक फ़ंक्शन है जो ask को कॉल करता है, अन्य काम के लिए दो स्लॉट खाली छोड़ता है। ट्रायल कुंजी के साथ 2 वर्कर्स का उपयोग करें। यदि आप एक बड़ा नंबर पास करते हैं, तो API अतिरिक्त अनुरोधों को concurrency त्रुटियों के साथ उत्तर देगी, और आपका पुनः प्रयास लूप काम करने के बजाय प्रतीक्षा में समय बिताएगा। एसींक कोड के लिए, हर कॉल के चारों ओर AsyncOpenAI का उपयोग asyncio.Semaphore(6) के साथ करें; यह थ्रेड्स के बिना वही कैप देता है। X-RateLimit-Limit-Requests और X-RateLimit-Limit-Concurrency प्रतिक्रिया हेडर आपकी कुंजी के लिए सीमाएं दिखाते हैं।
कोडिंग वर्कलोड की लागत
कीमत 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50 है। मान लीजिए कि आप 200 फ़ंक्शंस के लिए यूनिट टेस्ट जनरेट कर रहे हैं। प्रत्येक कॉल 1,500 इनपुट टोकन भेजती है और 700 टोकन लौटाती है। इनपुट: 200 x 1,500 = 300,000 टोकन, या $0.045। आउटपुट: 200 x 700 = 140,000 टोकन, या $0.07। कुल: $0.115।
एक बड़े फ़ाइल का रीफैक्टर 30,000 टोकन इनपुट और 8,000 आउटपुट भेजता है: $0.0045 + $0.004 = $0.0085 प्रति रन। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, और क्रेडिट कभी खत्म नहीं होता। टॉप-अप $20 से शुरू होते हैं और कार्ड या क्रिप्टो से भुगतान किए जा सकते हैं, $50 से 5% बोनस, $100 से 10% और $200 से 15% मिलता है। कीमतें देखें, और पूर्ण पैरामीटर सूची के लिए दस्तावेज़ीकरण पढ़ें।
