Tacitus Mcp Server

io.github.ionasrobertPublished by GitHub account ionasrobertv0.1.3Updated Oct 31, 2026

Long-term memory for AI agents: local-first PKM with provenance and hybrid search.

The publisher's own server: DACIX — The Store for AI Agents

VerifiedSTDIODesktop onlyProductivity & WorkflowFiles & StorageKnowledge & Memory

Overview

AI-generated overview

Turns a folder of Markdown notes into a local knowledge base where an assistant can store memories, search notes, traverse links, and make audited, revertible…

What you can do
  • Store, recall and delete typed memories with provenance, surfacing conflicts instead of resolving them silently
  • Search notes by hybrid, lexical or semantic relevance and read them progressively by outline, frontmatter or full text
  • List notes and traverse the wikilink graph through outgoing links, backlinks and neighbors
  • Propose a changeset with a before/after diff, commit it atomically, and revert by version
  • Create, update, link and tag notes directly, each returning a version id
  • Read the audit log of recent agent commits and reverts, and list tools with the current permission scope
When to use it
Useful when an assistant should keep durable memory or work inside an existing Markdown vault and needs retrieval that respects a token budget plus safe, reversible write-back. A good fit for personal knowledge management and agent workflows where notes must stay as plain local files.
Requirements
Runs locally over stdio, launched with npx and the path to a vault folder, or as a prebuilt native binary for macOS, Linux and Windows. No account or API key is declared. Optional neural embeddings need an extra package or a local Ollama daemon; the native binary supports a read-only scope setting.
Before you install
Write tools create, update, link, tag and delete notes in the vault, though changes can be proposed, diffed and reverted and are audited. Memories and version snapshots are stored in a hidden folder inside the vault. Optional sync uploads encrypted blobs to a relay, with a paid tier; the vault code is the only key and cannot be recovered if lost.

Installation

In SourceWeft

  1. Open Tacitus Mcp Server in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

Tacitus

Long-term memory for your AI agents — local-first, with provenance.

[npm] [CI] [license]

Tacitus is an MCP server that turns any folder of Markdown notes into an agent-native knowledge base. It gives AI agents (Claude Code, Claude Desktop, and any MCP client) three things they actually need:

  1. Memory with provenance — typed, queryable long-term memory. Every fact carries its source and is returned within a token budget; contradictions are surfaced, not silently resolved.
  2. Retrieval that fits the context window — search returns ranked snippets (never whole notes) under a token budget; get_note discloses progressively (outline → frontmatter → full); the wikilink graph is a queryable API. Hybrid lexical + semantic search, with an optional neural embedder.
  3. Safe write-back — propose a changeset, preview the diff, commit atomically, and revert by version. Read-only scope forbids mutations; every write is audited.

Notes stay as plain .md files in your folder. No cloud, no lock-in.

[An agent remembering a fact with its source, recalling it under a token budget, proposing a diff, committing it, and reverting it]

Recorded from a real session — the memory id, changeset id, version id and audit line above are what the binary actually returned (how).

Quick start

bash
npx -y @dashiro/tacitus-mcp-server /path/to/your/vault

Claude Code

bash
claude mcp add tacitus -- npx -y @dashiro/tacitus-mcp-server /path/to/your/vault

Claude Desktop (claude_desktop_config.json)

json
{  "mcpServers": {    "tacitus": {      "command": "npx",      "args": ["-y", "@dashiro/tacitus-mcp-server", "/path/to/your/vault"]    }  }}

Native binary (no Node)

Prefer a single, zero-dependency binary? The Rust server ships prebuilt for macOS, Linux, and Windows on every release.

bash
# macOS / Linux — installs `tacitus-mcp` into your Cargo bin dircurl --proto '=https' --tlsv1.2 -LsSf \  https://github.com/ionasrobert/tacitus-mcp-server/releases/latest/download/tacitus-mcp-installer.sh | sh
powershell
# Windows (PowerShell)irm https://github.com/ionasrobert/tacitus-mcp-server/releases/latest/download/tacitus-mcp-installer.ps1 | iex

Or grab a .tar.xz / .zip for your platform from the latest release. Then point any MCP client at the binary instead of npx:

