Log inSubmit server
In Memoria logo

In Memoria

by pi22by7

Learns codebase patterns and architecture locally, then gives MCP-compatible coding assistants persistent context, search, and file-routing guidance.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install In Memoria

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "pi22by7-in-memoria": {
      "command": "npx",
      "args": [
        "-y",
        "in-memoria"
      ]
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Install not yet sandbox-tested— we haven't run this command through our automated sandbox yet. Not a red flag; we're working through the catalog.

Overview

The pi22by7/In-Memoria MCP server gives coding assistants persistent, queryable knowledge about a project’s code, architecture, patterns, and decisions. It uses a TypeScript MCP layer with Rust-based parsing and analysis, storing structured data in SQLite and vector data in local SurrealDB. Agents can analyze and search files, learn codebase intelligence, retrieve project blueprints, predict implementation approaches, and record insights. Reach for it when repeated coding sessions need consistent project context without re-explaining conventions.

Use cases

  • Analyze a project’s architecture and entry points
  • Search code by meaning, text, or pattern
  • Route feature requests to relevant files
  • Retrieve learned coding conventions
  • Record architectural decisions across sessions

Key features

  • Persistent local codebase intelligence
  • Semantic, text, and pattern search
  • Project blueprints with learning status
  • Pattern recommendations and file routing
  • Automatic learning with staleness detection
  • Health, metrics, and performance tools

Tools13

What In Memoria lets your agent do. Expand a tool for its parameters.

Self-reported~230 tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked Today

Recent health check succeeded.

21/22 checks healthy over the last 79d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 12d ago via OSV.dev · in-memoria (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars175Stargazers on the source repository.
npm downloads343Package downloads in the last 30 days.
Last commit10mo agoMost recent push to the default branch.
Tools exposed13Callable tools this server registers over MCP.
Directory activity1 viewsConfig copies, upvotes, and views on AllMCPs.

How In Memoria works

What pi22by7/In-Memoria does

The pi22by7/In-Memoria MCP server maintains project intelligence across coding sessions. It analyzes a codebase to identify concepts, structural patterns, complexity, technology choices, entry points, and architectural relationships. The resulting information can be queried by an MCP-compatible AI assistant instead of being rebuilt from scratch during every session.

Its intended use is development work where an assistant needs to follow an existing project’s conventions. For example, an agent can search for related code, inspect a project blueprint, receive file-routing guidance for a feature, review learned pattern recommendations, or retrieve recorded architectural decisions. The server also exposes developer-profile information describing coding style and work context.

How it works

The implementation combines a TypeScript MCP server with a Rust processing core connected through napi-rs. Rust components handle Tree-sitter-based parsing, blueprint analysis, pattern learning, and semantic processing.

Storage is local-first. SQLite holds structured patterns and metadata, while SurrealDB with a SurrealKV backend stores persistent vector embeddings. Local transformers.js models generate embeddings. File watching supports incremental updates, and the server includes staleness detection so automatic learning can run when the stored intelligence needs refreshing.

Search supports semantic, text, and pattern modes. Semantic search finds related code by meaning, while text and pattern modes address keyword or structural queries.

Setup and configuration

Install the package globally with npm or invoke it through npx:

  • npm install -g in-memoria
  • npx in-memoria --help

Learn a project explicitly with npx in-memoria learn ./my-project, then start the MCP process with npx in-memoria server. The auto_learn_if_needed tool can also trigger learning and includes quick setup functionality.

Claude Desktop can launch the server with the npx in-memoria server command and no listed environment variables. Claude Code can register the same command with claude mcp add in-memoria -- npx in-memoria server.

Tools and capabilities

The server exposes 13 tools in four groups:

  • Analysis: analyze_codebase handles files and directories; search_codebase provides semantic, text, and pattern search.
  • Intelligence: learning, blueprints, semantic insights, pattern recommendations, coding-approach prediction, developer profiles, and contributed insights.
  • Automation: auto_learn_if_needed checks whether learning is stale and can initiate setup or learning.
  • Monitoring: system health, intelligence metrics, and performance diagnostics.

The pi22by7/In-Memoria MCP server is a fit when an agent needs both code understanding and retained project-specific guidance, including implementation routing and architectural context.

Limitations and notes

The README identifies version 0.6.0 and an MIT license. It also describes the system as focused on codebase intelligence, so the material does not establish general-purpose memory for unrelated personal or non-code information.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about In Memoria

pi22by7/In-Memoria is an MCP server that connects AI coding assistants to persistent, local codebase intelligence. Its main tools analyze and search files, learn architecture and patterns, provide project blueprints, predict coding approaches, record decisions, and report system or intelligence status across sessions.

Install it with npm or run it with npx. Use `npm install -g in-memoria` for a global installation, or run `npx in-memoria --help` without installing it globally.

Add an MCP server entry that launches `npx` with the arguments `in-memoria` and `server` in Claude Desktop’s configuration file. The README gives the path `~/Library/Application Support/Claude/claude_desktop_config.json` for this configuration.

Cursor is named in the README as an AI coding assistant that can use the project’s persistent intelligence, but the supplied setup instructions do not include a Cursor-specific configuration example.

Run `npx in-memoria learn ./my-project` to analyze and learn from a project explicitly. Alternatively, start the server and allow `auto_learn_if_needed` to initiate learning when the stored information is missing or stale.

Related MCP servers

All in Knowledge & Memory All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewIn Memoria AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/pi22by7-in-memoria?style=directory)](https://allmcps.com/mcp/pi22by7-in-memoria)
HTML Embed
<a href="https://allmcps.com/mcp/pi22by7-in-memoria"><img src="https://allmcps.com/api/badge/pi22by7-in-memoria?style=directory" alt="In Memoria on AllMCPs" /></a>