IT ▾
Ottieni la chiave API

Best LLM API Guida

Come usare un'API LLM: dalla prima richiesta allo streaming

Usare un'API LLM significa inviare una lista di messaggi in formato JSON via HTTPS e leggere la risposta. Questa guida ti porta dall'ottenimento della chiave alla prima richiesta, fino allo streaming, all'output in JSON e alle chiamate di funzioni.

Aggiornato:

Pacchetto di richiesta luminoso che viaggia da un terminale a un server e rimanda indietro token in streaming

Punti chiave

  • L'endpoint è compatibile con OpenAI: cambia il base URL e la chiave, mantieni il tuo SDK.
  • Usa l'ID del modello uncensored e fai una POST a /v1/chat/completions.
  • Sono supportati streaming, modalità JSON e chiamata di funzioni.
  • Un 429 significa rallentare; leggi il codice di errore per capire il motivo.

Cos'è una chiamata API LLM

Se ti chiedi come utilizzare i servizi LLM API in generale, l'idea è semplice. Invii una POST HTTPS con un elenco di messaggi. Ogni messaggio ha un ruolo (system, user o assistant) e del testo. Il server esegue il modello e restituisce il messaggio dell'assistant successivo. Questo è l'intero contratto.

Il modello non ha memoria tra le chiamate. Se vuoi una conversazione, invii di nuovo i messaggi precedenti ogni volta. Ecco perché i prompt crescono, perché il costo cresce con essi e perché la finestra di contesto da 100.000 token è importante: è il limite tra prompt e risposta insieme.

Questo servizio usa lo stesso protocollo dell'API Chat Completions di OpenAI. Qualsiasi SDK OpenAI o client compatibile funziona dopo aver cambiato due cose, il base URL e la chiave. Entrano ed escono solo testi. Non ci sono generazione di immagini, audio o video e nessun endpoint per gli embeddings.

Alcuni termini sono usati nel resto di questa guida. Un token è un blocco di testo, circa tre quarti di una parola inglese in media. Input tokens sono tutto ciò che invii, e output tokens è ciò che scrive il modello. Vieni fatturato per entrambi, a tariffe diverse, e la risposta ti dice esattamente quanti di ciascuno ha usato. Un base URL è l'indirizzo che il tuo client antepone a ogni percorso, e una API key è il segreto che dimostra che la richiesta è tua. Se conosci queste quattro parole, il resto è routine.

Passo 1: ottieni una chiave e annota tre valori

Crea un account con Google, oppure con email e password, e apri la pagina della chiave API. Lì puoi copiare la tua chiave e ottenere il credito di prova da $0,50 con un solo clic. Per la prova non serve la carta.

Hai bisogno di tre valori per ogni richiesta:

  • Base URL: https://api.bestllmapi.com/v1
  • ID modello: uncensored
  • Header Auth: Authorization: Bearer YOUR_KEY

Non inserire la chiave nel controllo di versione. Inseriscila in una variabile d'ambiente come LLM_API_KEY e leggila da lì. Chiunque abbia la chiave può spendere il tuo credito.

Passo 2: invia una prima richiesta con curl

Curl è il controllo più veloce che tutto funzioni, prima che intervenga qualsiasi libreria.

export LLM_API_KEY="paste-your-key-here"

curl https://api.bestllmapi.com/v1/chat/completions \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "Explain what a token is in two sentences."}
    ],
    "temperature": 0.7
  }'

La risposta è JSON. Il testo è a choices[0].message.content, e un oggetto usage elenca i token di prompt e completion, su cui vieni fatturato. Puoi anche elencare i modelli con GET https://api.bestllmapi.com/v1/models; dovresti vedere uncensored.

Aiutano anche gli header di risposta. X-Request-Id identifica la chiamata se contatti il supporto, e X-Balance-USD mostra quanto resta nel tuo account.

Leggere la risposta e scegliere i parametri

