Quale ID modello devo usare?

Usa uncensored come ID del modello in ogni richiesta. Imposta il Base URL su https://api.uncensoredllmhub.com/v1 e invia la tua chiave come token Bearer.

Funziona con il mio codice OpenAI esistente?

Sì. Qualsiasi SDK o client OpenAI funziona dopo aver modificato il Base URL e la chiave. Sono supportati completamenti di chat, streaming, chiamata di funzioni e modalità JSON.

Può generare immagini o embedding?

No. È un'API solo testo, senza generazione di immagini, audio o video, senza embeddings e senza fine-tuning.

Quanto può essere lunga una conversazione?

La finestra di contesto è di 100.000 token, condivisa tra prompt e risposta. Il corpo della richiesta può essere fino a 8 MB.

Uncensored LLM Hub: Un endpoint unico per chat e agent

Punti chiave

Un unico Base URL e un unico ID del modello, uncensored, funzionano con qualsiasi SDK o client OpenAI.
Sono supportati streaming, chiamata di funzioni e modalità JSON, con una finestra di contesto di 100.000 token.
Una chiave completa permette 8 richieste parallele e 300 al minuto, quindi pianifica una coda ridotta per le app più trafficate.
La fatturazione è di $0,15 per 1M di token di input e $0,50 per 1M di token di output dal credito prepagato, e i prompt non vengono utilizzati per l'addestramento.

Cosa ottieni da un singolo endpoint

Le persone cercano Uncensored LLM Hub quando vogliono un modello che risponda senza rifiuto dei contenuti per uso adulto legale, ma non vogliono gestire GPU. Il servizio è un'API HTTPS standard. Punti un client OpenAI a https://api.uncensoredllmhub.com/v1, invii l'ID del modello uncensored e ti autentichi con Authorization: Bearer YOUR_KEY. Esistono due metodi: POST /v1/chat/completions per le conversazioni e GET /v1/models per l'elenco.

È utile chiarire cosa si nasconde dietro quell'endpoint. È un unico modello a pesi aperti, gestito da un provider indipendente e ottimizzato per saltare i rifiuti sui contenuti. Non è l'API ufficiale di alcun grande vendor e non è un router che sceglie tra modelli. Gestisce solo testo: nessuna immagine, audio, video, embedding o fine-tuning. Una regola rigida si applica senza eccezioni: nessun contenuto sessuale che coinvolga minorenni.

Questa portata limitata è il punto. Un singolo endpoint stabile è facile da integrare. Le sezioni seguenti mostrano un piccolo backend di chat, poi un loop di agent, infine i limiti che devi considerare per il design.

Passo 1: connetti un client esistente

Poiché l'API segue il formato OpenAI, raramente scrivi nuovo codice client. Apri il tuo SDK o strumento, modifica l'URL di base e la chiave, e imposta il modello su uncensored. Iscriviti prima alla pagina delle chiavi API (Google, o email e password), poi rivendica il credito di prova da $0,50 con un clic. La prova non richiede carta, dura 7 giorni ed è limitata a una per persona.

Una richiesta minima in Python:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmhub.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant for a writing tool."},
        {"role": "user", "content": "Give me three opening lines for a mystery set on a ferry."},
    ],
    temperature=0.9,
    top_p=0.95,
)
print(resp.choices[0].message.content)

Le impostazioni di campionamento come temperature, top_p, stop, seed e le penalità di frequenza e presenza vengono passate al modello, quindi le manopole che conosci da altri provider si comportano allo stesso modo. La stessa chiamata funziona negli strumenti che accettano un endpoint compatibile con OpenAI, ad esempio SillyTavern o Open WebUI: incolla il Base URL, aggiungi la chiave, digita manualmente l'ID del modello.

Passo 2: trasmetti le risposte in un'interfaccia di chat

Le app di chat sembrano lente se l'utente fissa una casella vuota fino all'arrivo della risposta completa. Lo streaming risolve questo problema. Imposta stream: true e l'API invia la risposta come eventi server-sent, con l'utilizzo riportato alla fine dello stream. Ecco una versione Node che inoltra i token man mano che arrivano:

import OpenAI from "openai";

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

export async function streamReply(history, onToken, signal) {
  const stream = await client.chat.completions.create(
    { model: "uncensored", messages: history, stream: true },
    { signal }
  );
  let text = "";
  for await (const chunk of stream) {
    const piece = chunk.choices[0]?.delta?.content ?? "";
    if (piece) {
      text += piece;
      onToken(piece);
    }
  }
  return text;
}

Due abitudini evitano problemi in seguito. Primo, passa sempre un segnale di abort e annullalo quando l'utente chiude la scheda o preme stop. Una richiesta in streaming occupa la sua slot di concorrenza fino alla fine dello stream, quindi gli stream abbandonati consumano il tuo limite. Secondo, conserva il testo completo che hai assemblato, perché lo aggiungerai alla cronologia come messaggio dell'assistant per il turno successivo.

