NL ▾

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

Unfiltered AI

Ruwe, ongecensureerde LLM API voor ontwikkelaars.

Unfiltered AIAPI-sleutel aanvragen

Unfiltered AI voor game NPC-gesprekken en interactieve fictie

Houd de spelautoriteit in de engine: sla de status van elke NPC op, valideer voorgestelde toolaanroepen en behoud de toegestane verhaalovergangen. Deze gids past die regels toe op gegenereerde dialoog en toont hoe je tokenkosten kunt schatten.

Unfiltered AI voor game NPC-gesprekken en interactieve fictie

Belangrijkste punten

  • Gespecialiseerde inference providers zoals Unfiltered AI bieden consistente ongecensureerde gedraging op een enkel model, waardoor je de willekeurigheid van aggregator-routing vermijdt.
  • Aggregators zoals OpenRouter bieden toegang tot meerdere modellen, maar kunnen variëren in hoe strikt ze inhoudsfilters toepassen afhankelijk van de specifieke modelversie.
  • Unfiltered AI gebruikt een open-weight model op dedicated hardware met een contextvenster van 100k tokens, geprijsd op $0,15/$0,50 per miljoen tokens.
  • Voor strikte NSFW of roleplay consistentie elimineert een dedicated ongecensureerde LLM API de behoefte aan complexe prompt engineering om generieke filters te omzeilen.

De gameloop, beschreven in woorden

Houd dit diagram in je hoofd. Een spelerlijn komt binnen in de engine. De engine composeert een prompt uit drie delen: vaste instructies, de huidige statusrecord van de NPC, en de recente dialogen. De prompt gaat naar het model. Het model antwoordt met text, met tool calls, of met beide. Tekst gaat naar het scherm. Tool calls gaan terug naar de engine, die ze valideert, de statusrecord wijzigt, en een korte resultaatstring teruggeeft zodat het model zijn zin kan afmaken. Dan wacht de lus op de speler.

De belangrijke eigenschap is dat de engine de enige bron van waarheid is. Het model stelt voor; de engine beslist. Als het model zegt dat een personage een sleutel overhandigt maar de tool nooit aanroept, blijft de sleutel in de inventaris. Die scheiding is wat gegenereerde dialogen veilig maakt om te integreren in een spel met regels. Alles hieronder volgt hieruit.

Alle verzoeken gebruiken het standaard chat-completions endpoint op https://api.unfilteredaiapi.com/v1 met de model id uncensored. Tools gebruiken het OpenAI function-calling formaat, dus dezelfde code werkt met de officiële clientbibliotheken.

Scope en een opmerking voor volwassenen

Interactieve fictie voor volwassenen is een legitiem gebruik. De dienst weigert geen wettelijke volwassen inhoud, donkere thema's of controversiële onderwerpen in fictie. Het is bedoeld voor volwassenen van 18 jaar en ouder, en je spel moet dat zeggen op zijn store pagina en de toegang dienovereenkomstig begrenzen.

Één regel is vast: seksuele inhoud met minderjarigen wordt altijd geblokkeerd met een 403, zowel in fictie als in roleplay. Ontwerp daar expliciet op. Geef elk personage een volwassen leeftijd in de statusrecord, en laat je engine een 403 afhandelen door de wisselwerking te beëindigen in plaats van opnieuw te proberen.

Gestructureerde NPC-status

Vrije karakterbeschrijvingen wijken af. Een compacte gestructureerde record niet. Houd het klein, zet het in het systeembericht op elke beurt, en label het als autoritair zodat het model het als feit behandelt in plaats van suggestie.

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

Elk veld verdient zijn plaats. mood en trust sturen de toon. inventory bepaalt wat kan worden gegeven. knows beperkt wat de NPC kan onthullen, zodat spelers geen plotpunten kunnen ontlokken die het personage geen reden heeft om te bewaren. will_never is een korte lijst van harde weigeringen die het personage een ruggengraat geeft. Bij ongeveer 120 tokens kost de hele record per beurt bijna niets.

Tool calls voor game-acties

Tools zetten proza om in statuswijzigingen. De drie hieronder dekken de meeste dialog-gedreven mechanismen: vertrouwen verschuiven, een item overdragen, en keuzes presenteren. Merk op dat apply_tool vertrouwen clamps en items afwijst die de NPC niet vasthoudt; validatie zit in de code.

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."))

Twee details verdienen aandacht. Ten eerste zijn tool-call rondes beperkt tot vier, zodat een verward model niet oneindig kan lopen. Ten tweede krijgt elke tool call een bijpassend tool bericht met dezelfde tool_call_id; laat het weg en het volgende verzoek is foutief. De resultaatstrings zijn kort en feitelijk, wat het model in staat stelt te erkennen wat er gebeurde zonder consequenties te verzinnen.

Vertakkingen zonder het plot te verliezen

Laat de engine de verhaalgrafiek beheren en het model de zinnen. Een node vermeldt welk NPC spreekt, welke poort moet worden gepasseerd, en waar elke keuze naartoe leidt. Als het model offer_choices aanroept, map je elke optie naar een nodesleutel; niet-herkende vrije tekst valt terug op de huidige node.

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

