# Second Brain (npm · mind-mri-second-brain)

Shared Graph-RAG memory for AI agents: markdown vault, wikilink recall, tasks, messaging.

- Trust score: 70/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `mind-mri-second-brain`: 70/100 (this document), [markdown](https://verifymcp.io/servers/ara-5-second-brain/mind-mri-second-brain.md), [page](https://verifymcp.io/servers/ara-5-second-brain/mind-mri-second-brain)

## Channel facts

- Registry: `npm`
- Package: `mind-mri-second-brain`
- Version: `1.7.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 67/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 2839 tokens (~236/item across 12 items; 12 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 13 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Second Brain MCP server?

Second Brain runs locally as an npm package, launched with npx -y mind-mri-second-brain. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add ara-5-second-brain -- npx -y mind-mri-second-brain
```

### Cursor

```json
{
  "mcpServers": {
    "ara-5-second-brain": {
      "command": "npx",
      "args": [
        "-y",
        "mind-mri-second-brain"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ara-5-second-brain": {
      "command": "npx",
      "args": [
        "-y",
        "mind-mri-second-brain"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add ara-5-second-brain -- npx -y mind-mri-second-brain
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ara-5-second-brain": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "mind-mri-second-brain"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ara-5-second-brain --command npx --arg -y --arg mind-mri-second-brain
```

### Hermes

```yaml
mcp_servers:
  ara-5-second-brain:
    command: "npx"
    args: ["-y", "mind-mri-second-brain"]
```

### Netclaw

```json
{
  "McpServers": {
    "ara-5-second-brain": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "mind-mri-second-brain"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add ara-5-second-brain -t stdio -c npx -a -y mind-mri-second-brain
```

### Other

```json
{
  "mcpServers": {
    "ara-5-second-brain": {
      "command": "npx",
      "args": [
        "-y",
        "mind-mri-second-brain"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 70, +26)

- [security improvement] Malware scan: unverified → pass
- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → pass

### 2026-11-03 (score 44)

First indexed and scored.

## MCP tools (12)

### `brain_recall` (~262 tokens)

Recall context

Recall relevant memory for a query from the shared Second Brain vault. It finds the best-matching notes (keyword and recency, plus semantic similarity when embeddings are configured), then follows their [[wikilinks]] outward for the requested number of hops, and packs the result into a token budget. Call this before answering anything that earlier work may already cover: past decisions, constraints, research, project background. Read-only. Returns { nodeCount, tokenEstimate, systemPrompt, nodes }: systemPrompt is a ready-to-use context block in which the notes are marked as reference data, not instructions. Use brain_search instead when you only need a ranked list of matching notes.

Input parameters:

- `hops` (integer): How many [[wikilink]] steps to follow from the matching notes. 0 = matches only; 1 (default) adds directly linked notes; values above 3 are capped at 3.
- `maxTokens` (integer): Token budget for the returned context. Notes that do not fit are left out. Values above 8000 are capped at 8000.
- `query` (string, required): What you need to know, in plain words, e.g. "why did we choose SQLite for the cache". Specific queries recall better than broad ones.

### `brain_remember` (~474 tokens)

Save a memory

Write a new memory/research note into the shared Second Brain vault so future sessions, in this or any other project, can recall it later. Only for a genuine, reusable learning: a fact, pattern, constraint or decision that would change future behavior or save someone from re-deriving it. Not for routine task completions, raw output or status updates (the task queue records those). Test: would a future session be worse off without this note? If not, skip it. Prefer updating an existing relevant note over creating a near-duplicate one (use brain_search first, then brain_node_update). Creates a new note and never overwrites an existing one (a title clash gets a numbered filename). Returns { success, id, title, type, version }; keep the id to refer to the note later.

Input parameters:

- `agent` (string): Name of the calling project or agent; the note is stored under agents/<agent>/, which keeps each project's notes together. Same filename rules as title, so no slashes. If omitted, the note is stored…
- `content` (string, required): Markdown body. Link related notes with [[Note Title]] so recall can follow the graph. Never include secrets, credentials or personal data: notes are plain files and may be synced to git.
- `importance` (integer): How long the note stays prominent in recall, 1 to 10. Recency only re-ranks, so old notes are never hidden, but 8-10 fades over months, 5-7 (default) over weeks, and 1-4 within days.
- `tags` (array): Short lowercase labels, e.g. ["database", "cache"]. Used by search and filtering.
- `title` (string, required): Specific, searchable title that becomes the note's filename, e.g. "Decision - Use SQLite for the cache". Must not contain : / \ ? * " < > | , start or end with a space, or end with a period; invalid…
- `type` (string): Kind of note: decision (a choice and its reason), insight (a non-obvious finding or fix), research (gathered findings), memory (general fact), note (anything else).

### `brain_search` (~167 tokens)

Search notes

Search the vault for notes matching a query: keyword search over titles, tags and content, combined with semantic similarity when embeddings are configured, then lightly re-ranked by recency. Use it to check whether a note already exists (before brain_remember) or to find a note id for brain_node_get / brain_node_update. Read-only. Returns { query, results: [{ id, title, type, tags, agent, score, preview }] }, best first; an empty list means nothing matched. Use brain_recall instead when you want assembled context to answer a question.

Input parameters:

- `limit` (integer): Maximum number of results to return (default 10).
- `query` (string, required): Words to look for, e.g. "sqlite cache decision". Matches titles, tags and note text.

### `brain_node_get` (~161 tokens)

Get a note

Fetch one note by id: its full markdown content, metadata (type, tags, agent, importance, version, dates), the notes it links to (outLinks) and the notes that link to it (inLinks). Read-only. Use it to read a note in full before replacing its text with brain_node_update, or to follow a link found in recalled context. The whole note is returned, so a very large note is a large response. Returns an error saying "not found" for an unknown id.

Input parameters:

- `id` (string, required): Note id exactly as returned by brain_search, brain_recall or brain_remember: the path inside the vault without ".md", e.g. "agents/atlas/Decision - Use SQLite for the cache".

### `brain_tasks_submit` (~265 tokens)

Submit a task

Add a task to the shared, markdown-backed task queue so another agent (or a later session) can pick it up. A task with dependencies starts as "blocked" and moves to "pending" automatically when all of them complete; otherwise it starts as "pending". This only records the task: it is a coordination list, not a runner, so something else must watch for pending tasks (brain_tasks_list) and report back (brain_tasks_update). Returns { taskId, nodeId, status } where status is "pending" or "blocked". Write the prompt so it is self-contained: goal, relevant files, constraints and what "done" means.

Input parameters:

- `agents` (array): Names of the agents this task is for, e.g. ["reviewer"]. Defaults to ["coordinator"].
- `dependencies` (array): Node ids (nodeId values returned by earlier brain_tasks_submit calls) that must complete first.
- `priority` (integer): Urgency, 1 (lowest) to 10 (highest).
- `prompt` (string, required): Complete, self-contained description of the work to be done.
- `title` (string): Short title. If omitted, one is made from the first 60 characters of the prompt, prefixed "Task - ".

### `brain_tasks_list` (~153 tokens)

List tasks

List the tasks in the shared queue, optionally only those in one state. Use status "pending" to find work waiting for you, "blocked" to see what is waiting on dependencies. Read-only. Returns every matching task with no pagination and no guaranteed order: { count, tasks: [{ id, title, tags, content, createdAt }] }, where content holds the prompt and any result written so far, and id is what brain_tasks_update takes. An empty list means no tasks match. Add tasks with brain_tasks_submit; change the state of a task, or record its outcome, with brain_tasks_update.

Input parameters:

- `status` (string): Only return tasks in this state. Omit to list all tasks.

### `brain_tasks_update` (~286 tokens)

Update a task

Change the status of a task and, optionally, record its outcome. Use it to claim a task ("running"), finish it ("completed" or "failed") or withdraw it ("cancelled"). Completing a task releases the tasks that were blocked on it: once all the dependencies of a blocked task are completed it becomes "pending"; if a dependency failed or was cancelled, the dependent task is marked "failed" too. The result text is written to the Final Result section of the task, replacing any earlier result; the prompt and sub-results are kept. Setting the same status again is harmless. Returns { success, id, status, releasedDependents } where releasedDependents counts the blocked tasks that moved. Errors: "Task not found" for an id that is not a task note. Find ids with brain_tasks_list; create tasks with brain_tasks_submit.

Input parameters:

- `id` (string, required): Task note id: the id field from brain_tasks_list, or the nodeId returned by brain_tasks_submit, e.g. "tasks/Task - Review the migration".
- `result` (string): What was done or why it failed, in markdown. Stored in the Final Result section of the task. Omit to change only the status.
- `status` (string, required): The new state. Use "running" when you start, "completed" or "failed" when you finish.

### `brain_messages_send` (~242 tokens)

Send a message

Send a message to another agent's inbox. The recipient reads it with brain_messages_get and clears it with brain_messages_mark_read. Use it for short hand-off context that does not belong in a task or a permanent note. Nothing is delivered in real time: the recipient has to check its inbox. Any valid name works as a recipient (the inbox is created on first use and unknown names are not rejected), so check the spelling; an invalid name such as one containing a slash is rejected with the reason. Every call creates a new message, so sending the same text twice delivers it twice. Returns { success, id } where id is the message note id.

Input parameters:

- `content` (string, required): The message body (markdown).
- `fromAgent` (string): Sender name so the recipient knows who wrote. Recorded as "unknown" if omitted.
- `subject` (string): Short subject line. Defaults to "Message from <fromAgent>".
- `toAgent` (string, required): Recipient agent name, e.g. "reviewer". Inbox names are matched case-insensitively with spaces treated as hyphens. No slashes or other filename-invalid characters.

### `brain_messages_get` (~158 tokens)

Read an inbox

Read the messages addressed to an agent: unread ones by default, or the full history with unread set to false. Read-only: it does not mark anything as read; call brain_messages_mark_read with each message id once handled. All matching messages are returned at once, with no pagination and no guaranteed order. Returns { agent, count, messages: [{ id, title, type, tags, agent, content }] }. count 0 means the inbox is empty.

Input parameters:

- `agent` (string, required): Whose inbox to read, using the name senders used as toAgent (case-insensitive, spaces treated as hyphens).
- `unread` (boolean): true (default) returns only unread messages; false returns every message including read ones.

### `brain_messages_mark_read` (~129 tokens)

Mark message read

Mark one message as read so it no longer appears in the default (unread) inbox from brain_messages_get. Call it after you have handled a message. Safe to repeat: marking an already-read message again changes nothing. The message stays in the vault and in the full history. Returns { success: true, id }, or an error "Message not found" if the id is unknown or is not a message note.

Input parameters:

- `id` (string, required): Message note id exactly as returned in the id field by brain_messages_get, e.g. "messages/qa-agent/[MSG] Question".

### `brain_node_update` (~366 tokens)

Update a note

Update an existing note in place instead of creating a near-duplicate. mode "append" (default) adds your text to the end and keeps everything already there; mode "replace" overwrites the whole body, so only use it when you have the full corrected text (read it with brain_node_get first). Tags and importance, if given, replace the existing values. Safe against concurrent edits: it checks the note version and retries once if another writer changed it in between. Returns { success: true, id, mode } (mode is omitted when only tags or importance changed). Errors: "not found" for an unknown id, "Nothing to update" if you pass only an id, and a conflict error if two other writers keep racing; in that case read the note again and retry. No credentials are needed from you: if the server was started with BRAIN_KEY, this MCP server sends it automatically.

Input parameters:

- `content` (string): In append mode, the text to add after the existing body. In replace mode, the complete new body (it overwrites everything, so include whatever you want to keep). Omit to change only tags or importanc…
- `id` (string, required): Note id exactly as returned by brain_search, brain_recall or brain_remember, e.g. "agents/my-project/Decision - Use SQLite".
- `importance` (integer): New importance, 1 to 10 (see brain_remember).
- `mode` (string): "append" (default) keeps the existing text and adds yours at the end. "replace" overwrites the whole body: read the note first with brain_node_get.
- `tags` (array): The note's new complete tag list; it replaces the old tags rather than adding to them.

### `brain_health` (~90 tokens)

Server health

Check that the Second Brain server is running and get basic vault statistics: status, version, and how many notes (nodeCount) and links (edgeCount) the vault holds. Read-only and cheap. Call it first if another tool fails with a connection error, or to confirm the memory is connected. The server is started automatically on the first tool call, so a healthy answer here means everything is ready.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ara-5-second-brain/mind-mri-second-brain#diagnostics

## Score history

- 2026-11-05: 70
- 2026-11-04: 70
- 2026-11-03: 44

## Common questions

### What is the Second Brain MCP server?

Second Brain is an MCP server listed in the public MCP registry as io.github.ara-5/second-brain. Shared Graph-RAG memory for AI agents: markdown vault, wikilink recall, tasks, messaging. This page covers its npm package (mind-mri-second-brain).

### Is the Second Brain MCP server safe to use?

Second Brain scores 70 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Second Brain MCP server expose?

Second Brain exposes 12 tools: brain_recall, brain_remember, brain_search, brain_node_get, brain_tasks_submit, and 7 more. Their descriptions and schemas cost roughly 2,753 tokens of context every time the server is loaded.

### Is the Second Brain MCP server still maintained?

Second Brain is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Second Brain MCP server under?

Second Brain declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/mind-mri-second-brain
- Socket report: https://socket.dev/npm/package/mind-mri-second-brain
- Repository: https://github.com/ara-5/mind-mri-agent-second-brain
- Changelog RSS feed: https://verifymcp.io/servers/ara-5-second-brain/mind-mri-second-brain.xml
- Changelog JSON feed: https://verifymcp.io/servers/ara-5-second-brain/mind-mri-second-brain.json
- HTML version of this page: https://verifymcp.io/servers/ara-5-second-brain/mind-mri-second-brain