Skip to main content
Glama

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

capture

Durable idea. Use when work produces something worth preserving beyond the task.

checkpoint

Lightweight working-memory trace. Use mid-task for observations, decisions, next steps.

promote

Promote a checkpoint to a durable idea, preserving its id, links, and provenance.

dump

Text-blob summary of the scoped corpus under a token budget.

search

FTS5 + bm25 ranked search with snippets. Auto-tokenizes by default.

list

Filter ideas by scope, actor, tags, date range.

get

Full detail for one idea, with notes and outbound links.

related

Nearest neighbors by tag overlap → shared originator → recency.

annotate

Append a free-text note to an idea without mutating it.

archive

Hide an idea; write a typed archive note with reason.

link

Connect two ideas (related, supersedes, evolved_from, duplicate, part_of, answers). part_of goes from the part to the whole; answers from the answer to the question.

recognize

Inspect the actor table.

register

Add an actor (e.g. human:you) so it can be an originator. Idempotent.

ping

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:

  • capture writes a durable idea that should survive the task.

  • checkpoint writes 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 a kind='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 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

Install

uvx ideahub_mcp        # try it
uv tool install ideahub_mcp   # keep it around

Claude 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

IDEAHUB_MCP_HOME

~/.ideahub_mcp/

Data directory (SQLite store, logs, backups).

IDEAHUB_ACTOR

—

Default actor id (human:you or agent:name).

IDEAHUB_SCOPE

—

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 pyright

License

MIT.

Available Tools

14 tools
annotateA

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

archiveA
Idempotent

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

captureA
Idempotent

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

dumpA
Read-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

getA
Read-onlyIdempotent

Get a single idea by id with its notes and outbound links.

Inputs: id (required). Returns: object

listA
Read-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

pingA
Read-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

promoteA
Destructive

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

recognizeA
Read-onlyIdempotent

Inspect the actor table. Pass id for detail on one actor; omit to list all.

Inputs: id. Returns: object

registerA
Idempotent

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

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 14 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count5/5

    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.

    Completeness4/5

    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

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An 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
    • A
      license
      Not graded
      quality
      D
      maintenance
      An 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 npm
      736
      MIT