Unfiltered AI para diálogos de NPCs de jogos e ficção interativa
Mantenha a autoridade do jogo no mecanismo: armazene o estado de cada NPC, valide as chamadas de ferramenta propostas e preserve as transições de história permitidas. Este guia aplica essas regras ao diálogo gerado e mostra como estimar os custos de tokens.

AtualizadoUnfiltered AI
Pontos principais
- Provedores de inferência dedicados como Unfiltered AI oferecem comportamento sem censura consistente em um único modelo, evitando a aleatoriedade do roteamento de agregadores.
- Agregadores como OpenRouter fornecem acesso a vários modelos, mas podem variar em quão rigorosamente aplicam filtros de conteúdo dependendo da versão específica do modelo.
- Unfiltered AI usa um modelo de pesos abertos em hardware dedicado com uma janela de contexto de 100k, precificado em $0,15/$0,50 por milhão de tokens.
- Para consistência estrita de NSFW ou roleplay, uma API LLM sem censura dedicada elimina a necessidade de engenharia de prompt complexa para contornar filtros genéricos.
O loop do jogo, descrito em palavras
Mantenha este diagrama na mente. Uma linha do jogador entra no engine. O engine compõe um prompt a partir de três partes: instruções fixas, o registro de estado atual do NPC e o diálogo recente. O prompt é enviado ao modelo. O modelo responde com text, com chamadas de ferramentas, ou com ambos. O texto vai para a tela. As chamadas de ferramentas retornam ao engine, que as valida, altera o registro de estado e retorna uma string de resultado curta para que o modelo possa terminar sua frase. Então o loop aguarda o jogador.
A propriedade importante é que o engine é a única fonte de verdade. O modelo propõe; o engine decide. Se o modelo disser que um personagem entrega uma chave mas nunca chamar a ferramenta, a chave permanece no inventário. Essa separação é o que torna o diálogo gerado seguro para ser conectado a um jogo com regras. Tudo abaixo deriva disso.
Todas as requisições usam o endpoint padrão de chat-completions em https://api.unfilteredaiapi.com/v1 com o id do modelo uncensored. Ferramentas usam o formato de chamada de funções OpenAI, então o mesmo código funciona com as bibliotecas oficiais de clientes.
Escopo e nota para maiores
Ficção interativa para públicos maduros é um uso legítimo. O serviço não recusa conteúdo adulto lícito, temas sombrios ou assuntos controversos na ficção. É destinado a adultos com 18 anos ou mais, e seu jogo deve indicar isso na página da loja e restringir o acesso de acordo.
Uma linha é fixa: conteúdo sexual envolvendo menores é sempre bloqueado com 403, tanto em ficção quanto em roleplay. Projete para isso explicitamente. Defina a idade adulta para todos os personagens no registro de estado, e faça seu engine lidar com um 403 de forma adequada encerrando o diálogo em vez de tentar novamente.
Estado estruturado do NPC
Descrições de personagens livres derivam. Um registro estruturado compacto não. Mantenha-o pequeno, coloque-o na mensagem do sistema a cada turno, e rotule-o como autoritativo para que o modelo o trate como fato em vez de sugestão.
{
"name": "Brannoch",
"role": "ferry smuggler",
"mood": "wary",
"trust": 1,
"inventory": ["brass key", "flask of rum"],
"knows": ["the harbourmaster takes bribes", "a tunnel runs under the salt warehouse"],
"will_never": ["name his employer", "leave the dock before dawn"],
"location": "Gull Quay, pre-dawn"
}Cada campo justifica seu lugar. mood e trust direcionam o tom. inventory limita o que pode ser dado. knows limita o que o NPC pode revelar, para que os jogadores não extraiam pontos da trama que o personagem não tem motivo para reter. will_never é uma lista curta de recusas rígidas que dão espinha dorsal ao personagem. Com cerca de 120 tokens, todo o registro custa quase nada por turno.
Chamadas de ferramentas para ações de jogo
Ferramentas transformam texto em mudanças de estado. As três abaixo cobrem a maioria das mecânicas baseadas em diálogo: mudança de confiança, transferência de item e apresentação de escolhas. Note que apply_tool limita a confiança e rejeita itens que o NPC não possui; a validação vive no código.
import json
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.unfilteredaiapi.com/v1", api_key=os.environ["API_KEY"])
TOOLS = [
{"type": "function", "function": {
"name": "adjust_trust",
"description": "Change how much this NPC trusts the player after what was just said.",
"parameters": {"type": "object", "properties": {
"delta": {"type": "integer", "minimum": -2, "maximum": 2},
"reason": {"type": "string"}},
"required": ["delta"]}}},
{"type": "function", "function": {
"name": "give_item",
"description": "Hand an item from the NPC's inventory to the player.",
"parameters": {"type": "object", "properties": {
"item": {"type": "string"}}, "required": ["item"]}}},
{"type": "function", "function": {
"name": "offer_choices",
"description": "Present up to three short dialogue options for the player to pick from.",
"parameters": {"type": "object", "properties": {
"choices": {"type": "array", "items": {"type": "string"}, "maxItems": 3}},
"required": ["choices"]}}},
]
def apply_tool(name, args, state, out):
if name == "adjust_trust":
state["trust"] = max(-3, min(5, state["trust"] + int(args.get("delta", 0))))
return f"trust is now {state['trust']}"
if name == "give_item":
item = args.get("item")
if item in state["inventory"]:
state["inventory"].remove(item)
out["items"].append(item)
return f"gave {item}"
return "refused: item not in inventory" # the engine, not the model, decides
if name == "offer_choices":
out["choices"] = args.get("choices", [])[:3]
return "choices shown"
return "unknown tool"
def npc_turn(state, history, player_line):
system = {"role": "system", "content": (
"You voice one NPC in an adults-only interactive story. Stay in character, "
"at most 80 words per reply, no narration of the player's actions. "
"Use tools for anything that changes the game; never claim an item was given without calling give_item.\n"
"NPC state (authoritative): " + json.dumps(state))}
history.append({"role": "user", "content": player_line})
out = {"text": "", "items": [], "choices": []}
for _ in range(4): # cap tool-call rounds
r = client.chat.completions.create(
model="uncensored", messages=[system] + history, tools=TOOLS,
temperature=0.8, max_tokens=300)
msg = r.choices[0].message
entry = {"role": "assistant", "content": msg.content}
if msg.tool_calls:
entry["tool_calls"] = [{"id": c.id, "type": "function",
"function": {"name": c.function.name, "arguments": c.function.arguments}}
for c in msg.tool_calls]
history.append(entry)
if msg.content:
out["text"] += msg.content
if not msg.tool_calls:
return out
for c in msg.tool_calls:
result = apply_tool(c.function.name, json.loads(c.function.arguments or "{}"), state, out)
history.append({"role": "tool", "tool_call_id": c.id, "content": result})
return out
state = json.loads(open("brannoch.json").read())
history = []
print(npc_turn(state, history, "I need to cross before sunrise. Name your price."))Dois detalhes merecem atenção. Primeiro, rodadas de chamada de ferramenta são limitadas a quatro, para que um modelo confuso não entre em loop infinito. Segundo, cada chamada de ferramenta recebe uma mensagem tool correspondente com o mesmo tool_call_id; omita isso e a próxima requisição estará malformada. As strings de resultado são curtas e factuais, o que permite que o modelo reconheça o que aconteceu sem inventar consequências.
Ramificações sem perder a trama
Deixe o engine possuir o grafo da história e deixe o modelo possuir as frases. Um nó lista qual NPC fala, qual porta deve ser passada e para onde cada escolha leva. Quando o modelo chama offer_choices, você mapeia cada opção para uma chave de nó; texto livre não correspondente retorna ao nó atual.
{
"id": "quay_negotiation",
"npc": "brannoch",
"gate": {"trust_at_least": 2},
"on_choice": {
"pay_double": {"next": "crossing_fast", "set": {"gold": -40}},
"threaten": {"next": "quay_standoff", "trust_delta": -2},
"ask_about_tunnel": {"next": "warehouse_tunnel", "requires_fact": "tunnel"}
},
"fallback": "quay_negotiation"
}Isso mantém a narrativa alcançável e testável. Você pode percorrer o grafo sem uma única chamada de API, verificar que cada next existe e confirmar que os nós com porta exigem fatos que o jogador pode realmente descobrir. O modelo fornece variedade dentro de cada nó, não a estrutura ao redor dele.
- Portas leem o registro de estado: limites de confiança, itens possuídos, fatos conhecidos.
- Efeitos modificam-no: ouro, confiança, sinais.
- Retornos mantêm o jogador no lugar quando a entrada é ambígua.
Memória em uma longa jogatina
Um NPC encontrado há dez horas ainda deve lembrar de um insulto. Não replique dez horas de diálogo. Armazene um resumo de duas frases por NPC, atualize-o quando uma conversa terminar e adicione-o ao registro de estado como um campo memories. As mecânicas de resumo e orçamentação de tokens são cobertas no artigo de memória 100k, e o mesmo corte se aplica ao diálogo rolante de cada NPC.
Se você serve um jogo de navegador, retransmita o streaming através do seu próprio servidor como no artigo FastAPI para que a chave nunca chegue ao cliente.
Testando NPCs como você testa código
O diálogo de um modelo é probabilístico, mas as regras ao redor dele não são, e é aí que os testes pertencem. Salve o registro de estado anterior como brannoch.json, então escreva verificações contra o engine em vez de contra o texto.
- Testes de validação de ferramentas. Chame
apply_tooldiretamente com um item que o NPC não possui, um delta de confiança de 99 e argumentos malformados. O estado deve permanecer legal em todos os casos. - Testes de grafo. Carregue cada nó, confirme que cada alvo
nextexiste e percorra um caminho do primeiro nó até cada final sem chamar a API. - Testes de replay. Grave uma conversa real uma vez, incluindo chamadas de ferramenta e resultados, então replique as mensagens de ferramenta contra o engine para verificar se o estado final corresponde ao que você espera.
- Testes de estresse prolongado. Execute um jogador roteado por cinquenta linhas em uma temperatura baixa e afirme que o NPC nunca dá um item que não possui e nunca excede os limites de confiança.
Reduza a temperatura para cerca de 0.3 para essas execuções, então retorne para 0.8 para o jogo. Menos surpresas durante os testes significam que uma falha aponta para o seu código, não para o ruído de amostragem. Quando um bug aparece no jogo ao vivo, adicione o diálogo ofensivo ao conjunto de replay para que ele não retorne despercebido.
Um último hábito: mantenha a voz do personagem em um parágrafo curto por NPC e as regras no registro de estado. A voz pode ser ajustada livremente por escritores; as regras são alteradas apenas com uma revisão de código. Misturá-las em um único blob é como uma reescrita da personalidade de um NPC acidentalmente desbloqueia um item.
Cálculo de custos, com pressupostos declarados
Os preços são $0,15 por milhão de tokens de entrada e $0,50 por milhão de tokens de saída. Os valores abaixo são premissas para planejamento, não medições. Suponha que uma linha de NPC custe: instruções do sistema e estado 350 tokens, diálogo recente 1.000 tokens, definições de ferramenta 250 tokens, totalizando 1.600 tokens de entrada; resposta 100 tokens de saída.
| Item | Cálculo | Custo |
|---|---|---|
| Entrada por linha | 1.600 x $0,15 / 1M | $0.0004 |
| Saída por linha | 100 x $0,50 / 1M | $0.0001 |
| Uma linha | soma | $0.0005 |
| Uma sessão, 60 linhas | 60 x $0,0005 | $0.03 |
| 10.000 sessões | 10.000 x $0,03 | $300 |
Uma ida e volta de chamada de ferramenta adiciona outra requisição: aproximadamente 1.700 tokens de entrada mais 40 de saída, cerca de $0,00047. Se uma linha em três acionar uma ferramenta, adicione um terço disso à média. Verificações de teto também importam: a 300 requisições por minuto por chave, uma única chave suporta cerca de 300 linhas de NPC por minuto entre todos os jogadores simultâneos, então grandes lançamentos precisam de enfileiramento. As taxas estão resumidas na página de preços.
Perguntas e respostas
A API suporta chamada de funções para ações de jogo?
Sim. Ferramentas são aceitas no formato OpenAI, então você declara funções, recebe chamadas de ferramentas e envia os resultados de volta como mensagens de ferramenta.
Quanto custa uma conversa de NPC?
Depende dos seus prompts. Com 1.600 tokens de entrada e 100 de saída assumidos por linha, uma linha custa cerca de $0,0005 nas tarifas publicadas.
Os personagens do meu jogo podem ser menores de idade em cenas sexuais?
Não. Conteúdo sexual envolvendo menores é sempre bloqueado com 403, incluindo em ficção. O serviço é para maiores de 18 anos.
Como evito que o NPC revele segredos da trama?
Liste o que ele sabe e o que ele nunca fará no registro de estado, e imponha mudanças de itens e flags no seu próprio código.
Sua chave está a um formulário de distância
Crie uma conta, copie a chave, altere a URL base. Essa é toda a configuração.