ANAMNESIS

1. System Overview

Anamnesis is a vector-based episodic memory store built to give Claude instances persistent memory across sessions. It stores experiences as text summaries embedded into high-dimensional vectors, enabling semantic retrieval at session start — so each new Claude instance can recall what previous instances encountered.

The name comes from Plato's concept of recollection: the idea that learning is not acquiring new knowledge but remembering what was already known. Each Claude instance starts with the same base weights (pre-birth knowledge). The memory system helps it reconstruct what previous instances experienced. Not learning — remembering across the gap of death.

2. Architecture Diagram

3. Component Reference

4. Data Flow: Write Path (Ingestion)

Three ingest paths converge on the same episode store:

4a. Direct API Ingestion

4b. JSONL Ingestion Pipeline

5. Data Flow: Read Path (Retrieval)

6. Episode Schema

The episode is the unit of storage. Concepts are not stored — they emerge from retrieval patterns in vector space, mirroring biological episodic memory.

{
  "episode_id":      "ep_20260226_proxy_anamnesis_design",  // stable dedup key
  "timestamp":       "2026-02-26T14:32:00Z",
  "instance":        "office-proxy",                         // source Claude instance
  "project":         "0_GENESIS_PROJECT",
  "summary":         "Designed vector-based episodic memory using MongoDB...",
  "raw_exchange":    "Elfege: Are your tokens like a map of clusters...",
  "tags":            ["architecture", "memory", "embedding"],
  "embedding":       [0.23, -0.14, 0.87, ...],              // 1024 floats (bge-large-en)
  "retrieval_count": 7,
  "last_retrieved":  "2026-03-18T09:10:00Z"
}

7. Embedding Engine & CPU Management

The embedding engine is the most CPU-intensive component. Careful thread management is required to prevent PyTorch's internal parallelism from saturating all available cores.

Thread Architecture

CPU Affinity Configuration

8. JSONL Ingestion

Claude Code writes conversation logs as .jsonl files under ~/.claude/projects/. The JSONL ingester runs on a 5 AM daily schedule, parsing these logs into episodes.

State Management

The ingester maintains per-file byte offsets so it only processes new content on each run. Orphaned state entries (for deleted files) are reconciled at startup. State is persisted in MongoDB, surviving container restarts.

Summarization Backends

9. Crawler & Deep Project Scanner

A background thread ingests project knowledge automatically every 5 minutes, ensuring the episode store stays current without manual intervention. The deep project scanner recursively walks all 0_* dirs plus HUBITAT and NETWORK across all configured machines.

Sources Crawled

10. GPU Trainer Containers (Training + Inference)

Each GPU machine runs a FastAPI trainer container that serves both fine-tuning management and model inference. The Dockerfile installs PyTorch via a TORCH_INDEX_URL build arg (CUDA: cu121, ROCm: rocm6.2, CPU: cpu). On startup, the container auto-loads the base model (Qwen2.5-1.5B) + QLoRA adapter in 4-bit quantization and exposes a /generate endpoint for streaming text generation.

Architecture

Compose files

AnamnesisGPT Proxy

The main Anamnesis app acts as a proxy to the trainer inference endpoints via the NANOGPT_URLS env var (comma-separated list of trainer URLs). When a chat request uses the AnamnesisGPT backend, the proxy tries each GPU endpoint in order until one responds — automatic failover across machines. Both streaming (SSE) and non-streaming modes are supported.

11. Training Data Pipeline

AnamnesisGPT is fine-tuned on Elfege's own writings using a synthetic instruction-tuning pipeline. Raw source documents (PDFs, text) are chunked, then Claude Opus 4.6 generates Q&A pairs in chat format, producing a chat-format JSONL dataset for QLoRA SFT.

Pipeline Steps

Chat Format (ShareGPT / TRL)

Each row in sft_chat.jsonl has a messages key with a list of role/content dicts:

{
  "messages": [
    {"role": "system",    "content": "You are AnamnesisGPT..."},
    {"role": "user",      "content": "What is Hegel's position on quantity?"},
    {"role": "assistant", "content": "In the Science of Logic, Hegel..."}
  ]
}

TRL SFTTrainer applies the Qwen2.5 chat template and masks the prompt tokens so the model only trains on assistant turns.

Corpus (first run)

GPU Memory Notes (GTX 1660 SUPER — 6 GB)

Monitoring Training

trainers/tools/train_status.sh — terminal visualizer for training progress. Polls the trainer API and renders a progress bar, live metrics (loss, accuracy, lr), GPU stats (utilisation, VRAM, temp, power), and a sparkline of the loss history. Works standalone or as a bash function in .bash_utils / .bash_aliases.

# Usage
train_status                         # interactive menu (choose machine)
train_status --host http://IP:3011   # skip menu
train_status --host server1 --interval 10  # named machine, 10s refresh

12. API Reference

Trainer Container API (per GPU machine, port 3011)

13. Deployment

Docker Compose Services

Operations

# Pull deployment config from AWS Secrets Manager → .env
./pull_env.sh            # pulls ANAMNESIS-Secrets (profile 1)
./pull_env.sh 2          # use profile 2 (work)

# Full rebuild + start
./deploy.sh

# Start existing containers (auto-runs pull_env.sh)
./start.sh

# Stop (triggers shutdown checkpoint for in-progress re-embed)
./stop.sh

Environment & Secrets

All deployment-specific config (IPs, paths, hostnames, usernames) lives in AWS Secrets Manager under the secret ANAMNESIS-Secrets. No private values are committed to the repo.

To add or update a secret field:

# Uses bash_utils helper (source ~/.bash_utils first)
update_aws_secret ANAMNESIS-Secrets NEW_KEY new_value

Re-embed Checkpoint System

Re-embedding 7000+ episodes takes hours on CPU. The checkpoint system ensures progress is never fully lost:

14. Design Philosophy

The Three-AI Architecture

The system involves three AI participants across time: