Skip to main content
Glama

brain_folder

Idempotent

Manage where your personal AI memory is stored and which of your own PCs share it; get terminal commands for moving, sharing, importing, or exporting memories.

Instructions

Where the user's own personal memory lives, and which of their own PCs share it.

    Not for teams: project brains shared with teammates are brain_checkpoint.

    Anything that changes where the memory goes (`path`, `share_existing`, `export_to`,
    `import_from`) is not done from here: the tool returns `command`, and the user runs it in
    a terminal. A web page or file you read can then never move their memory somewhere else.
    Show the user the command, say what it does, and call this again without arguments after
    they ran it to confirm. Codes and passwords appear only in that terminal.

    Call it with `path` when the user names a folder for their memory, e.g. "use my Google
    Drive's Turnbook folder as my brain". A folder that OneDrive, Google Drive or Dropbox
    syncs makes the same memory available on every PC where the user chooses it too; nothing
    else is needed but the password: lines there are encrypted, and the first PC's terminal
    shows a password the user types on each other PC (the terminal asks for it). Without
    `path` it reports the current folder and the devices writing to it.
    `path="local"` keeps the brain in this PC's own Postgres instead, shared the instant it is
    written (no sync delay).

    Other PCs: when the user asks to let their other PCs use this brain ("다른 PC도 붙게 해줘"),
    call it with `path="share"`. It opens this PC's Postgres to the local network and Tailscale
    (Windows may ask the user to approve a firewall rule once) and returns a
    `connection_code` in the terminal. On the other PC the user runs
    `turnbook folder <that code>`; it contains the password, so say not to post it anywhere
    public.
    Codes: when the user pastes any Turnbook code ("gm1." for their own other PC, "gmt1."
    for a team invite), call this with `path=<the code>`; it does the right thing for either
    (a team invite is joined at once), so never ask the user which kind it is.

    `share_existing=true` sends what this PC remembers and the shared memory lacks (only that:
    it also repairs turns that missed a hub that was down). It uploads
    it to wherever the folder syncs. Set it only when the user has explicitly agreed to that.

    `reindex=true` brings the search index up to date (links new memories, embeds unembedded
    ones). Saving already does this; it is for a large imported backlog.

    Moving a whole memory as one file ("내 기억 파일로 내보내줘", "이 기억 파일 가져와"):
    `export_to=<file path>` writes every memory and conversation turn into that file;
    `import_from=<file path>` adds such a file's contents to this memory, skipping what is
    already here. Only when the user asks. Tell them the file holds their entire memory
    (secrets were masked when saved), so keep it private like a diary.
    With `project=<folder>`, `export_to` writes only the conversations held in that folder
    (or below it) and the memories drawn from them ("이 프로젝트 대화만 넘겨줘"): every word
    of those conversations goes in the file, so say so. Facts saved on request carry no
    folder and are not included.
    

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "brain_folder"
  }
}

Input Schema

NameRequiredDescriptionDefault
pathNo
projectNo
reindexNo
export_toNo
import_fromNo
share_existingNo

Output Schema

NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changedv0.9.39
    • addedInput schema / properties / project
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Project"
      +}
  2. Changed2 schema fields changedv0.9.0
    • addedInput schema / properties / export_to
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Export To"
      +}
    • addedInput schema / properties / import_from
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Import From"
      +}
  3. First observedv0.1.0

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond the annotations: it discloses that all mutating actions are delegated to a `command` returned in `connection_code` and run by the user in a terminal (a deliberate prompt-injection defense), that codes contain the password and must not be posted publicly, that Windows may raise a firewall prompt, and that an export file holds the entire memory with secrets already masked. These are the exact side-effect, auth, and data-sensitivity facts an agent needs and none of them are in the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Length is defensible for a six-mode tool with no schema descriptions, and it is front-loaded with identity and the not-for-teams exclusion before mode details. It sprawls somewhat: parameters interleave with user-facing instructions and Korean examples, and a short mode list at the top would let an agent route faster than scanning prose paragraphs.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, and the description still names the key returned artifacts (`command`, `connection_code`) and what to tell the user about them. Combined with the explicit follow-up instruction (re-call with no arguments after the user runs the command to confirm), nothing an agent needs to invoke this safely is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description carries the full burden, and it defines all six parameters: `path` (folder, `"local"`, `"share"`, or a code), `project` (limits export to a folder subtree), `export_to`, `import_from`, `share_existing` (uploads only what is missing, plus hub-gap repair), and `reindex`. It also gives the semantics of combining `project` with `export_to` and notes that request-saved facts carry no folder and are excluded.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening states this covers where the user's personal memory lives and which of their PCs share it, and it explicitly excludes team project brains by naming the sibling brain_checkpoint. It is a multi-mode tool (report / set path / LAN share / redeem code / export / import), so the single nominal opening line does not fully capture the surface — the agent must read several paragraphs to learn all six behaviors.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Every mode has an explicit trigger condition: call with `path` when the user names a folder, `path="local"` to keep memory on this PC, `path="share"` when the user asks other PCs to attach, `path=<code>` for any pasted Turnbook code (never ask which kind), `share_existing` only after explicit user agreement, export/import only when asked, reindex only for a large imported backlog. It even quotes the Korean user phrasings that should map to each mode, and states the no-argument behavior when `path` is omitted.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.