LLM Inference APIGuida
LLM Inference API: Streaming, strumenti e modalità JSON
Un'API di inferenza LLM ti permette di inviare un prompt via HTTPS e ricevere testo generato, senza GPU dal tuo lato. Questa pagina mostra una configurazione funzionante contro un endpoint compatibile con OpenAI, dalla prima richiesta allo streaming, agli strumenti, alla modalità JSON e ai limiti di richieste.
Aggiornato:

Punti chiave
- Indirizza qualsiasi SDK OpenAI a https://api.llminferenceapi.com/v1, usa l'ID del modello uncensored e invia la tua chiave come token Bearer.
- Sono disponibili due endpoint: POST /v1/chat/completions e GET /v1/models.
- Streaming, chiamata di funzioni e modalità JSON funzionano tramite i campi standard della richiesta.
- Una chiave completa permette 8 richieste concorrenti e 300 al minuto; una risposta 429 ti dice quale limite hai raggiunto.
Cosa ti serve prima della prima chiamata
Ti servono tre cose: un URL base, una chiave e il nome del modello. L'URL base è https://api.llminferenceapi.com/v1, l'ID del modello è uncensored e la chiave proviene dalla pagina della chiave API dopo esserti registrato con Google o con email e password. I nuovi utenti possono richiedere $0,50 di credito di prova con un clic. Non serve la carta, dura 7 giorni ed è limitato a uno per persona.
Il servizio è solo testo. Espone POST /v1/chat/completions e GET /v1/models. Non ci sono route per gli embeddings, nessuna generazione di immagini o audio e nessun fine-tuning. Esegue un modello a pesi aperti, gestito da un provider indipendente e ottimizzato per rispondere senza rifiutare i contenuti per uso adulto lecito. Non è l'API ufficiale di alcun fornitore di modelli. Una regola rigida: non è consentito il contenuto che sessualizza i minorenni.
Tieni la chiave in una variabile d'ambiente piuttosto che nel codice sorgente. Gli esempi sottostanti la leggono da API_KEY dove il linguaggio lo permette.
La tua prima richiesta
Inizia con curl, perché mostra esattamente cosa passa sulla rete.
curl https://api.llminferenceapi.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": "List three uses of a message queue."}
],
"temperature": 0.7
}'
La risposta è il solito oggetto chat completion: choices[0].message.content contiene il testo e usage contiene i conteggi dei token. Puoi anche elencare i modelli con GET /v1/models, che è un modo rapido per confermare che la chiave e l'URL siano corretti prima di fare debug di altro.
In Python con l'SDK ufficiale OpenAI, cambia solo il costruttore:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.llminferenceapi.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "List three uses of a message queue."}],
)
print(resp.choices[0].message.content)
E in Node:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.llminferenceapi.com/v1",
apiKey: process.env.API_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "List three uses of a message queue." }],
});
console.log(resp.choices[0].message.content);
Il completamento può utilizzare tutto ciò che resta della finestra da 100.000 token dopo il tuo prompt, quindi max_tokens è opzionale. Impostalo comunque quando vuoi un limite rigido su costi o lunghezza. I controlli di campionamento come temperature, top_p, stop, seed e le penalità di frequenza e presenza vengono passati invariati.
Due impostazioni vale la pena conoscere fin dall'inizio. seed rende il campionamento ripetibile per i test, utile quando confronti due versioni di un prompt e vuoi che la differenza derivi dal prompt e non dal caso. stop accetta una o più stringhe che terminano la generazione non appena il modello le scrive, un modo economico per troncare una risposta a un delimitatore ed evitare di pagare per i token che scarteresti.
Risposte in streaming
Con stream: true il server risponde tramite eventi server-sent e invia il testo in piccoli delta. Gli utenti vedono le prime parole rapidamente, il che è importante nelle interfacce chat. I dati di utilizzo arrivano alla fine dello stream.
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about a lighthouse."}],
stream=True,
stream_options={"include_usage": True},
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
if chunk.usage:
print("\n", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
Due punti sono facili da perdere. Primo, l'ultimo chunk può contenere dati di utilizzo e una lista choices vuota, quindi verifica che choices non sia vuoto prima di indicizzarla. Secondo, una richiesta in streaming occupa la sua slot di concorrenza fino alla fine dello stream. Se un client apre uno stream e non lo legge fino alla fine, quella slot resta occupata e le tue richieste successive possono incontrare un errore concurrency. Chiudi sempre o consuma completamente gli stream.
Chiamata di strumenti
La chiamata di funzioni permette al modello di chiedere al tuo codice di eseguire una funzione e usarne il risultato. Descrivi le funzioni in tools, guida opzionalmente la scelta con tool_choice, esegui ciò che il modello richiede e invia l'output indietro come un messaggio con role: "tool".
import json
tools = [{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Look up the status of an order by its id.",
"parameters": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
},
}]
messages = [{"role": "user", "content": "Where is order A-1043?"}]
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)
result = {"order_id": args["order_id"], "status": "shipped"}
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result),
})
final = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools
)
print(final.choices[0].message.content)
Analizza sempre function.arguments in modo difensivo. È una stringa JSON prodotta da un modello linguistico e, in rari casi, può essere malformata o contenere un campo non definito. Validala prima di agire, specialmente quando la funzione modifica i dati. Le chiamate di funzioni funzionano anche con lo streaming, in cui i tool_calls arrivano come frammenti che devi unire per indice prima dell'analisi.
Gestione della cronologia delle conversazioni
L'API è stateless. Non ricorda le richieste precedenti, quindi una chat multi-turno funziona solo perché il tuo codice invia di nuovo i turni precedenti ogni volta. Tieni una lista di messaggi, aggiungi il nuovo messaggio dell'utente, chiama l'endpoint, poi aggiungi la risposta dell'assistant prima del turno successivo.
history = [{"role": "system", "content": "You are a patient writing coach."}]
def chat(user_text):
history.append({"role": "user", "content": user_text})
resp = client.chat.completions.create(model="uncensored", messages=history)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(chat("Give me a prompt for a ghost story."))
print(chat("Make it set on a ferry."))
Poiché ogni turno reinvia la cronologia, i token di input crescono con la lunghezza della chat. La finestra contiene 100.000 token, che sono sufficienti per la maggior parte delle conversazioni, ma il costo aumenta ben prima di raggiungere il limite. Un pattern comune è mantenere il messaggio di sistema e gli ultimi diversi turni, e sostituire i turni più vecchi con un breve riassunto scritto dallo stesso modello. Leggi usage.prompt_tokens dopo ogni chiamata per vedere quanto è grande la cronologia.
Modalità JSON
Quando hai bisogno di un output leggibile dalla macchina, imposta response_format su {"type": "json_object"} e specifica nel prompt che vuoi JSON. Descrivere le chiavi che ti aspetti rende il risultato molto più stabile.
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON only, using the keys title, tags and summary."},
{"role": "user", "content": "Describe a short story about a lost robot."},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
La modalità JSON fa sì che l'output sia analizzabile come JSON, ma non impone il tuo schema. Controlla le chiavi nel codice e mantieni un fallback nel caso in cui un valore mancasse. Se la risposta viene troncata perché ha raggiunto un limite di token, il JSON sarà incompleto, quindi non impostare max_tokens troppo basso per l'output strutturato.
Una breve checklist quando qualcosa fallisce
La maggior parte dei problemi del primo giorno deriva da un paio di cause, che puoi escludere in ordine.
- Base URL. Deve terminare con
/v1. L'SDK aggiunge/chat/completionsda solo, quindi un URL con il percorso già incluso non funzionerà. - Intestazione della chiave. La chiave va in
Authorization: Bearerseguita dalla chiave. Uno spazio o un a capo residui copiati con la chiave sono una causa frequente di errori di autenticazione. - Model ID. Usa
uncensoredesattamente. I nomi di modelli di altri fornitori non sono validi qui. - Dimensione della richiesta. Il limite del corpo della richiesta è 8 MB, e prompt più completamento devono stare in 100.000 token.
- Saldo. Guarda l'intestazione
X-Balance-USDsu qualsiasi risposta per vedere se il credito è il problema. - Cita l'ID della richiesta. Se contatti il supporto, includi il valore
X-Request-Iddalla risposta fallita così la richiesta può essere trovata.
Tieni presente che un rifiuto non è lo stesso di un errore. Poiché il modello è ottimizzato per evitare rifiuti di contenuti per uso adulto lecito, ne vedrai meno rispetto ai servizi con filtri, ma il modello può comunque rifiutare o dare una risposta debole a un prompt vago. Un messaggio di sistema più chiaro di solito risolve meglio di una temperatura più alta.
Limiti, intestazioni e ritentativi
Una chiave completa permette 8 richieste parallele e 300 richieste al minuto. Una chiave di prova permette 2 richieste parallele e 60 al minuto. Il corpo della richiesta può essere fino a 8 MB. Ogni risposta include X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency, che sono utili per il logging e per mostrare un saldo in una schermata di amministrazione.
Quando superi un limite, l'API restituisce HTTP 429. Il codice di errore rate_limited significa troppe richieste al minuto, e concurrency significa troppe contemporaneamente. In caso di sovraccarico temporaneo ricevi anche 429, con un'intestazione Retry-After: 5. Un semplice wrapper di retry copre tutti e tre i casi:
import time
from openai import RateLimitError
def ask(messages, tries=4):
for attempt in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError as e:
wait = 5 if attempt == 0 else 5 * (attempt + 1)
retry_after = getattr(e.response, "headers", {}).get("retry-after")
time.sleep(int(retry_after) if retry_after else wait)
raise RuntimeError("still rate limited after retries")
Per un pool di worker, limita la dimensione del pool al tuo limite di concorrenza invece di affidarti ai ritentativi. Otto worker su una chiave completa raramente vedranno un errore concurrency. Se incontri errori imprevisti, l'articolo sulla risoluzione dei problemi passa in rassegna le cause comuni.
Pagamento
La fatturazione è pagamento a consumo da credito prepagato: $0,15 per 1M token di input e $0,50 per 1M token di output, senza abbonamento. Le richieste fallite o rifiutate non vengono addebitate e il credito non scade mai. Una richiesta con 1.500 token di input e 400 token di output costa 1.500 / 1.000.000 x $0,15 + 400 / 1.000.000 x $0,50 = $0,000225 + $0,0002 = $0,000425.
Le ricariche sono qualsiasi importo intero da $20 a $500, con un bonus del 5% da $50, 10% da $100 e 15% da $200. Puoi pagare con cripto (USDT su TRC20, USDC su Base). I prompt non sono usati per l'addestramento. La pagina dei prezzi elenca i dettagli e la guida rapida ripete i passaggi di configurazione in forma breve.
Altre guide
Domande e risposte
Posso usare la libreria ufficiale OpenAI con questa API?
Sì. Installa l'SDK OpenAI per Python o Node, imposta il base URL su https://api.llminferenceapi.com/v1, passa la tua chiave e usa l'ID del modello uncensored.
L'API supporta la chiamata di funzioni?
Sì. Passa gli strumenti e opzionalmente tool_choice, quindi restituisci ogni risultato come un messaggio con role tool. Sono supportati anche gli stream di tool_calls.
Cosa significa un errore 429 qui?
Hai raggiunto un limite. Il codice rate_limited indica troppe richieste al minuto, la concorrenza indica troppe richieste simultanee, e un'intestazione Retry-After: 5 segnala un sovraccarico temporaneo. Attendi e riprova.
Posso usarlo per embedding o immagini?
No. L'API è solo testuale e offre completamenti di chat e un elenco di modelli.
La tua chiave è a un modulo di distanza
Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.
Ottieni la chiave API