Configuração e uma primeira chamada
Este é um serviço independente compatível com OpenAI, não a própria API Codex da OpenAI. Seu único modelo é de pesos abertos, apenas texto, e é capaz de lidar bem com código o suficiente para geração, explicação e tarefas de refatoração que você ainda deve revisar. Se quiser o contexto primeiro, a página sobre a OpenAI Codex API explica como as duas se relacionam.
Instale o SDK com pip install openai, crie uma chave na página de chave de API e execute:
# 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)O crédito de teste de novos usuários de $0,50 cobre milhares de chamadas pequenas como esta. A temperatura é 0,2 porque o código se beneficia de menos aleatoriedade. Se você vir uma cerca de markdown ao redor da resposta, remova-a no código ou peça na mensagem do sistema por texto bruto. A página de URL base, Codex API base URL, lista o endereço exato novamente.
Prompting para código que executa
Alguns hábitos melhoram a saída mais do que qualquer parâmetro.
- Declare a linguagem e a versão. "Python 3.11, apenas biblioteca padrão" remove muitas suposições.
- Forneça a assinatura. Cole o cabeçalho da função e um docstring, e peça ao modelo para preencher o corpo.
- Mostre um exemplo de entrada e saída. Ele delimita melhor os casos extremos do que o texto corrido.
- Peça uma coisa. Gere a função, depois peça testes em uma segunda chamada.
- Solicite um diff para edições. Reescritas de arquivo inteiro consomem tokens de saída, que custam mais que os de entrada.
A janela de contexto tem 100.000 tokens, e max_tokens é opcional. Para uma tarefa de código, você pode colar vários módulos e ainda ter espaço para a resposta. Definir max_tokens é útil apenas como uma rede de segurança contra saída descontrolada.
Modo JSON para resultados estruturados
Quando o código consome a resposta, use o modo JSON. Isso torna a saída JSON válida; não impõe seu esquema, então nomeie as chaves no prompt e verifique-as.
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"])Associe isso a um try/except ao redor de json.loads e uma única nova tentativa que envia o erro de análise de volta. Na prática, isso lida com a resposta malformada rara. Use temperatura 0 para que execuções repetidas correspondam.
Chamada de funções
Com ferramentas, você descreve funções e o modelo decide quando chamá-las. Você roda a função e depois envia a saída de volta com o papel tool. Esta é a base de todo agente de codificação.
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)Teste o código gerado como qualquer outra contribuição: execute-o, faça lint e mantenha um pequeno conjunto de prompts com saídas conhecidas e confiáveis para notar quando uma mudança no prompt piora os resultados. Fixe seed e temperatura enquanto compara versões.
Notas: mantenha as descrições das funções curtas e literais, valide argumentos antes de rodar qualquer coisa e nunca passe a saída do modelo diretamente para um shell. Para um loop, repita a chamada enquanto tool_calls estiver presente e pare após um número máximo de etapas. Cada etapa reenvia o histórico, então uma execução de dez etapas paga por aproximadamente dez vezes o contexto.
Streaming e retentativa em 429
Para ferramentas interativas, faça streaming de tokens conforme chegam. O uso vem no final do fluxo, o que facilita o registro de custos.
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.")Os limites por trás desse loop de nova tentativa: uma chave completa permite 8 requisições simultâneas e 300 por minuto, e uma chave de teste 2 e 60. Acima do limite você recebe HTTP 429 com código rate_limited ou concurrency. Sobrecarga temporária também dá 429 com um cabeçalho Retry-After: 5. O exemplo define max_retries=0 no cliente para que seu próprio loop controle as esperas. Uma solicitação streaming mantém seu slot de concorrência até que o fluxo termine, então sempre consuma ou feche o fluxo.
Executando muitas requisições de uma vez
Trabalhos em lote, como gerar testes para cem funções, precisam de um limite de concorrência. Use um pool de threads com no máximo 8 trabalhadores em uma chave completa.
Um padrão simples é ThreadPoolExecutor(max_workers=6) ao redor de uma função que chama ask, deixando dois slots livres para outro trabalho. Com a chave de teste use 2 trabalhadores. Se você passar um número maior, a API responderá solicitações extras com erros de concurrency, e seu loop de nova tentativa gastará tempo esperando em vez de trabalhar. Para código assíncrono, use AsyncOpenAI com um asyncio.Semaphore(6) ao redor de cada chamada; isso dá o mesmo limite sem threads. Os cabeçalhos de resposta X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency mostram os limites para sua chave.
Custo de cargas de trabalho de código
O preço é $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída. Digamos que você gere testes unitários para 200 funções. Cada chamada envia 1.500 tokens de entrada e retorna 700 tokens. Entrada: 200 x 1.500 = 300.000 tokens, ou $0,045. Saída: 200 x 700 = 140.000 tokens, ou $0,07. Total: $0,115.
Uma refatoração de um arquivo grande envia 30.000 tokens de entrada e 8.000 de saída: $0,0045 + $0,004 = $0,0085 por execução. Solicitações falhas ou recusadas não são cobradas, e o crédito nunca expira. Recargas começam em $20 e podem ser pagas com cartão ou cripto, com um bônus de 5% a partir de $50, 10% a partir de $100 e 15% a partir de $200. Veja preços e leia a documentação para a lista completa de parâmetros.
