IT ▾

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

Unfiltered AI

API LLM grezza, senza censura, pensata per gli sviluppatori.

Unfiltered AIOttieni la chiave API

Memoria conversazionale in una finestra da 100k: budget, riduzione e riassunti

Una finestra da 100.000 token sembra enorme finché un lungo roleplay o una storia non la riempiono. Questo articolo tratta il contesto come un registro: riservi spazio per la risposta, proteggi un piccolo set di fatti fissati, compatti i turni più vecchi in un riassunto rotante e riduci il resto. Ogni passaggio è accompagnato da brevi snippet Python che puoi adattare.

Memoria conversazionale in una finestra da 100k: budget, riduzione e riassunti

Punti chiave

  • Provider di inferenza dedicati come Unfiltered AI offrono un comportamento senza censura coerente su un singolo modello, evitando la casualità del routing degli aggregator.
  • Aggregator come OpenRouter offrono l'accesso a più modelli ma possono variare nel modo in cui applicano rigorosamente i filtri sui contenuti a seconda della versione specifica del modello.
  • Unfiltered AI utilizza un modello a pesi aperti su hardware dedicato con una finestra di contesto da 100k, al prezzo di $0,15/$0,50 per milione di token.
  • Per una coerenza rigorosa NSFW o di roleplay, un'API LLM senza censura dedicata elimina la necessità di complesse tecniche di prompt engineering per aggirare i filtri generici.

Pensa alla finestra come a un libro mastro

Il modello non ha memoria tra una chiamata e l'altra. Ciò che sembra un ricordo è in realtà il tuo reinvio del testo, e ogni token reinviato è una riga in un registro con un limite rigido: 100.000 token, condivisi tra il prompt and e la risposta. Se spendi di più per il prompt, lasci meno spazio per la risposta; se chiedi troppo per entrambi, la richiesta viene rifiutata con un 400.

Un registro funzionante si presenta così. Riserva 1.500 token per la risposta, poiché è quello che passerai come max_tokens. Riserva altri 3.000 come margine, poiché qualsiasi conteggio locale dei token è una stima. Questo lascia 59.500 token di budget per il prompt. All'interno di questo budget, quattro tipi di contenuto competono: il prompt di sistema, i fatti fissati, un riassunto rotante e i turni recenti testuali. Il resto di questo articolo riguarda il decidere chi vince.

L'ordine di priorità è semplice da enunciare. I contenuti di sistema e fissati non vengono mai tagliati. Il riassunto viene sostituito invece che tagliato. I turni recenti vengono tagliati dal più vecchio al più recente. Tutto ciò che viene rimosso dai turni recenti non è perso, perché viene prima compattato nel riassunto.

Conteggio senza tokenizer

Usa i conteggi usage restituiti per verificare le tue stime. Una scorciatoia basata sui caratteri per token può variare a seconda della lingua, della punteggiatura e del codice. Lascia spazio per l'output e riduci l'input quando le stime si avvicinano al limite combinato del contesto.

Ecco perché esiste il margine e perché conviene calibrare. Dopo ogni chiamata, confronta i caratteri inviati con usage.prompt_tokens e regola il tuo rapporto verso il valore osservato. Un piccolo fattore di smoothing evita che un messaggio strano lo alteri.

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

Se scambi il est del calibratore con il riduttore, il budget si stringe o si allenta da solo mentre emerge il carattere reale della conversazione. Una storia ricca di dialoghi e parole brevi tende a costare più token per carattere rispetto alla prosa espositiva, quindi il rapporto osservato vale la pena di essere monitorato.

Riduzione: prima i più recenti, mai a metà coppia

Analizza la cronologia recente in ordine inverso e aggiungi solo i messaggi che rientrano nel budget. Se anche lo scambio più recente è troppo grande, troncalo o rifiutalo deliberatamente. Mantieni il contesto richiesto e i ruoli consentiti in una sequenza valida; selezionare i turni recenti non garantisce risposte coerenti.

# 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

La funzione restituisce due cose: i messaggi da inviare e i turni che sono usciti. Restituire i turni eliminati, invece di scartarli, è la decisione di progettazione che rende possibili i riassunti. Nulla viene eliminato in silenzio.

Fissare i fatti che devono sopravvivere

Un riassunto è per natura con perdita. I fatti sui personaggi che non devono mai deviare, come un nome, un segreto, una promessa o una regola del mondo, non dovrebbero dipendere dalla scelta del riassuntatore di mantenerli. Memorizzali come un breve elenco esterno alla cronologia e iniettili come messaggio di sistema dedicato a ogni chiamata.

  • Fissa l'identità: nomi, relazioni, specie, età (solo adulti), professione.
  • Fissa i vincoli: cose che il narratore non deve fare o rivelare ancora.
  • Fissa lo stato che cambia raramente: posizione, stagione, chi possiede cosa.
  • Non fissare l'atmosfera. L'umore appartiene al riassunto, dove può evolversi.

Mantieni il blocco fissato sotto circa 400 token. Se cresce oltre questo limite, inizia a comportarsi come un secondo prompt di sistema e il modello inizia a trattare ogni riga fissata come ugualmente urgente. Rivedi l'elenco occasionalmente e archivia i fatti che non sono più veri.

