Wygasanie pamięci i garbage collection

Pamięć rośnie bez ograniczeń

Dlaczego usuwać wspomnienia?

Strategia 1: TTL

ALTER TABLE semantic_facts ADD COLUMN expires_at TIMESTAMPTZ;

-- short-lived
INSERT INTO semantic_facts (..., expires_at) VALUES (..., NOW() + INTERVAL '7 days');

-- garbage collect
DELETE FROM semantic_facts WHERE expires_at < NOW();

Strategia 2: wygaszanie oparte na czasie

import math

def decayed_confidence(original, age_days, half_life_days=30):
    return original * math.exp(-age_days * math.log(2) / half_life_days)

# Then retrieval filters: WHERE decayed_confidence > 0.3
for age in [0, 30, 60, 90]:
    print(f"Age {age} days -> confidence {decayed_confidence(1.0, age):.3f}")

Strategia 3: wygaszanie oparte na użyciu

ALTER TABLE semantic_facts ADD COLUMN last_used_at TIMESTAMPTZ DEFAULT NOW();

-- update on retrieval
UPDATE semantic_facts SET last_used_at = NOW() WHERE id = ANY(:retrieved_ids);

-- gc
DELETE FROM semantic_facts WHERE last_used_at < NOW() - INTERVAL '90 days';

Strategia 4: limit pojemności na użytkownika

MAX_FACTS = 500

SELECT COUNT(*) FROM semantic_facts WHERE user_id = %s;
-- if > MAX_FACTS: delete oldest unused

Kompaktowanie: łączenie podobnych wspomnień

def compact(user_id):
    facts = all_facts(user_id)
    clusters = cluster_by_embedding(facts, threshold=0.85)
    for cluster in clusters:
        merged = llm.invoke(f'Merge these into one canonical statement: {cluster}')
        replace_with_merged(cluster, merged)

Rozwiązywanie sprzeczności

def resolve(user_id, new_fact):
    similar = retrieve(user_id, new_fact, k=5)
    for s in similar:
        if llm_says_contradicts(s, new_fact):
            mark_obsolete(s.id)
    save(new_fact)

Strategia 5: ważenie według ważności

importance_prompt = 'Rate the importance of this fact for future interactions (0-1):\n{fact}'

for fact in facts:
    score = float(llm.invoke(importance_prompt.format(fact=fact)).content)
    update_importance(fact.id, score)

# Retrieval: weight by importance and recency

Podsumowywanie w stylu Letta

if archival_size > LIMIT:
    block = oldest_facts(50)
    summary = summarise(block)
    replace(block, summary)

Usuwanie na żądanie użytkownika

def forget_user(user_id):
    conn.execute('DELETE FROM semantic_facts WHERE user_id = %s', (user_id,))
    conn.execute('DELETE FROM episodes WHERE user_id = %s', (user_id,))
    vector_db.delete(filter={'user_id': user_id})

Usuwanie miękkie a usuwanie trwałe

ALTER TABLE semantic_facts ADD COLUMN deleted_at TIMESTAMPTZ;
-- queries always: WHERE deleted_at IS NULL

Zaplanowane zadania GC

# Daily cron at 03:00 UTC
for user_id in all_users():
    decay_confidence(user_id)
    delete_expired(user_id)
    compact_clusters(user_id)

Dlaczego stosować wygaszanie?

Podsumowanie