PT ▾

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

Unfiltered AI

API LLM crua, sem censura, feita para desenvolvedores.

Unfiltered AIObter chave de API

Memória de conversa em janela de 100k: orçamento, corte e resumos

Uma janela de 100.000 tokens parece enorme até que um roleplay ou história longa a preencha. Este artigo trata o contexto como um livro-razão: você reserva espaço para a resposta, protege um conjunto pequeno de fatos fixados, resuma turnos antigos e corta o restante. Cada etapa vem com código Python curto para adaptar.

Memória de conversa em janela de 100k: orçamento, corte e resumos

Pontos-chave

  • Provedores de inferência dedicados como Unfiltered AI oferecem comportamento sem censura consistente em um único modelo, evitando a aleatoriedade do roteamento de agregadores.
  • Agregadores como OpenRouter oferecem acesso a vários modelos, mas podem variar na aplicação estrita de filtros de conteúdo dependendo da versão específica do modelo.
  • Unfiltered AI usa um modelo de pesos abertos em hardware dedicado com janela de contexto de 100k, custando $0,15/$0,50 por milhão de tokens.
  • Para consistência estrita de NSFW ou roleplay, uma API LLM sem censura dedicada elimina a necessidade de engenharia de prompt complexa para contornar filtros genéricos.

Pense na janela como um livro-razão

O modelo não tem memória entre chamadas. O que parece ser lembrança é você reenviando texto, e cada token reenviado é uma linha em um livro-razão com um teto rígido: 100.000 tokens, compartilhados pelo prompt and e pela resposta. Gastar mais no prompt deixa menos espaço para a resposta; pedir demais para ambos resulta em rejeição da requisição com erro 400.

Um livro-razão viável se parece com isto. Reserve 1.500 tokens para a resposta, pois esse é o valor que você passará como max_tokens. Reserve mais 3.000 como margem, já que qualquer contagem local de tokens é uma estimativa. Isso deixa 59.500 tokens de orçamento para o prompt. Dentro desse orçamento, quatro tipos de conteúdo competem: o prompt do sistema, fatos fixados, um resumo contínuo e os turnos recentes literais. O restante deste artigo trata de decidir quem vence.

A ordem de prioridade é simples de declarar. Conteúdo do sistema e fixado nunca é cortado. O resumo é substituído em vez de cortado. Turnos recentes são cortados do mais antigo ao mais recente. Tudo descartado dos turnos recentes não se perde, pois é incorporado ao resumo primeiro.

Contagem sem tokenizer

Use as contagens de usage retornadas para verificar suas estimativas. Um atalho de caracteres por token pode variar conforme o idioma, a pontuação e o código. Deixe espaço para a saída e reduza a entrada quando as estimativas se aproximarem do limite de contexto combinado.

É por isso que a margem existe, e por que vale a pena calibrar. Após cada chamada, compare os caracteres enviados com usage.prompt_tokens e ajuste sua proporção para o valor observado. Um pequeno fator de suavização evita que uma mensagem estranha desequilibre tudo.

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 você substituir o est do calibrador no trimmer, o orçamento se ajusta automaticamente à medida que a natureza real da conversa emerge. Uma história com muitos diálogos e palavras curtas tende a custar mais tokens por personagem do que a prosa expositiva, portanto, a razão observada vale a pena ser monitorada.

Corte: mais recentes primeiro, nunca no meio

Percorra o histórico recente de trás para frente e adicione apenas as mensagens que cabem no orçamento. Se até a troca mais recente for muito grande, trunque ou rejeite-a deliberadamente. Mantenha o contexto necessário e os papéis permitidos em uma sequência válida; selecionar rodadas recentes não garante respostas coerentes.

# 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

A função retorna duas coisas: as mensagens para enviar e os turnos que saíram. Retornar os turnos descartados, em vez de descartá-los, é a decisão de design que torna os resumos possíveis. Nada é deletado silenciosamente.

Fixando fatos que devem sobreviver

Um resumo é inerentemente com perda. Fatos do personagem que nunca devem sofrer deriva, como um nome, um segredo, uma promessa ou uma regra do mundo, não devem depender do resumo escolher mantê-los. Armazene-os como uma lista curta fora do histórico e injete-os como uma mensagem de sistema dedicada em cada chamada.

  • Fixe a identidade: nomes, relacionamentos, espécies, idade (apenas adultos), ocupação.
  • Fixe restrições: coisas que o narrador não deve fazer ou revelar ainda.
  • Fixe estado que muda raramente: localização, estação, quem segura o quê.
  • Não fixe atmosfera. O humor pertence ao resumo, onde pode evoluir.

