Come implementare un LLM in Python con un'API ospitata
Per la maggior parte dei progetti, implementare un LLM in Python si riduce a chiamare un modello ospitato via HTTP, non ad addestrarlo o servirlo tu stesso. Con un'API compatibile con OpenAI bastano circa dieci righe e lo stesso codice evolve verso lo streaming, l'output JSON e la chiamata di funzioni.
Aggiornato

Punti chiave
- Installa il pacchetto openai, imposta un base URL e una chiave, e usa l'ID del modello uncensored.
- Streaming, modalità JSON e chiamata di funzioni sono tutti supportati e usano gli argomenti standard dell'SDK.
- Mantieni la cronologia delle chat in una lista e tieni d'occhio la finestra di 100.000 token.
- Gestisci l'HTTP 429 con un breve retry; le richieste fallite o rifiutate non vengono addebitate.
Inizia con il credito di prova
E-mail e password, la chiave compare subito sullo schermo.
Ottieni la chiave APIAPI ospitata o il tuo modello
Ci sono due modi per inserire un modello linguistico in un programma Python. Puoi eseguire i pesi tu stesso, il che significa una GPU, uno stack di servizio, scelte di quantizzazione e molto tempo di attesa per i download. Oppure puoi inviare richieste a un modello già gestito da altri. La prima strada ha senso per la ricerca, l'isolamento rigoroso dei dati o un volume elevato e costante. La seconda si adatta a quasi tutto il resto: uno script, un bot, una funzionalità di prodotto, un prototipo che vuoi funzionante per pranzo.
Questa guida segue la seconda strada. Il servizio qui è un'API testuale ospitata compatibile con OpenAI con un unico modello a pesi aperti, gestito da un provider indipendente e ottimizzato per rispondere senza rifiuti di contenuti per uso adulto lecito. Non è un'API ufficiale di alcun fornitore di modelli. Poiché segue il formato delle richieste OpenAI, il pacchetto standard openai funziona, e funziona anche requests semplice se preferisci non avere dipendenze.
Passo 1: installa e fai la prima chiamata
Installa l'SDK e memorizza la tua chiave in una variabile d'ambiente, così non finisce mai nel tuo codice sorgente.
pip install openai
export API_KEY="your-key-here"
Poi crea un client con il base URL del servizio. Le uniche cose che cambi rispetto a qualsiasi altra configurazione stile OpenAI sono l'URL, la chiave e il nome del modello.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.fluxapikey.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain list comprehensions in two sentences."},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
Questo è un programma completo e funzionante. L'endpoint dietro di esso è POST /v1/chat/completions, autenticato con Authorization: Bearer <key>, e GET /v1/models elenca l'ID del modello. Puoi ottenere una chiave e un piccolo credito di prova nella pagina della chiave.
Passo 2: streamma la risposta
Attendere diversi secondi per una risposta completa sembra lento in un terminale o in una pagina web. Imposta stream=True e stampa i token man mano che arrivano tramite eventi inviati dal server.
# client from step 1: base_url https://api.fluxapikey.com/v1
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening about a lighthouse keeper."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
I numeri di utilizzo arrivano alla fine dello stream, quindi l'ultimo chunk potrebbe non avere scelte. Ecco perché il ciclo controlla prima chunk.choices. Una cosa da ricordare: una richiesta in streaming mantiene il suo slot di concorrenza fino alla fine dello stream, quindi leggi sempre fino alla fine o chiudilo.
Passo 3: mantieni una conversazione
Il modello non ha memoria tra le chiamate. Una chat è solo una lista di messaggi in crescita che invii di nuovo ogni volta. Una piccola classe è sufficiente:
# client from step 1: base_url https://api.fluxapikey.com/v1
class Chat:
def __init__(self, system):
self.messages = [{"role": "system", "content": system}]
def say(self, text):
self.messages.append({"role": "user", "content": text})
r = client.chat.completions.create(model="uncensored", messages=self.messages)
answer = r.choices[0].message.content
self.messages.append({"role": "assistant", "content": answer})
return answer
bot = Chat("You are a patient Python tutor.")
print(bot.say("What is a generator?"))
print(bot.say("Show me one with yield."))
La finestra di contesto è di 100.000 token, condivisa tra il prompt e il completamento. È spaziosa, ma una chat lunga cresce ad ogni turno e paghi per l'intera cronologia in ogni richiesta. Quando diventa grande, rimuovi i turni più vecchi o sostituiscili con un breve riassunto che chiedi al modello di scrivere.
Passo 4: ottieni un output strutturato
I programmi vogliono dati, non paragrafi. La modalità JSON rende la risposta JSON valida. Specifica nel prompt quali chiavi ti aspetti.
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
r = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": 'Return JSON like {"title": str, "tags": [str]}.'},
{"role": "user", "content": "Summarise: a tutorial on async IO in Python."},
],
)
data = json.loads(r.choices[0].message.content)
print(data["title"], data["tags"])
JSON valido non garantisce le tue chiavi. Controllale nel codice e riprova una volta se una manca.
Passo 5: lascia che il modello chiami le tue funzioni
La chiamata di funzioni permette al modello di chiedere al tuo programma di eseguire una funzione, poi di continuare con il risultato. Descrivi lo strumento, controlli se la risposta contiene una chiamata, la esegui e invii l'output indietro con il ruolo tool.
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
tools = [{
"type": "function",
"function": {
"name": "get_word_count",
"description": "Count the words in a text.",
"parameters": {
"type": "object",
"properties": {"text": {"type": "string"}},
"required": ["text"],
},
},
}]
messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = len(args["text"].split())
messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
Convalida sempre gli argomenti prima di agire su di essi, perché il modello può produrre una chiamata che non ti aspettavi. Anche le chiamate di strumenti sono in streaming, come delta di tool_calls, se ne hai bisogno. La documentazione elenca ogni campo.
Passo 6: gestisci limiti ed errori
Una chiave completa permette 8 richieste concorrenti e 300 al minuto; una chiave di prova ne permette 2 e 60. Superi il limite e l'API risponde HTTP 429. Il codice di errore è rate_limited per troppe richieste al minuto e concurrency per troppe in una volta. Su sovraccarico temporaneo ottieni anche un 429, con un'intestazione Retry-After: 5. Un piccolo wrapper di retry copre tutti e tre i casi:
# client from step 1: base_url https://api.fluxapikey.com/v1
import time
from openai import RateLimitError
def ask(messages, tries=4):
for i in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError:
time.sleep(5 * (i + 1))
raise RuntimeError("still limited after retries")
Se esegui lavoro in thread, limitati a 8 con un ThreadPoolExecutor(max_workers=8) così raramente raggiungi il limite di concorrenza. Ogni risposta trasporta X-Request-Id, che è quello da citare se contatti il supporto, e X-Balance-USD mostra il tuo credito rimanente. La dimensione massima del corpo è 8 MB.
Impostazioni che modificano l'output
La maggior parte della regolazione quotidiana avviene in un manipolo di parametri, tutti passati al modello.
temperaturecontrolla la casualità. Usa 0,2 o meno per estrazione e classificazione, circa 0,7 per la chat, e 1,0 o più per brainstorming e narrativa.top_ptaglia la coda improbabile delle scelte di parole. Cambia top_p o la temperatura, non entrambi insieme, così puoi capire quale ha fatto il lavoro.seedrende le esecuzioni ripetute più confrontabili. È utile nei test dove vuoi vedere l'effetto di un cambiamento del prompt e non il rumore.stoptermina la generazione a una stringa che scegli, il che è utile per tagliare un modello che continua ad aggiungere commenti.max_tokensè opzionale. Senza di esso il completamento può usare tutto ciò che rimane della finestra di 100.000 token. Impostalo quando vuoi un limite rigido su lunghezza e costo.- Le penalità di frequenza e presenza scoraggiano la ripetizione, il che aiuta con l'output creativo lungo che inizia a fare loop.
Annota le impostazioni che hai usato accanto a qualsiasi output che ti interessa. Dopo qualche mese, "perché ha risposto diversamente" è quasi sempre un parametro cambiato o un messaggio di sistema cambiato.
Esecuzione di molte richieste in parallelo
Un ciclo che invia una richiesta alla volta spreca la maggior parte della tua quota. Con una chiave completa puoi avere 8 richieste in volo, quindi un pool di thread riduce un lungo batch a circa un ottavo del tempo effettivo.
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI
client = OpenAI(base_url="https://api.fluxapikey.com/v1", api_key="YOUR_KEY")
def summarise(text):
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarise in one line: " + text}],
max_tokens=60,
)
return r.choices[0].message.content
texts = ["first document", "second document", "third document"]
with ThreadPoolExecutor(max_workers=8) as pool:
for line in pool.map(summarise, texts):
print(line)
Mantieni il conteggio dei worker a 8 o meno, o a 2 su una chiave di prova. Se vedi ancora risposte 429 con il codice concurrency, abbassa il numero di uno o due. Il limite di 300 al minuto conta per le richieste veloci e brevi, quindi un batch di chiamate minuscole può raggiungerlo prima del limite di concorrenza.
Problemi comuni e soluzioni
La maggior parte degli errori del primo giorno deriva da un breve elenco di cause.
- 401 o errore di autenticazione. La chiave manca, è digitata male o inviata all'host sbagliato. Stampa il base URL che il tuo client usa effettivamente e assicurati che finisca con
/v1. - Modello non trovato. L'ID del modello deve essere
uncensored. ChiamaGET /v1/modelsse vuoi confermare cosa elenca il server. - Risposta vuota o troncata. Un
max_tokensbasso ferma la risposta a metà frase. Aumentalo o rimuovilo. Controllafinish_reasonsulla scelta:lengthsignifica che il limite è stato raggiunto. - JSON che non si analizza. O la risposta è stata troncata, o il prompt non ha mai descritto la forma. Correggi prima il prompt e avvolgi l'analisi in un blocco try.
- Primo token lento. Un prompt molto lungo richiede più tempo per essere elaborato. Taglia la cronologia o invia meno contesto.
- Richiesta troppo grande. Il limite del corpo è 8 MB e la finestra di token è 100.000. Dividi i documenti grandi in pezzi e riassumi ciascuno.
Quando qualcosa sembra ancora sbagliato, registra l'intestazione X-Request-Id con l'input fallito. Permette al supporto di trovare la richiesta esatta.
Quanto costa
Paghi $0,15 per 1M di token di input e $0,50 per 1M di token di output dal credito prepagato. Una chiamata tipica con 2.000 token in ingresso e 500 in uscita costa 0,002 x $0,15 = $0,0003 per l'input più 0,0005 x $0,50 = $0,00025 per l'output, quindi $0,00055 in totale. Diecimila chiamate di questo tipo costano $5,50. Le richieste fallite o rifiutate non vengono addebitate e il credito non scade mai. Le ricariche vanno da $20 a $500; vedi prezzi per i livelli bonus. I prompt non sono usati per l'addestramento.
I token di output costano di più dei token di input, quindi l’abitudine più economica è chiedere risposte brevi: dì due frasi, o solo JSON, e imposta max_tokens a un limite ragionevole. Leggi resp.usage durante lo sviluppo per vedere i conteggi reali dei token per i tuoi prompt e moltiplica per i tariffe sopra prima di scalare un lavoro. L’intestazione X-Balance-USD mostra quanto rimane dopo ogni chiamata.
Altre guide
Domande e risposte
Ho bisogno di una GPU per implementare un LLM in Python?
No con un’API ospitata. Il tuo codice Python invia solo richieste HTTP, quindi qualsiasi laptop funziona.
Posso usare il pacchetto ufficiale openai?
Sì. Imposta base_url sull’URL del servizio e api_key sulla tua chiave, e usa l’ID del modello uncensored.
Supporta il codice asincrono?
Il client AsyncOpenAI dell’SDK funziona con lo stesso base URL e chiave. Mantieni la concorrenza a 8 o meno richieste.
Come posso provarlo senza pagare?
Registrati e richiedi il credito di prova da $0,50 nella pagina della chiave. È valido per 7 giorni e non richiede carta.
La tua chiave è a un modulo di distanza
Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.