PT ▾
Obter chave de API

LLM Inference APIGuia

LLM Inference API: streaming, ferramentas e modo JSON

Uma API de inferência LLM permite enviar um prompt via HTTPS e receber texto gerado, sem precisar de GPU do seu lado. Esta página mostra uma configuração funcional contra um endpoint compatível com OpenAI, desde a primeira requisição até streaming, tool calling, modo JSON e limites de requisições.

Atualizado:

Ilustração isométrica de pacotes de dados fluindo de um terminal para um gateway na nuvem, representando uma chamada de API de inferência

Pontos principais

  1. Aponte qualquer SDK OpenAI para https://api.llminferenceapi.com/v1, use o ID do modelo uncensored e envie sua chave como token Bearer.
  2. Dois endpoints estão disponíveis: POST /v1/chat/completions e GET /v1/models.
  3. Streaming, chamada de ferramentas e modo JSON funcionam através dos campos padrão da requisição.
  4. Uma chave completa permite 8 requisições simultâneas e 300 por minuto; uma resposta 429 indica qual limite você atingiu.

O que você precisa antes da primeira chamada

Você precisa de três coisas: uma base URL, uma chave e um nome de modelo. A base URL é https://api.llminferenceapi.com/v1, o ID do modelo é uncensored, e a chave vem da página da chave de API após se cadastrar com Google ou com e-mail e senha. Novos usuários podem reivindicar $0,50 de crédito de teste lá com um clique. Não precisa de cartão, dura 7 dias e é limitado a um por pessoa.

O serviço é apenas de texto. Ele expõe POST /v1/chat/completions e GET /v1/models. Não há rota de embeddings, nem geração de imagens ou áudio, nem ajuste fino. Ele executa um único modelo de pesos abertos, operado por um provedor independente e ajustado para responder sem recusas de conteúdo para uso adulto lícito. Não é a API oficial de nenhum fornecedor de modelo. Uma regra rígida se aplica: conteúdo que sexualiza menores de idade não é permitido.

Mantenha a chave em uma variável de ambiente em vez de no código-fonte. Os exemplos abaixo a leem de API_KEY onde a linguagem permitir.

Sua primeira requisição

Comece com curl, porque ele mostra exatamente o que vai pela rede.

curl https://api.llminferenceapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "List three uses of a message queue."}
    ],
    "temperature": 0.7
  }'

A resposta é o objeto de chat completion usual: choices[0].message.content contém o texto e usage contém as contagens de tokens. Você também pode listar modelos com GET /v1/models, que é uma maneira rápida de confirmar que a chave e a URL estão corretas antes de depurar qualquer outra coisa.

Em Python com o SDK oficial da OpenAI, apenas o construtor muda:

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List three uses of a message queue."}],
)
print(resp.choices[0].message.content)

E em Node:

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "List three uses of a message queue." }],
});
console.log(resp.choices[0].message.content);

A conclusão pode usar o que restar da janela de 100.000 tokens após o seu prompt, então max_tokens é opcional. Defina-o de qualquer forma quando quiser um limite rígido de custo ou comprimento. Controles de amostragem como temperature, top_p, stop, seed e as penalidades de frequência e presença são passados diretamente.

Duas configurações valem a pena saber desde o início. seed torna a amostragem repetível o suficiente para testes, o que ajuda quando você compara duas versões de um prompt e quer que a diferença venha do prompt e não do acaso. stop aceita uma ou mais strings que encerram a geração assim que o modelo as escreve, uma maneira barata de cortar uma resposta em um delimitador e evitar pagar por tokens que você descartaria.

Respostas em streaming

Com stream: true o servidor responde via server-sent events e envia o texto em pequenos deltas. Os usuários veem as primeiras palavras rapidamente, o que é importante em interfaces de chat. Os dados de uso chegam no final do stream.

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

Dois pontos são fáceis de perder. Primeiro, o último chunk pode conter uso e uma lista choices vazia, então verifique se choices não está vazia antes de indexá-la. Segundo, uma solicitação em streaming mantém sua cota de concorrência até que o stream termine. Se um cliente abrir um stream e nunca o ler até o fim, esse slot permanece ocupado e suas solicitações posteriores podem atingir um erro de concurrency. Sempre feche ou consuma totalmente os streams.

Chamada de funções

A chamada de funções permite que o modelo peça ao seu código para executar uma função e usar o resultado. Você descreve as funções em tools, direciona opcionalmente a escolha com tool_choice, executa o que o modelo solicitar e envia a saída de volta como uma mensagem com role: "tool".

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its id.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1043?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

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 = {"order_id": args["order_id"], "status": "shipped"}
        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 analise function.arguments de forma defensiva. É uma string JSON produzida por um modelo de linguagem e, em raras ocasiões, pode estar malformada ou conter um campo que você não definiu. Valide-a antes de agir sobre ela, especialmente quando a função altera dados. As chamadas de ferramentas também funcionam com streaming, caso em que os tool_calls chegam como fragmentos que você deve unir por índice antes de analisar.

Gerenciando histórico de conversas

A API é stateless. Ela não lembra das solicitações anteriores, então um chat multirrodada funciona apenas porque seu código envia as rodadas anteriores novamente a cada vez. Mantenha uma lista de mensagens, anexe a nova mensagem do usuário, chame o endpoint e depois anexe a resposta do assistente antes da próxima rodada.

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

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

print(chat("Give me a prompt for a ghost story."))
print(chat("Make it set on a ferry."))

