# lumayapartners/memini [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/lumayapartners/memini  
**GitHub Stars:** 0  
**npm Downloads (last month):** 427  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/lumayapartners-memini

## Description
Local-first project memory and guardrails for coding agents. Records failed attempts, fragile files, and decisions per repo; warns the agent before it repeats a recorded mistake. npx -y memini mcp

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "memini": {
    "command": "npx",
    "args": ["-y","memini"]
  }
}
```

## Documentation

## What lumayapartners/memini MCP server does

The lumayapartners/memini MCP server adds persistent project memory for AI coding workflows. It records lessons such as failed approaches, fragile files, architecture decisions, deployment rules, client preferences, and session summaries. Memories are stored locally in a repository’s `.memini/` directory, with a SQLite index and Markdown representations that can be reviewed in pull requests.

The main use is preventing known mistakes from recurring. A memory can be associated with one or more files and assigned `warn` or `block` severity. When a supported edit targets a file with a matching guardrail, memini can inject the recorded context before the edit. Warning-level memories allow the agent to continue after a prompt; block-level memories deny the edit until a human archives or otherwise resolves the memory.

## How it works

At session start, memini prepares a severity-prioritized digest of relevant memories within a token budget. MCP tools allow an agent to save new lessons, request project context, check a path before editing, and submit a session summary. Claude Code hooks can also prompt for durable lessons after sessions that changed files.

The project supports three memory scopes. Project memories live in the current repository, workspace memories apply to repositories below a parent directory, and user memories live under the user’s home directory. Broader-scope guardrails require human verification before they can fire, limiting the ability of an agent to create rules that affect unrelated repositories.

File references are linked to Git information and file hashes. When referenced code changes, the memory becomes stale and stops triggering guardrails until it is verified again. Local review commands can identify duplicates, contradictions, dormant guardrails, and memories that have not provided useful coverage.

## Setup and configuration

Run the lumayapartners/memini MCP server with `npx -y memini mcp`. In a repository, `npx -y memini init` creates the `.memini/` store and installs the available Claude Code hooks. The CLI can also generate MCP configuration for clients or write client-specific setup for Cursor. Separate setup commands install Copilot hooks and Git pre-commit protection.

The project does not require an account, hosted service, or telemetry connection. Memory remains on the local machine, and secrets are redacted from memory bodies before storage. A diagnostic command is available for checking setup and active scopes.

## Tools and capabilities

The MCP interface includes tools for:

- Recording failed attempts, fragile files, decisions, and session summaries.
- Recalling project context and checking a path before editing.
- Supplying session-start memory digests.
- Applying warning or blocking guardrails to referenced files.
- Detecting stale memories and reviewing them for verification.

The CLI additionally supports listing, showing, archiving, approving, promoting, and inspecting memory statistics. Git pre-commit protection can block commits touching block-severity files, regardless of which editor or agent made the changes.

## Limitations and notes

Memini is marked early-stage at version 0.1 in the provided material. Its edit interception covers supported edit tools rather than arbitrary shell commands. Warning-level guardrails are advisory, and block-level protection is not described as an absolute security boundary. Git pre-commit protection fails open and can be bypassed with `git commit --no-verify`.

Team-wide synchronized memory and a review workflow are listed as future roadmap items. Broad workspace and user rules also depend on human verification, so they are not immediately propagated from agent-created project memories.

_Full upstream README: https://allmcps.com/mcp/lumayapartners-memini/readme_