IT ▾

API Python OpenAI: usa l'SDK OpenAI con il nostro modello

Cavo a forma di serpente stilizzato collegato a un server con bolle di chat, che rappresenta Python che chiama un'API

Per il codice dell'API Python OpenAI non serve una libreria speciale. Il pacchetto openai ufficiale funziona con questo servizio dopo aver impostato un base URL e una chiave diversi, e l'ID del modello è uncensored. Di seguito trovi una guida completa con esempi da copiare e incollare.

Aggiornato

Punti chiave

  • Installa openai, quindi passa base_url e api_key al client; il resto del tuo codice non cambia.
  • Streaming, modalità JSON e chiamata di funzioni funzionano tutti tramite gli stessi metodi SDK.
  • Cattura RateLimitError e riprova; i limiti sono 300 richieste al minuto e 8 concorrenti con una chiave completa.
  • Il costo è $0,15 per 1M di token di input e $0,50 per 1M di token di output, addebitato solo per le richieste riuscite.

Installa ed effettua la prima chiamata

Ti servono Python 3.9 o superiore e l'SDK ufficiale. Crea prima una chiave API nella pagina delle chiavi; i nuovi account possono richiedere $0,50 di credito di prova con un clic, senza carta.

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

Ecco lo script funzionante minimo. Il client accetta la base URL e la chiave; la richiesta usa l'ID del modello uncensored.

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise writing assistant."},
        {"role": "user", "content": "Give me three opening lines for a mystery novel."},
    ],
    temperature=0.8,
)

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

Questa è l'integrazione completa. Il servizio implementa POST /v1/chat/completions e GET /v1/models, che coprono l'uso della maggior parte degli script. È un modello solo testo, quindi gli endpoint per immagini, audio ed embeddings non sono disponibili.

Cos'è e cosa non è

L'SDK è sviluppato da OpenAI, ma l'endpoint qui non è quello di OpenAI. È un modello a pesi aperti ospitato, gestito da un provider indipendente e ottimizzato per rispondere senza rifiuti di contenuti per uso adulto legale. Non c'è instradamento verso GPT o il modello di qualsiasi altro fornitore. Ecco perché cambi la base URL: stai parlando con un server diverso che accetta lo stesso formato di richiesta.

Se stai migrando un progetto esistente, cerca OpenAI( e i nomi di modello hard-coded. Sono le uniche due posizioni da modificare. La checklist di produzione GPT API su questo sito copre le abitudini applicabili a qualsiasi endpoint in formato OpenAI, come timeout e retry.

Attiva lo streaming della risposta

Per le interfacce chat vuoi i token man mano che vengono prodotti. Imposta stream=True e itera. Chiedi l'utilizzo alla fine se vuoi i dati di fatturazione:

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a four-line poem about a night train."}],
    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)

Il controllo su chunk.choices è importante: l'ultimo chunk può contenere l'utilizzo e nessuna scelta. Inoltre, una richiesta in streaming occupa uno dei tuoi slot concorrenti fino alla fine dello stream, quindi leggi sempre fino alla fine o chiudilo.

Modalità JSON

Quando il tuo codice deve analizzare la risposta, attiva la modalità JSON e descrivi le chiavi nel prompt:

import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "user", "content": "Return JSON with keys name (string) and traits (list of 3 strings) for a fictional ship captain."}
    ],
)
character = json.loads(resp.choices[0].message.content)
print(character["name"], character["traits"])

Un JSON valido è l'esito probabile, non una promessa del tuo schema esatto, quindi controlla le chiavi e riprova una volta in caso di errore.

Chiamata di funzioni

Descrivi le funzioni in tools, esegui ciò che chiede il modello e invia il risultato indietro con role: "tool":

import json

tools = [{
    "type": "function",
    "function": {
        "name": "roll_dice",
        "description": "Roll a die with the given number of sides",
        "parameters": {
            "type": "object",
            "properties": {"sides": {"type": "integer"}},
            "required": ["sides"],
        },
    },
}]

messages = [{"role": "user", "content": "Roll a 20-sided die for my character."}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
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 = {"value": 14, "sides": args["sides"]}  # replace with real logic
        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)
else:
    print(msg.content)

Puoi passare tool_choice per forzare una funzione. Gli argomenti arrivano come stringa JSON, quindi esegui sempre json.loads e validali prima dell'uso.

