IT ▾
Ottieni la chiave API

API LLM in Python: chat, streaming e chiamate di funzioni

Questa guida all'API LLM in Python utilizza l'SDK OpenAI ufficiale puntato a un endpoint compatibile con OpenAI. Ottieni una prima chiamata, lo streaming, una chiamata di funzione e la logica di retry in codice che puoi incollare ed eseguire.

Aggiornato

Nastro di blocchi di codice che scorre da un laptop a bolle di chat, che illustra una chiamata API LLM Python
01

Punti chiave

  • Installa openai, imposta il base URL e la chiave, e usa l'ID del modello uncensored.
  • Attiva lo streaming con stream=True e chiudi lo stream in anticipo per liberare lo slot di concorrenza.
  • Le chiamate di funzioni restituiscono argomenti che devi analizzare e validare prima di eseguire qualsiasi cosa.
  • Gestisci il 429 con Retry-After e limita le richieste parallele a 8 con una chiave completa.

Installa l'SDK e fai la prima chiamata

Se vuoi un setup llm api python che funzioni in cinque minuti, l'SDK OpenAI è tutto ciò che ti serve. L'API è compatibile con OpenAI, quindi mantieni il client ufficiale e modifica due valori: il base URL e la chiave. L'ID del modello è uncensored.

Ottieni prima una chiave. Iscriviti alla pagina delle chiavi API, ottieni il credito di prova in un clic e copia la chiave. Poi installa il client e tieni la chiave fuori dal codice sorgente.

pip install openai
export LLM_API_KEY="your-key-here"

Ora il programma più piccolo utile:

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)

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

Questa è l'intera integrazione. resp.usage fornisce i conteggi dei token di prompt e completion, che puoi moltiplicare per i tassi nella pagina dei prezzi ($0,15 per 1M di token di input, $0,50 per 1M di token di output) per vedere quanto costa ogni chiamata. Lo stesso endpoint accetta anche POST /v1/responses se il tuo codice usa già quel formato, e GET /v1/models elenca l'ID del modello.

Aspetto della richiesta e della risposta

Il client OpenAI nasconde i dettagli HTTP, ma è utile conoscerli quando qualcosa va storto. L'SDK invia un POST a /v1/chat/completions con un token bearer. Puoi riprodurre la chiamata con curl e confrontare.

curl https://api.llmmodelsapi.com/v1/chat/completions \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello"}]}'

Parametri utili che vengono passati al modello: temperature, top_p, stop, seed e le penalità di frequenza e presenza. max_tokens è facoltativo. Se lo ometti, il testo generato può occupare tutto lo spazio rimanente nella finestra da 100.000 token (prompt e output insieme).

Due header di risposta vale la pena registrare in ogni chiamata: X-Request-Id per le domande di supporto e X-Balance-USD per il tuo credito residuo. Con l'SDK Python li accedi tramite la risposta grezza:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Ping"}],
    max_tokens=20,
)
print(raw.headers.get("X-Request-Id"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

Streaming dei token in arrivo

Per le interfacce chat e per qualsiasi cosa stia aspettando un utente, attiva lo streaming della risposta. Imposta stream=True e itera sui chunk. L'API li invia tramite eventi inviati dal server (SSE), e l'ultimo chunk contiene i dati di utilizzo se lo richiedi.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a mechanical keyboard."}],
    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)

Due dettagli creano spesso problemi. Primo, alcuni chunk hanno una lista choices vuota (ad esempio il chunk di utilizzo), quindi verifica prima di indicizzare. Secondo, una richiesta in streaming mantiene il suo slot di concorrenza fino alla fine dello stream. Se apri uno stream e lo abbandoni senza chiuderlo, quello slot rimane occupato e le chiamate successive potrebbero fallire con un errore di concurrency. Usa lo stream in un blocco with o chiama stream.close() quando smetti di leggere prima.

Se uno streaming si interrompe con un messaggio non chiaro, l'articolo su come usare un modello LLM su questo sito copre le basi per leggere gli errori e riprovare.

Una chiamata di funzione al modello

La chiamata di funzioni permette al modello di chiedere al tuo codice di eseguire una funzione e poi continuare con il risultato. Il flusso ha tre passaggi: invia le definizioni delle funzioni, esegui qualsiasi cosa richieda il modello e invia l'output indietro con role: "tool".

import json

def get_order_status(order_id: str) -> str:
    # Replace with a real lookup
    return json.dumps({"order_id": order_id, "status": "shipped"})

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-1042?"}]
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": get_order_status(**args),
        })
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

