记忆增强AI服务

❌ Standard AI (e.g., ChatGPT without plugins):
User: "I'm working on a React project with TypeScript"
AI: *Helps with code*
[Next session]
User: "How do I add a new component to my project?"
AI: "What framework are you using?" ← Forgot everything!

✅ HOPE Memory:
User: "I'm working on a React project with TypeScript"
HOPE: *Stores in long-term memory: React + TypeScript project*
[Next session]
User: "How do I add a new component?"
HOPE: *Recalls context* → "Here's a TypeScript React component for your project..."

Conversation: "My dog Max is 3 years old and loves fetch"

HOPE storage:
- Short-term: "User talking about Max right now"
- Long-term: "User has dog named Max, age 3" (promoted after repeated mentions)
- Archive: "User is pet owner" (core fact, rarely changes)

Standard AI: Learn once → Deploy → Never changes
HOPE: Learn → Deploy → Keep learning from every interaction

❌ Standard: Knows "cat", "sat", "mat" as separate words
✅ HOPE: Understands "cat sat on mat" as a pattern

User: "The cat..."
HOPE: *Predicts "sat on mat"* (learned sequence)

Input: "The sky is blue"
HOPE: Low surprise → Process quickly, minimal storage

Input: "The sky is green with purple clouds"
HOPE: High surprise! → Deep processing, strong memory trace

┌─────────────────────────────────────┐
│  INPUT: "Help me debug this code"  │
└──────────────┬──────────────────────┘
               │
        ┌──────▼─────────┐
        │  Memory Router  │  ← Decides where to look
        │  (Surprise-based)│
        └──────┬──────────┘
               │
    ┌──────────┼──────────┐
    │          │          │
 ┌──▼─┐    ┌──▼─┐    ┌──▼─┐
 │Short│    │Long│    │Arch│  ← Three memory tiers
 │Term │    │Term│    │ive │
 └──┬─┘    └──┬─┘    └──┬─┘
    │          │          │
    └──────────┼──────────┘
               │
        ┌──────▼─────────┐
        │ Retentive Core  │  ← Processes & integrates
        │ (Sequence Model)│
        └──────┬──────────┘
               │
        ┌──────▼─────────┐
        │  Momentum       │  ← Smooth learning
        │  + Forgetting   │
        └──────┬──────────┘
               │
        ┌──────▼─────────┐
        │  OUTPUT         │
        │  + Memory Update│
        └─────────────────┘

# Install
npm install @henryhawke/mcp-titan

# Or with bun
bun add @henryhawke/mcp-titan

{
  "mcp": {
    "servers": {
      "hope-memory": {
        "command": "npx",
        "args": ["-y", "@henryhawke/mcp-titan"],
        "workingDirectory": "/path/to/your/memory/storage"
      }
    }
  }
}

# Start the HOPE server
npx @henryhawke/mcp-titan

# The server will:
# 1. Create ~/.hope_memory/ directory
# 2. Initialize empty memory banks
# 3. Start listening for MCP tool calls

// In your AI chat interface (Claude, Cursor, etc.)

// 1. Initialize memory (first time)
> init_model

// 2. Store some context
> bootstrap_memory text="I'm building a Python web app with FastAPI and PostgreSQL"

// 3. Have conversations - HOPE learns automatically
> help me set up database migrations
[HOPE stores: User uses FastAPI + PostgreSQL]

> how do I add authentication?
[HOPE recalls context: FastAPI project → suggests FastAPI-specific auth]

// 4. Check what's stored
> get_memory_state

// 5. Save for later
> save_checkpoint path="my_project_memory.json"

// Explicit training on patterns
> train_step
  x_t: "def hello"
  x_next: "world"

// HOPE learns: "def hello" → "world" pattern

// Later:
> forward_pass input="def hello"
// Predicts: "world" (or similar completion)

// Start continuous learning
> init_learner

// Feed training samples as you work
> add_training_sample data="function add(a, b) { return a + b; }"

