NL ▾

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

Unfiltered AI

Ruwe, ongecensureerde LLM API voor ontwikkelaars.

Unfiltered AIAPI-sleutel aanvragen

Conversatiegeheugen in een venster van 100k: budgettering, trimmen en samenvattingen

Een venster van 100.000 tokens klinkt enorm totdat een lang rollenspel of verhaal het vult. Dit artikel behandelt context als een grootboek: je zet ruimte vrij voor het antwoord, beschermt een kleine set gepinde feiten, vouwt oudere beurten in een lopende samenvatting en trimt de rest. Elke stap wordt geleverd met korte Python-code die je kunt aanpassen.

Conversatiegeheugen in een venster van 100k: budgettering, trimmen en samenvattingen

Belangrijkste punten

  • Gespecialiseerde inference-aanbieders zoals Unfiltered AI bieden consistent ongecensureerd gedrag op één 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 100k contextvenster, geprijsd op $0,15/$0,50 per miljoen tokens.
  • Voor strikte NSFW- of rollenspelconsistentie elimineert een dedicated ongecensureerde LLM API de behoefte aan complexe prompt-engineering om generieke filters te omzeilen.

Denk aan het venster als een grootboek

Het model heeft geen geheugen tussen calls. Wat lijkt op onthouden is dat jij tekst opnieuw verstuurt, en elke opnieuw verzonden token is een regel in een grootboek met een harde plafond: 100.000 tokens, gedeeld door de prompt and het antwoord. Geef meer uit aan de prompt en je laat minder ruimte over voor het antwoord; vraag je te veel van beide, dan wordt het verzoek afgewezen met een 400.

Een bruikbaar grootboek ziet er zo uit. Reserveer 1.500 tokens voor het antwoord, omdat dat is wat je als max_tokens doorgeeft. Reserveer nog eens 3.000 als marge, omdat elke lokale telling een schatting is. Dat laat 59.500 tokens budget over voor de prompt. Binnen dat budget concurreren vier soorten inhoud: de system prompt, gepinde feiten, een lopende samenvatting en de recente beurten letterlijk. De rest van dit artikel gaat over wie wint.

De prioriteitsvolgorde is eenvoudig te formuleren. Systeem- en gepinde inhoud worden nooit geknipt. De samenvatting wordt vervangen in plaats van geknipt. Recentere beurten worden oudste-eerst geknipt. Alles wat uit de recente beurten valt, gaat niet verloren, omdat het eerst in de samenvatting wordt verwerkt.

Tellen zonder een tokenizer

Gebruik de teruggegeven usage-tellingen om je schattingen te controleren. Een schatting van tekens per token kan variëren op basis van taal, leestekens en code. Houd rekening met de uitvoer en verklein de invoer wanneer de schattingen de gecombineerde contextlimiet naderen.

Daarom bestaat de marge, en het is de moeite waard om te kalibreren. Vergelijk na elke call de tekens die je verstuurt met usage.prompt_tokens en pas je ratio aan naar de waargenomen waarde. Een kleine smoothing factor houdt in dat één vreemde boodschap het niet uit balans brengt.

class Calibrator:
    """Learns the real chars-per-token ratio from the usage block."""
    def __init__(self):
        self.ratio = 4.0

    def update(self, sent_messages, prompt_tokens):
        chars = sum(len(m["content"]) for m in sent_messages)
        if prompt_tokens > 0 and chars > 2000:
            observed = chars / prompt_tokens
            self.ratio = 0.8 * self.ratio + 0.2 * observed   # smooth it

    def est(self, text):
        return int(len(text) / self.ratio) + 4

Als je de calibrator's est in de trimmer zet, versmalt of verbreedt het budget zich automatisch naarmate het echte karakter van het gesprek duidelijk wordt. Een verhaal vol dialoog en korte woorden kost vaak meer tokens per teken dan beschrijvende proza, dus de waargenomen ratio is het waard om te volgen.

Trimmen: nieuwste eerst, nooit in paren

Loop recente geschiedenis achteruit en voeg alleen berichten toe die binnen het budget passen. Als zelfs de nieuwste uitwisseling te groot is, kort deze dan bewust in of wijs deze af. Behoud de vereiste context en toegestane rollen in een geldige volgorde; het selecteren van recente beurten garandeert geen coherente antwoorden.

# memory.py
WINDOW = 64_000      # prompt + completion share this
MAX_OUT = 1_500      # what we ask for in max_tokens
MARGIN = 3_000       # slack for estimation error
BUDGET = WINDOW - MAX_OUT - MARGIN   # 59,500 tokens for the prompt

def est_tokens(text: str) -> int:
    # Rough heuristic: about 4 characters per token for English prose.
    return len(text) // 4 + 4

def build_messages(system, pinned, summary, turns):
    """Return (messages_to_send, dropped_turns). turns is oldest-first."""
    head = [{"role": "system", "content": system}]
    if pinned:
        head.append({"role": "system", "content": "Pinned facts (always true):\n- " + "\n- ".join(pinned)})
    if summary:
        head.append({"role": "system", "content": "Story so far: " + summary})

    used = sum(est_tokens(m["content"]) for m in head)
    kept = []
    for m in reversed(turns):                  # walk from the newest turn backwards
        cost = est_tokens(m["content"])
        if used + cost > BUDGET:
            break
        kept.append(m)
        used += cost
    kept.reverse()
    while kept and kept[0]["role"] != "user":  # never start on an orphaned assistant turn
        kept.pop(0)
    dropped = turns[: len(turns) - len(kept)]
    return head + kept, dropped

De functie retourneert twee dingen: de berichten om te versturen en de beurten die eruit vielen. Het teruggeven van de verwijderde beurten, in plaats van ze te discarteren, is de ontwerpkeuze die samenvattingen mogelijk maakt. Niets wordt stil verwijderd.

Feiten vastzetten die moeten overleven

Een samenvatting is van nature verliesgevend. Feiten die nooit mogen afwijken, zoals een naam, een geheim, een belofte of een wereldregel, mogen niet afhangen van een samenvatter die kiest ze te behouden. Sla ze op als een korte lijst buiten de geschiedenis en injecteer ze als een dedicated system bericht bij elke call.

  • Pin identiteit: namen, relaties, soort, leeftijd (alleen volwassenen), beroep.
  • Pin beperkingen: dingen die de narrator niet mag doen of onthullen.
  • Pin status die zelden verandert: locatie, seizoen, wie wat vasthoudt.
  • Pin sfeer niet. Sfeer hoort in de samenvatting, waar het kan evolueren.

Houd het gepinde blok onder ongeveer 400 tokens. Als het daarboven groeit, gedraagt het zich als een tweede system prompt en begint het model elke gepinde regel als even urgent te behandelen. Bekijk de lijst af en toe en verwijder feiten die niet langer van toepassing zijn.

Lopende samenvattingen

Wanneer beurten uit het venster vallen, vraag het model dan om ze in een bestaande samenvatting te verwerken. De prompt is belangrijker dan de code: vertel het wat het moet behouden (wie er aanwezig is, wat er veranderde, beloftes, openstaande draden, huidige locatie) en wat het moet weggooien (vuller, herhaalde beschrijving), en beperk de lengte in woorden. Een cap houdt de samenvatting tegen langzaam opzwellen tot precies het probleem dat het oplost.

import os
from openai import OpenAI

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

SUMMARY_PROMPT = (
    "Compress the material below into a running summary of at most 250 words. "
    "Keep: who is present, what changed, promises and secrets, unresolved threads, "
    "the current location and mood. Drop: filler and repeated description. "
    "Write plain past-tense prose, no bullet points."
)

def fold_into_summary(old_summary, dropped_turns):
    transcript = "\n".join(f"{m['role']}: {m['content']}" for m in dropped_turns)
    user = f"Existing summary:\n{old_summary or '(none)'}\n\nNew material:\n{transcript}"
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "system", "content": SUMMARY_PROMPT}, {"role": "user", "content": user}],
        temperature=0.2,
        max_tokens=450,
    )
    return r.choices[0].message.content.strip()

Gebruik een lage temperatuur. Een samenvatting moet trouw zijn, niet inventief. Een goedkope veiligheidsmaatregel is om de samenvatting zelf elke twintig keer te lezen tijdens de ontwikkeling; fouten cumuleren omdat elke nieuwe samenvatting is gebouwd op de vorige.

De stukken aan elkaar leggen

De klasse hieronder verbindt trimmen, pinning en samenvatten in één lus. Elke call bouwt de prompt, controleert of er iets is verwijderd, verwerkt het in de samenvatting indien van toepassing, en bouwt opnieuw. De regel is opzettelijk lui: het samenvat alleen als het venster het afdwingt, zodat korte gesprekken nooit betalen voor een samenvatting call.

from memory import build_messages, fold_into_summary, client, MAX_OUT

class Conversation:
    def __init__(self, system, pinned):
        self.system, self.pinned = system, pinned
        self.summary, self.turns = "", []

    def say(self, text):
        self.turns.append({"role": "user", "content": text})
        messages, dropped = build_messages(self.system, self.pinned, self.summary, self.turns)
        if dropped:                                   # something fell out of the window
            self.summary = fold_into_summary(self.summary, dropped)
            self.turns = self.turns[len(dropped):]
            messages, _ = build_messages(self.system, self.pinned, self.summary, self.turns)
        r = client.chat.completions.create(
            model="uncensored", messages=messages, max_tokens=MAX_OUT, temperature=0.8
        )
        answer = r.choices[0].message.content
        self.turns.append({"role": "assistant", "content": answer})
        return answer

