Avant de lancer quoi que ce soit
Vous avez besoin d’une clé et rien d’autre. Créez-en une sur la page Clé API ; les nouveaux comptes peuvent réclamer 0,50 $ de crédit d’essai en un clic, sans carte. Exportez-la pour que les exemples puissent la lire :
export API_KEY="YOUR_KEY"
pip install openai
npm install openai
L'API suit le format des complétions de chat OpenAI. Elle expose POST /v1/chat/completions et GET /v1/models, accepte Authorization: Bearer, et sert un seul modèle avec l'ID uncensored. Ce modèle est un modèle à poids ouverts exécuté par un fournisseur indépendant et ajusté pour répondre sans refus de contenu pour une utilisation adulte légale. Ce n'est l'API officielle d'aucun fournisseur de modèle. Il ne gère que le texte : pas d'images, d'audio, d'embeddings ou de fine-tuning.
Les exemples ci-dessous vont de l'appel le plus simple à l'appel de fonctions. Si vous avez seulement besoin de la vérification la plus courte possible pour vous assurer que votre clé fonctionne, la première commande curl suffit.
Une première requête avec curl, et les paramètres qui comptent
curl https://api.glmapikey.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "What is a mutex, in one sentence?"}
],
"temperature": 0.3,
"max_tokens": 80
}'
La réponse est un objet JSON avec choices[0].message.content contenant la réponse et un objet usage avec prompt_tokens et completion_tokens. Les en-têtes de réponse incluent X-Request-Id, X-Balance-USD et les deux en-têtes X-RateLimit-Limit. Ajoutez -i à curl pour les afficher.
Les champs temperature, top_p, stop, seed et les pénalités de présence et de fréquence sont transmis au modèle. max_tokens est optionnel. Sans lui, la complétion peut utiliser tout ce qui reste de la fenêtre de 100 000 tokens après votre prompt.
Le corps des complétions de chat contient de nombreux champs optionnels, mais cinq font la majeure partie du travail. Tous sont transmis au modèle.
| Champ | Ce qu'il fait | Usage typique |
|---|---|---|
temperature | Des valeurs plus élevées donnent des formulations plus variées | 0,2 pour l'extraction, 0,8 pour la fiction |
top_p | Limite l'échantillonnage aux tokens les plus probables | Laissez par défaut sauf si vous le réglez |
stop | Arrête la réponse lorsqu'une chaîne apparaît | Coupez à un délimiteur tel qu'une ligne vide |
seed | Rend l'échantillonnage répétable dans la mesure du possible | Comparaison de deux versions de prompt |
presence_penalty, frequency_penalty | Décourage la répétition de tokens | Petites valeurs telles que 0,3 lorsque le texte boucle |
Modifiez une valeur à la fois et gardez le prompt identique, sinon vous ne pouvez pas savoir quel changement a aidé. Pour tout ce qui alimente du code, comme la classification ou l'extraction, utilisez une température basse et une graine fixe afin de pouvoir relancer un test et voir le même résultat. Pour l'écriture créative, augmentez la température et laissez les pénalités gérer la répétition.
Le champ max_tokens est optionnel ici. Lorsque vous l’omettez, la réponse peut utiliser tout l’espace restant dans la fenêtre de 100 000 tokens, ce qui est rarement ce que vous souhaitez pour une réponse en une ligne. Définissez-le chaque fois que vous savez quelle doit être la longueur de la réponse.
Python : une conversation avec mémoire
L'API est sans état, donc vous gérez vous-même la conversation et l'envoyez à chaque fois. Cette boucle conserve une liste de messages et ajoute les deux côtés :
from openai import OpenAI
client = OpenAI(
base_url="https://api.glmapikey.com/v1",
api_key="YOUR_KEY",
)
messages = [{"role": "system", "content": "You are a helpful assistant."}]
while True:
user = input("you> ")
if not user:
break
messages.append({"role": "user", "content": user})
resp = client.chat.completions.create(model="uncensored", messages=messages)
reply = resp.choices[0].message.content
messages.append({"role": "assistant", "content": reply})
print("bot>", reply)
Chaque appel renvoyant la liste complète, les tokens d'entrée augmentent avec la longueur de la conversation. À 0,15 $ par 1 M de tokens d'entrée, c'est peu coûteux, mais cela s'accumule dans les longues sessions, alors coupez les anciens messages une fois que la conversation dépasse la taille que vous souhaitez payer. La page tarifs contient des exemples concrets.
Streaming en Python et Node
Définissez stream: true et le serveur envoie des tokens au fur et à mesure de leur production, via des événements envoyés par le serveur. En Python :
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write four lines about the sea."}],
stream=True,
)
text = ""
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
text += piece
print(piece, end="", flush=True)
if getattr(chunk, "usage", None):
print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
Le flux se termine par des informations d'utilisation, c'est pourquoi la boucle vérifie cela. La même chose en Node :
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.glmapikey.com/v1",
apiKey: process.env.API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Write four lines about the sea." }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
Un détail sur les limites : une requête en streaming conserve son slot de concurrence jusqu'à la fin du flux. Si vous lancez un flux et ne le lisez pas jusqu'au bout, ce slot reste occupé. Consommez ou fermez toujours le flux.
Mode JSON pour les sorties structurées
Lorsque votre code doit analyser la réponse, demandez un objet JSON avec response_format. Indiquez également dans le prompt la forme souhaitée, car l'indicateur de format garantit une syntaxe JSON valide, pas votre schéma particulier.
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}."},
{"role": "user", "content": "Suggest a title and three tags for a post about home espresso."},
],
temperature=0.2,
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
Vérifiez que les clés dont vous avez besoin existent avant de les utiliser, et gardez une température basse pour le travail d'extraction. Si une analyse échoue, réessayer une fois avec la même entrée fonctionne généralement, et les requêtes échouées ne sont pas facturées.
Appel de fonctions : un aller-retour complet
L'appel de fonctions permet au modèle de demander à votre code d'exécuter une fonction. Vous décrivez la fonction dans tools, le modèle répond avec une entrée tool_calls, vous l'exécutez et renvoyez le résultat sous forme de message role: "tool".
import json
def get_weather(city: str) -> dict:
return {"city": city, "temp_c": 18, "sky": "cloudy"}
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
messages = [{"role": "user", "content": "Is it warm in Lisbon right now?"}]
first = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(get_weather(**args)),
})
final = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools
)
print(final.choices[0].message.content)
else:
print(msg.content)
La fonction ici renvoie des données fixes, remplacez-la par une véritable recherche. Les arguments d'outil arrivent sous forme de chaîne JSON, donc analysez-les toujours et validez les valeurs avant d'agir. Avec stream: true, les tool_calls arrivent par morceaux que vous assemblez avant l'analyse. Utilisez tool_choice pour forcer un outil spécifique lorsque cela est nécessaire.
Ce que coûtent les exemples, et les erreurs qui gaspillent une heure
L'exécution des exemples coûte très peu, mais cela aide de voir l'arithmétique une fois. À 0,15 $ par 1 M de tokens d'entrée et 0,50 $ par 1 M de tokens de sortie :
- La boucle de conversation, avec un prompt de 1 200 tokens et une réponse de 300 tokens : 0,00018 $ pour l'entrée plus 0,00015 $ pour la sortie font 0,00033 $. Un millier de tours coûtent 0,33 $.
- Le tour d'outil fait deux appels. Si le premier utilise 400 tokens en entrée et 60 en sortie, et le second 500 en entrée et 150 en sortie, les totaux sont 900 en entrée et 210 en sortie : 0,000135 $ plus 0,000105 $ font 0,00024 $.
- Le streaming coûte la même chose qu'un appel normal avec les mêmes comptes de tokens. Cela change quand vous voyez le texte, pas ce que cela coûte.
Le crédit d'essai de 0,50 $ pourrait payer plus de 1 500 tours de la boucle de conversation à cette taille (0,50 $ / 0,00033 $), vous pouvez donc expérimenter librement avant de recharger. Les requêtes échouées et refusées ne sont pas facturées, ce qui signifie qu'un bug dans votre analyse qui vous amène à relancer un appel ne vous coûte pas pour les tentatives échouées.
- Une URL de base incorrecte. Elle doit se terminer par
/v1. Ajouter/chat/completionsvous-même à une URL de base SDK donne une erreur 404 car le SDK ajoute le chemin. - Un nom de modèle différent. Les noms copiés d'autres plateformes n'existent pas ici. L'ID est
uncensored. - S'attendre à une mémoire. L'API ne se souvient pas des appels précédents. Envoyez l'historique à chaque fois.
- L'analyse du JSON du modèle sans protection. Enveloppez
json.loadsdans un bloc try et ayez un plan pour une réponse incorrecte. - Laisser les flux ouverts. Un flux inachevé occupe un slot de concurrence, et une clé d'essai n'en dispose que de deux.
- Placer la clé dans le code front-end. Conservez-la sur un serveur.
Si quelque chose semble toujours incorrect, envoyez une requête avec curl et comparez-la à ce que votre code produit. La requête curl supprime le SDK de l'équation et rend les différences dans le corps évidentes.
Lecture de l'utilisation, du solde et des erreurs
Pour voir les en-têtes du SDK Python, utilisez le wrapper de réponse brute :
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"))
print("rpm limit:", raw.headers.get("x-ratelimit-limit-requests"))
completion = raw.parse()
print(completion.usage.total_tokens)
Journalisez l'ID de requête à chaque appel afin de pouvoir pointer vers une requête unique plus tard. Utilisez l'en-tête de solde pour déclencher une alerte avant l'épuisement du crédit.
Lorsque vous dépassez une limite, l'API renvoie un HTTP 429, et le code d'erreur indique laquelle :
| Code ou en-tête | Que faire | Que faire |
|---|---|---|
rate_limited | Trop de requêtes par minute (300 sur une clé complète, 60 sur un essai) | Réduisez le rythme et répartissez les appels |
concurrency | Trop en même temps (8 sur une clé complète, 2 sur un essai) | Attendez qu'une requête en cours se termine |
Retry-After: 5 | Surcharge temporaire | Réessayez après cinq secondes |
Les requêtes échouées ou refusées ne sont pas facturées. Le corps de la requête peut faire jusqu'à 8 Mo. Pour la référence complète et la façon de réutiliser le code client existant, consultez les docs. Pour un guide pas à pas sur comment obtenir une clé, consultez l'article sur la clé API GLM.
