Continuum Context Hub

Persistent AI memory for your codebase. Stop repeating yourself to Claude Code, Cursor, and Windsurf. Store architectural decisions once — every AI session recalls them automatically via MCP.

The Problem

Every AI session starts from zero. Claude Code, Cursor, and Windsurf don't know:

• Your payment-service requires idempotency keys on all API calls
• user-service changes always need a corresponding notification-service update
• Your team switched to UUIDs 6 months ago — and exactly why
• The AppError class exists and should be used instead of plain exceptions

So they guess. They write plausible-looking code that silently breaks your conventions.

Continuum fixes this. One local hub, queried automatically before every AI response.

How It Works

┌──────────────────────────────────────────────────┐
│                  Your Codebase                   │
│                                                  │
│  .continuum/          git commits      VS Code   │
│  ├── overview.md  ──┐                 sidebar    │
│  ├── cross-cutting.md├──▶ Continuum ◀── memories │
│  └── services/       │   (local hub)             │
│      └── payment.md ─┘        │                 │
│                               │  MCP tools       │
│                               ▼                  │
│         Claude Code · Cursor · Windsurf           │
│         (queries context before every change)     │
└──────────────────────────────────────────────────┘

Context is stored locally on your machine. Nothing is sent to any external server.

Quick Start

1. Install the Python backend

pip install continuum-context-hub

The extension auto-starts and manages the server — no manual process needed.

2. Install this extension

Search Continuum Context Hub in the Extensions panel, or install from the Marketplace.

3. Set up your project

Open the Continuum sidebar (activity bar icon) and click Set Up Project. This scaffolds a .continuum/ directory with auto-detected services:

.continuum/
├── overview.md          ← architecture, tech stack, team conventions
├── cross-cutting.md     ← auth, logging, error handling, API patterns
├── change-impact.md     ← what breaks when things change
└── services/
    ├── payment-service.md   ← auto-detected from your repo
    └── user-service.md

Fill in the templates, then click Import in the sidebar to load everything into memory. Done.

The Sidebar

The Continuum panel gives you a full memory interface without leaving VS Code:

Status pill — shows whether the server is connected and how many memories are stored.

Action buttons:

• + Save Memory — capture any fact, decision, or convention in one step
• ⌕ Search — open the full Memory Explorer for semantic search across all memories
• ↓ Import — pull memories from git history

Live search — filter all memories instantly as you type. Results grouped by category.

Memory list — collapsible sections by category (architecture, security, decisions, etc.) with importance indicators:

• 🔴 Critical — correctness-breaking if missed
• 🟠 High — important convention or decision
• 🔵 Medium — useful context
• ⚪ Low / 🕐 Ephemeral

Hover any memory to edit or delete it inline.

Automatic Memory Capture

Continuum captures knowledge without interrupting your flow:

@memory: annotations — add a comment anywhere in code:

# @memory: Redis cache TTL is 5 minutes for user sessions

On save, it's automatically stored as a memory.

Dependency file watcher — when package.json, go.mod, requirements.txt, or Cargo.toml changes, Continuum records it.

New service directories — detecting a new *-service/, *-api/, or *-worker/ directory logs the addition automatically.

Git commit hook — run Context Hub: Install Git Commit Hook to capture every commit message. Decisions buried in commit history become searchable memories.

Idle prompt — after 20+ minutes in the same file:

"You've been in payment-service/auth.ts for 23 minutes. Learn something worth saving?"

One click → memory saved before you context-switch.

What AI Assistants See

Continuum registers MCP tools with Claude Code and Cursor automatically. They call these before writing code:

With Continuum: Claude knows which auth pattern to use, which error class to throw, and which other services need updating.

Without Continuum: Claude makes its best guess — and it will be wrong in subtle ways.

Saving Memories

From the sidebar (fastest)

Click + Save Memory → type what should be remembered → Enter. Continuum infers category and importance from the content automatically.

From a selection

Select any code or text → right-click → Save Selection as Memory.

Keyboard shortcuts

From git history

Run Context Hub: Import from Git History to mine past commits. Commit messages containing words like "decided", "switched to", "replaced", or "because" are extracted and stored as architectural decisions automatically.

Linked Projects

In a polyrepo setup (each service is its own repo), AI assistants only see memories from the repo currently open. Linked Projects fixes this — connect related repos so their memories are shared.

How to link:

1. Open the Continuum sidebar
2. In the "Linked Projects" section at the bottom, click + Link
3. Select another project from the list (all previously opened repos appear)
4. Done — memories from both projects now appear in searches and AI context

Linking is bidirectional: linking payment-service → user-service also makes payment-service memories available when working in user-service.

What changes after linking:

• Semantic search spans both projects — results show [project-name] labels for memories from other repos
• MCP load_project_context and recall tools include linked project memories automatically
• The AI knows user-service JWT tokens expire in 15 minutes even when you're editing payment-service

To unlink, click the ✕ next to a linked project name in the sidebar.

Commands

Settings

Privacy

All data is stored locally. No memory or context leaves your machine. The server runs as a local process; the only network traffic is between VS Code and localhost.

Requirements

• VS Code 1.80+
• Python 3.9+ with pip install continuum-context-hub
• Claude Code or Cursor for MCP-powered context queries (optional — memories are also browsable in the sidebar)

Related

• continuum — Python backend (FastAPI + ChromaDB + SQLite)
• PyPI: continuum-context-hub
• GitHub Issues

Apache 2.0 — LICENSE