Riassunti rotanti

Quando i turni escono dalla finestra, chiedi al modello di compattarli in un riassunto esistente. Il prompt è più importante del codice: digli cosa mantenere (chi è presente, cosa è cambiato, promesse, fili irrisolti, luogo attuale) e cosa scartare (riempitivi, descrizioni ripetute), e limita la lunghezza in parole. Un limite impedisce al riassunto di gonfiarsi lentamente nel problema che risolve.

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()

Usa una temperatura bassa. Un riassunto dovrebbe essere fedele, non inventivo. Una protezione economica è leggere il riassunto stesso ogni venti o più compattazioni durante lo sviluppo; gli errori si accumulano perché ogni nuovo riassunto è costruito su quello precedente.

Mettere insieme i pezzi

La classe seguente collega riduzione, fissaggio e riassunzione in un unico ciclo. Ogni chiamata costruisce il prompt, controlla se è stato perso qualcosa, lo compatta nel riassunto se sì, e lo ricostituisce. La regola è intenzionalmente pigra: riassume solo quando la finestra lo impone, quindi le conversazioni brevi non pagano mai per una chiamata di riassunto.

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

Questo si abbina naturalmente al relay di streaming nell'articolo sul backend FastAPI, dove lo store della sessione manterrebbe summary, pinned e turns invece di un unico elenco piatto. Per lo stato NPC strutturato sullo stesso modello, vedi la guida al dialogo di gioco.

Il costo del ricordo

La memoria lunga non è gratuita, perché l'intero prompt viene fatturato di nuovo a ogni chiamata. Supponi due configurazioni. Nella prima, la cronologia è consentita di riempire 50.000 token di prompt e ogni risposta è di 500 token. Il costo di input è 50.000 x $0,15 / 1.000.000 = $0,0075, il costo di output è 500 x $0,50 / 1.000.000 = $0,00025, quindi ogni turno costa circa $0,00775. Nella seconda, mantieni 8.000 token di turni recenti più un riassunto da 600 token e 400 token fissati, per un totale di circa 9.000. L'input è $0,00225, l'output $0,00025, quindi ogni turno è vicino a $0,0028.

Su 1.000 turni questo è circa $13 contro $2,75 sotto queste ipotesi. L'approccio del riassunto costa anche una chiamata extra occasionale di forse 3.000 input e 450 token di output, circa $0,0012, che è trascurabile rispetto al risparmio. I tassi sono nella pagina dei prezzi.

Il consiglio pratico: non riempire la finestra solo perché c'è. Usa la grande finestra come assicurazione per i momenti in cui una scena ha davvero bisogno di un contesto verbatim lungo, e lascia che i riassunti gestiscano il resto.

Dove i piani di memoria falliscono silenziosamente

Tre modelli di errore si presentano di nuovo e di nuovo. Il primo è la deriva del riassunto: un dettaglio è parafrasato, la parafrasi è riassunta di nuovo e dopo una dozzina di compattazioni il fatto originale è irriconoscibile. Il fissaggio è la cura per qualsiasi cosa tu non possa permetterti di perdere, e un limite rigido di parole impedisce al riassunto di assorbire tutto.

Il secondo è il dirupo. Con una pura riduzione e nessun riassunto, il turno più vecchio scompare semplicemente e il personaggio improvvisamente dimentica qualcosa che sapeva un attimo fa. Gli utenti se ne accorgono. Eseguire il riassuntore un passo prima che la finestra lo imponga, ad esempio quando il prompt supera circa l'80 percento del budget, attenua la transizione.

Il terzo è la confusione di ruolo dopo la riduzione, quando la cronologia inizia a metà scambio. Il controllo del leading-assistant nel riduttore esiste per questo. Aggiungi un test che costruisce una lunga conversazione finta, la riduce e afferma che il primo messaggio mantenuto è dell'utente e che il totale stimato rimane sotto il budget. Ci vogliono cinque minuti e previene una classe di bug difficili da individuare nel gioco manuale.

Domande e risposte

Cosa succede se prompt più max_tokens superano i 100.000?

La richiesta non viene rifiutata: max_tokens viene ridotto allo spazio disponibile nella finestra e la risposta termina alla fine della finestra. Solo un prompt superiore a 100.000 token restituisce un errore 400 bad request.

Posso contare i token con esattezza prima di una richiesta?

Non esattamente in anticipo. Stima localmente, mantieni un margine di sicurezza e calibra rispetto al valore usage.prompt_tokens restituito con ogni risposta.

Con quale frequenza devo riassumere?

Solo quando i turni escono dalla finestra di contesto. Questo mantiene le conversazioni brevi senza chiamate extra.

I fatti fissati e i riassunti sono fatturati?

Sì. Tutto ciò che invii come token del prompt viene fatturato a $0,15 per milione di token di input su ogni chiamata, quindi mantieni entrambi compatti.

La tua chiave è a un modulo di distanza

Crea un account, copia la chiave, modifica l'URL di base. Questa è l'intera configurazione.

Ottieni chiave APILeggi la documentazione