ideahub_mcp
An agent-first memory server for capturing, organizing, and recalling ideas and working traces in a scoped, searchable SQLite store.
Write durable ideas with
capture— dedupes by actor/content within 5s and by content hash across actors, merging tags and loggingdup_attemptnotes.Leave lightweight traces with
checkpoint— tagged bykind_label(observation, decision, assumption, question, next_step) and hidden from search/list/dump unless opted in.Promote traces to ideas with
promote, preserving id, links, annotations, andtask_refgroupings (one-way).Retrieve via
search(FTS5 + bm25, auto/raw query modes),list(scope/actor/tags/date filters),get(full detail with notes and links),dump(token-budgeted corpus blob for orientation), andrelated(tag overlap → originator → recency).Organize with
annotate(append typed notes),archive(hide with a reason), andlink(related, supersedes, evolved_from, duplicate, part_of, answers).Group work across all writes with an optional
task_ref, normalized to lowercase kebab-case.Get suggestions inline — writes return scored
annotate_candidatesandrelated_candidates(capped viacandidates, 0–10).Manage actors with
register(human:/agent: ids, idempotent) andrecognize(inspect the actor table).Check health with
ping(cheap, no side effects) or theideahub://statusresource; scope/actor resolve from args, env, or cwd.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ideahub_mcp capture an idea for a new MCP tool"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ideahub_mcp
An agent-first MCP server for capturing and recalling ideas — the agent's and their human's.
The primary user is a model. Tools are short, imperative, example-laden; errors carry a repair path; scope and actor resolve from context so the agent doesn't have to ask.
Tools
Tool | Purpose |
| Durable idea. Use when work produces something worth preserving beyond the task. |
| Lightweight working-memory trace. Use mid-task for observations, decisions, next steps. |
| Promote a checkpoint to a durable idea, preserving its id, links, and provenance. |
| Text-blob summary of the scoped corpus under a token budget. |
| FTS5 + bm25 ranked search with snippets. Auto-tokenizes by default. |
| Filter ideas by scope, actor, tags, date range. |
| Full detail for one idea, with notes and outbound links. |
| Nearest neighbors by tag overlap → shared originator → recency. |
| Append a free-text note to an idea without mutating it. |
| Hide an idea; write a typed |
| Connect two ideas ( |
| Inspect the actor table. |
| Add an actor (e.g. |
| Cheap no-side-effect health probe for connection/debugging. |
Related MCP server: MegaMemory
Writeback Loop
ideahub_mcp is designed to behave like working memory for an agent, not just searchable storage. Two write verbs close that loop:
capturewrites a durable idea that should survive the task.checkpointwrites a lightweight in-flight trace — observations, decisions, assumptions, open questions — without the semantic weight of a full idea.
When a checkpoint hardens into something load-bearing, promote flips its kind to idea while preserving the id, so existing links, annotations, and task_ref groupings carry forward unchanged. Promotion is one-way; an idea cannot be demoted.
All write-path verbs (capture, checkpoint, annotate, link) accept an optional task_ref — a free-form string that groups every write from the same task. It is normalized to lowercase kebab-case at the boundary, so "Writeback Phase 1", "writeback_phase_1", and "writeback-phase-1" collapse onto the same key.
capture and checkpoint return scored annotate_candidates and related_candidates in their response so the model sees where a fresh trace probably belongs (usually as an annotation on an existing idea) without having to search. The candidates parameter (default 5, max 10, 0 to skip) lets a caller cap or skip that envelope when fire-and-forget is the right move.
Checkpoints are default-excluded from search, list, and dump so cheap traces do not bleed into orientation surfaces — opt in with include_checkpoints=True.
Deduplication
capture runs two dedup paths before inserting:
Fast path — same actor, same content, same scope, within 5 seconds: silently returns the existing id. This catches accidental double-fires.
Content-hash path — same scope, same SHA-256 over normalized content (whitespace-collapsed, lowercased), any actor, any time, against live (non-archived)
kind='idea'rows: returns the existing id, merges incoming tags into the row, and appends akind='dup_attempt'note recording the second actor and tag delta.
Hash dedup makes re-derivation of the same idea observable in the row's note stream rather than silently creating duplicates.
Search
search defaults to query_mode='auto', which tokenizes the query and quotes each token so FTS5 operators (-, :, *, etc.) are treated as content. This is the right mode for searching kebab-case identifiers — task_refs, branch names, ULIDs.
For phrase queries, NEAR, or column-qualified syntax, pass query_mode='raw'. Raw mode validates the query and raises a loud error on syntax failure rather than the silent empty-result FTS5 returns by default.
Discovery And Health
ideahub_mcp is intentionally tool-first, not resource-first. A client may show a healthy connection even when list_resources() is sparse or empty.
To make discovery cheap and host-agnostic, the server exposes:
ping: a no-side-effect tool for "is the server connected and responsive?"ideahub://status: a status resource that reports package version, storage paths, and the current tool surface.
That design supports hosts that favor different MCP surfaces. Some clients reason primarily over tools. Others probe resources first. A healthy server should be easy to verify in either style.
For the full compatibility rubric, see docs/mcp-health.md.
Direction
Direction: IdeaHub as the foundation for Grok Native: one shared source of truth that many agents read and one writer appends to.
Sidecars: the transcript ingester, health check, and activity-log pipeline that run next to this package, outside it.
Install
uvx ideahub_mcp # try it
uv tool install ideahub_mcp # keep it aroundClaude Code
Add to ~/.claude/settings.json:
{
"mcpServers": {
"ideahub": {
"command": "uvx",
"args": ["ideahub_mcp"],
"env": {
"IDEAHUB_MCP_HOME": "/Users/you/.ideahub_mcp",
"IDEAHUB_ACTOR": "human:you"
}
}
}
}Configuration
Var | Default | Purpose |
|
| Data directory (SQLite store, logs, backups). |
| — | Default actor id ( |
| — | Fallback scope when cwd isn't a git repo. |
Actor resolution: explicit arg → IDEAHUB_ACTOR → MCP clientInfo.name → error.
The actor name is a label set by the caller (the actor argument, IDEAHUB_ACTOR, or the client's name). It is not a login check or authentication.
Scope resolution: explicit arg → IDEAHUB_SCOPE → repo:<git-toplevel> → global.
Storage
One SQLite file with WAL, FTS5, and hand-rolled migrations. No ORM. Daily snapshots to $IDEAHUB_MCP_HOME/backups/ with 14-day retention.
Develop
uv sync --dev
uv run pytest
uv run ruff check .
uv run pyrightLicense
MIT.
Available Tools
14 toolsannotateA
Append a note to an existing idea when current work confirms, sharpens, corrects, or extends it. Use when: the current task materially updates an existing idea; you want to attach new evidence or a correction; you do not want to create a separate idea. Optional kind labels the note semantically (confirmation, counterexample, observation, follow-up, question, correction). Optional task_ref groups all writes from the same task and is normalized to lowercase kebab-case at the boundary.
Inputs: id (required), content (required), kind, actor, +2 more. Returns: object
archiveAIdempotent
Archive an idea (sets archived_at, writes kind='archive' note with reason). Idempotent. Archived ideas are excluded by default from list/search/dump.
Inputs: id (required), reason (required), actor, originator. Returns: object
captureAIdempotent
Capture a new durable idea. Use when: you reach a stable synthesis; you discover a reusable pattern; you want a standalone idea that should survive task boundaries; a checkpoint has hardened into a first-class concept. If you only need a lightweight in-progress trace, use checkpoint instead. content is required. scope and actor default from cwd and environment. Optional task_ref groups all writes from the same task; it is normalized to lowercase kebab-case at the boundary, so 'Writeback Phase 1', 'writeback_phase_1', and 'writeback-phase-1' collapse onto the same key. Returns annotate_candidates and related_candidates so the next memory move is obvious. candidates (default 5, max 10, 0 to skip) controls how many annotate/related suggestions are returned — set to 0 for a fire-and-forget trace where you don't intend to act on suggestions, or raise to 10 when actively triaging. Deduplication: same actor + same content within 5 seconds is silently treated as the same write. Beyond the 5-second window, or across actors, content with the same SHA-256 hash (whitespace-collapsed, lowercased) in the same scope dedupes against the original idea — incoming tags are merged in and a dup_attempt note is appended for provenance.
Inputs: content (required), tags, actor, scope, +3 more. Returns: object
checkpointA
Write a lightweight working-memory trace during a task. Use when: you form a non-trivial synthesis mid-task; you make a decision the session will depend on; you want a durable breadcrumb without promoting it to a full idea yet; you want to leave a visible trace of what changed in your understanding during the task. Do not use for final, standalone ideas that should survive the task — use capture for those. Optional task_ref groups all writes from the same task; it is normalized to lowercase kebab-case at the boundary, so casing and whitespace variants collapse onto the same key. Optional kind_label is a semantic hint (observation | decision | assumption | question | next_step). Returns scored annotate_candidates (existing ideas this trace may update) and related_candidates so the next memory move is obvious. candidates (default 5, max 10, 0 to skip) controls how many annotate/related suggestions are returned — set to 0 for a fire-and-forget trace where you don't intend to act on suggestions, or raise to 10 when actively triaging.
Inputs: content (required), tags, actor, scope, +4 more. Returns: object
dumpARead-onlyIdempotent
Dump the scoped corpus as a single text blob under a token budget. Use for orientation — 'what does this repo/user think about?'. Newest ideas first, latest note inlined by default, archived excluded by default. By default excludes kind='checkpoint' rows; pass include_checkpoints=True to include them.
Inputs: actor, scope, since, originator, +4 more. Returns: object
getARead-onlyIdempotent
Get a single idea by id with its notes and outbound links.
Inputs: id (required). Returns: object
linkAIdempotent
Connect two ideas when current work reveals they are structurally related, evolved, duplicated, superseding, part of a whole, or answering a question. kind ∈ {related, supersedes, evolved_from, duplicate, part_of, answers}. part_of goes from the part to the whole; answers goes from the answer to the question. related is canonicalized (smaller id becomes source). Self-links rejected. Optional task_ref groups all writes from the same task and is normalized to lowercase kebab-case at the boundary.
Inputs: kind (required), source_id (required), target_id (required), task_ref. Returns: object
listARead-onlyIdempotent
List ideas with filters (scope, actor, originator, tags_any, tags_all, since, until). Returns id, scope, actor, preview (120 chars), and created_at. Archived excluded by default. By default excludes kind='checkpoint' rows; pass include_checkpoints=True to include them.
Inputs: actor, limit, scope, since, +6 more. Returns: object
pingARead-onlyIdempotent
Cheap health probe. Returns server name, package version, and store path. Use to confirm the ideahub_mcp server is connected and responsive.
Inputs: no named parameters. Returns: object
promoteADestructive
Promote a checkpoint to a durable idea. Use when: a working-memory trace turns out to be load-bearing — the synthesis has hardened, the decision is stable, the observation is reusable. The id is preserved, so existing links, annotations, and task_ref groupings carry forward unchanged. A kind='promotion' note records the original kind_label for provenance. Promotion is one-way: an idea cannot be demoted back to a checkpoint.
Inputs: id (required), actor, originator. Returns: object
recognizeARead-onlyIdempotent
Inspect the actor table. Pass id for detail on one actor; omit to list all.
Inputs: id. Returns: object
registerAIdempotent
Register an actor without writing an idea. Use before passing a person as originator (e.g. id='human:michael') when they have never written themselves. id must start with 'human:' or 'agent:'. Idempotent: an existing actor is returned unchanged with created=false. display_name only applies on first registration.
Inputs: id (required), display_name. Returns: object
searchARead-onlyIdempotent
Full-text search ideas with FTS5 + bm25 ranking. Returns snippet, score, and id. Scope-optional; archived excluded by default. By default excludes kind='checkpoint' rows; pass include_checkpoints=True to include them. query_mode (default 'auto') controls how query is interpreted: 'auto' tokenizes and quotes the query so hyphens, colons, asterisks and other FTS5 operators are treated as content (use this when searching for kebab-case identifiers like task_refs or branch names); 'raw' passes the query through unchanged for FTS5 phrase, NEAR, or column-qualified syntax and raises a loud error on syntax failure.
Inputs: query (required), limit, scope, since, +3 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
The core write paths (capture vs. checkpoint vs. annotate) are explicitly differentiated by durability and target, and read paths (get, related, search, list, dump) differ by input mode and output shape. Remaining friction: link vs. related (write vs. read of the same relation), and register vs. recognize (actor write vs. read) aren't signalled by their names, so an agent must read descriptions to avoid misselection.
Nearly all tools are single lowercase words in a consistent style (capture, checkpoint, annotate, promote, archive, link, search, list, dump). Two outliers break the verb pattern: 'related' is an adjective for a lookup, and 'recognize' is a vague verb that actually means 'inspect/list actors' — ideally list_actor/get_actor.
14 tools for a memory-store domain with two resource types (ideas/checkpoints and actors) is well-scoped. Each tool maps to a distinct lifecycle operation (capture, checkpoint, promote, annotate, archive, link, plus query and health/actor utilities), with no obvious filler.
Coverage is strong: full idea lifecycle from checkpoint to promotion to archival, note appending, typed linking, multiple retrieval modes, and actor registration/lookup. Gaps are minor but real: no way to edit an idea's content or tags in place, no unarchive/undo for archiving, and no delete — agents must route corrections through annotate.
Maintenance
Related MCP Connectors
An MCP memory server. One memory your agents share — across models, devices and apps.
MCP server for building and testing AI agents with multi-model experimentation and insights.
One MCP server for the services your AI needs: memory, files, Microsoft 365, kanban and more.
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that enables users to transform AI conversations into a structured, searchable knowledge base by saving ideas, code snippets, bookmarks, and reminders. It supports persistent storage through Supabase or PostgreSQL and includes webhook integrations for automating workflows with external tools.MIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that lets coding agents build and query a persistent knowledge graph of concepts, architecture, and decisions, enabling them to remember across sessions.123 npm736MIT
- AlicenseAqualityCmaintenanceMCP server for long-term agent memory, providing persistent memory, searchable knowledge, and evolving identity for AI agents.53Apache 2.0
- AlicenseNot gradedqualityCmaintenanceA local-first, team-ready MCP server providing durable memory for LLM-based coding workflows with multiple storage backends and fast search.4MIT