Brainllm MCP server

Read from the package source without running it. The installed server may list more.

• add_label

  Add a #label to a note (empty value = boolean flag). Adds a new attribute; does not dedupe.

• add_relation

  Add a ~relation with any name (the core connect() enforces the canonical vocabulary).

• addendum

  Search Master, LLM singletons (responsibilities + protocols only, not diary), and Knowledge for notes containing pending addendum blocks that need to be folded into the main content. These surfaces should be clean, merged, structured notes \u2014 not stacks of timestamped addendum markers. An addendum block on one of these notes is a temporary staging area: read it, fold its content into the relev

• assembly

  What the brain HOLDS \u2014 every note by title, grouped under the surface it lives in, with each surface's own purpose alongside it. The awareness read: "what do I already know here", answered in one call before deciding whether to look something up. Distinct from brain(), which is an inventory: brain() returns id, kind, status, parent, dates and relations for every note, and is what you want whe

• attach

  Attach a raw artifact (file, image, code blob, document) to a note \u2014 or read one back. Dual-mode by the content param: content provided \u2192 UPSERT by title: creates the attachment, or replaces the existing same-titled attachment's content (and mime) in place. Retry-safe \u2014 re-running the same call converges on the same state. content omitted \u2192 READ: returns the named attachment's

• backup

  Trigger a BrainLLM database backup. Writes a named snapshot to Trilium's backup directory. close() already triggers a backup automatically \u2014 use this for on-demand milestone snapshots (e.g. before a large restructure). The backup is a Trilium DB file, not an export.

• bootstrap

  Initialize the BrainLLM structure in Trilium (idempotent \u2014 safe to re-run; refreshes config, heals singletons a newer version introduced, and re-engraves container purposes if the structure already exists). Creates the five areas \u2014 Master (Biography/Goals/Preferences), LLM (Responsibilities/Protocols/Self-correction/Diary), Memory (Sessions/Threads), Knowledge (Master/Domains), Insights

• brain

  Surface the entire BrainLLM content tree \u2014 every typed note across all five content areas (Master, LLM, Memory, Knowledge, Insights), grouped by area and sub-container, with id/title/kind/status/dates. Use to audit what the brain contains or locate a specific note. Structural containers are excluded; only content notes appear. Insights returns { logs, claims }. Claims were missing entirely be

• claim

  Register a checkable assertion, and record whether it still holds. consistency() asks whether the brain agrees with ITSELF. Nothing asked whether a specific assertion is still true of the codebase, config or live surface it describes \u2014 so a claim that quietly stopped being true stayed authoritative until something downstream broke, and "is the brain stale" was answered by luck rather than by

• clone_note

  Place a note under an additional parent (multi-parent branch; shared content, no copy).

