IT ▾

API LLM uncensored compatibile con OpenAIuncensoredapis.com

HomeAgenti

Tester API compatibile con OpenAI: verifica qualsiasi endpoint

Terminale che invia richieste di test a un cubo del gateway API, ognuna delle quali restituisce un segno di spunta verde

Non hai bisogno di un tester API openai compatibile speciale per verificare un endpoint. Quattro richieste e uno script Python breve ti dicono se un Base URL si comporta davvero come l'API OpenAI.

Aggiornato

Punti chiave

  1. Inizia con GET /v1/models, poi una completamento della chat minimale.
  2. Testa lo streaming e leggi l'utilizzo alla fine dello stream.
  3. Invia richieste errate apposta per vedere come appaiono gli errori.
  4. Uno script può eseguire tutti i controlli e stampare pass o fail.

I quattro controlli fondamentali

Molti servizi dicono di essere compatibili con OpenAI. Alcuni copiano solo l'endpoint chat, altri modificano il formato degli errori, altri ancora eliminano i dettagli dello streaming. Un tester dovrebbe confermare ciò su cui si basa il tuo codice client:

  1. Autenticazione e scoperta: GET /v1/models con una chiave Bearer.
  2. Una completazione chat minimale: POST /v1/chat/completions.
  3. Streaming: la stessa chiamata con stream: true.
  4. Errori: cosa viene restituito per una chiave errata, un nome di modello errato e un corpo malformato.

Gli esempi qui sotto usano l'endpoint di questo sito, https://api.uncensoredapis.com/v1, e il modello uncensored. Sostituisci con il base URL e il modello di ciò che stai testando. Se non hai ancora una chiave, creane una qui; i nuovi account possono richiedere un credito di prova da $0,50 senza carta.

Controllo 1: elenca i modelli con curl

export API_KEY="sk-your-key"
curl -s -w "\nHTTP %{http_code}\n" \
  https://api.uncensoredapis.com/v1/models \
  -H "Authorization: Bearer $API_KEY"

Ci si aspetta HTTP 200 e un oggetto JSON con un array data. Ogni elemento ha un id. Qui l'ID che userai ovunque è uncensored. Questa singola chiamata verifica DNS, TLS, il prefisso del percorso e la chiave, quindi se fallisce non ha senso testare nient'altro. Le cause usuali sono un /v1 mancante nell'URL base, una barra finale extra o una chiave incollata con un a capo.

Controllo 2: una richiesta chat minimale

curl -s https://api.uncensoredapis.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Reply with the word ok."}]}'

Nella risposta, controlla choices[0].message.content, finish_reason e l'oggetto usage con i conteggi dei token prompt e completion. Usa anche le intestazioni: aggiungi -i e cerca X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency. Sono utili per il logging e per il tracciamento dei costi in seguito. Lo stesso servizio accetta anche POST /v1/responses, che viene trattato nella spiegazione della reference API.

Controllo 3: uno script Python che testa tutto

Curl va bene per una prima occhiata, ma uno script che puoi rieseguire dopo ogni modifica è meglio. Questo usa il pacchetto ufficiale openai e segnala ogni controllo.

import sys
from openai import OpenAI, AuthenticationError, NotFoundError, RateLimitError

BASE = "https://api.uncensoredapis.com/v1"
MODEL = "uncensored"
client = OpenAI(base_url=BASE, api_key=sys.argv[1])

def check(name, fn):
    try:
        print("PASS", name, "-", fn())
    except Exception as e:
        print("FAIL", name, "-", type(e).__name__, e)

def models():
    ids = [m.id for m in client.models.list().data]
    assert MODEL in ids, ids
    return ids

def chat():
    r = client.chat.completions.create(
        model=MODEL, messages=[{"role": "user", "content": "Say ok."}])
    assert r.choices[0].message.content
    return r.usage.total_tokens

def stream():
    parts, usage = [], None
    for c in client.chat.completions.create(
            model=MODEL, stream=True,
            messages=[{"role": "user", "content": "Count to five."}]):
        if c.choices and c.choices[0].delta.content:
            parts.append(c.choices[0].delta.content)
        usage = getattr(c, "usage", None) or usage
    assert parts
    return f"{len(parts)} chunks, usage={usage}"

def bad_model():
    try:
        client.chat.completions.create(
            model="no-such-model", messages=[{"role": "user", "content": "hi"}])
    except NotFoundError as e:
        return "NotFoundError " + str(e.status_code)
    except Exception as e:
        return type(e).__name__
    raise AssertionError("bad model name was accepted")

for n, f in [("models", models), ("chat", chat), ("stream", stream), ("bad model", bad_model)]:
    check(n, f)