Se vedi errori vaghi nel tuo frontend durante lo streaming, la nostra nota sulla diagnosi dei fallimenti dello streaming copre le cause comuni, come un URL di base errato, un proxy che memorizza gli eventi e i due codici 429.

Passo 3: usa il contesto lungo deliberatamente

La finestra di contesto è di 100.000 token, condivisa tra prompt e completamento. Per uno strumento di scrittura di storie, una chat di personaggi o un assistente documentale, c'è spazio per una lunga cronologia, un prompt di sistema grande e materiale di riferimento contemporaneamente. Non devi impostare max_tokens; il completamento può usare tutto ciò che rimane.

Il contesto lungo è economico da provare a questi prezzi. Riempire l'intera finestra con input costa 0,1 × $0,15 = $0,015 per 100.000 token di input. Aggiungi una risposta da 2.000 token (0,002 × $0,50 = $0,001) e una chiamata quasi completa costa $0,016. Vorrai comunque gestire la finestra, per tre motivi: la latenza cresce con la dimensione del prompt, ogni turno reinvia la cronologia quindi i costi si accumulano in una sessione, e cronologie molto lunghe diluiscono le istruzioni in alto.

Una politica semplice funziona bene:

Mantieni il prompt di sistema e qualsiasi testo di riferimento fisso all'inizio.
Conserva i turni più recenti parola per parola.
Quando la cronologia supera una soglia che scegli, ad esempio 60.000 token, chiedi al modello di riassumere la parte più antica in una breve nota e sostituisci quei turni con essa.
Leggi usage.prompt_tokens da ogni risposta per sapere quanto sarà grande la richiesta successiva, invece di stimare per caratteri.

Passo 4: strumenti e output strutturato per agent

Gli agent hanno bisogno di due cose da un modello: un modo per chiamare funzioni e un output che puoi analizzare. Entrambi sono supportati. La chiamata di funzioni usa i parametri standard tools e tool_choice, le chiamate di funzioni possono essere trasmesse e i risultati tornano come messaggi con role: "tool". Un singolo round trip appare così:

import json
from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmhub.com/v1",
    api_key="YOUR_API_KEY",
)

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_order",
        "description": "Find an order by its number.",
        "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)
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"}  # your real lookup goes here
    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)

Convalida sempre gli argomenti prima di eseguire qualsiasi cosa con effetti collaterali. Un modello può produrre un valore malformato o inaspettato e il tuo codice è l'ultima linea di difesa.

Per output strutturato semplice senza strumenti, usa la modalità JSON con response_format impostato su {"type": "json_object"}. Descrivi la forma desiderata nel prompt e analizza la risposta all'interno di un blocco try così un errore innesca un nuovo tentativo invece di un crash.

curl https://api.uncensoredllmhub.com/v1/chat/completions   -H "Authorization: Bearer $API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "Reply with JSON: {"title": string, "tags": [string]}"},
      {"role": "user", "content": "Describe a noir story set in a rainy port city."}
    ]
  }'

Limiti da considerare nel design

Una chiave completa permette 8 richieste parallele e 300 richieste al minuto. Una chiave di prova permette 2 e 60. Il corpo può essere fino a 8 MB. Ogni risposta trasporta X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency, utili per il logging.

Quando superi un limite, l'API restituisce HTTP 429. Il codice è rate_limited per troppe richieste al minuto e concurrency per troppe contemporanee. Un sovraccarico temporaneo restituisce anche 429, con Retry-After: 5. Per un'app multi-utente, metti una piccola coda davanti all'API: un semaforo dimensionato sotto il limite di concorrenza e un ritentativo che onora Retry-After. Per un agent che si espande in chiamate di funzioni parallele, limita l'espansione allo stesso numero.

L'elenco completo dei parametri e il formato degli errori sono nella documentazione API.

Costi, ricariche e gestione dei dati

I prezzi sono $0,15 per 1M di token di input e $0,50 per 1M di token di output, dal credito prepagato. Non c'è abbonamento, il credito non scade mai e le richieste fallite o rifiutate non vengono addebitate. Un turno di chat con 1.500 token di input e 500 di output costa 0,0015 × $0,15 + 0,0005 × $0,50 = $0,000225 + $0,00025 = $0,000475, quindi $20 di credito coprono circa 42.000 turni di questo tipo.

Puoi ricaricare qualsiasi importo intero da $20 a $500. Il bonus è +5% da $50, +10% da $100 e +15% da $200. Paga con carta (Visa, Mastercard, Apple Pay, Google Pay) o cripto (USDT su TRC20, USDC su Base). La pagina dei prezzi ha la tabella attuale.

Sui dati: i prompt non vengono usati per l'addestramento. Leggi la privacy policy per il testo completo. Rimani responsabile di ciò che costruisci con il modello e il servizio è destinato solo all'uso legale per maggiorenni.