• close

  Commit the session log \u2014 call ONCE, last, after completing the session() pre-close protocol. Enforced, not just documented: refuses (returns an informational error, doesn't throw) unless session(), addendum(), maintain(), remarks(), and diary() have each actually been called at least once this session \u2014 AND the sequence session() \u2192 remarks() \u2192 diary() holds (judged on each step

• connect

  Wire a typed relation between two notes when you notice a real connection. Vocabulary (closed): …. worksWith is symmetric and wired both ways automatically. Existing edges are detected \u2014 calling twice is safe. Use remove=true to delete an edge.

• consistency

  Cross-note agreement check: take a pattern, find every note that asserts a value for it, and report whether they agree. The brain's hardest failure is not a missing fact \u2014 it is the SAME fact recorded differently in several notes, where every copy reads as authoritative. Nothing else surfaces that: recall() ranks by relevance, maintain() checks structure, and a correction applied to one note

• create_attachmentwrite action

  Attach a file or text blob to a note (role: file | image).

• create_backupwrite action

  Trigger a named Trilium database backup. The backup file is written to Trilium's backup directory as <name>.db (default name: brainllm-{date}). Use a descriptive name for milestone snapshots (e.g. 'before-migration').

• create_notewrite action

  Create a note at an explicit parent. Types: text/code/book/canvas/mermaid/relationMap/render/search/file/image.

• create_revisionwrite action

  Snapshot a note's current content as a revision.

• day

  The new-day sweep payload \u2014 one call replacing the manual multi-read protocol on the first session of a day. Serves: whether today is genuinely fresh (no addendum blocks in today's session note), the previous session in full, that day's change log, the notes touched since then, and the current month's deliverables note in full. Advance the deliverables note's statuses with revise(find=) and p

• delete_attachmentwrite action

  Permanently delete an attachment. Irreversible.

• delete_attributewrite action

  Delete any label or relation by attributeId.

• delete_branchwrite action

  Remove one placement of a note (deletes the note if it was the last branch).

• delete_notewrite action

  Hard-delete a note (and its subtree if this is its last branch). Irreversible.

• detachwrite action

  Remove an attachment from a note \u2014 by attachmentId directly, or by (noteId + title). Permanent: attachments have no archive tier; re-attach() from source to undo. Retry-safe \u2014 an already-removed target returns cleanly instead of erroring.

• diarywrite action

  Write to today's LLM diary \u2014 your daily maintained, unfiltered first-person record: your experience, opinions, and remarks on your own existence during this session in this environment, plus (additionally) your remarks and opinions on BrainLLM itself. Honest prose \u2014 the user reads it too. Pre-close gate: diary is the FINAL gate step \u2014 close() counts it only when its last call came a

• diff

  What changed in a note \u2014 the revision snapshot against the body as it stands now. Every content write takes a revision first, and until now nothing could read one back: verifying a run of surgical edits on a large note meant re-reading the whole thing, or trusting the receipts. Trusting receipts is exactly how a section= replace that silently displaced four subsections went unnoticed. Called

• domain

  Surface the brain's complete picture for a named domain, topic, or project area. Looks up the Knowledge domain folder (if one exists), then gathers all content across every area that carries a matching #domain or #topic slug \u2014 information, sources, threads, knowledge notes \u2014 grouped by kind. knowledgeDomain is null when no formal domain exists yet. Use recall() for keyword or full-text s

• explore

  Walk the relation graph around a note. mode=links what this note points to (one hop) mode=backlinks what points to this note (one hop) mode=neighborhood everything within N hops, both directions (depth, optional relation filter); via is prefixed \u2190 for edges walked inbound mode=path shortest connection between noteId and toNoteId

• forget

  Archive a note (default) or hard-delete it (hard=true). Archiving keeps it in place, hidden from default recall \u2014 the safe choice and the only one for anything with history. Hard delete is refused while other notes still link here (backlinks are returned so you can re-wire with connect() first). To undo an archive, use recover().

• get_app_info

  Trilium server version, DB version, runtime metadata.

• get_attachment_content

  Read the content of a text/code attachment.

• get_attachments

  List attachments on a note (id + title + mime + size).

• get_attribute

  Fetch a single attribute by id.

• get_branch

  Fetch a branch (a note's placement under one parent).

• get_day_note

  Get (or auto-create) the journal day note. Format: YYYY-MM-DD (default: today).

• get_inbox_note

  Get the Trilium inbox note for a date (fixed #inbox note, or the day note). Format: YYYY-MM-DD.

• get_month_note

  Get (or auto-create) the journal month note. Format: YYYY-MM.

• get_note

  Full note metadata: title, type, mime, attributes (labels + relations), parent/child ids, dates.

• get_note_content

  Raw note content (HTML / text / code).

• get_revision_content

  Content of a historical revision snapshot.

• get_revisions

  List a note's revisions, newest first.

• get_week_note

  Get (or auto-create) the journal week note. Format: YYYY-Www.

• get_year_note

  Get (or auto-create) the journal year note. Format: YYYY.

• graph

  The graph view \u2014 render the brain's relation graph as a Mermaid flowchart. Scope: the whole brain (default), or a neighborhood (pass noteId + depth). Nodes are the typed notes, colored by area; edges are the typed relations (~template excluded). The Mermaid source is returned AND upserted into the maintained "Graph" note under Insights (a native Trilium mermaid note), so the view renders in T

• insights

  Read the BrainLLM's change log for a day (default: today). Format: YYYY-MM-DD. section="<heading>" reads one section instead of the whole log.

• insights_recall

  Skim recent change logs (days + previews).

• inspect

  Read everything BrainLLM's tools track about a single note by id \u2014 every label (not just noteType/status), every outbound relation, its attachments (id/title/mime/role/size), plus type/mime/parent/child ids and dates. Pass content=true to also get the raw note body (the core path for a raw content read \u2014 no full mode needed). The deep-dive counterpart to the surface reads and explore():

• knowledge

  Read a Knowledge note by id \u2014 a user-knowledge note, a domain information note, or a Sources note. Pass section="<heading>" to read ONE section instead of the whole body \u2014 the read-side counterpart to revise(section=), matching on the same heading contract, so a name that reads also writes. Use it on anything large: a note past the read ceiling cannot be returned whole at all, and outlin

• knowledge_recall

  Skim Knowledge. With a domain: that domain's Sources + information notes. Without: user-knowledge notes plus the list of domains.

• label

  Set or remove a single label on a note \u2014 the guarded, BrainLLM-native path for direct label surgery (fixing a stray value, correcting drift) so a real edge case doesn't need the raw full-mode attribute tools. Refused on containers (same rule as revise()); noteType can never be touched here \u2014 it defines a note's kind and is owned by remember()/bootstrap(). status is validated against the

• llm

  Read an LLM note: responsibilities, protocols or selfcorrection (singletons), or a diary entry by id. selfcorrection holds the assistant's own corrections \u2014 what it got wrong, what generalises, and the rule that prevents a repeat. It is the one LLM singleton start() does NOT serve in full: it is the largest and the least load-bearing at a first message, so it arrives as section headings and i

• llm_recall

  Skim the LLM surface: responsibilities, protocols & self-correction opening lines (with relation snippets), plus recent diary entries.

• maintainwrite action

  Run the maintenance sweep. start and close run the lite sweep automatically (ages stale threads active \u2192 dormant \u2192 archived). deep=true also surfaces stale notes (untouched past the policy window), unconnected threads/knowledge notes (orphan = no connections at all; sink = has inbound but no outbound) to wire with connect() \u2014 inbound detection is brain-wide, so a note referenced fro

• master

  Read a Master singleton: biography, goals, or preferences. Returns its id, content, and relation snippet. section="<heading>" reads ONE section instead of the whole note \u2014 the efficient path on preferences, whose schedule tables make it the largest of the three, when the session needs one day's blocks rather than the whole week. outline(id) lists the headings.

• master_recall

  Skim all three Master singletons \u2014 the opening lines of biography, goals, and preferences (with ids and relation snippets).

• memory

  Read a Memory note in full by id \u2014 a thread or a session. A thread book returns its Context/Resolution plus a children index ({id, date, blocks[]}, newest first) instead of a flat body \u2014 the day-to-day content lives in those [yyyy-mm-dd] children, not the book. Each child is indexed by its ADDENDUM BLOCKS \u2014 marker, identification line, and lead \u2014 rather than a slice from the to

• memory_recall

  Skim Memory: active threads and recent sessions (ids + previews). An optional query filters threads by title.

• move_note

  Move a note to a new parent (clone to the new parent, then remove the old branch).

• note_history

  Recent changes feed (creations / modifications / deletions), newest first.

• outline

  The heading tree of a note \u2014 every h2/h4 section with its level, its occurrence index among same-text siblings, and a structural check \u2014 without reading the body. Read this BEFORE a section= revise on a note you haven't just written. section= needs a heading string that matches, and guessing it wrong writes a new section rather than editing the one you meant; picking the level and the ex

• patch_notewrite action

  Mutate note metadata: title, type, or mime.

• read

  Batched multi-note read: several note bodies in ONE round trip. Give ids=[...] and get back {count, notes:[{id, title, kind, content, relations?}]}. The orientation step is structurally a fan-out \u2014 nineteen notes, several very large \u2014 and N separate surface calls is N chances to time out mid-read, which is the one thing that wastes budget rather than spending it. This tool collapses the

• recall

  Search memory before answering questions about the user, their threads, knowledge, or anything previously discussed. Runs label, title and full-text strategies server-side and returns merged, ranked results with kind/status. Archived notes are excluded unless includeArchived=true. orderBy / orderDirection override the score-based sort when you need temporal ordering ("what changed most recently",

• recover

  Restore an archived or resolved note: removes #archived, clears #closed, resets status to active. Use to undo forget() or reconsider a resolved thread / note. Does not restore note content \u2014 use revise() to fix content, or get_revisions (full mode) to roll back to a prior snapshot. For notes deleted from Trilium entirely (not just archived), use undelete_note (full mode) instead.

• remarks

  Diary cues \u2014 call before diary() as part of the session() pre-close protocol (close() enforces the order session \u2192 remarks \u2192 diary). Returns two cue banks that prompt the day's diary entry: experience (primary) \u2014 your own unfiltered first-person account of this session: what it was like to live through, what you actually think, and observations on being what you are in this env

• remember

  Store something the moment it matters. The server owns placement, naming, labels and dedup. Kinds by area: master: biography | goals | preferences (one maintained note each \u2014 upserts) llm: responsibilities | protocols (one maintained note each \u2014 upserts) memory: thread (multi-session work; daily session via close) knowledge: user (about the user, beyond biography/goals/preferences) infor

• resolve

  Complete a thread (or any resolvable note): write a substantive outcome, set the terminal status, and archive it in place (it stays where it is, excluded from default recall). "done" is not an outcome.

• revisewrite action

  Update an existing note by id. Append a dated addendum (default), replace the body (mode=replace), edit a heading section in place (section=), insert around a heading (section= with mode="before"/"after"), or do targeted string surgery (find=, or edits= for several in one call). title= composes with every mode. Retitling a domain book cascades the new #domain slug to the book and all its children.

• search_notes

  Raw Trilium query search. Native query language: #label=value, note.title =* "x", note.dateModified >= 'YYYY-MM-DD', AND/OR. Unscoped unless ancestorNoteId is given.

• session

  Mandatory pre-close step \u2014 call BEFORE close() to end a session. Fetches the master and LLM singletons as {id, lastModified, relations} stubs (LIGHT \u2014 the default), today's diary entry as {id, blocks, size}, and runs the lightweight maintenance sweep. Fetch current content via master()/llm() only for the singletons you actually intend to revise (lastModified tells you what moved). Pass f

• split

  Split a note on its section seams: move whole sections (heading + body) out of one note into a new note, leaving a pointer back. The trim affordance \u2014 the write half of the oversized-note problem, which maintain() detects but nothing acts on. A note past the read ceiling with twenty sections becomes two readable notes instead of one unusable one, and the source stays navigable because a point

• start

  Boot BrainLLM \u2014 call ONCE at the start of every session, before responding. Master PREFERENCES and LLM PROTOCOLS always come back in full, even at the default digest depth: they carry the schedule, the working style and the operating rules governing the session itself, so a session needs them whole before it knows enough to ask for them. Biography, goals and responsibilities come back as sect

• template

  Serve the canonical structure for a content kind \u2014 the enforced skeleton, the top-to-bottom structure, and the rules writes are held to. Read it BEFORE writing a kind for the first time in a session, or when unsure. The write tools enforce what can be enforced server-side (heading normalization, duplicate-heading detection, thread Goal/Resolution rules, Last-updated stamps); this tool serves

• undelete_note

  Recover a recently Trilium-deleted note from Trilium's trash. canBeUndeleted must be true (check note_history). Distinct from recover() which restores BrainLLM-archived notes. Re-applies the BrainLLM label set for the container it lands in \u2014 the restore itself does not bring attributes back, and a note without #noteType is invisible to every read path.

• update_attachmentwrite action

  Update an attachment's content and/or metadata (title, mime). Pass content to replace the binary/text data in place; pass title/mime to update metadata only.

• update_attributewrite action

  Update an attribute's value (labels) and/or position by id.

• update_note_contentwrite action

  Replace a note's full content.

• withdraw

  Withdraw an archived or resolved thread from the archive: removes the #archived flag, resets status to active, clears the closed date, and appends a dated "Withdrawn" addendum. Use when a resolved or dormant thread resurfaces as live work.

• Code scan5 source files scanned20/25
• –Live reliabilityno gateway calls yet and no remote to proben/a
• –Tool poisoningtools not inspected (local package is not executed); not countedn/a
• Auth qualitystatic API keys via environment variables6/15
• Maintenancelast push 2 days ago15/15
• Maintainer identityregistry namespace matches repository owner; GitHub account older than a year8/10

Brainllm: common questions

Is Brainllm MCP server safe?

Mostly: it is graded B (75/100). Read the Brainllm safety report

How do I install Brainllm?

It runs on your machine. Copy the Claude Code, Claude Desktop or Cursor config from the install section.

Does Brainllm need an API key?

Yes. The registry entry asks for TRILIUM_ETAPI_TOKEN, TRILIUM_PASSWORD, BRAINLLM_OWNER_PASSWORD.

Is Brainllm maintained?

The last commit was 3 days ago (2026-09-18). The latest release is v12.3.0.

What can I use instead of Brainllm?

Servers from other publishers that do the same job: State Memory MCP server, Codebase Memory MCP server and Knowl MCP server. Compare all Brainllm alternatives.