Eseguilo con python tester.py sk-your-key. Il controllo del modello errato registra qualsiasi classe di errore sollevata dal tuo SDK, il che è di per sé un'informazione utile. Se il servizio accetta un nome di modello sconosciuto, probabilmente lo instrada o lo aliasa, e dovresti scoprire come.

Controllo 4: gestione degli errori

La tua applicazione vedrà dei fallimenti, quindi osservali deliberatamente.

  • Chiave errata: modifica un carattere nella chiave. Ci si aspetta HTTP 401 e un corpo di errore JSON, non una pagina HTML.
  • Corpo malformato: invia {"model":"uncensored"} senza messages. Ci si aspetta un 4xx con un messaggio leggibile.
  • Limiti di velocità: questa API restituisce 429 con il codice rate_limited per le richieste al minuto e concurrency per troppe richieste simultanee. Un sovraccarico temporaneo restituisce anche 429, con Retry-After: 5.

Un buon client tratta il 429 come un segnale per attendere e riprovare, e il 4xx diverso da 429 come un bug da correggere. Scrivi la regola di retry una volta e testala lanciando dieci richieste contemporaneamente. I limiti per tipo di chiave sono nella pagina errori e limiti di velocità.

Lacune di compatibilità da cercare

Superare i quattro controlli è un buon inizio. Questi sono i punti in cui i cloni differiscono più spesso, quindi esamina ciascuno se la tua app ne dipende:

  • Parametri: invia temperature, top_p, stop, seed e le penalità. Alcuni server li ignorano silenziosamente. Esegui lo stesso prompt tre volte con un seed fisso e una temperatura bassa e confronta gli output.
  • Ruoli dei messaggi: prova prima un messaggio system, poi una lunga cronologia multi-turno. Verifica che il messaggio system cambi effettivamente il comportamento.
  • Chiamate di funzioni: chiedi una chiamata a una funzione che definisci tu, poi invia il risultato indietro come messaggio role: "tool". In modalità streaming, tool_calls arrivano a pezzi che devi concatenare.
  • Modalità JSON: imposta response_format su {"type":"json_object"} e analizza 20 risposte.
  • Dimensione del corpo: questa API accetta corpi fino a 8 MB. Una richiesta oltre il limite dovrebbe fallire con un chiaro 4xx, non rimanere in attesa.

Annota ogni lacuna che trovi e decidi se il tuo codice può aggirarla. Tieni le note accanto allo script, perché la prossima volta che il provider rilascia un aggiornamento vorrai rieseguire gli stessi controlli e confrontare. Se testi più provider, esegui lo script identico contro ciascuno e tieni l'output in una tabella, così le differenze sono visibili a colpo d'occhio invece di essere sepolte nella memoria. Un parametro mancante di solito è innocuo. Un formato di errore diverso o uno streaming rotto di solito non lo è.

Cosa il superamento non dimostra

Un'esecuzione verde mostra la compatibilità del protocollo. Non dice nulla sulla qualità delle risposte, sulla velocità sotto carico o sul prezzo. Questi richiedono test separati sui tuoi prompt. Due aggiunte rapide valgono la pena: una richiesta con un prompt lungo vicino alla tua dimensione reale (questo endpoint ha una finestra di contesto di 100.000 token) e una richiesta di chiamata di funzioni se la tua app usa agent.

Tieni anche presente contro cosa stai testando. Questo servizio ospita un modello a pesi aperti, ottimizzato per rispondere senza rifiuti di contenuto per uso adulto legale. È solo testo e non è l'API ufficiale di alcun fornitore di modelli. I prezzi sono $0,15 per 1M di token di input e $0,50 per 1M di token di output, elencati nella pagina dei prezzi, e le richieste fallite non vengono fatturate, quindi le esecuzioni di test ripetute costano molto poco. La documentazione elenca ogni parametro supportato.

Domande e risposte

Esiste uno strumento online per testare un endpoint compatibile con OpenAI?

Funziona qualsiasi client HTTP: curl, Postman o uno script breve con l'SDK OpenAI. Il vantaggio di uno script è che puoi eseguirlo di nuovo dopo ogni modifica.

Quale base URL devo inserire nell'SDK?

Usa l'URL completo includendo /v1, ad esempio https://api.uncensoredapis.com/v1. Non aggiungere /chat/completions, poiché l'SDK lo aggiunge.

Perché ottengo un 404 su una richiesta che sembra corretta?

La causa più comune è un base URL senza /v1 o con un percorso duplicato. Verificalo prima con una GET a /v1/models.

Come controllo il saldo residuo durante il test?

Leggi l'intestazione X-Balance-USD su qualsiasi risposta, oppure chiama GET /v1/balance.

La tua chiave è a un modulo di distanza

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