Scegli prima il pattern di integrazione
La maggior parte delle integrazioni GLM API rientra in una di quattro forme, e la scelta influisce su tutto il resto: dove risiedono i segreti, come gestisci i picchi e come appare un errore all'utente.
| Pattern | Adatto per | Rischio principale |
|---|---|---|
| Proxy backend | App web e app mobili con i loro utenti | Endpoint aperto che chiunque può svuotare |
| Worker di coda | Bot, lavori batch, elaborazione di massa di testo | Accumulo quando le richieste superano i limiti |
| Chat bot | Personaggi e compagni su Discord, Telegram o Matrix | Cronologie lunghe che gonfiano il costo |
| Strumento di automazione | Workflow in strumenti che offrono un nodo HTTP o OpenAI | Errori silenziosi quando un passaggio genera un errore |
Tutti e quattro usano la stessa chiamata sottostante: POST /v1/chat/completions su https://api.glmapikey.com/v1 con una chiave bearer e il modello uncensored. L'API è compatibile con OpenAI, quindi puoi usare qualsiasi SDK OpenAI, o HTTP grezzo se il tuo stack non ha SDK. È un modello a pesi aperti gestito da un provider indipendente, non l'API ufficiale di alcun vendor e non un router, quindi progetta per il comportamento di un modello. Solo testo: se il tuo prodotto ha bisogno anche di immagini o embedding, pianifica un secondo provider per quelle parti.
La pagina docs elenca endpoint e header, e l'articolo chiave GLM spiega come ottenere una chiave.
Proxy backend: tieni la chiave fuori dal client
Qualsiasi cosa che giri in un browser o in un bundle app può essere ispezionata. Se la chiave viene distribuita lì, chiunque può copiarla e spendere il tuo credito. La soluzione è una route server sottile che detiene la chiave, applica le tue regole e inoltra la richiesta.
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import AsyncOpenAI
from pydantic import BaseModel
app = FastAPI()
client = AsyncOpenAI(
base_url="https://api.glmapikey.com/v1",
api_key="YOUR_KEY",
)
class Ask(BaseModel):
prompt: str
@app.post("/ask")
async def ask(body: Ask):
async def gen():
stream = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": body.prompt[:4000]}],
max_tokens=600,
stream=True,
)
async for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
yield chunk.choices[0].delta.content
return StreamingResponse(gen(), media_type="text/plain")
La route tronca il prompt e limita la risposta, che è il minimo. Aggiungi controlli reali prima del lancio: autenticazione utente, un budget token giornaliero per utente e un limite sulla frequenza delle richieste per IP o account. L'API restituisce l'utilizzo su ogni chiamata, quindi puoi contare i token per utente nel tuo database e rifiutare le richieste che superano la loro quota.
Lo streaming attraverso un proxy richiede un controllo: conferma che il tuo reverse proxy non applichi buffering alle risposte, altrimenti il testo arriverà in un unico blocco alla fine invece che parola per parola.
Worker di coda: rispetta il limite di concorrenza
I limiti sono per chiave. Una chiave completa permette 8 richieste concorrenti e 300 richieste al minuto. Una chiave di prova ne permette 2 e 60. Per un flusso costante di lavori, la concorrenza è solitamente quella che fa da collo di bottiglia per prima, perché ogni richiesta occupa uno slot fino al completamento, e una in streaming fino alla fine dello stream.
Un pool di worker dimensionato al limite è la soluzione pulita. I lavori aspettano nella tua coda invece di fallire con 429:
import asyncio
from openai import AsyncOpenAI, RateLimitError
client = AsyncOpenAI(
base_url="https://api.glmapikey.com/v1",
api_key="YOUR_KEY",
max_retries=0,
)
WORKERS = 8 # use 2 on a trial key
async def run_job(prompt: str) -> str:
for attempt in range(5):
try:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
max_tokens=500,
)
return r.choices[0].message.content
except RateLimitError as e:
delay = float(e.response.headers.get("retry-after", 2 * (attempt + 1)))
await asyncio.sleep(delay)
raise RuntimeError("gave up after repeated 429 responses")
async def worker(queue: asyncio.Queue, results: list):
while True:
prompt = await queue.get()
try:
results.append(await run_job(prompt))
finally:
queue.task_done()
async def main(prompts):
queue, results = asyncio.Queue(), []
for p in prompts:
queue.put_nowait(p)
tasks = [asyncio.create_task(worker(queue, results)) for _ in range(WORKERS)]
await queue.join()
for t in tasks:
t.cancel()
return results
Il codice di errore nel corpo 429 ti dice perché sei stato fermato: rate_limited per richieste al minuto, concurrency per troppi contemporaneamente, e un 429 normale con Retry-After: 5 per un sovraccarico breve. Onorare l'header è più semplice che indovinare un ritardo. Le richieste fallite e rifiutate non vengono addebitate, quindi i ritentativi non costano nulla.
Bot e personaggi
Un chat bot è il luogo usuale dove appaiono le sorprese sui costi, perché un bot che mantiene la cronologia la reinvia su ogni messaggio. Decidi presto quanti messaggi di cronologia mantenere e memorizza la cronologia tu stesso, poiché l'API non mantiene stato tra le chiamate.
Un esempio di budget chiarisce il punto. Supponi che un bot abbia 500 utenti attivi che inviano ciascuno 20 messaggi al giorno. Ogni messaggio trasporta 1.500 token di input (persona, una breve cronologia e la nuova riga) e restituisce 250 token:
- Per messaggio: 1.500 / 1.000.000 x $0,15 = $0,000225 input, più 250 / 1.000.000 x $0,50 = $0,000125 output, quindi $0,00035
- Al giorno: 500 x 20 = 10.000 messaggi, quindi $3,50
- In 30 giorni: $105
Se lasci crescere la cronologia fino a riempire un contesto di 12.000 token, l'input per messaggio sale otto volte a 12.000 token, o $0,0018 solo per l'input, e la cifra mensile sale di conseguenza. Una finestra scorrevole più un breve riassunto degli eventi più vecchi mantiene la persona coerente a un prezzo inferiore.
Per bot companion e roleplay, tieni le regole del prodotto nel tuo strato. Il modello è ottimizzato per rispondere senza rifiuti di contenuti per uso adulto legale, e l'unico limite rigido è il contenuto sessuale che coinvolge minorenni, che il servizio rifiuta. Se il tuo bot vive in un server pubblico, aggiungi il controllo dell'età e le regole del canale che corrispondono alla piattaforma su cui lo esegui.
Strumenti di automazione e workflow no-code
Gli strumenti di workflow che offrono un nodo stile OpenAI con un URL di base configurabile possono usare questa API modificando tre campi: l'URL a https://api.glmapikey.com/v1, la chiave e il nome del modello a uncensored. Gli strumenti che hanno solo un nodo di richiesta HTTP generica possono inviare la richiesta grezza invece:
curl https://api.glmapikey.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "uncensored", "messages": [{"role": "user", "content": "Classify this ticket: printer offline"}], "response_format": {"type": "json_object"}}'
Per i passaggi del flusso di lavoro che alimentano un altro passaggio, vale la pena usare la modalità JSON, in modo che il nodo successivo riceva testo analizzabile. Aggiungi un ramo di errore per qualsiasi passaggio che chiama l'endpoint, perché si verificheranno occasionalmente risposte 429 e 5xx e un errore silenzioso nel mezzo di un flusso di lavoro è difficile da trovare in seguito. Imposta un nuovo tentativo con una breve attesa su quel nodo e assicurati che i rami paralleli non superino il numero di richieste parallele consentite dalla tua chiave.
Cosa vedono i tuoi utenti quando qualcosa fallisce
Ogni integrazione ha bisogno di un piano per il percorso sfortunato, e la parte visibile all'utente è importante quanto il codice di ritentativo. Tre situazioni si presentano in pratica.
La prima è un sovraccarico breve: un 429 con Retry-After: 5. Ritenta in silenzio e mostra un indicatore di digitazione nel frattempo, così l'utente vede una risposta leggermente più lenta invece di un errore. La seconda è raggiungere il limite del tuo pool. Se tutti gli otto slot sono occupati, accoda il messaggio e dì all'utente che sta aspettando, che è meglio di uno schermo vuoto. La terza è finire il credito, che nessun ritentativo risolve. Monitora l'header del saldo, avvisa te stesso a una soglia e tieni pronto un messaggio di fallback per il giorno in cui finisce inosservato.
Non mostrare errori API grezzi agli utenti finali. Registrali con l'ID della richiesta e mostra una frase semplice che dice cosa è successo e cosa fare dopo. Non includere mai la chiave, l'URL di base o gli stack trace in qualcosa che un utente può leggere.
Soldi, monitoraggio e controlli di lancio
La fatturazione è prepagata. Ricarichi qualsiasi importo intero da $20 a $500, con +5% da $50, +10% da $100 e +15% da $200. Il credito non scade mai e non c'è abbonamento. Paga con cripto (USDT su TRC20, USDC su Base). I nuovi utenti possono richiedere $0,50 di credito di prova con un clic sulla pagina chiave API, valido per 7 giorni, così puoi testare un'integrazione prima di finanziarla. Vedi la pagina prezzi per le tariffe.
Cosa monitorare in produzione:
- Saldo. Leggi
X-Balance-USDdalle risposte e imposta un alert quando scende sotto una soglia che scegli tu. - ID richiesta. Memorizza
X-Request-Idaccanto a ogni lavoro in modo che un singolo errore possa essere tracciato. - Utilizzo token. Somma
usageper utente e per funzionalità per capire dove vanno i soldi. - Frequenza 429. Un aumento del conteggio indica che il tuo pool è più grande dei limiti della chiave.
Una breve lista di lancio: esegui una richiesta reale dall'host di produzione, testa un 429 forzato in staging, conferma che un utente non può raggiungere l'API senza la tua autenticazione e annota cosa mostra il tuo servizio quando l'API è irraggiungibile. I prompt non vengono utilizzati per l'addestramento, cosa che puoi comunicare ai tuoi utenti, ma indica nella tua privacy policy che il loro testo viene inviato a un provider di terze parti per generare le risposte.