Dit houdt de narratief bereikbaar en testbaar. Je kunt de grafiek doorlopen zonder een enkele API-aanroep, controleren dat elke next bestaat, en bevestigen dat afgesloten nodes feiten vereisen die de speler daadwerkelijk kan ontdekken. Het model levert variatie binnen elke node, niet de structuur eromheen.

  • Gates lezen het statusrecord: vertrouwensdrempels, vastgehouden items, bekende feiten.
  • Effects wijzigen het: goud, vertrouwen, vlaggen.
  • Fallbacks houden de speler op zijn plaats wanneer input ambigu is.

Geheugen over een lange speelsessie

Een NPC die tien uur geleden is ontmoet, moet zich nog een belediging herinneren. Speel tien uur aan dialogen niet af. Sla een samenvatting van twee zinnen per NPC op, update deze wanneer een gesprek eindigt, en voeg het toe aan de statusrecord als een memories veld. De mechanica van samenvatten en budgetteren wordt behandeld in het artikel over geheugen van 100k, en dezelfde trimming geldt voor de lopende dialogen van elke NPC.

Als je een browsergame serveert, stuur de stream dan door via je eigen server zoals in het FastAPI-artikel, zodat de sleutel de client nooit bereikt.

NPC's testen zoals je code test

Dialogen van een model zijn probabilistisch, maar de regels eromheen niet, en daar horen tests thuis. Sla de statusrecord van eerder op als brannoch.json, schrijf dan controles tegen de engine in plaats van tegen proza.

  1. Toolvalidatietests. Roep apply_tool direct aan met een item dat het NPC niet vasthoudt, een vertrouwensdelta van 99, en malformed arguments. De status moet in elke geval geldig blijven.
  2. Grafiek tests. Laad elke node, bevestig dat elke next target bestaat, en loop een pad van de eerste node naar elke eindstand zonder de API aan te roepen.
  3. Replay tests. Registreer een echt gesprek één keer, inclusief tool calls en resultaten, en replay de tool berichten tegen de engine om te controleren of de finale status overeenkomt met wat je verwacht.
  4. Soak tests. Voer een gescriptte speler door vijftig lijnen bij een lage temperatuur en asserteer dat de NPC nooit een item geeft dat hij niet heeft en nooit de trust grenzen overschrijdt.

Verlaag de temperatuur naar ongeveer 0,3 voor die runs, en keer daarna terug naar 0,8 voor het spelen. Minder verrassingen tijdens het testen betekent dat een fout wijst naar je code, niet naar steekproefruis. Als er een bug verschijnt in live spel, voeg dan de aanstootgevende wisselwerking toe aan de replay-set, zodat deze niet onopgemerkt kan terugkeren.

Een laatste gewoonte: houd karakterstem in één korte alinea per NPC en de regels in de statusrecord. Stem kan vrij getuned worden door schrijvers; regels worden alleen gewijzigd met een code review. Ze samen in een enkele blob mengen is hoe een herschrijving van de NPC persoonlijkheid per ongeluk een item ontgrendelt.

Kostenberekening, met gestelde aannames

Prijzen zijn $0,15 per miljoen inputtokens en $0,50 per miljoen outputtokens. De cijfers hieronder zijn aannames voor planning, geen metingen. Neem aan dat één NPC regel kost: systeem instructies en status 350 tokens, recente dialogen 1 000 tokens, tool definities 250 tokens, dus 1 600 inputtokens; antwoord 100 outputtokens.

ItemBerekeningKosten
Input per regel1.600 x $0,15 / 1M$0,0004
Uitvoer per regel100 x $0,50 / 1M$0,0001
Eén regelsom$0,0005
Eén sessie, 60 lijnen60 x $0,0005$0,03
10.000 sessies10.000 x $0,03$300

Een tool-call round trip voegt nog een verzoek toe: ongeveer 1 700 inputtokens plus 40 output, ongeveer $0,00047. Als één regel op drie een tool activeert, tel dan een derde daarvan bij het gemiddelde. Ceiling checks zijn ook belangrijk: bij 300 verzoeken per minuut per sleutel ondersteunt één sleutel ongeveer 300 NPC lijnen per minuut over alle gelijktijdige spelers, dus grote lanceringen hebben queuing nodig. Tarieven worden samengevat op de pricing pagina.

Vragen en antwoorden

Ondersteunt de API function calling voor game-acties?

Ja. Tools worden geaccepteerd in het OpenAI-formaat, dus je declareert functies, ontvangt tool calls en stuurt resultaten terug als tool berichten.

Hoeveel kost een NPC-gesprek?

Dit hangt af van je prompts. Met aangenomen 1 600 input- en 100 outputtokens per regel kost één regel ongeveer $0,0005 volgens de gepubliceerde tarieven.

Kunnen personages in mijn game minderjarigen zijn in seksuele scènes?

Nee. Seksuele inhoud met minderjarigen wordt altijd geblokkeerd met een 403, ook in fictie. De dienst is voor volwassenen van 18 jaar en ouder.

Hoe voorkom ik dat het NPC plotgeheimen uitlekt?

Lijst op wat het weet en wat het nooit zal doen in het state record, en handhaaf item- en flagwijzigingen in je eigen code.

Je sleutel is nog maar één formulier verwijderd

Maak een account aan, kopieer de sleutel, wijzig de base URL. Dat is de hele setup.

Haal API-sleutelLees de documentatie