Mantenha o bloco fixado abaixo de aproximadamente 400 tokens. Se crescer além disso, começa a se comportar como um segundo prompt do sistema e o modelo começa a tratar cada linha fixada como igualmente urgente. Revise a lista ocasionalmente e retire fatos que deixaram de ser verdadeiros.

Resumos contínuos

Quando turnos saem da janela, peça ao modelo para incorporá-los a um resumo existente. O prompt importa mais que o código: diga o que manter (quem está presente, o que mudou, promessas, fios soltos, local atual) e o que descartar (preenchimento, descrição repetida), e limite o comprimento em palavras. Um limite evita que o resumo cresça lentamente até se tornar o próprio problema que resolve.

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

Use uma temperatura baixa. Um resumo deve ser fiel, não inventivo. Uma proteção barata é ler o resumo você mesmo a cada vinte ou mais iterações durante o desenvolvimento; os erros se acumulam porque cada novo resumo é construído sobre o anterior.

Juntando as peças

A classe abaixo conecta corte, fixação e resumo em um loop. Cada chamada constrói o prompt, verifica se algo foi descartado, incorpora ao resumo se for o caso, e reconstrói. A regra é intencionalmente preguiçosa: ela só resume quando a janela força, então conversas curtas nunca pagam por uma chamada de resumo.

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

Isso combina naturalmente com o relé de streaming no artigo sobre o backend FastAPI, onde o armazenamento de sessão manteria summary, pinned e turns em vez de uma lista plana. Para o estado de NPC estruturado no mesmo padrão, consulte o guia de diálogo de jogos.

O custo de lembrar

Memória longa não é gratuita, porque todo o prompt é cobrado novamente em cada chamada. Assuma duas configurações. Na primeira, o histórico é permitido preencher 50.000 tokens de prompt e cada resposta tem 500 tokens. Custo de entrada: 50.000 x $0,15 / 1.000.000 = $0,0075; custo de saída: 500 x $0,50 / 1.000.000 = $0,00025, então cada turno custa cerca de $0,00775. Na segunda, você mantém 8.000 tokens de turnos recentes mais um resumo de 600 tokens e 400 tokens fixados, cerca de 9.000 no total. Entrada: $0,00225; saída: $0,00025, então cada turno é próximo de $0,0028.

Em 1.000 turnos, isso dá cerca de $13 versus $2,75 sob estas suposições. A abordagem de resumo também custa uma chamada extra ocasional de talvez 3.000 entrada e 450 tokens de saída, cerca de $0,0012, que é insignificante perto das economias. Taxas estão na página de preços.

O conselho prático: não preencha a janela só porque ela está lá. Use a janela grande como seguro para os momentos em que uma cena realmente precisa de contexto literal longo, e deixe os resumos carregarem o resto.

Onde esquemas de memória falham silenciosamente

Três padrões de falha aparecem repetidamente. O primeiro é a deriva do resumo: um detalhe é parafrasado, a paráfrase é resumida novamente e, após uma dúzia de iterações, o fato original torna-se irreconhecível. Fixar é a cura para qualquer coisa que você não possa perder, e um limite rígido de palavras impede que o resumo absorva tudo.

O segundo é a queda abrupta. Com um corte puro e sem resumo, o turno mais antigo simplesmente desaparece e o personagem de repente esquece algo que sabia há pouco tempo. Os usuários percebem. Executar o resuminizador um passo antes da janela força, por exemplo, quando o prompt passa cerca de 80 por cento do orçamento, suaviza a transição.

O terceiro é a confusão de papéis após o corte, quando o histórico começa no meio da troca. A verificação do assistente líder no cortador existe para isso. Adicione um teste que construa uma conversa falsa longa, corte-a e afirme que a primeira mensagem mantida é do usuário e que o total estimado permanece dentro do orçamento. Leva cinco minutos e impede uma classe de bugs difíceis de detectar no jogo manual.

Perguntas e respostas

O que acontece se o prompt mais max_tokens exceder 100.000?

A solicitação não é rejeitada: max_tokens é ajustado ao espaço restante na janela, e a resposta é interrompida no final da janela. Apenas um prompt com mais de 100.000 tokens retorna um erro 400 bad request.

Posso contar tokens com precisão antes de uma requisição?

Não exatamente de antemão. Estime localmente, mantenha uma margem de segurança e calibre contra o valor de usage.prompt_tokens retornado com cada resposta.

Com que frequência devo resumir?

Apenas quando os turnos saem da janela. Isso mantém conversas curtas livres de chamadas extras.

Fatos fixados e resumos têm cobrança?

Sim. Tudo que você envia como token de prompt é cobrado a $0,15 por milhão de tokens de entrada em cada chamada, então mantenha ambos compactos.

Sua chave está a um formulário de distância

Crie uma conta, copie a chave, altere a base URL. Essa é toda a configuração.

Obter chave de APILer a documentação