Come usare un modello LLM tramite API, passo dopo passo
Usare un modello linguistico ospitato si riduce a una chiamata HTTP con una chiave, un nome del modello e un elenco di messaggi. Questa guida ti porta da una cartella vuota allo streaming, all'output JSON e alle chiamate di funzioni.

Punti chiave
- L'API è compatibile con OpenAI: cambia il base URL e la chiave, mantieni il tuo SDK.
- Usa l'ID modello uncensored con POST /v1/chat/completions.
- Streaming, modalità JSON e chiamata di funzioni funzionano tutti con i parametri standard.
- Un 429 indica che è stato raggiunto un limite, e il codice di errore ti dice quale.
Cosa ti serve prima della prima richiesta
Se vuoi sapere come usare gli endpoint dei modelli LLM nel tuo codice, ti bastano tre cose: una chiave, un base URL e un nome del modello. Non c'è bisogno di installare un client speciale. Qualsiasi SDK o client OpenAI funziona una volta che lo punti a un indirizzo diverso.
- URL di base:
https://api.llmmodelsapi.com/v1 - ID modello:
uncensored - Autenticazione: un'intestazione
Authorization: Bearer YOUR_KEY, che gli SDK aggiungono per te
Per ottenere una chiave, registrati con Google o con email e password, poi apri la pagina chiave API. I nuovi account possono richiedere $0.50 di credito di prova lì con un clic, senza carta, valido per 7 giorni. È più che sufficiente per tutto ciò che è descritto in questo articolo. L'endpoint supporta due metodi: POST /v1/chat/completions per la generazione e GET /v1/models per elencare ciò che è disponibile.
È utile conoscere il modello, così le tue aspettative saranno corrette. È un modello a pesi aperti gestito da un provider indipendente e ottimizzato per rispondere senza rifiuti sui contenuti per uso adulto lecito. Non è l'API ufficiale di nessun grande fornitore e gestisce solo testo. Non ci sono generazione di immagini o audio, embedding né fine-tuning.
Passo 1: verifica la chiave con curl
Prima di scrivere codice per le applicazioni, conferma che la chiave e il percorso di rete funzionino. L'elenco dei modelli è il controllo più economico, perché non genera nulla.
export LLM_KEY="paste-your-key-here"
# the list should include the model id: uncensored
curl https://api.llmmodelsapi.com/v1/models -H "Authorization: Bearer $LLM_KEY"
Dovresti ottenere un elenco JSON che include uncensored. Se vedi un 401, la chiave è errata o manca la parola Bearer. Ora invia una vera richiesta di chat.
curl https://api.llmmodelsapi.com/v1/chat/completions -H "Authorization: Bearer $LLM_KEY" -H "Content-Type: application/json" -d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain what a context window is in two sentences."}
],
"max_tokens": 150
}'
La risposta contiene un array choices, e il testo si trova a choices[0].message.content. Le intestazioni di risposta contengono X-Request-Id e X-Balance-USD, così puoi vedere il tuo credito residuo in ogni chiamata. Il campo usage mostra i token conteggiati per la fatturazione.
Passo 2: chiamalo da Python o Node
In pratica userai un SDK. Installa il pacchetto ufficiale OpenAI, poi imposta l'URL di base quando crei il client. Niente altro nel tuo codice cambia.
Python
from openai import OpenAI
client = OpenAI(
base_url="https://api.llmmodelsapi.com/v1",
api_key="YOUR_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You answer in plain language."},
{"role": "user", "content": "Give me three names for a fantasy tavern."},
],
temperature=0.9,
max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
Node
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.llmmodelsapi.com/v1",
apiKey: process.env.LLM_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Summarise HTTP caching in one paragraph." }],
});
console.log(resp.choices[0].message.content);
Mantieni la chiave in una variabile d'ambiente invece che nel file di origine. Se una chiave viene trapelata, sostituiscila nella pagina delle chiavi e quella vecchia smetterà di funzionare.
Passo 3: modula l'output con i parametri
Il modello è un predittore di testo, quindi il modo in cui formuli la richiesta è importante quanto i parametri. Alcune abitudini pagano subito.
- Usa il messaggio di sistema per le regole fisse. Metti tono, formato e ruolo lì, e mantieni il messaggio dell'utente per il compito effettivo.
- Sii specifico sulla lunghezza. Chiedi "tre punti elenco" o "sotto le 120 parole". È più affidabile che abbassare solo
max_tokens, che tronca il testo a metà frase. - Regola la temperatura in base al compito. Intorno a 0.2 è adatta per estrazione e classificazione. Intorno a 0.8-1.0 è adatta per narrativa e roleplay.
- Passa ciò che ti serve.
top_p,stop,seede le penalità di frequenza e presenza sono passate al modello.
La finestra di contesto è di 100.000 token, contando prompt e completamento insieme. Non devi impostare max_tokens, perché la risposta può usare tutto lo spazio rimasto. Impostarlo comunque è un buon modo per mettere un tetto al costo.
Un modo pratico per imparare queste impostazioni è eseguire lo stesso prompt tre volte a temperature diverse e confrontare i risultati. Modifica un valore per esecuzione e mantieni gli altri fissi, usando lo stesso seed dove possibile. Dopo dieci minuti di questo esercizio saprai come si comporta il modello per il tuo compito molto meglio di quanto potrebbe dire qualsiasi descrizione, e il costo dell'esperimento è una frazione di centesimo.
Il prezzo è $0,15 per milione di token di input e $0,50 per milione di token di output. Una richiesta con 1.500 token di input e 400 di output costa 1.500 x 0,15 / 1.000.000 = $0,000225 più 400 x 0,50 / 1.000.000 = $0,0002, per un totale di $0,000425. La pagina dei prezzi mostra le opzioni di ricarica.
Passo 4: attiva lo streaming della risposta
Aspettare una risposta completa sembra lento in un'app interattiva. Con stream: true il server invia i token come eventi inviati dal server, e la tua UI può stamparli man mano che arrivano. L'utilizzo viene segnalato alla fine dello streaming.
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening 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("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
Una cosa da ricordare sulla concorrenza: una richiesta in streaming occupa il suo slot fino al termine dello streaming. Una chiave completa permette 8 richieste concorrenti, una chiave di prova ne permette 2. Se apri uno streaming nel browser e non lo chiudi mai, quello slot rimane occupato.
Passo 5: modalità JSON e chiamata di funzioni
Quando un altro programma deve leggere la risposta, il testo libero diventa un problema. La modalità JSON chiede al modello di restituire un oggetto JSON valido.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON only: {\"title\": string, \"tags\": [string]}"},
{"role": "user", "content": "Describe a post about growing tomatoes on a balcony."},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
Descrivi anche la forma che vuoi nel prompt, poiché la modalità JSON garantisce una sintassi valida e non i tuoi nomi di campo esatti. Avvolgi l'operazione di parsing in un blocco try e riprova una volta se fallisce.
La chiamata di funzioni permette al modello di chiedere al tuo codice di eseguire una funzione. Descrivi gli strumenti, il modello risponde con un elemento tool_calls, lo esegui e invii il risultato indietro come messaggio con role: "tool".
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "get_time",
"description": "Return the current time for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
messages = [{"role": "user", "content": "What time is it in Lisbon?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]
messages.append(first.choices[0].message)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps({"time": "14:05"}),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
In produzione, controlla che tool_calls sia presente prima di accedervi per indice, perché il modello potrebbe rispondere direttamente invece di chiamare la funzione. Il parametro tool_choice ti permette di forzare o vietare una chiamata quando ne hai bisogno.
Mantenere viva una conversazione
L'API non ha memoria tra le chiamate. Se vuoi che il modello ricordi ciò che è stato detto due turni fa, invii di nuovo quei turni. Un'app di chat è quindi una lista che cresce: aggiungi il messaggio dell'utente, chiama l'API, aggiungi la risposta dell'assistente e ripeti.
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
history = [{"role": "system", "content": "You are a friendly writing coach."}]
def say(text):
history.append({"role": "user", "content": text})
resp = client.chat.completions.create(model="uncensored", messages=history, max_tokens=300)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(say("Give me a tip for opening a short story."))
print(say("Now apply it to a story about a night train."))
Poiché ogni chiamata trasporta l'elenco intero, costo e latenza crescono con la conversazione. Una volta che la cronologia diventa lunga, elimina i turni più vecchi o sostituiscili con un riassunto di un paragrafo. Hai molto spazio, poiché 100,000 token sono circa la lunghezza di un romanzo breve, ma non c'è motivo di pagare per token che non aiutano più la risposta.
Per lo stesso motivo, mantieni breve e stabile il messaggio di sistema. Viene inviato in ogni chiamata, quindi un prompt di sistema di 1.000 token su 500 richieste è 500.000 token di input, che costa 500.000 x 0,15 / 1.000.000 = $0,075 da solo.
Gli errori che commettono i principianti
- Dimenticare di aggiungere la risposta dell'assistente. Il modello vede solo le tue domande e perde il filo.
- Mettere i segreti nel frontend. Una chiave nel codice del browser è visibile a tutti. Chiama l'API dal tuo server ed esponi il tuo endpoint al suo posto.
- Ci si aspetta che un predittore di testo fornisca fatti. Il modello può affermare con sicurezza dettagli errati. Fornisci il testo di origine nel prompt quando l'accuratezza è importante e verifica l'output rilevante.
- Analisi del testo libero. Se il codice deve leggere la risposta, usa la modalità JSON o una chiamata di funzione invece delle espressioni regolari.
Errori, limiti e risorse correlate
La maggior parte dei problemi rientra in un breve elenco.
| Sintomo | Causa probabile | Risoluzione |
|---|---|---|
| Risposta 401 | Chiave mancante o errata | Controlla l'intestazione Bearer e la chiave nella pagina delle chiavi |
429, codice rate_limited | Oltre 300 richieste al minuto (60 su una chiave di prova) | Rallenta o accoda le richieste |
429, codice concurrency | Oltre 8 richieste contemporanee (2 su una chiave di prova) | Limita i worker paralleli, chiudi gli stream aperti |
429 con Retry-After: 5 | Sovraccarico temporaneo | Attendi 5 secondi e ritenta |
| Richiesta troppo grande | Corpo oltre 8 MB | Invia meno testo per chiamata |
Un semplice retry con un breve ritardo gestisce i casi 429. Le richieste fallite non vengono addebitate, quindi ritentare non costa nulla in più. I prompt non vengono utilizzati per l'addestramento.
Da qui, la documentazione API elenca ogni parametro, e la panoramica pay-per-token copre per chi è il servizio. Una regola vale ovunque: i contenuti sessuali che coinvolgono minorenni non sono mai consentiti.
Altre guide
Domande e risposte
Quale ID modello invio nella richiesta?
Usa uncensored come valore del modello in ogni richiesta. Puoi confermarlo chiamando GET /v1/models.
Ho bisogno di un SDK speciale?
No. Qualsiasi SDK o client OpenAI funziona una volta che cambi l'URL di base in https://api.llmmodelsapi.com/v1 e usi la tua chiave.
Posso usarlo senza carta di credito?
Sì, per i test. I nuovi utenti possono richiedere $0,50 di credito di prova con un clic dopo l'accesso, senza carta, valido per 7 giorni.
Quanto può essere lungo il mio prompt?
La finestra di contesto è di 100,000 token per prompt e completamento insieme, e il corpo della richiesta può essere fino a 8 MB.
La tua chiave è a un modulo di distanza
Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.