Nel codice effettivo, analizza sempre call.function.arguments come JSON all'interno di un blocco try, perché i modelli occasionalmente producono argomenti che non corrispondono al tuo schema. Convalida prima di eseguire qualsiasi operazione con effetti collaterali. Per loop di agenti più lunghi, consulta la guida all'uso di questa API per gli agent.

Le chiamate di funzioni supportano anche lo streaming: gli argomenti arrivano in pezzi in delta.tool_calls, e li concateni per indice fino alla fine dello streaming.

Modalità JSON per output strutturato

Quando hai bisogno di output strutturato invece che di testo, imposta response_format a un oggetto JSON. Descrivi la forma che vuoi nel prompt, poiché la modalità JSON garantisce una sintassi JSON valida ma non il tuo schema specifico.

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"sentiment\": \"positive|negative|neutral\", \"confidence\": 0-1}"},
        {"role": "user", "content": "The setup took ten minutes and everything just worked."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["sentiment"])

Usa temperature=0 per l'estrazione e la classificazione in modo che esecuzioni ripetute diano le stesse etichette. Aggiungi seed se vuoi fissare ulteriormente il campionamento, e comunque convalida il risultato analizzato contro il tuo schema.

Limiti, retry e gestione degli errori

Una chiave completa permette 8 richieste concorrenti e 300 richieste al minuto. Una chiave di prova permette 2 concorrenti e 60 al minuto. Superare uno dei due restituisce HTTP 429. Il codice di errore ti dice quale limite hai raggiunto: rate_limited per le richieste al minuto e concurrency per troppe contemporanee. In caso di sovraccarico temporaneo ricevi anche un 429 con un'intestazione Retry-After: 5.

L'SDK OpenAI già ritenta alcuni errori, ma dovresti impostare la politica tu stesso:

import os
import time
from openai import OpenAI, RateLimitError, APIConnectionError

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key=os.environ["LLM_API_KEY"], max_retries=0, timeout=120)

def ask(messages, tries=5):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("gave up after retries")

Se distribuisci il lavoro con thread o asyncio, limita il pool a 8 (o 2 con una chiave di prova) usando un semaforo. Questo ti mantiene sotto il limite di concorrenza senza contare sui retry. Le richieste fallite o rifiutate non vengono addebitate, quindi ritentare non costa extra per i tentativi falliti.

Controlla il tuo saldo da codice con GET /v1/balance, oppure leggi X-Balance-USD da qualsiasi risposta. L'elenco completo dei parametri si trova nella documentazione API.

Quanto costano questi esempi

Gli esempi sopra sono minimi. Una chiamata con 300 token di prompt e 200 token di output costa 300 x $0,15 / 1M più 200 x $0,50 / 1M, ovvero $0,000045 più $0,0001, per un totale di $0,000145. Circa 6.900 chiamate di questo tipo rientrano in un dollaro. Il credito di prova da $0,50 copre circa 3.400 chiamate e vale per 7 giorni senza bisogno di inserire i dati di pagamento.

Dopo la prova, ricarica qualsiasi importo intero da $20 a $500, con un bonus del 5% da $50, 10% da $100 e 15% da $200. Il credito non scade mai e non c'è abbonamento. I prompt non sono usati per l'addestramento.

02

Domande e risposte

Posso usare la libreria Python ufficiale di OpenAI?

Sì. Imposta base_url sull'indirizzo dell'API e api_key sulla tua chiave, quindi chiama chat.completions.create con model=uncensored.

L'API supporta Python asincrono?

Sì, usa AsyncOpenAI con lo stesso URL di base e chiave. Mantieni le attività concorrenti a o sotto 8 con una chiave completa, o 2 con una chiave di prova.

Come faccio a vedere quanti token ha usato una chiamata?

Leggi resp.usage in una chiamata normale, oppure passa stream_options con include_usage in una chiamata in streaming. Moltiplica per $0,15 per 1M di token di input e $0,50 per 1M di token di output.

Quanto può essere lungo il mio prompt?

La finestra di contesto è di 100.000 token, prompt e completion combinati. Il corpo della richiesta è limitato 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.

Ottieni la chiave API