Como usar um modelo LLM por API, passo a passo
Usar um modelo de linguagem hospedado se resume a uma única chamada HTTP com uma chave, um nome de modelo e uma lista de mensagens. Este guia leva você de uma pasta vazia até o streaming, saída JSON e chamadas de ferramentas.

Pontos-chave
- A API é compatível com OpenAI: altere a base URL e a chave, mantenha seu SDK.
- Use o ID do modelo uncensored com POST /v1/chat/completions.
- Streaming, modo JSON e chamada de ferramentas funcionam com os parâmetros padrão.
- Um 429 significa que um limite foi atingido, e o código de erro indica qual.
O que você precisa antes da primeira requisição
Se você quer saber como usar endpoints de modelos LLM no seu próprio código, três coisas são suficientes: uma chave, uma base URL e um nome de modelo. Não há cliente especial para instalar. Qualquer SDK ou cliente OpenAI funciona assim que você o aponta para um endereço diferente.
- URL base:
https://api.llmmodelsapi.com/v1 - ID do modelo:
uncensored - Autenticação: um cabeçalho
Authorization: Bearer YOUR_KEY, que os SDKs adicionam para você
Para obter uma chave, cadastre-se com Google ou com e-mail e senha, depois abra a página da chave de API. Contas novas podem reivindicar $0,50 de crédito de teste com um clique, sem cartão, válido por 7 dias. Isso é mais do que suficiente para tudo neste artigo. O endpoint suporta dois métodos: POST /v1/chat/completions para geração e GET /v1/models para listar o que está disponível.
Ajuda saber o que é o modelo, para que suas expectativas estejam corretas. É um único modelo de pesos abertos executado por um provedor independente e ajustado para responder sem recusas de conteúdo para uso adulto legal. Não é a API oficial de nenhum grande fornecedor e lida apenas com texto. Não há geração de imagem ou áudio, nem embeddings nem ajuste fino.
Passo 1: verificar a chave com curl
Antes de escrever qualquer código de aplicativo, confirme se a chave e o caminho de rede funcionam. Listar os modelos é a verificação mais barata, pois não gera nada.
export LLM_KEY="paste-your-key-here"
# the list should include the model id: uncensored
curl https://api.llmmodelsapi.com/v1/models -H "Authorization: Bearer $LLM_KEY"
Você deve receber uma lista JSON que inclui uncensored. Se você vir um 401, a chave está errada ou falta a palavra Bearer. Agora envie uma solicitação de chat real.
curl https://api.llmmodelsapi.com/v1/chat/completions -H "Authorization: Bearer $LLM_KEY" -H "Content-Type: application/json" -d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain what a context window is in two sentences."}
],
"max_tokens": 150
}'
A resposta contém uma matriz choices, e o texto está em choices[0].message.content. Os cabeçalhos de resposta contêm X-Request-Id e X-Balance-USD, para que você possa ver seu crédito restante em cada chamada. O campo usage mostra os tokens contados para faturamento.
Passo 2: chamar do Python ou Node
Na prática, você usará um SDK. Instale o pacote oficial OpenAI, depois defina a base URL ao criar o cliente. Nada mais no seu código muda.
Python
from openai import OpenAI
client = OpenAI(
base_url="https://api.llmmodelsapi.com/v1",
api_key="YOUR_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You answer in plain language."},
{"role": "user", "content": "Give me three names for a fantasy tavern."},
],
temperature=0.9,
max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
Node
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.llmmodelsapi.com/v1",
apiKey: process.env.LLM_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Summarise HTTP caching in one paragraph." }],
});
console.log(resp.choices[0].message.content);
Mantenha a chave em uma variável de ambiente em vez de no arquivo de origem. Se uma chave vazar, substitua-a na página de chaves e a antiga deixará de funcionar.
Passo 3: formatar a saída com parâmetros
O modelo é um preditor de texto, então como você formula a requisição importa tanto quanto os parâmetros. Alguns hábitos rendem resultados imediatamente.
- Use a mensagem do sistema para regras fixas. Defina tom, formato e papel ali, e mantenha a mensagem do usuário para a tarefa real.
- Seja específico sobre o tamanho. Peça "três tópicos" ou "menos de 120 palavras". É mais confiável do que apenas reduzir
max_tokens, que corta o texto no meio da frase. - Ajuste a temperatura para a tarefa. Cerca de 0,2 serve para extração e classificação. Cerca de 0,8 a 1,0 serve para ficção e roleplay.
- Passe o que você precisa.
top_p,stop,seede as penalidades de frequência e presença são passadas para o modelo.
A janela de contexto é de 100.000 tokens, contando o prompt e a conclusão juntos. Você não precisa definir max_tokens, porque a resposta pode usar qualquer espaço restante. Definir mesmo assim é uma boa maneira de colocar um teto no custo.
Uma maneira prática de aprender essas configurações é executar o mesmo prompt três vezes em temperaturas diferentes e comparar. Altere um valor por execução e mantenha o resto fixo, usando o mesmo seed onde puder. Após dez minutos disso, você saberá como o modelo se comporta para sua tarefa muito melhor do que qualquer descrição poderia dizer, e o custo do experimento é uma fração de um centavo.
O preço é $0.15 por milhão de tokens de entrada e $0.50 por milhão de tokens de saída. Uma solicitação com 1.500 tokens de entrada e 400 tokens de saída custa 1.500 x 0,15 / 1.000.000 = $0,000225 mais 400 x 0,50 / 1.000.000 = $0,0002, totalizando $0,000425. A página de preços tem as opções de recarga.
Passo 4: fazer streaming da resposta
Aguardar uma resposta completa parece lento em um aplicativo interativo. Com stream: true, o servidor envia tokens como eventos enviados pelo servidor, e sua interface pode imprimi-los conforme chegam. O uso é relatado no final do streaming.
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening 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("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
Uma coisa a lembrar sobre concorrência: uma requisição em streaming ocupa seu slot até que o streaming termine. Uma chave completa permite 8 requisições simultâneas, uma chave de teste permite 2. Se você abrir um streaming no navegador e nunca fechá-lo, esse slot permanecerá ocupado.
Passo 5: modo JSON e chamada de ferramentas
Quando outro programa precisa ler a resposta, texto livre torna-se um problema. O modo JSON pede ao modelo para retornar um objeto JSON válido.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON only: {\"title\": string, \"tags\": [string]}"},
{"role": "user", "content": "Describe a post about growing tomatoes on a balcony."},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
Descreva também a forma que você deseja no prompt, já que o modo JSON garante sintaxe válida e não seus nomes exatos de campos. Envolva o parse em um bloco try e tente novamente uma vez se falhar.
A chamada de funções permite que o modelo peça ao seu código para executar uma função. Você descreve as ferramentas, o modelo responde com uma entrada tool_calls, você a executa e envia o resultado de volta como uma mensagem com role: "tool".
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "get_time",
"description": "Return the current time for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
messages = [{"role": "user", "content": "What time is it in Lisbon?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]
messages.append(first.choices[0].message)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps({"time": "14:05"}),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
Em produção, verifique se tool_calls está presente antes de indexar nele, porque o modelo pode responder diretamente em vez de chamar a função. O parâmetro tool_choice permite forçar ou proibir uma chamada quando você precisa disso.
Mantendo uma conversa
A API não tem memória entre chamadas. Se você quiser que o modelo lembre do que foi dito duas rodadas atrás, envie essas rodadas novamente. Um aplicativo de chat é portanto uma lista que cresce: você anexa a mensagem do usuário, chama a API, anexa a resposta do assistente e repete.
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
history = [{"role": "system", "content": "You are a friendly writing coach."}]
def say(text):
history.append({"role": "user", "content": text})
resp = client.chat.completions.create(model="uncensored", messages=history, max_tokens=300)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(say("Give me a tip for opening a short story."))
print(say("Now apply it to a story about a night train."))
Como cada chamada carrega a lista inteira, custo e latência crescem com a conversa. Quando o histórico fica longo, remova as rodadas mais antigas ou substitua-as por um resumo de um parágrafo. Você tem muito espaço, já que 100.000 tokens equivalem aproximadamente ao tamanho de um romance curto, mas não há motivo para pagar por tokens que já não ajudam na resposta.
Pelo mesmo motivo, mantenha a mensagem do sistema curta e estável. Ela é enviada em todas as chamadas, então um prompt de sistema de 1.000 tokens em 500 solicitações são 500.000 tokens de entrada, o que custa 500.000 x 0,15 / 1.000.000 = $0,075 apenas por si só.
Erros comuns de iniciantes
- Esquecer de anexar a resposta do assistente. O modelo então vê apenas suas perguntas e perde o fio da meada.
- Colocar segredos no front-end. Uma chave dentro do código do navegador é visível para todos. Chame a API do seu servidor e exponha seu próprio endpoint.
- Esperar fatos de um preditor de texto. O modelo pode afirmar detalhes errados com confiança. Forneça o texto de origem no prompt quando a precisão for importante e verifique a saída importante.
- Analisando texto livre. Se o código precisa ler a resposta, use o modo JSON ou uma chamada de ferramenta em vez de expressões regulares.
Erros, limites e próximos passos
A maioria dos problemas se enquadra em uma lista curta.
| Sintoma | Causa provável | Correção |
|---|---|---|
| Resposta 401 | Chave ausente ou errada | Verifique o cabeçalho Bearer e a chave na página de chaves |
429, código rate_limited | Limite de mais de 300 solicitações por minuto (60 em uma chave de teste) | Diminua a velocidade ou faça fila nas requisições |
429, código concurrency | Limite de mais de 8 solicitações simultâneas (2 em uma chave de teste) | Limite os trabalhadores paralelos, feche os streams abertos |
429 com Retry-After: 5 | Sobrecarga temporária | Espere 5 segundos e tente novamente |
| Requisição muito grande | Corpo com mais de 8 MB | Envie menos texto por chamada |
Uma nova tentativa com um breve atraso resolve os casos 429. Solicitações falhas não são cobradas, então uma nova tentativa não custa nada a mais. Os prompts não são usados para treinamento.
Daqui, a documentação da API lista todos os parâmetros, e a visão geral de pagamento por token aborda para quem o serviço se destina. Uma regra se aplica em todos os lugares: conteúdo sexual envolvendo menores de idade nunca é permitido.
Mais guias
Perguntas e respostas
Qual ID de modelo eu envio na requisição?
Use uncensored como o valor do modelo em todas as requisições. Você pode confirmar isso chamando GET /v1/models.
Preciso de um SDK especial?
Não. Qualquer SDK ou cliente OpenAI funciona assim que você altera a URL base para https://api.llmmodelsapi.com/v1 e usa sua própria chave.
Posso usar sem cartão de crédito?
Sim, para testes. Novos usuários podem reivindicar $0,50 de crédito de teste com um clique após o cadastro, sem cartão, válido por 7 dias.
Qual o tamanho máximo do meu prompt?
A janela de contexto é de 100.000 tokens para prompt e output juntos, e o corpo da requisição pode ter até 8 MB.
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.