FR ▾

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

Unfiltered AI

API LLM brute, sans censure, pensée pour les développeurs.

Unfiltered AIObtenir une clé API

Mémoire de conversation dans une fenêtre de 100k : budgétisation, réduction et résumés

Une fenêtre de 100 000 tokens semble énorme jusqu'à ce qu'un long jeu de rôle ou une histoire la remplisse. Cet article traite le contexte comme un ledger : vous réservez de la place pour la réponse, protégez un petit ensemble de faits épinglés, pliez les anciens tours dans un résumé roulant et réduisez le reste. Chaque étape est accompagnée de courts extraits Python adaptables.

Mémoire de conversation dans une fenêtre de 100k : budgétisation, réduction et résumés

Points clés

  • Les fournisseurs d'inférence dédiés comme Unfiltered AI offrent un comportement sans censure cohérent sur un modèle unique, évitant l'aléa du routage par agrégateur.
  • Les agrégateurs comme OpenRouter donnent accès à plusieurs modèles mais peuvent varier dans la stricte application des filtres de contenu selon la version spécifique du modèle.
  • Unfiltered AI utilise un modèle à poids ouverts sur du matériel dédié avec une fenêtre de contexte de 100k, au prix de $0,15/$0,50 par million de tokens.
  • Pour une cohérence NSFW stricte ou un jeu de rôle, une API LLM sans censure dédiée élimine le besoin d'ingénierie de prompt complexe pour contourner les filtres génériques.

Pensez à la fenêtre comme à un grand livre

Le modèle n'a pas de mémoire entre les appels. Ce qui ressemble à de la mémoire est en fait vous renvoyant du texte, et chaque token renvoyé est une ligne dans un ledger avec un plafond strict : 100 000 tokens, partagé entre le prompt and la réponse. Dépenser plus sur le prompt laisse moins de place à la réponse ; demander trop des deux entraîne une requête rejetée avec un 400.

Un ledger utilisable ressemble à ceci. Réservez 1 500 tokens pour la réponse, car c'est ce que vous passerez en max_tokens. Réservez 3 000 tokens supplémentaires comme marge, car tout comptage local de tokens est une estimation. Il reste alors 59 500 tokens de budget pour le prompt. Dans ce budget, quatre types de contenu entrent en concurrence : le prompt système, les faits épinglés, un résumé roulant et les derniers tours verbatim. Le reste de cet article porte sur la décision de qui l'emporte.

L'ordre de priorité est simple à énoncer. Le contenu système et épinglé n'est jamais coupé. Le résumé est remplacé plutôt que coupé. Les tours récents sont coupés du plus ancien au plus récent. Tout ce qui est supprimé des tours récents n'est pas perdu, car il est intégré au résumé en premier.

Compter sans un tokenizer

Utilisez les compteurs usage retournés pour vérifier vos estimations. Un raccourci caractères par token peut varier selon la langue, la ponctuation et le code. Laissez de la place pour la sortie et réduisez l'entrée lorsque les estimations approchent de la limite de contexte combinée.

C'est pourquoi la marge existe, et pourquoi il est utile de calibrer. Après chaque appel, comparez les caractères envoyés avec usage.prompt_tokens et ajustez votre ratio vers la valeur observée. Un petit facteur de lissage évite qu'un message étrange ne dérange le tout.

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

Si vous intégrez l'est du calibreur dans le trimmer, le budget se resserre ou se desserre automatiquement à mesure que le caractère réel de la conversation émerge. Une histoire riche en dialogues et mots courts a tendance à coûter plus de tokens par caractère que le texte explicatif, donc le ratio observé vaut la peine d'être surveillé.

Réduction : du plus récent au plus ancien, jamais au milieu d'une paire

Parcourez l'historique récent à l'envers et ajoutez uniquement les messages qui tiennent dans le budget. Si même l'échange le plus récent est trop volumineux, tronquez-le ou rejetez-le délibérément. Conservez le contexte requis et les rôles autorisés dans une séquence valide ; sélectionner les tours récents ne garantit pas des réponses cohérentes.

# 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 fonction retourne deux choses : les messages à envoyer et les tours qui sont sortis. Retourner les tours supprimés, au lieu de les jeter, est la décision de conception qui rend les résumés possibles. Rien n'est supprimé silencieusement.

Épingler les faits qui doivent survivre

Un résumé est par nature avec perte. Les faits de personnage qui ne doivent jamais dériver, comme un nom, un secret, une promesse ou une règle du monde, ne devraient pas dépendre du choix d'un réducteur de les conserver. Stockez-les sous forme de courte liste en dehors de l'historique et injectez-les en tant que message système dédié à chaque appel.

  • Épinglez l'identité : noms, relations, espèces, âge (adultes uniquement), profession.
  • Épingler les contraintes : choses que le narrateur ne doit pas faire ou révéler encore.
  • Épingler l'état qui change rarement : lieu, saison, qui détient quoi.
  • Ne pas épingler l'atmosphère. L'ambiance appartient au résumé, où elle peut évoluer.

Conservez le bloc épinglé sous environ 400 tokens. S'il dépasse ce seuil, il commence à se comporter comme un second prompt système et le modèle commence à traiter chaque ligne épinglée comme également urgente. Révisez la liste occasionnellement et retirez les faits qui ne sont plus vrais.