Como cada rodada reenvia o histórico, os tokens de entrada crescem com o comprimento do chat. A janela suporta 100.000 tokens, o que é suficiente para a maioria das conversas, mas o custo sobe bem antes de você atingir o limite. Um padrão comum é manter a mensagem do sistema e as últimas várias rodadas, e substituir as rodadas mais antigas por um resumo curto que o próprio modelo escreve. Leia usage.prompt_tokens após cada chamada para ver o tamanho que o histórico atingiu.

Modo JSON

Quando você precisa de saída legível por máquina, defina response_format como {"type": "json_object"} e diga no prompt que deseja JSON. Descrever as chaves que você espera torna o resultado muito mais estável.

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only, using the keys title, tags and summary."},
        {"role": "user", "content": "Describe a short story about a lost robot."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

O modo JSON faz com que a saída seja analisada como JSON, mas não impõe seu esquema. Verifique as chaves no código e mantenha um fallback para o caso de um valor estar ausente. Se a resposta for cortada porque atingiu um limite de tokens, o JSON estará incompleto, então não defina max_tokens muito baixo para saída estruturada.

Uma lista de verificação rápida quando algo falha

A maioria dos problemas do primeiro dia vem de um punhado de causas, e você pode descartá-las em ordem.

  1. Base URL. Deve terminar em /v1. O SDK anexa /chat/completions automaticamente, então uma URL com o caminho já incluído não funcionará.
  2. Cabeçalho de chave. A chave vai em Authorization: Bearer seguida pela chave. Um espaço ou nova linha solta copiados com a chave é uma causa frequente de erros de autenticação.
  3. ID do modelo. Use uncensored exatamente. Nomes de modelos de outros fornecedores não são válidos aqui.
  4. Tamanho da requisição. O limite do corpo é 8 MB, e prompt mais conclusão devem caber em 100.000 tokens.
  5. Saldo. Olhe o cabeçalho X-Balance-USD em qualquer resposta para ver se o crédito é o problema.
  6. Cite o ID da requisição. Se você contatar suporte, inclua o valor X-Request-Id da resposta falha para que a requisição possa ser encontrada.

Lembre-se de que uma recusa não é a mesma coisa que um erro. Como o modelo é ajustado para evitar recusas de conteúdo para uso adulto lícito, você verá menos delas do que em serviços filtrados, mas o modelo ainda pode recusar ou dar uma resposta fraca a um prompt vago. Um prompt de sistema mais claro geralmente resolve isso melhor do que uma temperatura mais alta.

Limites, cabeçalhos e tentativas

Uma chave completa permite 8 requisições simultâneas e 300 requisições por minuto. Uma chave de teste permite 2 requisições simultâneas e 60 por minuto. O corpo da requisição 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 logging e para mostrar um saldo em uma tela de administração.

Quando você excede um limite, a API retorna HTTP 429. O código de erro rate_limited significa muitas requisições por minuto, e concurrency significa muitas ao mesmo tempo. Em sobrecarga temporária você também recebe 429, com um cabeçalho Retry-After: 5. Um wrapper de retry simples cobre os três casos:

import time
from openai import RateLimitError

def ask(messages, tries=4):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = 5 if attempt == 0 else 5 * (attempt + 1)
            retry_after = getattr(e.response, "headers", {}).get("retry-after")
            time.sleep(int(retry_after) if retry_after else wait)
    raise RuntimeError("still rate limited after retries")

Para um pool de workers, limite o tamanho do pool ao seu limite de concurrency em vez de confiar em retries. Oito workers em uma chave completa raramente verão um erro de concurrency. Se você encontrar erros inesperados, o artigo de solução de problemas aborda as causas comuns.

Pagando por isso

O faturamento é pagamento por uso a partir de crédito pré-pago: $0,15 por 1M tokens de entrada e $0,50 por 1M tokens de saída, sem assinatura. Requisições falhas ou recusadas não são cobradas, e o crédito nunca expira. Uma requisição com 1.500 tokens de entrada e 400 tokens de saída custa 1.500 / 1.000.000 x $0,15 + 400 / 1.000.000 x $0,50 = $0,000225 + $0,0002 = $0,000425.

Recargas são qualquer valor inteiro de $20 a $500, com bônus de 5% a partir de $50, 10% a partir de $100 e 15% a partir de $200. Você pode pagar com cripto (USDT na TRC20, USDC na Base). Prompts não são usados para treinamento. A página de preços lista os detalhes e o quickstart repete os passos de configuração de forma resumida.

Perguntas e respostas

Posso usar a biblioteca oficial da OpenAI com esta API?

Sim. Instale o SDK OpenAI para Python ou Node, defina a base URL como https://api.llminferenceapi.com/v1, passe sua chave e use o ID do modelo uncensored.

A API suporta chamada de funções?

Sim. Passe as ferramentas e opcionalmente tool_choice, depois retorne cada resultado como uma mensagem com role tool. tool_calls em streaming também são suportados.

O que significa o erro 429 aqui?

Você atingiu um limite. O código rate_limited significa muitas requisições por minuto, concurrency significa muitas ao mesmo tempo, e um cabeçalho Retry-After: 5 marca uma sobrecarga temporária. Aguarde e tente novamente.

Posso usá-lo para embeddings ou imagens?

Não. A API é apenas de texto e oferece chat completions e uma lista de modelos.

Sua chave está a um clique de distância

Crie uma conta, copie a chave e altere a URL base. Essa é toda a configuração.

Obter chave de API