Uncensored LLM Hub: Um endpoint para chat e agentes

O que você obtém de um endpoint

As pessoas buscam o Uncensored LLM Hub quando querem um modelo que responde sem recusas de conteúdo para uso adulto legal, mas não querem executar GPUs. O serviço é uma API HTTPS simples. Você aponta um cliente OpenAI para https://api.uncensoredllmhub.com/v1, envia o ID do modelo uncensored e autentica com Authorization: Bearer YOUR_KEY. Existem dois métodos: POST /v1/chat/completions para conversas e GET /v1/models para listagem.

É importante deixar claro o que há por trás desse endpoint. É um único modelo de pesos abertos, executado por um provedor independente e ajustado para pular recusas de conteúdo. Não é a API oficial de nenhum grande fornecedor, nem um roteador que escolhe entre modelos. Ele lida apenas com texto: sem imagens, áudio, vídeo, embeddings ou fine-tuning. Uma regra rígida se aplica sem exceção: sem conteúdo sexual envolvendo menores de idade.

Esse escopo restrito é o ponto. Um único endpoint estável é fácil de integrar. As seções abaixo mostram um backend de chat simples, depois um loop de agente e, por fim, os limites que você precisa considerar no design.

Passo 1: conectar um cliente existente

Como a API segue o formato da OpenAI, você raramente precisa escrever novo código de cliente. Abra seu SDK ou ferramenta, altere a base URL e a chave, e defina o modelo para uncensored. Primeiro, faça o cadastro na página da chave de API (Google, ou e-mail e senha), depois resgate o crédito de teste de $0,50 com um clique. O teste não precisa de cartão, dura 7 dias e é limitado a um por pessoa.

Uma requisição mínima em Python:

Copyfrom 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)

Configurações de amostragem como temperature, top_p, stop, seed e as penalidades de frequência e presença são passadas diretamente ao modelo, então os controles que você conhece de outros provedores funcionam da mesma forma. A mesma chamada funciona em ferramentas que aceitam um endpoint compatível com OpenAI, como SillyTavern ou Open WebUI: cole a base URL, adicione a chave e digite o ID do modelo manualmente.

Passo 2: transmitir respostas para uma interface de chat

Apps de chat parecem lentos se o usuário ficar olhando para uma caixa vazia até a resposta completa chegar. O streaming resolve isso. Defina stream: true e a API envia a resposta como eventos enviados pelo servidor, com o uso reportado no final do stream. Aqui está uma versão em Node que encaminha tokens conforme chegam:

Copyimport 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;
}

Dois hábitos evitam problemas futuros. Primeiro, sempre passe um sinal de abort e cancele-o quando o usuário fechar a aba ou pressionar parar. Uma requisição de streaming ocupa sua slot de concorrência até o stream terminar, então streams abandonados consomem sua cota. Segundo, mantenha o texto completo que você montou, pois você o anexará ao histórico como a mensagem do assistente para o próximo turno.

Se você ver erros vagos no front-end durante o streaming, nossa nota sobre diagnóstico de falhas de streaming cobre as causas comuns, como uma base URL errada, um proxy que armazena eventos e os dois códigos 429.

Passo 3: usar o contexto longo deliberadamente

A janela de contexto tem 100.000 tokens, compartilhada pelo prompt e pela conclusão. Para uma ferramenta de escrita de histórias, um chat de personagem ou um assistente de documentos, isso é espaço para um histórico longo, um prompt de sistema grande e material de referência ao mesmo tempo. Você não precisa definir max_tokens; a conclusão pode usar o que sobrar.

Contexto longo é barato para testar a esses preços. Preencher toda a janela com entrada custa 0,1 × $0,15 = $0,015 para 100.000 tokens de entrada. Adicione uma resposta de 2.000 tokens (0,002 × $0,50 = $0,001) e uma chamada quase cheia custa $0,016. Você ainda quererá gerenciar a janela, por três motivos: a latência cresce com o tamanho do prompt, cada turno reenvia o histórico então os custos se somam ao longo de uma sessão e históricos muito longos diluem as instruções no topo.

Uma política simples funciona bem:

1. Mantenha o prompt de sistema e qualquer texto de referência fixo no início.
2. Mantenha as conversas mais recentes literalmente.
3. Quando o histórico passar de um limite que você escolher, por exemplo 60.000 tokens, peça ao modelo para resumir a parte mais antiga em uma nota curta e substitua esses turnos por ela.
4. Leia usage.prompt_tokens de cada resposta para saber o tamanho da próxima requisição, em vez de estimar por caracteres.

Passo 4: ferramentas e saída estruturada para agentes

Agentes precisam de duas coisas de um modelo: uma maneira de chamar funções e uma saída que você possa analisar. Ambas são suportadas. A chamada de funções usa os parâmetros padrão tools e tool_choice, as chamadas de ferramentas podem ser transmitidas e os resultados voltam como mensagens com role: "tool". Uma única ida e volta se parece com isso:

Copyimport 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)

Sempre valide os argumentos antes de executar qualquer coisa com efeitos colaterais. Um modelo pode produzir um valor malformado ou inesperado, e seu código é a última linha de defesa.

Para saída estruturada simples sem ferramentas, use o modo JSON com response_format definido como {"type": "json_object"}. Descreva a forma desejada no prompt e analise a resposta dentro de um bloco try para que uma resposta ruim dispare uma nova tentativa em vez de uma falha.

Copycurl 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."}
    ]
  }'

Limites para considerar no design

Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 e 60. O corpo pode ter até 8 MB. Cada resposta carrega X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests e X-RateLimit-Limit-Concurrency, que são úteis para registrar.

Quando você ultrapassa um limite, a API retorna HTTP 429. O código é rate_limited para muitas requisições por minuto e concurrency para muitas ao mesmo tempo. Uma sobrecarga temporária também retorna 429, com Retry-After: 5. Para um app multiusuário, coloque uma pequena fila à frente da API: um semáforo dimensionado abaixo do limite de concorrência e uma nova tentativa que respeita Retry-After. Para um agente que se ramifica em chamadas de ferramentas paralelas, limite a ramificação ao mesmo número.

A lista completa de parâmetros e o formato de erro estão na documentação da API.

Custo, recargas e tratamento de dados

O preço é $0,15 por 1M de tokens de entrada e $0,50 por 1M de tokens de saída, descontados do crédito pré-pago. Não há assinatura, o crédito nunca expira e requisições falhas ou recusadas não são cobradas. Um turno de chat com 1.500 tokens de entrada e 500 de saída custa 0,0015 × $0,15 + 0,0005 × $0,50 = $0,000225 + $0,00025 = $0,000475, então $20 de crédito cobrem cerca de 42.000 turnos assim.

Você pode recarregar qualquer valor inteiro de $20 a $500. O bônus é +5% a partir de $50, +10% a partir de $100 e +15% a partir de $200. Pague com cartão (Visa, Mastercard, Apple Pay, Google Pay) ou cripto (USDT na TRC20, USDC na Base). A página de preços tem a tabela atual.

Sobre dados: os prompts não são usados para treinamento. Leia a política de privacidade para o texto completo. Você permanece responsável pelo que constrói com o modelo e o serviço é destinado apenas ao uso adulto legal.

Mais guias

• Erro desconhecido no stream da LLM: causas e correções
• Como hospedar um LLM você mesmo, ou pular isso com uma API
• Modelos Ollama sem censura vs APIs hospedadas