// HOPE learns in background, memory updates automatically

// Check learning progress
> get_learner_stats

Day 1: "I'm learning Rust"
HOPE: Stores preference for Rust

Day 5: "Show me how to handle errors"
HOPE: Recalls Rust context → Shows Result<T, E> pattern
      (Not Python try/catch or JavaScript throw)

Store once: "Working on e-commerce site, React frontend, Django backend, Stripe payments"

Every question after:
- "Add a new product page" → HOPE knows React + Django + ecommerce context
- "How do I refund a payment" → HOPE knows you use Stripe
- "Deploy to production" → HOPE remembers full stack (React + Django)

Feed HOPE 50 research papers on neural networks

Query: "What's the consensus on attention mechanisms?"
HOPE:
- Short-term: Current paper's view
- Long-term: Cross-paper patterns identified
- Archive: Fundamental concepts
→ Synthesized answer from all levels

Traditional bot:
- User: "No, I meant X not Y"
- Bot: "OK" → Forgets next session

HOPE bot:
- User: "No, I meant X not Y"
- HOPE: Stores correction in long-term memory
- Next session: Remembers correction automatically

src/hope_model/
├── index.ts              # Main HopeMemoryModel class
├── continuum_memory.ts   # Three-tier memory management
├── retention_core.ts     # Sequence processing
├── memory_router.ts      # Surprise-based routing
├── mamba_filters.ts      # Selective state-space filters
└── optimizer_hooks.ts    # Delta compression, layer scheduling

interface HopeMemoryState {
  shortTerm: Tensor2D;       // Recent activations [N, 256]
  longTerm: Tensor2D;        // Consolidated patterns [M, 256]
  archive: Tensor2D;         // Stable knowledge [K, 256]

  surpriseHistory: Tensor1D; // Surprise scores over time
  accessCounts: Tensor1D;    // How often each memory accessed
  timestamps: Tensor1D;      // When each memory created

  // HOPE-specific enhancements
  momentumState?: Tensor2D;  // Momentum for smooth learning
  tokenFlowHistory?: number[][]; // Sequence patterns
  levelIndex: Tensor1D;      // Which tier each memory belongs to
}

git clone https://github.com/henryhawke/mcp-titan.git
cd mcp-titan

# Install dependencies
bun install  # or npm install

# Build
bun run build

# Test
bun test

# Run locally
bun start

mcp-titan/
├── src/
│   ├── hope_model/          # Core HOPE architecture
│   ├── tokenizer/           # BPE tokenization & embeddings
│   ├── training/            # Training pipeline
│   ├── index.ts             # MCP server entry point
│   └── types.ts             # TypeScript interfaces
├── docs/
│   ├── api/                 # API documentation
│   ├── architecture-overview.md
│   └── typescript-error-resolution-guide.md
├── test/                    # Test suites
├── HOPE.md                  # Research paper
├── PLAN.md                  # Implementation roadmap
└── README.md                # This file

# All tests
bun test

# With coverage
bun test --coverage

# Specific test file
bun test src/__tests__/hope_model.test.ts

# Ensure Node.js 22+
node --version

# Reinstall dependencies
rm -rf node_modules package-lock.json
npm install

// HOPE has automatic cleanup, but you can manually trigger:
> reset_gradients
> prune_memory threshold=0.1

# Skip type checking
npm run build --skipTypeCheck

# Or use published version
npx @henryhawke/mcp-titan

// Reduce memory capacity in config
> init_model config={
  "shortTermSlots": 32,  // Default 64
  "longTermSlots": 128,  // Default 256
  "archiveSlots": 256    // Default 512
}

@article{behrouz2025nested,
  title={Nested Learning: The Illusion of Deep Learning Architectures},
  author={Behrouz, Ali and Razaviyayn, Meisam and Zhong, Peiling and Mirrokni, Vahab},
  journal={NeurIPS},
  year={2025}
}

Base Model → Fine-tuning → HOPE Learning
(General)    (Domain)      (User-specific)