ES ▾

unfilteredaiapi.comhttps://api.unfilteredaiapi.com/v1

Unfiltered AI

API LLM sin censura para desarrolladores.

Unfiltered AIObtener clave de API

Unfiltered AI para diálogos de NPCs de juegos e historia interactiva

Mantén la autoridad del juego en el motor: almacena el estado de cada NPC, valida las llamadas a herramientas propuestas y preserva las transiciones de historia permitidas. Esta guía aplica esas reglas al diálogo generado y muestra cómo estimar los costos de tokens.

Unfiltered AI para diálogos de NPCs de juegos e historia interactiva

Puntos clave

  • Proveedores de inferencia dedicados como Unfiltered AI ofrecen comportamiento sin censura consistente en un solo modelo, evitando la aleatoriedad del enrutamiento de agregadores.
  • Los agregadores como OpenRouter proporcionan acceso a múltiples modelos, pero pueden variar en cómo aplican estrictamente los filtros de contenido dependiendo de la versión específica del modelo.
  • Unfiltered AI utiliza un modelo de pesos abiertos en hardware dedicado con una ventana de contexto de 100k, a $0,15/$0,50 por millón de tokens.
  • Para consistencia estricta de NSFW o roleplay, una API LLM sin censura dedicada elimina la necesidad de ingeniería de prompts compleja para eludir filtros genéricos.

El bucle del juego, descrito en palabras

Mantén este diagrama en tu mente. Una línea de jugador entra en engine. El motor compone un prompt a partir de tres partes: instrucciones fijas, el registro de estado actual del NPC y el diálogo reciente. El prompt se envía al modelo. El modelo responde con text, con llamadas a funciones, o con ambas. El texto va a la pantalla. Las llamadas a funciones vuelven al motor, que las valida, muta el registro de estado y devuelve una cadena de resultado corta para que el modelo termine su frase. Luego el bucle espera al jugador.

La propiedad importante es que el motor es la única fuente de verdad. El modelo propone; el motor decide. Si el modelo dice que un personaje entrega una clave pero nunca llama a la función, la clave permanece en el inventario. Esa separación es lo que hace seguro conectar el diálogo generado a un juego con reglas. Todo lo demás se deriva de esto.

Todas las peticiones usan el endpoint estándar de chat-completions en https://api.unfilteredaiapi.com/v1 con el id de modelo uncensored. Las herramientas usan el formato de llamadas a funciones de OpenAI, por lo que el mismo código funciona con las bibliotecas oficiales de clientes.

Alcance y nota para mayores de edad

La historia interactiva para audiencias maduras es un uso legítimo. El servicio no rechaza contenido adulto legal, temas oscuros o temas controvertidos en la ficción. Está pensado para adultos mayores de 18 años, y tu juego debería decirlo en su página de la tienda y restringir el acceso en consecuencia.

Una línea es fija: el contenido sexual con menores siempre se bloquea con un 403, tanto en ficción como en roleplay. Diseña para eso explícitamente. Asigna a cada personaje una edad adulta en el registro de estado, y haz que tu motor maneje un 403 de manera elegante terminando el intercambio en lugar de reintentar.

Estado estructurado del NPC

Las descripciones de personajes de texto libre se desvían. Un registro estructurado compacto no lo hace. Manténlo pequeño, ponlo en el mensaje del sistema en cada turno, y etiquétalo como autoritativo para que el modelo lo trate como hecho en lugar de sugerencia.

{
  "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 gana su lugar. mood y trust dirigen el tono. inventory acota qué se puede dar. knows limita lo que el NPC puede revelar, para que los jugadores no puedan extraer puntos de la trama que el personaje no tenga razón para guardar. will_never es una lista corta de rechazos firmes que le dan carácter al personaje. Aproximadamente 120 tokens, todo el registro cuesta casi nada por turno.

Llamadas a funciones para acciones de juego

Las herramientas convierten prosa en cambios de estado. Las tres siguientes cubren la mayoría de las mecánicas basadas en diálogo: cambiar la confianza, transferir un objeto y presentar opciones. Observa que apply_tool ajusta la confianza y rechaza objetos que el NPC no posee; la validación está en el 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."))

Dos detalles merecen atención. Primero, las rondas de llamadas a funciones se limitan a cuatro, para que un modelo confundido no entre en bucle infinito. Segundo, cada llamada a función recibe un mensaje tool coincidente con el mismo tool_call_id; omitirlo hace que la siguiente petición esté mal formada. Las cadenas de resultado son cortas y factuales, lo que permite al modelo reconocer lo ocurrido sin inventar consecuencias.

Ramificación sin perder la trama

Deja que el motor posea el grafo de la historia y que el modelo posea las frases. Un nodo lista qué NPC habla, qué puerta debe superarse y hacia dónde lleva cada elección. Cuando el modelo llama a offer_choices, mapeas cada opción a una clave de nodo; el texto libre no coincidente vuelve al nodo actual.

{
  "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"
}

Esto mantiene la narrativa alcanzable y comprobable. Puedes recorrer el grafo sin una sola llamada a la API, verificar que cada next existe y confirmar que los nodos con puerta requieren hechos que el jugador puede descubrir realmente. El modelo aporta variedad dentro de cada nodo, no la estructura que lo rodea.

  • Gates leen el registro de estado: umbrales de confianza, objetos poseídos, hechos conocidos.
  • Efectos lo modifican: oro, confianza, banderas.
  • Fallbacks mantienen al jugador en su lugar cuando la entrada es ambigua.

Memoria a lo largo de una partida larga

Un NPC que se conoció hace diez horas debería recordar aún un insulto. No repitas diez horas de diálogo. Almacena un resumen de dos frases por NPC, actualízalo cuando termine una conversación y añádelo al registro de estado como un campo memories. La mecánica de resumir y presupuestar se cubre en el artículo de memoria de 100k, y el mismo recorte se aplica al diálogo acumulado de cada NPC.

Si sirves un juego de navegador, retransmite el streaming a través de tu propio servidor como en el artículo de FastAPI para que la clave nunca llegue al cliente.

Prueba NPCs como si fueran código

El diálogo de un modelo es probabilístico, pero las reglas que lo rodean no lo son, y ahí es donde pertenecen las pruebas. Guarda el registro de estado anterior como brannoch.json y luego escribe comprobaciones contra el motor en lugar de contra la prosa.

  1. Pruebas de validación de herramientas. Llama a apply_tool directamente con un objeto que el NPC no posee, un delta de confianza de 99 y argumentos malformados. El estado debe permanecer legal en todos los casos.
  2. Pruebas del grafo. Carga todos los nodos, confirma que cada objetivo next existe y recorre un camino desde el primer nodo hasta cada final sin llamar a la API en absoluto.
  3. Pruebas de repetición. Graba una conversación real una vez, incluyendo llamadas a funciones y resultados, luego repite los mensajes de herramienta contra el motor para verificar que el estado final coincide con lo que esperas.
  4. Pruebas de resistencia. Ejecuta un jugador preescrito a través de cincuenta líneas a una temperatura baja y afirma que el NPC nunca da un objeto que no tiene y nunca excede los límites de confianza.

Baja la temperatura a alrededor de 0.3 para esas ejecuciones, luego vuelve a 0.8 para jugar. Menos sorpresas durante las pruebas significa que un fallo apunta a tu código, no al ruido de muestreo. Cuando aparece un error en la partida en vivo, añade el intercambio ofensivo al conjunto de repetición para que no regrese sin ser notado.

Un último hábito: mantén la voz del personaje en un párrafo corto por NPC y las reglas en el registro de estado. La voz se puede ajustar libremente por escritores; las reglas se cambian solo con una revisión de código. Mezclarlas en un solo bloque es cómo una reescritura de la personalidad de un NPC desbloquea accidentalmente un elemento.

Cálculo de costos, con supuestos declarados

Los precios son $0,15 por millón de tokens de entrada y $0,50 por millón de tokens de salida. Las cifras de abajo son supuestos para planificación, no mediciones. Asume que una línea de NPC cuesta: instrucciones del sistema y estado 350 tokens, diálogo reciente 1.000 tokens, definiciones de herramientas 250 tokens, es decir, 1.600 tokens de entrada; respuesta 100 tokens de salida.

ArtículoCálculoCosto
Entrada por línea1.600 x $0,15 / 1M$0,0004
Salida por línea100 × $0,50 / 1M$0,0001
Una líneasuma$0,0005
Una sesión, 60 líneas60 × $0,0005$0,03
10.000 sesiones10.000 × $0,03$300

Una ida y vuelta de llamada a función añade otra petición: aproximadamente 1.700 tokens de entrada más 40 de salida, unos $0,00047. Si una línea de cada tres activa una herramienta, añade un tercio de eso al promedio. Las verificaciones del límite también importan: a 300 peticiones por minuto por clave, una sola clave soporta unas 300 líneas NPC por minuto entre todos los jugadores concurrentes, por lo que los lanzamientos grandes necesitan colas. Las tarifas se resumen en la página de precios.

Preguntas y respuestas

¿La API admite llamadas a funciones para acciones de juego?

Sí. Se aceptan herramientas en formato OpenAI, así que declaras funciones, recibes llamadas a funciones y envías los resultados de vuelta como mensajes de herramienta.

¿Cuánto cuesta una conversación de NPC?

Depende de tus prompts. Con 1.600 tokens de entrada y 100 de salida por línea asumidos, una línea cuesta unos $0,0005 a las tarifas publicadas.

¿Pueden ser menores de edad los personajes de mi juego en escenas sexuales?

No. El contenido sexual que involucra a menores siempre se bloquea con un 403, incluso en ficción. El servicio es para mayores de 18 años.

¿Cómo evito que el NPC revele secretos de la trama?

Enumera lo que sabe y lo que nunca hará en el registro de estado, y aplica los cambios de elementos y banderas en tu propio código.

Tu clave está a un formulario de distancia

Crea una cuenta, copia la clave y cambia la URL base. Ese es todo el proceso de configuración.

Obtener clave de APILeer la documentación