Errori, retry e async

L'SDK riprova alcuni errori autonomamente e puoi impostare il conteggio con max_retries. Per i limiti di velocità, cattura l'eccezione e attendi. L'API restituisce HTTP 429 con il codice rate_limited quando superi il limite per minuto, con concurrency quando troppe richieste sono in esecuzione contemporaneamente, e con l'intestazione Retry-After: 5 in caso di sovraccarico temporaneo.

import time
from openai import RateLimitError

def ask(prompt, tries=4):
    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")

Per i batch, usa il client asincrono e limita il parallelismo al di sotto del tuo limite. Una chiave completa permette 8 richieste concorrenti e 300 al minuto; una chiave di prova permette 2 e 60.

import asyncio, os
from openai import AsyncOpenAI

aclient = AsyncOpenAI(base_url="https://api.aiapisource.com/v1", api_key=os.environ["API_KEY"])
sem = asyncio.Semaphore(6)

async def one(prompt):
    async with sem:
        r = await aclient.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Write a tagline for product number {i}." for i in range(20)]
    results = await asyncio.gather(*(one(p) for p in prompts))
    print(len(results), "done")

asyncio.run(main())

L'uso di 6 degli 8 slot lascia spazio per altro traffico sulla stessa chiave.

Mantieni viva la conversazione

L'API è stateless. Non ricorda nulla tra le chiamate, quindi una chat è solo l'elenco dei messaggi che invii ogni volta. Aggiungi la risposta all'elenco e invia di nuovo l'elenco intero:

history = [{"role": "system", "content": "You are a patient writing coach."}]

def chat(user_text):
    history.append({"role": "user", "content": user_text})
    r = client.chat.completions.create(model="uncensored", messages=history)
    reply = r.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

print(chat("Give me a prompt for a short story."))
print(chat("Make it darker and set it in a harbour town."))

Ogni chiamata invia più token della precedente e i token di input vengono fatturati in ogni chiamata. Quando l'elenco diventa lungo, rimuovi i turni più vecchi o sostituiscili con un breve riassunto. La finestra di contesto è di 100.000 token per prompt più completamento, che è molto, ma una cronologia lunga rende ogni richiesta più costosa e più lenta da avviare.

Le impostazioni di campionamento vengono inoltrate così come sono: temperature, top_p, stop, seed e le penalità di frequenza e presenza. Imposta seed e una temperatura bassa quando vuoi esecuzioni di test ripetibili.

Stima il costo prima di un'esecuzione grande

La fatturazione è per token dal credito prepagato: $0,15 per 1M di token di input e $0,50 per 1M di token di output. Le richieste fallite o rifiutate non vengono addebitate e il credito non scade mai. Prendi un batch di 10.000 richieste con 1.500 token di input e 400 token di output ciascuno. L'input è 15.000.000 di token, che è 15 x $0,15 = $2,25. L'output è 4.000.000 di token, che è 4 x $0,50 = $2,00. Il batch costa $4,25.

Le intestazioni di risposta includono X-Balance-USD, quindi puoi leggere il tuo saldo residuo nel codice tramite client.chat.completions.with_raw_response.create(...). Le ricariche sono qualsiasi importo intero da $20 a $500, con +5% da $50, +10% da $100 e +15% da $200. La pagina dei prezzi elenca le opzioni di pagamento e la guida rapida elenca ogni parametro supportato, inclusi stop, seed e le penalità.

Domande e risposte

Posso usare il pacchetto Python ufficiale di OpenAI con questa API?

Sì. Installa openai, imposta base_url sull'endpoint del servizio e api_key sulla tua chiave, quindi chiama chat.completions.create con il modello uncensored.

Mi serve una libreria diversa per lo streaming o gli strumenti?

No. Streaming, modalità JSON e chiamata di funzioni funzionano tramite gli stessi metodi SDK, con i parametri abituali.

È il modello di OpenAI?

No. È un modello a pesi aperti gestito da un provider indipendente. Il formato della richiesta è lo stesso, motivo per cui l'SDK funziona.

I miei prompt addestrano il modello?

No. I prompt inviati tramite l'API non vengono utilizzati per l'addestramento.

La tua chiave è a un modulo di distanza

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

Ottieni la chiave API