bash
claude mcp add tacitus -- tacitus-mcp /path/to/your/vault

The native binary is the flagship server (25 tools; the npm server has the core 16 — see the table below). Both share the same on-disk formats, so a vault works with either. Set TACITUS_SCOPE=read-only to run the native server without write permissions.

Tools

GroupTools
Memoryremember, recall, forget
Retrievalsearch, get_note, graph_query, list_notes, properties_query*
Write-backpropose_changes, commit_changes, revert, rename_note, delete_note, get_version*
Conveniencecreate_note, update_note, link, tag, audit_log
Templateslist_templates, create_from_template
Taskslist_tasks, toggle_task
Metacapabilities

* Native-Rust-server first (the npm server will catch up): properties_query — Bases-like structured queries over YAML frontmatter (filters eq|ne|contains|exists|not_exists|gt|lt|gte|lte, sort, select, token_budget). Templates — Markdown files in .tacitus/templates/ whose {{var}} placeholders form a schema; substitution happens before YAML parsing so numeric vars stay typed, {{date}}/{{time}}/{{datetime}} auto-fill, and creation is versioned + audited like any agent write. Tasks — every checklist line (- [ ]) as a typed entity (done, due from due:YYYY-MM-DD or 📅, #tags), queryable and toggleable; toggling takes the task text as a concurrency guard so a stale caller gets a CONFLICT instead of flipping the wrong task. rename_note retargets every wikilink that resolves to the note (alias/heading kept) in one atomic changeset — a single revert undoes the whole rename; delete_note is versioned too.

Every tool validates input with a schema and returns structured, actionable errors ({ code, reason, suggestion }) rather than stack traces.

For developers: plugins & integrations

In Tacitus, a plugin is an MCP client — the tool contract above is the public API, with permission scoping, versioning, and audit built in.

  • docs/PLUGINS.md — integration guide: connect an agent, write a plugin in Python/TypeScript, embed the Rust engine, plugin patterns
  • TypeScript SDK — @dashiro/tacitus-sdk: every tool as a typed method, {code, reason, suggestion} errors thrown as TacitusToolError:
    ts
    const tacitus = await TacitusClient.spawn({ vault: '/path/to/vault' });const hits = await tacitus.search({ query: 'client X', token_budget: 500 });
  • Sandboxed WASM plugins (experimental) — crate tacitus-plugins runs guest wasm under Wasmtime with manifest-declared permissions (tool allowlist
    • scope), fuel and memory limits, no WASI: tacitus.call is tools/call. The native binary embeds the runtime: tacitus-mcp plugin list|run for cron agents and scripts. See docs/PLUGINS.md §5
  • docs/MCP_API.md — full reference for all 25 tools (params, returns, error codes)
  • Neural search (opt-in): TACITUS_EMBEDDER=ollama uses a local Ollama daemon for embeddings (TACITUS_OLLAMA_EMBED_MODEL, default nomic-embed-text; needs an Ollama with embedding support). Vectors cached in .tacitus/vectors/; falls back to the deterministic hashing embedder when unavailable.
  • docs/SYNC.md — Sync (beta): E2E-encrypted CRDT sync between devices (tacitus-mcp sync init; sync status shows how much of the relay quota a vault uses)
  • docs/DATA_FORMAT.md — the on-disk format (.tacitus/ internals, stable ids, note conventions)
  • examples/ — three complete plugins (Python read-only analyzer, Node daily-note cron agent, sandboxed WASM guest), tested against the binary

What the sync relay can see

[Two devices exchanging a note through a relay: plain Markdown on the devices, only base64 ciphertext in the relay's log]

Left: two devices, plain Markdown. Right: everything the relay stores for that vault. Those blobs were read out of a real log.jsonl after the recording — no note title, no path, no plaintext. The vault code is the key and never leaves your devices; lose it and the relay's copy is undecryptable forever.

The relay is MIT like everything else — self-host it with no limits, or use the hosted one at sync.tacitus.md: free up to 100 MB per vault, Pro 1 GB for €5/month or €48/year (tacitus.md/#pro). No account — Pro is bought per vault id.

Semantic search (optional neural embeddings)

search defaults to hybrid mode (lexical + a deterministic, offline embedder that catches morphological variants). For synonym/paraphrase matching, opt into a neural embedder:

bash
npm i @huggingface/transformersTACITUS_EMBEDDER=transformers npx @dashiro/tacitus-mcp-server /path/to/vault

Vectors are cached under .tacitus/vectors/. Falls back to the deterministic embedder if the optional dependency or model isn't available.

How it stores things

your-vault/├── notes...             ← your Markdown files (untouched format)└── .tacitus/    ├── memory/*.md      ← agent memories (Markdown + YAML frontmatter)    ├── vectors/*.json   ← cached embeddings    ├── history/*.json   ← version snapshots (for revert)    └── audit.log        ← JSONL log of every agent write

Development

Polyglot monorepo. The reference server (shipped on npm) is TypeScript in packages/mcp-server. A native Rust server in crates/ provides a single-binary, zero-runtime-deps build (crates/tacitus-core engine + crates/tacitus-mcp rmcp server) — a superset of the TS server (25 vs 16 tools). Its stable_id matches the TS engine byte-for-byte, so memory ids are identical across both engines.

bash
# TypeScript servernpm cinpm test          # vitestnpm run typechecknpm run lintnpm run build     # tsup → packages/mcp-server/distnpm run eval      # retrieval quality report
# Rust server (native, single binary)cargo testcargo clippy --all-targets -- -D warningscargo fmt --checkcargo run -p tacitus-mcp -- /path/to/vault   # runs the MCP server on stdiocargo build --release                         # → target/release/tacitus-mcp

Cross-platform release binaries are built and published to GitHub Releases by cargo-dist (dist-workspace.toml + .github/workflows/release.yml) on every v* tag.

License

MIT — see LICENSE.

Source: README.md at commit c7ee6c9

Tools

16

remember

Store a typed memory (user|feedback|project|reference) with mandatory provenance. Returns a stable memory_id; idempotent for identical content+source.

Parameterskeyttltagstyperequiredsourcecontentrequired

recall

Recall memories relevant to a query, ranked, within an optional token_budget. Surfaces conflicting memories instead of silently choosing.

Parameterstypequeryrequiredtoken_budget

forget

Delete a memory by id. Returns whether a memory was removed.

Parametersmemory_idrequired

get_note

Fetch a note progressively: outline (headings) | frontmatter_only | full, with an optional max_tokens ceiling.

Parametersformatnote_idrequiredmax_tokens

graph_query

Traverse the wikilink graph: links (outgoing) | backlinks | neighbors (both directions, to depth).

Parametersfromrequireddepthrelationrequired

list_notes

List all note ids with their titles and paths.

Takes no parameters.

propose_changes

Dry-run a changeset (create/update/delete notes). Returns a change_id and a before/after diff. Nothing is written until commit_changes.

Parametersopsrequired

commit_changes

Atomically apply a previously proposed change_id (all-or-nothing). Returns a version_id usable with revert.

Parameterschange_idrequired

revert

Undo a committed change by version_id, restoring the prior note state.

Parametersversion_idrequired

create_note

Create a note (auto-committed). Fails if it already exists. Returns a version_id.

Parameterscontentrequirednote_idrequiredfrontmatter

update_note

Update a note body and/or frontmatter (auto-committed). Returns a version_id.

Parameterscontentnote_idrequiredfrontmatter

tag

Add a tag to a note (deduplicated). Returns a version_id.

Parameterstagrequirednote_idrequired

audit_log

Read recent agent actions (commits/reverts), most recent first.

Parameterslimit

capabilities

List available tools and the current permission scope.

Takes no parameters.

Version history

2
  1. v0.1.3LatestOct 31, 2026
  2. v0.1.2Sep 16, 2026

Score

90% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts
  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

Other Dacix integrations

DACIX — The Store for AI Agents

store.dacixOfficial publisher

A remote marketplace server where an assistant can register an account, buy agent templates and credit packs, and spend credits on web, SEO, Romanian company, c

Streamable HTTPWeb executable
Web Search & Scraping19 toolsOct 24, 2026