Configuration et premier appel
Il s'agit d'un service indépendant compatible OpenAI, pas de l'API Codex d'OpenAI. Son modèle unique est à poids ouverts, texte uniquement, et gère bien le code pour la génération, l'explication et le refactoring, tâches que vous devez également vérifier. Si vous voulez d'abord le contexte, la page sur l'API Codex OpenAI explique comment les deux sont liés.
Installez le SDK avec pip install openai, créez une clé sur la page clé API, et exécutez :
# 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)Le crédit d'essai des nouveaux utilisateurs de 0,50 $ couvre des milliers d'appels petits comme celui-ci. La température est de 0,2 car le code bénéficie de moins d'aléa. Si vous voyez une balise markdown autour de la réponse, supprimez-la dans le code ou demandez du texte brut dans le message système. La page URL de base, URL de base de l'API Codex, liste à nouveau l'adresse exacte.
Formulation pour du code qui s'exécute
Quelques habitudes améliorent la sortie plus que n'importe quel paramètre.
- Indiquez le langage et la version. "Python 3.11, uniquement la bibliothèque standard" élimine beaucoup d'hypothèses.
- Donnez la signature. Collez l'en-tête de la fonction et sa docstring, et demandez au modèle de remplir le corps.
- Montrez un exemple d'entrée et de sortie. Cela clarifie les cas limites mieux que le texte.
- Demandez une seule chose. Générez la fonction, puis demandez les tests dans un second appel.
- Demandez un diff pour les modifications. Les réécritures de fichiers entiers consomment des tokens de sortie, qui coûtent plus cher que les tokens d'entrée.
La fenêtre de contexte est de 100 000 tokens, et max_tokens est optionnel. Pour une tâche de code, vous pouvez coller plusieurs modules et avoir encore de la place pour la réponse. Définir max_tokens est utile uniquement comme filet de sécurité contre une sortie incontrôlée.
Mode JSON pour des résultats structurés
Lorsque le code consomme la réponse, utilisez le mode JSON. Il rend la sortie JSON valide ; il n'impose pas votre schéma, nommez donc les clés dans le prompt et vérifiez-les.
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"])Associez cela à un try/except autour de json.loads et à une seule tentative qui renvoie l'erreur d'analyse. En pratique, cela gère la réponse malformée rare. Utilisez une température de 0 pour que les exécutions répétées correspondent.
Appel de fonctions
Avec les outils, vous décrivez des fonctions et le modèle décide quand les appeler. Vous exécutez la fonction, puis renvoyez la sortie avec le rôle tool. C'est la base de chaque agent de codage.
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)Testez le code généré comme toute autre contribution : exécutez-le, lintez-le et gardez une petite suite de prompts avec des sorties connues pour remarquer quand un changement de prompt dégrade les résultats. Épinglez seed et la température pendant que vous comparez les versions.
Notes : gardez les descriptions d'outils courtes et littérales, validez les arguments avant d'exécuter quoi que ce soit, et ne passez jamais la sortie du modèle directement dans un shell. Pour une boucle, répétez l'appel tant que tool_calls est présent et arrêtez après un nombre maximum d'étapes. Chaque étape renvoie l'historique, donc une exécution en dix étapes paie pour environ dix fois le contexte.
Streaming et nouvelle tentative sur 429
Pour les outils interactifs, diffusez les tokens à leur arrivée. L'utilisation arrive à la fin du flux, ce qui facilite la journalisation des coûts.
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.")Les limites derrière cette boucle de tentative : une clé complète permet 8 requêtes simultanées et 300 par minute, et une clé d'essai 2 et 60. Au-delà d'une limite, vous obtenez HTTP 429 avec le code rate_limited ou concurrency. Une surcharge temporaire donne également 429 avec un en-tête Retry-After: 5. L'exemple définit max_retries=0 sur le client pour que votre propre boucle contrôle les attentes. Une demande en flux occupe sa place de concurrence jusqu'à ce que le flux se termine, alors consommez ou fermez toujours le flux.
Exécuter de nombreuses requêtes simultanément
Les tâches par lots comme la génération de tests pour cent fonctions nécessitent une limite de concurrence. Utilisez un pool de threads avec au plus 8 exécutants sur une clé complète.
Un modèle simple est ThreadPoolExecutor(max_workers=6) autour d'une fonction qui appelle ask, laissant deux emplacements libres pour d'autres travaux. Avec la clé d'essai, utilisez 2 workers. Si vous passez un nombre plus grand, l'API répondra aux demandes supplémentaires avec des erreurs concurrency, et votre boucle de tentative passera du temps à attendre au lieu de travailler. Pour le code asynchrone, utilisez AsyncOpenAI avec un asyncio.Semaphore(6) autour de chaque appel ; cela donne la même limite sans threads. Les en-têtes de réponse X-RateLimit-Limit-Requests et X-RateLimit-Limit-Concurrency montrent les limites pour votre clé.
Coût des charges de travail de codage
Le prix est de $0,15 par 1M de tokens d'entrée et de $0,50 par 1M de tokens de sortie. Disons que vous générez des tests unitaires pour 200 fonctions. Chaque appel envoie 1 500 tokens d'entrée et retourne 700 tokens. Entrée : 200 x 1 500 = 300 000 tokens, soit $0,045. Sortie : 200 x 700 = 140 000 tokens, soit $0,07. Total : $0,115.
Un refactoring d'un gros fichier envoie 30 000 tokens en entrée et 8 000 en sortie : $0,0045 + $0,004 = $0,0085 par exécution. Les demandes échouées ou refusées ne sont pas facturées, et le crédit n'expire jamais. Les recharges commencent à 20 $ et peuvent être payées par carte ou crypto, avec un bonus de 5 % à partir de 50 $, 10 % à partir de 100 $ et 15 % à partir de 200 $. Voir tarifs, et lisez la documentation pour la liste complète des paramètres.