Una risposta ha alcuni campi degni di nota prima di scrivere codice di parsing. choices è una lista, e quasi sempre vuoi il primo elemento. All'interno, message.content contiene il testo, e finish_reason ti dice perché il modello si è fermato. Un valore di stop significa che ha finito naturalmente. Un valore di length significa che ha raggiunto il limite di max_tokens o ha esaurito la finestra, quindi la risposta potrebbe essere tagliata a metà frase.

L'oggetto usage fornisce i token di prompt, i token di completion e un totale. Registra questi valori per ogni chiamata fin dal primo giorno. Sono l'unico modo affidabile per capire quanto costa davvero la tua app, e ti aiutano a individuare facilmente un bug che invia lo stesso prompt lungo due volte.

Scegliere i parametri è principalmente una questione di tipo di attività. Per estrazione, classificazione e codice, usa una temperatura bassa come 0,2, così lo stesso input dà quasi lo stesso output. Per brainstorming e storie, 0,8-1,0 dà più varietà. Cambia un valore alla volta, e usa seed quando vuoi confronti ripetibili tra due versioni di prompt.

Passo 3: usa l'SDK OpenAI in Python o Node

In pratica userai una libreria. In Python, installala con pip install openai e puntala al nuovo base URL.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.bestllmapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Give me three names for a hiking app."},
    ],
    temperature=0.8,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

La versione Node è quasi identica. Installa con npm install openai.

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.bestllmapi.com/v1",
  apiKey: process.env.LLM_API_KEY,
});

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Give me three names for a hiking app." }],
});

console.log(resp.choices[0].message.content);

max_tokens è facoltativo. Se lo lasci fuori, la risposta potrebbe usare tutto ciò che resta della finestra da 100.000 token, quindi impostalo quando vuoi risposte brevi. Le impostazioni di campionamento temperature, top_p, stop, seed e le penalità vengono passate al modello.

Passo 4: ricevere la risposta in streaming

Senza streaming, il tuo utente fissa uno schermo vuoto fino a quando l'intera risposta è pronta. Con stream: true il server invia i token tramite Server-Sent Events man mano che vengono prodotti, e i totali di utilizzo arrivano alla fine.

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a desk lamp."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\nTokens:", chunk.usage.total_tokens)

Una cosa da ricordare: una richiesta in streaming occupa il suo slot di concorrenza fino alla fine dello stream. Una chiave completa permette 8 richieste concorrenti, una chiave di prova 2. Se un utente chiude la scheda, chiudi anche tu lo stream dal tuo lato, altrimenti lo slot resta occupata.

Mantenere viva una conversazione

Poiché l'API non ha memoria, un'app chat è un ciclo che aggiunge a una lista. Il pattern qui sotto è il nucleo di quasi tutti i chatbot.

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])

messages = [{"role": "system", "content": "You are a friendly travel planner."}]

while True:
    user_text = input("You: ")
    if user_text.strip().lower() in ("quit", "exit"):
        break
    messages.append({"role": "user", "content": user_text})
    resp = client.chat.completions.create(model="uncensored", messages=messages)
    answer = resp.choices[0].message.content
    messages.append({"role": "assistant", "content": answer})
    print("Bot:", answer)

Ogni passaggio reinvia l'elenco intero, quindi il costo per turno aumenta man mano che la chat si allunga. Il prezzo è $0,15 per 1M di token di input e $0,50 per 1M di token di output. Un turno con 2.000 input tokens e 400 output tokens costa 2.000 / 1.000.000 x $0,15 = $0,0003 più 400 / 1.000.000 x $0,50 = $0,0002, quindi $0,0005. A quel tasso, il credito di prova da $0,50 copre circa 1.000 turni.

Quando la lista diventa lunga, rimuovi i messaggi user e assistant più vecchi ma mantieni il messaggio system in cima. Oppure chiedi al modello di scrivere un breve riassunto dei turni iniziali e sostituiscili con esso.

Passo 5: modalità JSON e tool calling

