FR ▾
Obtenir une clé API

Exemples GLM API : Python, mode JSON et streaming

Ces exemples GLM API s'exécutent tous contre un seul endpoint compatible OpenAI, avec l'URL de base https://api.glmapikey.com/v1 et le modèle uncensored. Chaque extrait est court et autonome, afin que vous puissiez le coller, ajouter votre clé et l'exécuter.

Mis à jour le

Fenêtre de terminal diffusant des tokens de données lumineux vers un serveur cloud, illustrant des exemples de code API

Points clés

  • Chaque exemple utilise l'URL de base https://api.glmapikey.com/v1, l'authentification bearer et l'ID de modèle uncensored.
  • Le streaming, le mode JSON et l'appel de fonctions sont tous pris en charge sur le même endpoint de complétions de chat.
  • Lisez X-Balance-USD et le bloc d'utilisation pour suivre les dépenses par appel.
  • Gérez le 429 par code : rate_limited, concurrence ou une surcharge Retry-After: 5.

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.

ChampCe qu'il faitUsage typique
temperatureDes valeurs plus élevées donnent des formulations plus variées0,2 pour l'extraction, 0,8 pour la fiction
top_pLimite l'échantillonnage aux tokens les plus probablesLaissez par défaut sauf si vous le réglez
stopArrête la réponse lorsqu'une chaîne apparaîtCoupez à un délimiteur tel qu'une ligne vide
seedRend l'échantillonnage répétable dans la mesure du possibleComparaison de deux versions de prompt
presence_penalty, frequency_penaltyDécourage la répétition de tokensPetites 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/completions vous-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.loads dans 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êteQue faireQue faire
rate_limitedTrop de requêtes par minute (300 sur une clé complète, 60 sur un essai)Réduisez le rythme et répartissez les appels
concurrencyTrop 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: 5Surcharge temporaireRé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.

Questions et réponses

Quelle URL de base les exemples utilisent-ils ?

Chaque exemple utilise https://api.glmapikey.com/v1 avec l'ID du modèle uncensored et un bearer token. Tout SDK OpenAI fonctionne une fois que vous avez modifié ces valeurs.

L'API prend-elle en charge le streaming ?

Oui. Définissez stream sur true et lisez les événements envoyés par le serveur. L'utilisation est rapportée à la fin du flux.

Comment obtenir un JSON valide en retour ?

Transmettez response_format avec le type json_object et décrivez la forme souhaitée dans le prompt. Analysez le résultat dans votre code et vérifiez les clés dont vous avez besoin.

Puis-je utiliser l'appel de fonctions ?

Oui. Transmettez tools et tool_choice, exécutez la fonction demandée par le modèle, et renvoyez le résultat en tant que message avec le rôle tool.

Où puis-je voir mon crédit restant ?

Chaque réponse inclut un en-tête X-Balance-USD avec votre solde restant, et le bloc d'utilisation fournit les comptes de tokens.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.

Obtenir une clé API