Configurazione e prima chiamata
Questo è un servizio indipendente compatibile con OpenAI, non l'API Codex ufficiale di OpenAI. Il suo modello singolo è open-weight, solo testo e gestisce bene il codice per generazione, spiegazione e refactoring, ma dovresti comunque revisionare i risultati. Se vuoi prima il contesto, la pagina sull'API Codex OpenAI spiega come si relazionano.
Installa l'SDK con pip install openai, crea una chiave nella pagina delle chiavi API e esegui:
# 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)Il credito di prova per i nuovi utenti di $0,50 copre migliaia di chiamate piccole come questa. La temperatura è 0,2 perché il codice beneficia di meno casualità. Se vedi un blocco markdown intorno alla risposta, rimuovilo nel codice o chiedi nel system message il testo grezzo. La pagina del base URL, base URL API Codex, elenca di nuovo l'indirizzo esatto.
Prompting per codice eseguibile
Alcune abitudini migliorano l'output più di qualsiasi parametro.
- Indica il linguaggio e la versione. "Python 3.11, solo libreria standard" elimina molte ipotesi.
- Fornisci la firma. Incolla l'intestazione della funzione e il docstring, e chiedi al modello di compilare il corpo.
- Mostra un esempio di input e output. Fissa i casi limite meglio del testo.
- Chiedi una cosa. Genera la funzione, poi chiedi i test in una seconda chiamata.
- Richiedi un diff per le modifiche. Le riscritture di file interi consumano token di output, che costano più degli input.
La finestra di contesto è di 100.000 token e max_tokens è opzionale. Per un compito di codice puoi incollare diversi moduli e avere ancora spazio per la risposta. Impostare max_tokens è utile solo come rete di sicurezza contro output incontrollati.
Modalità JSON per risultati strutturati
Quando il codice consuma la risposta, usa la modalità JSON. Rende l'output JSON valido; non impone il tuo schema, quindi nomina le chiavi nel prompt e verificale.
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"])Abbina questo a un blocco try/except intorno a json.loads e a un singolo ritentativo che invia indietro l'errore di parsing. In pratica gestisci le risposte malformate rare. Usa temperature 0 in modo che le esecuzioni ripetute corrispondano.
Chiamata di funzioni
Con gli strumenti descrivi le funzioni e il modello decide quando chiamarle. Esegui la funzione, poi invia l'output indietro con il ruolo tool. Questa è la base di ogni agente di codifica.
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)Testa il codice generato come qualsiasi altro contributo: eseguilo, lintalo e mantieni una piccola suite di prompt con output noti come corretti così noti quando un cambiamento nel prompt peggiora i risultati. Blocca seed e la temperatura mentre confronti le versioni.
Note: mantieni le descrizioni degli strumenti brevi e letterali, valida gli argomenti prima di eseguire qualsiasi cosa e non passare mai l'output del modello direttamente in una shell. Per un loop, ripeti la chiamata finché tool_calls è presente e fermati dopo un numero massimo di passaggi. Ogni passaggio reinvia la cronologia, quindi un'esecuzione di dieci passaggi paga per circa dieci volte il contesto.
Streaming e retry su 429
Per gli strumenti interattivi, invia in streaming i token man mano che arrivano. L'utilizzo viene fornito alla fine dello streaming, il che semplifica la registrazione dei costi.
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.")I limiti dietro questo ciclo di ritentativi: una chiave completa consente 8 richieste concorrenti e 300 al minuto, mentre una chiave di prova 2 e 60. Superato un limite ricevi HTTP 429 con codice rate_limited o concurrency. Anche un sovraccarico temporaneo restituisce 429 con l'intestazione Retry-After: 5. L'esempio imposta max_retries=0 sul client in modo che sia il tuo loop a controllare le attese. Una richiesta streaming mantiene il suo slot di concorrenza fino al termine dello stream, quindi consuma o chiudi sempre lo stream.
Esecuzione di molte richieste in parallelo
I lavori batch come la generazione di test per cento funzioni necessitano di un limite di concorrenza. Usa un pool di thread con al massimo 8 worker con una chiave completa.
Un semplice schema è ThreadPoolExecutor(max_workers=6) attorno a una funzione che chiama ask, lasciando due slot liberi per altri lavori. Con la chiave di prova usa 2 worker. Se passi un numero più grande, l'API risponderà alle richieste extra con errori concurrency, e il tuo ciclo di retry impiegherà tempo in attesa invece che a lavorare. Per il codice asincrono, usa AsyncOpenAI con un asyncio.Semaphore(6) attorno a ogni chiamata; questo offre lo stesso limite senza thread. Le intestazioni di risposta X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency mostrano i limiti per la tua chiave.
Costo dei carichi di lavoro di codifica
Il prezzo è $0,15 per 1M token di input e $0,50 per 1M token di output. Supponi di generare test unitari per 200 funzioni. Ogni chiamata invia 1.500 token di input e restituisce 700 token. Input: 200 x 1.500 = 300.000 token, o $0,045. Output: 200 x 700 = 140.000 token, o $0,07. Totale: $0,115.
Un refactoring di un file grande invia 30.000 token in input e 8.000 in output: $0,0045 + $0,004 = $0,0085 per esecuzione. Le richieste fallite o rifiutate non vengono addebitate e il credito non scade mai. I ricarichi partono da $20 e possono essere pagati con carta o cripto, con un bonus del 5% da $50, 10% da $100 e 15% da $200. Vedi prezzi e leggi la documentazione per l'elenco completo dei parametri.