Quando il tuo codice deve analizzare la risposta, chiedi il JSON. Imposta response_format su {"type": "json_object"} e dì anche "JSON" nel prompt così il modello sa che forma vuoi.

import os, json
from openai import OpenAI

client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply only with JSON."},
        {"role": "user", "content": "Extract name and city: 'Maria lives in Lisbon.' Use keys name and city."},
    ],
)
print(json.loads(resp.choices[0].message.content))

Il tool calling permette al modello di chiedere al tuo codice di eseguire una funzione. Descrivi la funzione in tools; il modello risponde con una voce tool_calls invece che testo; esegui la funzione e invia il risultato indietro con role: "tool".

import os, json
from openai import OpenAI

client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up an order by its id",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}
    messages.append(msg)
    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)

I modelli possono produrre occasionalmente argomenti malformati, quindi avvolgi json.loads in un blocco try nel codice reale e invia un errore indietro come risultato del tool se il parsing fallisce.

Quando qualcosa va storto

La maggior parte dei problemi del primo giorno è una di queste.

  • 401 o errore di autenticazione: la chiave manca, ha un errore di battitura, o l'header non è nella forma Bearer KEY.
  • 404: il base URL manca /v1, o hai chiamato il percorso sbagliato. Il percorso chat è /v1/chat/completions.
  • 429 con codice rate_limited: hai passato il limite di richieste al minuto (300 su una chiave completa, 60 su una chiave di prova).
  • 429 con codice concurrency: troppe richieste simultanee (8 su una chiave completa, 2 su una chiave di prova). Metti in coda le tue chiamate.
  • 429 con Retry-After: 5: sovraccarico temporaneo. Attendi cinque secondi e riprova.
  • Richiesta troppo grande: il limite del body è 8 MB, e prompt più risposta devono stare in 100.000 token.

Le richieste fallite o rifiutate non vengono addebitate, quindi riprovare con cura non costa nulla in più. Per ogni codice di errore e altri esempi, leggi la documentazione, e consulta pricing per stimare quanto costa un carico di lavoro a $0,15 per 1M di token di input e $0,50 per 1M di token di output.

Riprova educatamente nel codice

Uno script che invia molte richieste incontrerà eventualmente un 429. La soluzione è un piccolo wrapper di retry che aspetta e riprova. Questa versione rispetta la pausa di cinque secondi che l'API richiede in caso di sovraccarico temporaneo.

import os, time
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.bestllmapi.com/v1", api_key=os.environ["LLM_API_KEY"])

def ask(prompt, tries=5):
    for attempt in range(tries):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError:
            time.sleep(5 * (attempt + 1))
    raise RuntimeError("still rate limited after retries")

print(ask("List three uses for a paperclip."))

Se esegui molte richieste in parallelo, limita il numero di worker al tuo limite di concorrenza. Un thread pool di 8 corrisponde a una chiave completa, e 2 a una chiave di prova. Superare questo valore produce solo errori concurrency.

Domande e risposte

Mi serve un SDK speciale?

No. Funziona qualsiasi SDK OpenAI o client compatibile con OpenAI. Imposta il base URL su https://api.bestllmapi.com/v1, usa la tua chiave e imposta il modello su uncensored.

Posso provarla prima di pagare?

Sì. I nuovi utenti possono richiedere $0,50 di credito di prova gratuito con un clic nella pagina della chiave API. Non serve la carta ed è valido per 7 giorni.

L'API ricorda i messaggi precedenti?

No. Invia la cronologia della conversazione nella lista messages ad ogni richiesta. Prompt e risposta devono rientrare nella finestra di contesto da 100.000 token.

Cosa significa un errore 429?

Hai raggiunto un limite. Il codice rate_limited indica troppe richieste al minuto, concurrency indica troppe richieste simultanee, e un header Retry-After indica un sovraccarico temporaneo.

La tua chiave è a un modulo di distanza

Crea un account, copia la chiave, modifica il base URL. È tutta la configurazione.

Ottieni la chiave API