Claude Code has your repository, your folders and whatever it has learned about the work. What it does not have is anywhere to leave the reasoning except a message. Give it a space and it writes that out as a structure beside the code, which the next person’s agent reads as readily as yours does. Free on every plan, with nothing of ours in the path.
Create .mcp.json at the root of the project:
{
"mcpServers": {
"filamental": {
"command": "node",
"args": [
"--no-warnings",
"/absolute/path/to/filamental-mcp/dist/index.js",
"--vault",
"/absolute/path/to/your/vault"
]
}
}
}Copy both absolute paths from Settings, then AI Integrations, then Manual setup inside Filamental rather than typing them out, since the server ships with the application and lands somewhere platform-specific. Claude Code picks the file up automatically the next time it starts in that folder.
Configuration here is per project rather than global, which is how Claude Code reads it and which turns out to be the better arrangement. The --vault argument pins the connection to one space instead of following whatever the application has open, so a repository is always joined to its own structure.
Committing that file will not work, though. Both paths in it are specific to your own machine, so a teammate who clones the repository gets a config pointing at nothing. There is a version that travels:
{
"mcpServers": {
"filamental": {
"command": "npx",
"args": ["-y", "filamental-mcp", "--vault", "./knowledge"]
}
}
}npx fetches the server from npm rather than pointing at your install, and a relative vault path is resolved against the folder Claude Code started in, so both halves mean the same thing on every machine. That one is genuinely committable. It wants Node on the path and is a shade slower to start, so for your own machine the direct version above is still the better one.
A space is a folder of Markdown files with the relationships written into the YAML front matter. Claude Code already reads files, so you can hand it the folder and it has the structure: what exists, what each thing is, and which things point at which, in which direction and how strongly. No server, no configuration, no restart.
Two documents make it fluent rather than merely literate, and both are published here in full: the skill file and the file format reference. With those in place it can write properly formed new nodes straight back into the folder, and they appear in the application when you refresh.
This is the route that turns a space into something an agent works inside rather than visits through a window, and it is the one we would suggest first if you already keep an agent pointed at your project directory.
Code records what was built. The tracker records what was asked for. Neither holds why the boundary sits where it does, which constraint ruled out the obvious approach, what the migration was actually meant to unblock, or which of last year’s decisions are still load bearing. That part survives in the heads of whoever was in the room, which is most of what onboarding is really paying for.
A space holds it as things and relationships rather than as prose, so supersedes, blocks, depends on and was rejected because are different connections instead of one undifferentiated pile of documents. Ask the model which decisions a proposed change touches and it can follow the connections rather than grepping for keywords and hoping.
It also survives you. Since the whole thing is Markdown in a folder, it can sit in the repository next to the code, move with it, and be read years later by somebody with no Filamental and no interest in acquiring any.
An agent working in your repository can already produce a summary, a document or a commit message, all of which are prose, and all of which the next machine has to parse back into a structure it can reason about. Writing to a space skips that round trip: the nodes, the categories and the typed connections are the artefact, and they are ordinary Markdown files that sit in the repository next to the code.
Which means a decision record stops being something a person has to keep accurate. Somebody who clones the repository in two years points their own agent at the same folder, and it arrives briefed, with what depends on what and which way round, rather than with eleven documents and no map of them.
It travels outside the team just as well. A structure handed to a client, a contractor or an auditor asks nothing of them: no account, no licence and no copy of this application, since a folder of Markdown is legible to whoever holds it and to whatever they point at it.
Over MCP a short briefing arrives on connection, covering what nodes, categories and connectors are and the conventions that keep a structure readable, and the full skill guide and format specification are pulled on demand only when a task calls for them. Over the folder route you install the same two documents yourself.
Either way they are the same two files, and both are published on this website word for word as they are sent rather than as a summary of what they roughly say. Nothing else runs underneath them, since Filamental has no account, no sign-in and no telemetry of any kind, and the MCP server is a local process with no network access of its own.
One prerequisite, and it is the only one that catches people out. The server reads the index Filamental builds and never builds one itself, so the space has to have been opened in the application at least once on that machine. A folder it has not seen stops with a message saying exactly that. If reading a folder somebody sent you is what you want, point the AI at the files directly instead, since a space is plain Markdown and no index is involved.
You need Node.js 22 or later and Filamental v0.2.4 or later. The MCP server itself ships inside the application, so there is nothing separate to install, and it is also published on npm as filamental-mcp if you want it on a machine with no Filamental on it.
Unlike the one-click Claude Desktop route, this one is hand-configured and therefore works on Windows, macOS and Linux alike.
Free on the Personal plan, which is free permanently with no account and no card, and not credited, seat-limited or reserved for a better tier. Every install starts with fifteen days of everything unlocked, and when that ends nothing switches off.
The paid tier is $120 a year, annual only, and it buys the one thing this page has not mentioned: sending a finished structure to somebody who does not have Filamental, as a link or a single HTML file.
Create a file called .mcp.json at the root of your project with an mcpServers entry named filamental, running node against the bundled server and passing your space folder after a --vault argument. Copy both absolute paths for your own machine from Settings, then AI Integrations, then Manual setup inside Filamental rather than typing them out. Claude Code picks the file up automatically the next time it starts in that folder.
Because that is how Claude Code reads MCP configuration, and here it turns out to be the better arrangement, since the --vault argument pins the connection to one space instead of following whatever Filamental has open, so a repository is always joined to its own structure. Committing .mcp.json only helps if you use the portable form, because the ordinary one carries two absolute paths specific to your own machine. Set the command to npx with the arguments -y and filamental-mcp, give --vault a relative path, and the file works for everyone who clones it.
Yes, and for an agent with filesystem access it is often the better route. A space is a folder of Markdown files with the relationships written into the YAML front matter, so you can point Claude Code at the folder and it reads the structure directly with no server, no configuration and no restart. Install the skill file and the file format reference alongside it and it can also write properly formed new nodes straight back into the folder.
The part of a codebase that has nowhere to live: why a boundary sits where it does, which constraint made the obvious approach wrong, what a migration was meant to unblock, and which decisions are still load bearing years later. Code records what was built and issue trackers record what was asked for, but the reasoning that joins them usually survives only in the heads of whoever was there, which is why onboarding costs what it does.
No. The MCP server is a separate local process that reads the same folder and the same index, so it works whether or not the application window is open, and the --vault argument means it does not depend on which space you last had open either. In practice you will usually have Filamental open beside it, because watching the structure change as it is written is most of the point.
Nothing. It is free on the Personal plan, which is free permanently with no account and no card, and it is not metered, credited or seat-limited, because there is no server of ours in the path to meter it at. The only paid feature in Filamental is Publisher, which sends a finished structure to somebody who does not have the application, at $120 a year.
Let it read the code, then ask for the constraints and dependencies as a Filamental space. What comes back is a first draft you can correct, which is a considerably better starting point than an empty canvas.