Contextpoint
Your project's memory for AI coding sessions.
The problem it solves
You open a fresh Claude chat and type the same paragraph again: what you're building, which files matter, what the model must not touch, which approach already failed on Tuesday. Contextpoint keeps that paragraph for you, per project, and delivers it in one click.
It starts before you type anything. Open a git repo and Contextpoint reads your latest commit to name the task.
How you use it
- Open a project in VS Code and click the Contextpoint icon in the activity bar
- Accept the task Contextpoint detected from your last commit, or click it and rename it
- Add constraints (rules Claude must not break) and failed attempts (dead ends you already hit)
- Press send or
Ctrl+Alt+S
Contextpoint compiles your task, constraints, failed attempts, notes, branch, changed files, and open editors into a short prompt, then hands it to Claude.
Where the prompt goes
You pick once on first send. Change it any time with Contextpoint: Change AI Provider.
- Claude Code, opened in your project folder
- Claude desktop app
- claude.ai in your browser
- Anthropic API, with the reply shown inside VS Code
The first three ride on your Claude subscription. Only the API path asks for a key.
Claude Code works the context itself (MCP)
Contextpoint ships an MCP server, so Claude Code reads and updates your context without any copying.
Run Contextpoint: Connect Claude Code (MCP) once. It writes a project-scoped .mcp.json, keeps any other MCP servers you have configured, and points Claude Code at a version-stable launcher, so the connection survives extension updates. Restart Claude Code and it can call:
| Tool |
What Claude does with it |
get_context |
Reads the compiled context. If nothing changed since the last call, the server answers with one line instead of the full prompt. force:true overrides; max_tokens trims to a budget. |
get_changes_since_checkpoint |
Catches up after a break: commits and files since the last snapshot, plus a warning when you're on a different branch than the snapshot. |
start_task / complete_task |
Begins or finishes a task from inside Claude Code. |
add_constraint, add_note, add_failed_attempt, add_non_goal |
Writes context back mid-session. The server spots near-duplicates and skips them. |
add_important_file |
Marks a file as central to the task. |
remove_item |
Prunes context that no longer applies, so it stops costing tokens in future prompts. |
save_checkpoint |
Snapshots progress with branch and commit. |
set_task_status |
Sets active, paused, or done. |
get_state |
Reads the raw state as JSON. |
Contextpoint is not on npm, so an npx contextpoint entry in .mcp.json fails. Use the one-click command; it wires the correct path. If Claude Code launches the server from a subdirectory, the server walks up and finds your project state on its own.
Token accounting
Each compile shows an estimated token count. The sidebar keeps a per-project ledger: tokens sent, and tokens you skipped re-typing because the context was already saved. On the API path, real usage numbers from Anthropic calibrate the estimator.
Lockfiles and build output (package-lock.json, dist/, minified bundles) collapse into a single line in the changed-files list. This keeps a model from spending 20k tokens reading a lockfile it never needed.
Want a hard ceiling? Set contextpoint.maxPromptTokens. Contextpoint trims notes and file lists first, marks what it cut, and leaves your task, constraints, and failed attempts intact.
CLAUDE.md, maintained without clobbering yours
Contextpoint maintains a managed block, fenced by <!-- contextpoint:begin --> markers, inside your project's CLAUDE.md. Claude Code loads that file at the start of each session, so your context arrives before you type. If you hand-wrote a CLAUDE.md, Contextpoint appends its block and updates it in place, leaving the rest of the file untouched. Writes go through a temp file and rename, so Claude can't read a half-written file. Contextpoint caps the lists, so the file stays small.
A progress journal with no typing
Each git commit records a snapshot, with the commit message as the summary. Turn it off with contextpoint.autoSnapshotOnCommit. Paired with get_changes_since_checkpoint, your next session starts from a recorded trail of commits and snapshots.
Contextpoint catches branch changes
Switch branches and Contextpoint warns you that your saved context describes the old one, then offers a snapshot. This works in plain clones, git worktrees, and submodules.
Privacy
Contextpoint runs entirely on your machine. It reads your repo locally and compiles a prompt you can see before it goes anywhere. It needs no account, no backend, and no telemetry. If you use an API key, VS Code's secret storage holds it.
Install
Search Contextpoint in the VS Code Marketplace, or install the .vsix:
code --install-extension contextpoint-1.1.0.vsix
Commands
From the panel or Ctrl+Shift+P:
| Command |
|
Contextpoint: Send to Claude |
Ctrl+Alt+S / Cmd+Alt+S |
Contextpoint: Compile Prompt |
|
Contextpoint: Start New Task |
|
Contextpoint: Rename Task |
|
Contextpoint: Add Constraint |
|
Contextpoint: Add Note |
|
Contextpoint: Add Failed Attempt |
|
Contextpoint: Save Snapshot |
|
Contextpoint: Connect Claude Code (MCP) |
|
Contextpoint: Change AI Provider |
|
Contextpoint: Set Anthropic API Key |
|
Contextpoint: Reset AI Settings |
|
Contextpoint: How It Works |
|
Where your data lives
State sits in .contextpoint/state.json at your project root. Add .contextpoint/ to .gitignore; it's per-machine state.
CLAUDE.md lands in the project root too. Commit that one if you want your team to share the context.
Development
npm install
npm test # 305 assertions across 12 suites
npm run build
License
MIT
Built by Maksym Gavrylenko at Valten Studio