convo = Conversation(
    system="You narrate a slow-burn adult mystery set in a mountain hotel.",
    pinned=["Ines Duarte is the night manager and is lying about the ledger.",
            "It is the third night of the blizzard; the road is closed.",
            "The narrator never reveals the culprit before the player accuses someone."],
)
print(convo.say("I ask Ines why the guest book has a page missing."))

Dit past natuurlijk bij de streaming relay in de FastAPI backend article, waar de session store summary, pinned en turns zou bevatten in plaats van één vlakke lijst. Voor gestructureerde NPC status op hetzelfde patroon, zie de game dialogue guide.

De kosten van onthouden

Lang geheugen is niet gratis, omdat de hele prompt opnieuw wordt gefactureerd bij elke call. Neem twee setup's aan. In de eerste mag de geschiedenis 50.000 prompt tokens vullen en elke reply is 500 tokens. Input kost 50.000 x $0,15 / 1.000.000 = $0,0075, output kost 500 x $0,50 / 1.000.000 = $0,00025, dus elke beurt kost ongeveer $0,00775. In de tweede houd je 8.000 tokens van recente beurten plus een 600-token samenvatting en 400 gepinde tokens, ongeveer 9.000 in totaal. Input is $0,00225, output $0,00025, dus elke beurt is bijna $0,0028.

Over 1.000 beurten is dat ongeveer $13 versus $2,75 onder deze aannames. De samenvattingsaanpak kost ook af en toe een extra call van misschien 3.000 input en 450 output tokens, ongeveer $0,0012, wat verwaarloosbaar is naast de besparingen. Tarieven staan op de pricing page.

Het praktische advies: vul het venster niet alleen omdat het er is. Gebruik het grote venster als verzekering voor momenten dat een scène echt lange letterlijke context nodig heeft, en laat samenvattingen de rest dragen.

Waar geheugenregimes stil falen

Drie foutpatronen komen steeds terug. De eerste is samenvatting drift: een detail wordt parafraseerd, de parafrase wordt opnieuw samengevat, en na een dozijn folds is het oorspronkelijke feit onherkenbaar. Pinning is de remedie voor alles wat je niet kunt veroorloven te verliezen, en een harde woordcap voorkomt dat de samenvatting alles absorbeert.

De tweede is de cliff. Met een pure trim en geen samenvatting, verdwijnt de oudste beurt gewoon en vergeet het karakter plotseling iets wat het net nog wist. Gebruikers merken dit. Het draaien van de samenvatter één stap voordat het venster het afdwingt, bijvoorbeeld wanneer de prompt ongeveer 80 procent van het budget passeert, vermindert de overgang.

De derde is rolverwarring na trimmen, wanneer de geschiedenis begint in een uitwisseling. De leading-assistant check in de trimmer bestaat hiervoor. Voeg een test toe die een lange nep-gesprek bouwt, het trimt, en asserteert dat het eerste behouden bericht van de user is en dat de geschatte totaal onder budget blijft. Het kost vijf minuten en voorkomt een klasse van bugs die moeilijk te spotten zijn in manueel spel.

Vragen en antwoorden

Wat gebeurt er als prompt plus max_tokens meer dan 100.000 tokens zijn?

Het verzoek wordt niet afgewezen: max_tokens wordt afgekapt tot de resterende ruimte in het venster, en het antwoord stopt aan het einde van het venster. Alleen een prompt langer dan 100.000 tokens retourneert een 400 bad request.

Kan ik tokens exact tellen voor een verzoek?

Niet precies vooraf. Schat lokaal, houd een veiligheidsmarge aan en kalibreer tegen de usage.prompt_tokens waarde die bij elke respons wordt geretourneerd.

Hoe vaak moet ik samenvatten?

Alleen als wisselingen buiten het contextvenster vallen. Zo houd je korte gesprekken vrij van extra verzoeken.

Worden vastgezette feiten en samenvattingen gefactureerd?

Ja. Alles wat je als prompt-token verstuurt, wordt gefactureerd tegen $0,15 per miljoen input-tokens per verzoek, dus houd beide compact.

Je sleutel is nog maar één formulier verwijderd

Maak een account aan, kopieer de API-sleutel, pas de base URL aan. Dat is de hele setup.

API-sleutel verkrijgenDocumentatie lezen