Résumés glissants

Lorsque les tours sortent de la fenêtre, demandez au modèle de les intégrer dans un résumé existant. Le prompt est plus important que le code : dites-lui ce qu'il doit conserver (qui est présent, ce qui a changé, les promesses, les fils inachevés, le lieu actuel) et ce qu'il doit ignorer (remplissage, description répétée), et fixez une limite de longueur en mots. Une limite empêche le résumé de grossir lentement jusqu'à devenir le problème même qu'il résout.

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

Utilisez une température faible. Un résumé doit être fidèle, pas inventif. Une sauvegarde bon marché consiste à lire le résumé vous-même tous les vingt résumons environ pendant le développement ; les erreurs s'accumulent car chaque nouveau résumé est construit sur le précédent.

Assembler les morceaux

La classe ci-dessous relie la réduction, l'épinglage et la résumation dans une seule boucle. Chaque appel construit le prompt, vérifie si quelque chose a été supprimé, l'intègre au résumé si c'est le cas, et reconstruit. La règle est intentionnellement paresseuse : elle ne résume que lorsque la fenêtre le force, afin que les courtes conversations ne paient jamais pour un appel de résumé.

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

Cela s'associe naturellement au relais de streaming dans l'article sur le backend FastAPI, où le magasin de session contiendrait summary, pinned et turns au lieu d'une liste plate. Pour l'état structuré des PNJ selon le même modèle, consultez le guide de dialogue de jeu.

Le coût du souvenir

Une longue mémoire n'est pas gratuite, car l'intégralité du prompt est facturée à nouveau à chaque appel. Supposons deux configurations. Dans la première, l'historique est autorisé à remplir 50 000 tokens de prompt et chaque réponse fait 500 tokens. Le coût d'entrée est 50 000 x $0,15 / 1 000 000 = 0,0075 $, le coût de sortie est 500 x $0,50 / 1 000 000 = 0,00025 $, donc chaque tour coûte environ 0,00775 $. Dans la seconde, vous conservez 8 000 tokens de tours récents plus un résumé de 600 tokens et 400 tokens épinglés, soit environ 9 000 au total. L'entrée coûte 0,00225 $, la sortie 0,00025 $, donc chaque tour coûte près de 0,0028 $.

Sur 1 000 tours, cela représente environ 13 $ contre 2,75 $ selon ces hypothèses. L'approche par résumé coûte également un appel supplémentaire occasionnel d'environ 3 000 tokens d'entrée et 450 tokens de sortie, soit environ 0,0012 $, ce qui est négligeable par rapport aux économies. Les tarifs sont sur la page des tarifs.

Le conseil pratique : ne remplissez pas la fenêtre juste parce qu'elle est là. Utilisez la grande fenêtre comme assurance pour les moments où une scène a vraiment besoin d'un contexte littéral long, et laissez les résumés porter le reste.

Où les schémas de mémoire échouent silencieusement

Trois schémas d'échec réapparaissent encore et encore. Le premier est la dérive du résumé : un détail est paraphrasé, la paraphrase est à nouveau résumée, et après une douzaine de plis, le fait original est méconnaissable. L'épinglage est le remède pour tout ce que vous ne pouvez pas vous permettre de perdre, et un plafond strict de mots empêche le résumé d'absorber tout.

Le second est l'abrupt. Avec une simple réduction et sans résumé, le tour le plus ancien disparaît simplement et le personnage oublie soudainement quelque chose qu'il savait il y a un instant. Les utilisateurs le remarquent. Exécuter le résumiseur une étape avant que la fenêtre ne force, par exemple lorsque le prompt dépasse environ 80 % du budget, lisse la transition.

Le troisième est la confusion de rôle après la réduction, lorsque l'historique commence au milieu d'un échange. La vérification leading-assistant dans le trimmer existe pour cela. Ajoutez un test qui construit une fausse conversation longue, la réduit, et affirme que le premier message conservé est de l'utilisateur et que le total estimé reste sous le budget. Cela prend cinq minutes et prévient une classe de bugs difficiles à repérer en jeu manuel.

Questions et réponses

Que se passe-t-il si le prompt plus max_tokens dépasse 100 000 ?

La requête n'est pas rejetée : max_tokens est réduit à la place restante dans la fenêtre, et la réponse s'arrête à la fin de celle-ci. Seule une invite dépassant 100 000 tokens renvoie une erreur 400 bad request.

Puis-je compter les tokens exactement avant une requête ?

Pas exactement à l'avance. Estimez localement, gardez une marge de sécurité et calibrez par rapport à la valeur usage.prompt_tokens renvoyée avec chaque réponse.

À quelle fréquence dois-je résumer ?

Uniquement lorsque les échanges sortent de la fenêtre de contexte. Cela maintient les courtes conversations exemptes d'appels supplémentaires.

Les faits épinglés et les résumés sont-ils facturés ?

Oui. Tout ce que vous envoyez en tant que token de prompt est facturé à 0,15 $ par million de tokens d'entrée à chaque appel, donc gardez les deux compacts.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé API, modifiez l'URL de base. C'est toute l'installation.

Obtenir la clé APILire la documentation