Points clés
- Installez openai, puis créez OpenAI(base_url=..., api_key=...) avec le modèle défini sur uncensored.
- Le streaming, le mode JSON et l'appel d'outils utilisent les paramètres standard, et l'async fonctionne de la même manière.
- Limitez la concurrence à 8 avec un sémaphore et laissez le SDK réessayer les réponses 429.
- Lisez X-Balance-USD dans les en-têtes de réponse brute pour surveiller votre crédit depuis le code.
Exemple minimal fonctionnel
Voici la configuration proxy api openai python la plus courte utile. Elle suppose Python 3.9 ou plus récent, une clé depuis la page clé API, le package installé avec pip install openai et la clé exportée en tant que UNCENSORED_API_KEY.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.openaiapiproxy.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Give me a one-line product tagline for a hiking app."}],
temperature=0.8,
max_tokens=60,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)L'endpoint est compatible OpenAI, mais il s'agit d'un service distinct. Il ne s'agit pas de l'API officielle d'OpenAI ou d'un autre fournisseur, et il héberge un seul modèle, uncensored. Seules deux routes existent : POST /v1/chat/completions et GET /v1/models, donc restez sur l'interface de complétions de chat du SDK.
Quelques remarques sur ce code. La clé provient d'une variable d'environnement au lieu d'une valeur littérale, elle ne se retrouve donc jamais dans le contrôle de version. L'objet usage dans la réponse contient les comptes exacts de tokens sur lesquels la facture est basée, ce qui est utile pour la journalisation. Et max_tokens est optionnel : ne le spécifiez pas et la complétion peut utiliser le reste de la fenêtre, ce qui est acceptable pour des histoires mais coûteux pour une boucle avec un bug.
Streaming des tokens à leur arrivée
Le streaming utilise les événements envoyés par le serveur. Passez stream=True et itérez sur les chunks. La dernière partie du flux contient l'utilisation de tokens, alors protégez-vous contre les chunks sans choix.
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Tell a two-paragraph ghost story."}],
stream=True,
)
usage = None
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
if getattr(chunk, "usage", None):
usage = chunk.usage
print()
if usage:
print("tokens:", usage.prompt_tokens, usage.completion_tokens)Un détail opérationnel : un appel en streaming occupe l'un de vos slots de concurrence jusqu'à la fin du flux. Si votre code sort de la boucle plus tôt, fermez le flux (stream.close()) pour libérer le slot.
Une application web enveloppe généralement cette boucle dans un générateur et transmet chaque morceau au navigateur. Avec FastAPI, cela signifie retourner un StreamingResponse qui génère les parties de texte. Gardez la clé sur le serveur dans cette conception. Le navigateur communique avec votre route, et votre route communique avec l'API, donc la clé n'est jamais exposée au code client.
Clients asynchrones et contrôle de la concurrence
Une clé complète permet 8 requêtes simultanées et 300 par minute. Une clé d'essai permet 2 et 60. Si vous lancez 200 coroutines avec asyncio.gather, vous rencontrerez des erreurs 429 avec le code concurrency. Un sémaphore corrige cela avant qu'il n'arrive.
import asyncio
from openai import AsyncOpenAI
client = AsyncOpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)
gate = asyncio.Semaphore(8)
async def ask(prompt: str) -> str:
async with gate:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
max_tokens=200,
)
return r.choices[0].message.content
async def main():
prompts = [f"Write a title for chapter {i} of a sea adventure." for i in range(1, 41)]
results = await asyncio.gather(*(ask(p) for p in prompts))
for t in results:
print(t)
asyncio.run(main())Utilisez 2 comme taille du sémaphore tant que vous êtes sur la clé d'essai. Le SDK réessaie les réponses 429 avec une temporisation par défaut, et max_retries augmente le nombre de tentatives. Pour une surcharge temporaire, le service répond 429 avec Retry-After: 5, que le SDK respecte.
Un sémaphore limite uniquement les requêtes en cours dans un seul processus. Si vous exécutez plusieurs travailleurs, divisez la limite entre eux : avec une clé complète, quatre travailleurs devraient chacun utiliser un sémaphore de 2. La limite par minute de 300 est partagée par tous, donc une file d'attente avec un débit régulier est meilleure qu'une rafale pour les gros travaux hors ligne. La limite de corps de 8 Mo est rarement un problème pour le chat, mais elle s'applique à chaque requête.
Mode JSON et appels d'outils
Les deux fonctionnent via les paramètres normaux. Pour le mode JSON, définissez response_format et demandez du JSON dans le prompt.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
r = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Return JSON with keys name, mood and hook."},
{"role": "user", "content": "Invent a tavern keeper for a fantasy game."},
],
)
npc = json.loads(r.choices[0].message.content)
print(npc["name"])L'appel d'outils nécessite une étape supplémentaire : vous exécutez la fonction vous-même et retournez la sortie en tant que message tool.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "roll_dice",
"description": "Roll a die with the given number of sides.",
"parameters": {
"type": "object",
"properties": {"sides": {"type": "integer"}},
"required": ["sides"],
},
},
}]
messages = [{"role": "user", "content": "Roll a twenty-sided die for me."}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
call = msg.tool_calls[0]
sides = json.loads(call.function.arguments)["sides"]
messages.append(msg)
messages.append({"role": "tool", "tool_call_id": call.id, "content": "14"})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)La valeur retournée pour le dé ici est codée en dur pour plus de brièveté. Dans le code réel, appelez votre fonction avec sides et envoyez son résultat.
Deux détails supplémentaires sur les outils. Utilisez tool_choice lorsque vous devez forcer une fonction spécifique au lieu de laisser le modèle décider. Et gardez les descriptions d'outils spécifiques : le modèle choisit une fonction uniquement par son nom et sa description, donc "Lancer un dé avec le nombre de faces donné" fonctionne mieux que "dés". Si une réponse contient plusieurs appels d'outils, exécutez-les tous et ajoutez un message tool par ID d'appel avant de demander la réponse finale.
Erreurs, nouvelles tentatives et historique des conversations
Le SDK lève des exceptions typées, ce qui rend la gestion des erreurs concise. Une 429 lève openai.RateLimitError, une défaillance réseau lève openai.APIConnectionError, et d'autres statuts non réussis lèvent openai.APIStatusError. Le SDK a déjà réessayé lorsque vous voyez le premier, donc ce qui atteint votre code est un appel qui a échoué à plusieurs reprises.
import time
import openai
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=2)
def chat(messages, attempts=4):
delay = 2.0
for n in range(attempts):
try:
r = client.chat.completions.create(model="uncensored", messages=messages)
return r.choices[0].message.content
except openai.RateLimitError as e:
wait = float(e.response.headers.get("Retry-After", delay))
time.sleep(wait)
delay *= 2
except openai.APIConnectionError:
time.sleep(delay)
delay *= 2
raise RuntimeError("gave up after repeated failures")
print(chat([{"role": "user", "content": "Name a color."}]))Le code lit Retry-After lorsque le service l'envoie, ce qui se produit en cas de surcharge temporaire (la valeur est de 5 secondes). Lorsque l'en-tête est manquant, il temporise selon son propre calendrier. Notez que la boucle ne capture pas toutes les erreurs : une mauvaise requête ne s'améliorera pas avec une nouvelle tentative, alors laissez-la se propager.
L'historique des conversations est l'autre élément d'état. L'API ne le stocke pas pour vous, donc votre programme possède la liste des messages. Une politique simple qui fonctionne bien : gardez le message système, gardez les N derniers échanges, et lorsque le total dépasse une taille que vous choisissez, demandez au modèle de résumer la partie la plus ancienne en un court message.
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
def compact(history, keep=6):
system, rest = history[0], history[1:]
if len(rest) <= keep:
return history
old, recent = rest[:-keep], rest[-keep:]
text = "\n".join(m["role"] + ": " + m["content"] for m in old)
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarize this conversation in 120 words:\n" + text}],
max_tokens=250,
)
summary = {"role": "system", "content": "Earlier in this conversation: " + r.choices[0].message.content}
return [system, summary] + recentLes résumés coûtent aussi des tokens, mais ils s'amortissent : une conversation qui renverrait autrement 20 000 tokens à chaque tour passe à quelques milliers.
Lecture du solde et de l'ID de requête
Chaque réponse inclut X-Request-Id et X-Balance-USD. Le SDK cache les en-têtes par défaut, mais with_raw_response les expose tout en vous donnant l'objet analysé.
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("X-Request-Id"))
print("balance USD:", raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)Journalisez l'ID de requête avec chaque échec. Si vous devez contacter l'équipe via la page de support, cet ID pointe directement vers l'appel.
L'en-tête de solde est utile au-delà de la journalisation. Un travail planifié peut le lire après chaque lot et s'arrêter lorsque le crédit tombe en dessous d'un seuil que vous définissez, ou vous envoyer un message pour que vous puissiez recharger avant que les utilisateurs ne le remarquent. Le crédit n'expire jamais, donc il n'y a pas de pression pour le dépenser. Les recharges sont des montants entiers de 20 $ à 500 $, donc vous pouvez recharger en étapes plus grandes si vous préférez.
Sans le SDK : requests ou httpx
Si vous préférez éviter la dépendance, l'API est suffisamment simple pour un client HTTP standard.
import requests
r = requests.post(
"https://api.openaiapiproxy.com/v1/chat/completions",
headers={"Authorization": "Bearer YOUR_KEY"},
json={
"model": "uncensored",
"messages": [{"role": "user", "content": "Name three sea shanty topics."}],
},
timeout=120,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])Définissez un timeout généreux pour les longues complétions. Le modèle peut utiliser autant de la fenêtre de 100 000 jetons que le prompt laisse libre, donc une requête sans limite pour de la fiction peut prendre un certain temps.
La même approche fonctionne pour le streaming. Ajoutez "stream": true au corps JSON, passez stream=True à requests.post et lisez la réponse avec iter_lines(). Chaque ligne d'événement commence par data: suivi de JSON, et le flux se termine avec un marqueur data: [DONE]. Analyser cela manuellement est un bon exercice d'apprentissage, bien que pour le code de production, le SDK le fasse avec moins de cas limites, tels que les lignes partielles et les reconnectations.
Gestion du budget dans votre code Python
Les comptes de jetons dans resp.usage vous permettent de calculer la dépense par appel. Le prix est de $0,15 par 1M de jetons d'entrée et de $0,50 par 1M de jetons de sortie.
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
def cost_usd(prompt_tokens: int, completion_tokens: int) -> float:
return prompt_tokens * 0.15 / 1_000_000 + completion_tokens * 0.50 / 1_000_000
r = client.chat.completions.create(model="uncensored", messages=[{"role": "user", "content": "Hi"}])
print(cost_usd(r.usage.prompt_tokens, r.usage.completion_tokens))
print(cost_usd(1_000_000, 200_000)) # 0.25La deuxième ligne vérifiée manuellement : 1M de tokens d'entrée coûtent 0,15 $ et 200 000 tokens de sortie coûtent 0,2 x 0,50 $ = 0,10 $, ce qui fait 0,25 $. Les requêtes échouées ou refusées ne sont pas facturées, donc vous n'avez pas besoin de les soustraire. Les recharges commencent à 20 $, et la page de tarification liste les bonus à 50 $, 100 $ et 200 $.
Pour la liste complète des paramètres et les codes d'erreur, consultez la documentation.
Conservez un total cumulé dans votre tâche pour qu'une boucle ne puisse pas dépenser plus que prévu. Un lot de travail qui classe 50 000 courts textes à 400 tokens d'entrée et 20 tokens de sortie chacun utilise 20M de tokens d'entrée et 1M de tokens de sortie. Cela coûte 20 x 0,15 $ + 1 x 0,50 $ = 3,50 $. Si votre compteur indique que la tâche est à deux fois ce montant, quelque chose tourne en boucle.
