Mneme HQ + JetBrains IDEs

The corpus-first pattern

JetBrains AI Assistant is built into IntelliJ IDEA, PyCharm, WebStorm, GoLand, and the rest of the JetBrains family. It generates code, refactors, and answers questions inside the editor. Like every other AI coding surface, it depends on context: the more accurate the project-specific signal it receives, the closer its output lands to what the team actually wants.

Mneme HQ's design is corpus-first. The architectural decisions for a project live in a single file — .mneme/project_memory.json — with typed, scoped, versioned records. That same file feeds every surface in the AI coding stack:

• JetBrains AI Assistant reads the corpus as shared context. The model sees the team's real constraints when generating code.
• Claude Code hooks intercept edits before they reach disk, blocking violations.
• GitHub Actions runs mneme check against every PR diff — the deterministic backstop, regardless of which IDE or model produced the change.

One source of truth, multiple surfaces. The decision is written once, enforced everywhere.

What you can do today

Install

1. Install the package

   pip install mneme

2. Initialise project memory

   mkdir .mneme
   # Create .mneme/project_memory.json — see examples/project_memory.json for the schema.

3. Attach the corpus to JetBrains AI Assistant

   Open your JetBrains IDE settings, navigate to Tools → AI Assistant → Project Context, and pin .mneme/project_memory.json as a context file. AI Assistant now reads the corpus on every session.

4. Add the CI enforcement gate

   Add mneme check --mode strict as a step in your GitHub Actions workflow (or your CI of choice). The corpus is now enforced at the merge boundary regardless of which IDE produced the diff.

   - name: mneme check
     run: |
       pip install mneme
       mneme check --mode strict

Why corpus-first matters here

The JetBrains ecosystem is broad. A backend team uses IntelliJ; a data team uses PyCharm; a frontend team uses WebStorm. Without a tool-agnostic governance layer, every IDE becomes its own configuration surface — per-IDE rules files, per-IDE prompts, per-IDE drift.

The corpus-first pattern removes that surface area. .mneme/project_memory.json sits at the root of the repo, in version control, reviewed in PRs like any other file. Every JetBrains IDE on every developer's machine reads the same file. When a decision changes, it changes in one place and propagates everywhere.

This is the same design that makes the Mneme HQ Claude Code hook and the GitHub Actions enforcement gate consistent: one corpus, multiple enforcement points, no per-tool duplication. JetBrains slots into that pattern the same way every other tool does.

The two enforcement layers

JetBrains AI Assistant context injection is the fast path: the model sees the constraints while you are typing, and most of the time it generates code that respects them. This shortens the inner loop — you get on-spec suggestions without round-tripping through review.

But context injection is advisory. Models attend imperfectly, particularly under long context windows or noisy prompts. That is why mneme check in CI is non-negotiable: it is the deterministic backstop. Every PR diff is checked against the corpus before merge. A violation fails the build — whether it came from JetBrains AI Assistant, Claude Code, Cursor, Copilot, or a hand-typed line of code.

The two layers are complementary. The IDE layer makes generation faster; the CI layer makes correctness guaranteed.

What's on the roadmap

• Native JetBrains plugin. Direct in-editor enforcement (analogous to the Claude Code PreToolUse hook) for IntelliJ Platform IDEs. Recording decisions, querying the corpus, and surfacing violations without leaving the IDE.
• MCP server. Mneme is on the roadmap to expose its decision store as an MCP server. JetBrains AI Assistant's MCP-aware sessions will then query the corpus directly rather than through pinned context files.
• Per-language scope helpers. Smarter scope matching for JetBrains IDEs that specialise in one language (PyCharm, GoLand, RubyMine) where file naming conventions are tighter than in polyglot IntelliJ projects.

For the broader argument behind a single corpus across heterogeneous AI editors, see architectural governance across heterogeneous AI coding agents.

FAQ