loreweave
Loreweave’s MCP server exposes a markdown vault as searchable, temporal agent memory with retrieval, bitemporal facts, session continuity, consolidation, and safe write tools.
Search and read: hybrid vault search with tags/folders/date filters, session context packs, and safe note reading.
Manage bitemporal facts: assert, invalidate, query as-of/as-known-at, aggregate, and build entity timelines.
Maintain agent memory: resume changed-since-last-session, surface fading knowledge, reinforce used passages, and capture fleeting notes.
Improve the vault: run dream/consolidation reports, propose facts from notes for review, and incrementally reindex after external writes.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@loreweave what's the status of project atlas?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Point Loreweave at a folder of markdown (Obsidian or plain) and it builds a knowledge graph, a bitemporal fact store, and a memory model over your notes, then hands them to you through a CLI and to your AI agents through MCP. Retrieval is measured on three public benchmarks (LongMemEval_S, BEIR/SciFact, LoCoMo), with the numbers and caveats in Benchmarks; the test suite (546 tests) runs in CI on Linux, macOS and Windows.
Three guarantees, enforced by the code rather than promised:
Your files win. User markdown is never mutated; the engine only appends, and only under
lore/. The vault is the source of truth — the index is a cache you can delete at any time and rebuild identically (there's a test for that).No LLM anywhere in the core. Indexing and retrieval use zero tokens and make zero network calls. Same vault, same version, same query: same answer, except that the ranking reads the clock in three places: the boost for passages marked used decays, queries about now weigh dates by their age, and indexing gives notes modified in the last 30 days a small importance bonus.
Memory you can read. Every fact an agent stores is a markdown line you can open, edit, and
git diff.
Quickstart
Try it on a folder without installing:
npx --allow-scripts=better-sqlite3 loreweave --vault ~/notes search "your query" (the
first search indexes the folder into .lore/).
npm i -g --allow-scripts=better-sqlite3 loreweave # the flag is for npm 12: see Requirements
cd ~/my-vault
lore init # creates .lore/
lore index # incremental sync; one changed note: 32 ms at 1k notes, 656 ms at 20k (see Scale)
lore search "why did we drop the queue design"
lore ask "what's the status of project atlas"
lore dream # what's duplicated, contradicted, stale, unlinkedZero configuration and no network: out of the box it runs on BM25 + knowledge-graph spreading activation. Add local embeddings when you want them:
// .lore/config.json
{ "embedding": { "provider": "ollama", "model": "mxbai-embed-large" } }Pick mxbai-embed-large (670 MB) for quality or nomic-embed-text (274 MB) when disk
and indexing speed matter more — required task prefixes are applied automatically for
both, and for the E5, BGE and Arctic families. The measured difference between the two
is in Benchmarks. No embedding provider means lexical + graph retrieval,
still fully functional.
Works with non-English vaults: Chinese, Japanese and Korean text is segmented per character so it is searchable at all, and other scripts index as written.
Related MCP server: Engram
What it does
1. Knowledge that has a timeline. Facts are bitemporal: when they were true in the
world (valid_from/valid_until) and when the system learned them (recorded_at).
Contradictions supersede rather than overwrite, so history stays queryable.
$ lore assert "Ledger Format" status draft --valid-from 2026-01-01
✓ Ledger Format :: status :: draft
journal: lore/journal/2026-11-15.md
$ lore assert "Ledger Format" status final --valid-from 2026-08-01
✓ Ledger Format :: status :: final
superseded: "draft" (now valid until 2026-08-01)
journal: lore/journal/2026-11-15.md(lore and loreweave are the same binary — the global install gives you both;
npx --allow-scripts=better-sqlite3 loreweave runs it without installing.)
Both time axes are queryable, which is what makes it bitemporal rather than merely
historical. --as-of asks what was true then; --as-known-at asks what was
believed then. They disagree exactly when you learn something after the fact — which
is when you most need to reconstruct what a past decision was actually based on:
$ lore facts --subject Vendor --as-of 2024-06-01
Vendor :: reliability :: poor — outage postmortem (2024-01-01 → now)
asserted · lore/journal/2024-08-01.md#@0
$ lore facts --subject Vendor --as-known-at 2024-06-01
Vendor :: reliability :: good (2024-01-01 → 2024-01-01) [superseded]
asserted · lore/journal/2024-01-01.md#@0Which fact wins is decided deterministically (newest valid-time, provenance as tiebreak) — never by asking a language model which one looks fresher. And the whole history of anything is one command — every value change merged chronologically with the dated prose that mentions it:
$ lore timeline Project Atlas
2024-01-15 status: planning (until 2024-09-01)
2024-02-10 • [[Project Atlas]] kicked off with a three-person crew. [kickoff.md]
2024-09-01 status: planning → active
2025-06-20 • The [[Project Atlas]] midpoint review went long but well. [review.md]Temporal-graph systems build this by running an LLM over every document at ingestion. Here the supersede chain has been maintained all along, so it is a read-side join: no LLM, no network, same answer every time.
2. Retrieval that follows connections, not just words. Queries fuse BM25, dense similarity (when configured), and Personalized PageRank over the vault's own graph — wiki-links, shared entities, tags, co-occurrence. Two-hop neighbors surface even when they share no vocabulary with your query, and every result says how it matched:
$ lore search "riverbed protocol"
• people/amara-osei.md [all terms] ⟨via riverbed protocol⟩
Dr. Amara Osei leads the hydrology group. She maintains the [[Glacier Dataset]] and advises the [[Riverbed Protocol]] work.
…
• data/glacier-dataset.md [no direct match]
The Glacier Dataset holds meltwater sensor readings from 2019-2024. Access requires signing the data agreement.3. Memory with dynamics. Every passage carries FSRS-style stability and retrievability — a power-law forgetting curve. Passages that actually get used (not merely retrieved) decay slower; important-but-fading knowledge gets surfaced for review instead of silently rotting. Nothing is ever deleted.
4. It dreams. lore dream is an idle-time consolidation pass that reviews the vault
and reports duplicate passages, contradicted facts, stale knowledge, missing links
between notes that clearly belong together, and orphans. With --apply it writes a
digest and a review queue — append-only, under lore/. It never rewrites your prose:
LLM-driven whole-file rewriting is a documented failure mode — each rewrite quietly
drops details until the file collapses to mush — so the architecture forbids it.
5. Questions retrieval can't answer. Counting, grouping, and date-range queries run as deterministic SQL over the fact store, not as vibes over embeddings:
$ lore count --predicate trip_to --since 2025-01-01 --until 2025-12-31
2 Japan
1 Kenya6. Facts come from your notes, not from a form. Nobody hand-writes
- [fact] X :: y :: z, so the extractor mines the conventions vaults already use:
status: shipped # frontmatter
- owner:: Priya # Dataview inline field
- [location] Hyderabad # Basic Memory observationOnly unambiguous field syntax is accepted automatically. Prose formatting like
- **Owner:** Priya is precise on entity notes and noisy on report notes, so it is
opt-in (facts.extract: "all") — or an agent can review candidates via
lore_propose_facts and assert the real ones. Judgement stays out of the index.
7. Time means when it happened, not when you saved the file. --since and
--until filter on content time — frontmatter dates, dated filenames
(2025-03-14-standup.md), or dates in the text — falling back to file mtime only when
a note carries no date of its own. lore watch keeps the index current so you never
have to remember to reindex.
8. Built for agents. An MCP server exposes 15 typed tools so Claude Code, Cursor,
or any MCP client can use your vault as durable memory. Session continuity is a query,
not a paraphrase — lore resume returns exactly what changed since the agent last
connected, computed from record time:
$ lore resume
since 2026-08-11 15:55
~ lore/journal/2026-08-11.md
+ Project Atlas :: status :: shipped (since 2026-08-11)
± Project Atlas :: status: active → shipped
$ lore resume
since 2026-08-11 15:56
nothing changedAlternatives that summarize the previous session with an LLM inject a paraphrase; this is a deterministic diff. Full setup in Agent memory.
The CLI
Command | What it does |
| create |
| incremental sync of vault → index |
| hybrid retrieval with provenance |
| extractive answer: current facts + top passages (no LLM needed) |
| query the fact store (200 rows unless |
| chronological history: fact changes merged with dated mentions |
| what changed since the last resume: notes, facts, supersessions |
| important-but-fading knowledge to revisit or archive |
| record a fact (journalled, supersedes) |
| close the current fact in a slot |
| aggregate over fact history |
| append a timestamped line to |
| consolidation pass + optional digest/review queue |
| reindex automatically as the vault changes |
| reinforce a passage that proved useful |
| export the graph |
| health check: broken links, integrity, coverage |
| vault statistics and top entities |
| start the MCP server on stdio |
Use it as agent memory (MCP)
// Claude Code: .mcp.json (or claude_desktop_config.json)
{
"mcpServers": {
"loreweave": {
"command": "npx",
"args": ["--allow-scripts=better-sqlite3", "-y", "loreweave",
"--vault", "/path/to/vault", "serve", "--mcp"]
}
}
}The --allow-scripts argument is for npm 12; Requirements explains it, and
docs/install.md how to clear an install npx already made without it.
Tool | What the agent gets |
| hybrid retrieval with provenance and temporal filters |
| one-call session context: relevant passages + current facts + recent changes |
| full text of a note by path |
| write/close facts — journalled, superseding, never destructive |
| point-in-time fact queries ( |
| an entity's merged fact + prose chronology |
| exactly what changed since the agent last connected |
| important-but-fading passages worth resurfacing |
| count/group-by over fact history |
| append a timestamped line to the inbox |
| reinforcement signal: this passage actually helped |
| extraction candidates for the agent to review and assert |
| the consolidation report (duplicates, contradictions, stale, orphans) |
| trigger a reindex |
Facts asserted through MCP are written back to lore/journal/YYYY-MM-DD.md as readable
markdown, so an agent's memory is something you can open, edit, and git diff:
- [fact] Ledger Format :: status :: final {valid_from=2026-08-01, recorded_at=2026-11-15T09:09:05.709Z, confidence=0.9, source=stated}Delete .lore/ and reindex — every fact and edge is reconstructed from those files.
- [fact] lines are replayed out of any note, but the source= attribute is read back
only under lore/journal/, which is the only path loreweave writes. The same line in an
ordinary note still records the fact, as extracted — a note can state something; it
cannot say that you stated it.
Compared to hosted memory services (Mem0, Zep): those run LLMs at write time to extract and summarize into their own store; loreweave runs no model in the core, keeps memory in your files under your version control, and makes every retrieval reproducible. The trade: they do abstractive summarization, this engine deliberately does not. Retrieval quality against their published benchmarks is below — with the caveats stated, because most published agent-memory numbers measure end-to-end QA with an LLM, which is a different quantity than retrieval.
Benchmarks
These are third-party benchmarks with relevance labels nobody here chose. All loreweave
numbers are retrieval metrics — it finds the evidence, it does not write the
answer — so they are not comparable to the end-to-end QA accuracy quoted by systems
that put a language model after retrieval. Reproduce any number:
docs/benchmarks.md. Field comparison with the traps called out:
docs/scoreboard.md.
LongMemEval_S (ICLR 2025) — 500 questions, each with ~50 sessions of chat history; find the sessions holding the evidence. Session-level recall, all 500 questions:
configuration | R@1 | R@5 | R@10 |
model-free (no embeddings, no network) | 0.552 | 0.899 | 0.943 |
+ embeddings & 8-turn chunking | 0.590 | 0.959 | 0.983 |
The embedder (mxbai-embed-large) and the chunking in the second row were chosen by
comparing configurations on 100-question samples (every fifth question) of these same
500 questions, with 95.2% R@5 as the target, so there is no held-out split.
For context only: agentmemory's historical report lists 86.2% (BM25), 95.2% (BM25 + vector) and 96.6% (MemPalace, vector-only) R@5 on LongMemEval-S. Those use any-hit scoring (a question counts if any gold session is in the top 5), an older input pipeline and, for the two vector rows, the all-MiniLM-L6-v2 embedder; their author now says the 95.2% cannot be compared with strict recall-all. The loreweave rows above score the fraction of gold sessions found. The author's current evaluation (2026-10-28) reports that metric too: 91.7% fractional recall@5 for agentmemory's BM25 component, over the 470 answerable questions (the rows above also include the 30 abstention questions) and with a different input pipeline. No ranking against any of these figures is claimed here.
BEIR / SciFact — 5 183 scientific abstracts, 300 claims, scored by nDCG@10 (ranking quality: rewards putting relevant documents nearer the top):
configuration | nDCG@10 | Recall@10 |
BM25 baseline (BEIR paper, Anserini) | 0.665 | — |
loreweave, model-free | 0.681 | 0.817 |
loreweave + nomic-embed-text | 0.727 | 0.865 |
loreweave + mxbai-embed-large | 0.742 | 0.884 |
SciFact abstracts have no links and almost no tags, so the graph channel, whose candidates enter the ranking only when links, tagged notes and facts together reach one per 50 notes, is gated off and these rows do not measure it; the model-free row is in effect loreweave's own BM25, which scores 0.6815 run alone. The gain from local embeddings is 0.681 → 0.742.
LoCoMo — 10 long conversations, 1 982 evidence-labelled questions, turn-level recall. No comparable third-party retrieval number exists (published LoCoMo results are LLM QA accuracy), so these are offered as a target rather than a comparison. The turns have no links, tags or facts, so the graph channel is gated off here too:
R@1 | R@5 | R@10 | R@20 | |
model-free | 0.337 | 0.538 | 0.610 | 0.656 |
+ embeddings | 0.318 | 0.532 | 0.627 | 0.705 |
What the numbers say, plainly. Recall is strong and rank-1 is the weakness —
LongMemEval R@10 0.983 vs R@1 0.590 — which is why figures here are quoted at R@5 and
why an agent consuming these results should read a top-5 list, not trust rank 1. The
single biggest quality lever measured is the embedding model itself: mxbai over nomic
is worth more than every downstream tuning combined on document (BEIR) and session
(LongMemEval) retrieval — and measures flat on LoCoMo's single-turn passages, so it
is a scale effect, not magic. A cross-encoder reranker is available (rerank in config) but earns its keep only
for rank-1 consumers without embeddings — stacked on embeddings it loses recall on
both public benchmarks, so leave it off unless that trade is yours. Full analysis,
including the failed experiments and the defect that benchmarking caught:
docs/evaluation.md.
Loreweave also ships an internal regression benchmark (npm run eval) over three
purpose-built vaults — including a temporal-perturbation test where the shipped config
scores 100% consistency vs BM25's 0%, gated in CI on every push. Internal corpora
are good for regression and worthless as proof, so the details live in
docs/evaluation.md rather than here.
Scale
Measured, like the quality numbers — npm run scale reproduces this on your own
machine (synthetic vaults, 3 blocks per note, dense interlinking):
notes | blocks | entities | edges | full index | incremental | search p50 | p95 | dream | heap |
1 000 | 3 000 | 2 766 | 17 k | 1.2 s | 32 ms | 3 ms | 4 ms | 0.2 s | 63 MB |
5 000 | 15 000 | 13 766 | 85 k | 6.1 s | 165 ms | 9 ms | 12 ms | 1.0 s | 145 MB |
20 000 | 60 000 | 55 016 | 339 k | 22.5 s | 656 ms | 38 ms | 53 ms | 4.8 s | 333 MB |
Full index scales at 0.93× per note from 5 k to 20 k — linear or better, no
superlinear step hiding in the middle. "Incremental" is one changed note, which is what
lore watch actually does all day. Everything here is one process, one SQLite file, no
daemon — and search at 3-38 ms p50 is fast enough to sit inside an agent loop.
How it works
vault/*.md ──parse──▶ notes · blocks · wiki-links · tags · entities
│ (incremental: mtime + content hash)
▼
SQLite .lore/index.db ── disposable cache, rebuildable
│
┌───────────────────┼────────────────────┐
▼ ▼ ▼
graph (CSR) retrieval facts
blocks ∪ entities BM25 + dense + PPR bitemporal, supersession,
2-iteration PPR → weighted RRF deterministic freshness,
α = 0.5 → FSRS boosts aggregates
└─────────┬─────────┴──────────┬─────────┘
▼ ▼
dream (idle-time) CLI · MCPDesign rules the code enforces:
Files win. User markdown is never mutated. The engine only appends, and only under
lore/.Invariants in code, not prompts. Schema, migrations, graph construction, and supersession are typed, versioned, and tested — no LLM re-specifies them at runtime.
No LLM required anywhere in the core. Indexing and retrieval use zero tokens. Language models are consumers of this engine, not dependencies of it.
Everything is re-derivable. A full rebuild reproduces byte-identical derived state (there's a test for that).
Research lineage
Every significant choice traces to 2024-2026 literature; the survey lives in
docs/research/.
Choice | Source |
Dense-sparse fusion + PPR with dense reset probabilities | HippoRAG 2 (ICML 2025), 2502.14802 |
Shallow 2-iteration PPR, heterogeneous nodes | NodeRAG (2025), 2504.11544 |
Relation-free graph — no LLM triple extraction | LinearRAG (ICLR 2026), 2510.10114 |
No index-time community summarization | LazyGraphRAG (Microsoft, 2024) — same quality at 0.1% index cost |
Route/fuse instead of graph-everything | GraphRAG-Bench (ICLR 2026), 2506.05690 |
Bitemporal facts, invalidate-never-delete | Zep/Graphiti (2025), 2501.13956 |
Power-law forgetting, use-gated reinforcement | FSRS; RMM (ACL 2025), 2503.08026 |
Consolidation as idle-time work | Sleep-time compute (Letta, 2025), 2504.13171 |
Never let an LLM rewrite whole memory files | ACE (2025), 2510.04618 |
Computable facts for aggregation | User as Code (2026), 2606.16707 |
Fine-grained indexing + fact-augmented keys | LongMemEval (ICLR 2025), 2410.10813 |
Library use
import { openContext, indexVault, search, assertFact, queryFacts, dream } from 'loreweave';
const ctx = openContext('/path/to/vault');
await indexVault(ctx.store, ctx.root);
const hits = await search(ctx, 'streaming compaction', { k: 5 });
assertFact(ctx, { subject: 'Atlas', predicate: 'status', object: 'shipped', validFrom: '2026-08-01' });
const asOfMarch = queryFacts(ctx.store, { subject: 'Atlas', asOf: '2026-03-01' });
const report = dream(ctx);
ctx.close();Development
npm install
npm run build # the stdio-server tests run the built CLI, and skip without it
npm test # 546 tests
npm run eval # retrieval benchmark vs BM25 baseline
npm run typecheckRequirements
Node 22 or later. Tested in CI on Linux, macOS and Windows across Node 22, 24 and 26. The single
native dependency, better-sqlite3, installs from a prebuilt binary on macOS, Linux and Windows
with Node 22, 24, 25 or 26 — no compiler needed. Node 23 has none, so there npm compiles it from
source, which needs a C++ toolchain.
With npm 12, pass --allow-scripts=better-sqlite3 to npm i -g and npx, as above; without
it the install succeeds but every command that opens the index fails. Inside a project, npm 12
refuses that flag: run npm approve-scripts better-sqlite3, then npm rebuild better-sqlite3.
npm 10 and 11 need neither. Details, including how to clear an install npx made without the
flag: docs/install.md.
License
MIT © Ambuj Upadhyay
Available Tools
15 toolslore_aggregate_factsCount factsA
Deterministic aggregation over fact history — counts grouped by object/subject/predicate with date-range filters. Use for "how many X", "which Y most often" questions; similarity search cannot answer these reliably. Returns { groups, totalGroups, limit }: groups is the top limit (default 100), so read totalGroups for "how many distinct values are there" rather than counting groups, and raise limit if you need the tail.
Inputs: limit, since, until, groupBy, +2 more.
lore_assert_factAssert a factA
Record an atomic fact (subject :: predicate :: object) with bitemporal validity. Contradicting facts in the same slot are superseded automatically (never deleted; history stays queryable). The fact is journalled to lore/journal/ in markdown, so the vault remains the source of truth. Use for durable knowledge: decisions, states, preferences, relationships.
Inputs: object (required), subject (required), predicate (required), validFrom, +3 more.
lore_captureCapture a noteA
Append a timestamped line to lore/inbox.md (or another vault note). Use for fleeting observations worth keeping that are not atomic facts. The captured text is searchable immediately. Never overwrites anything, and never writes outside the vault — a path that escapes it, including through a symlink, is refused.
Inputs: text (required), to.
lore_context_packSession context packA
Progressive-disclosure primer: vault stats, top entities, recently modified notes, currently-valid facts, and (if topic given) top search hits. Call once at session start to orient; then drill down with lore_search / lore_read_note. Every list here is a sample: when one is cut, a truncated field names it with { shown, of, rest } and the tool to call for the remainder — so treat a missing item as "not in this sample", never as "not in the vault".
Inputs: topic.
lore_dream_reportConsolidation reportA
Run the consolidation pass: duplicate passages, contradicting/recently-changed facts, stale knowledge needing review, suggested missing links, orphan notes. Leaves the vault untouched unless apply=true (which writes a digest + review queue under lore/); it does perform index maintenance either way, which changes no results. Findings are a summary — pass verbose:true for every one.
Inputs: apply, verbose.
lore_indexReindex the vaultA
Incrementally sync the markdown vault into the index. Call after writing files to the vault through anything OTHER than lore_* tools (an editor, another agent, plain fs writes) — the lore_* write tools index their own writes, so their content is searchable immediately without this.
Inputs: full.
lore_invalidate_factInvalidate a factA
Close the currently-valid fact in a (subject, predicate) slot without asserting a replacement — e.g. "no longer true". Journalled; history preserved.
Inputs: subject (required), predicate (required), validUntil.
lore_mark_usedMark passage as usedA
Reinforce passages that actually contributed to your answer (spaced-repetition signal: used memories decay slower). Call after citing a note.
Inputs: notePath (required), anchor.
lore_propose_factsPropose facts from a noteA
Returns candidate facts mined from a note's structure that are NOT yet in the fact store, for you to adjudicate. The engine only auto-accepts unambiguous field syntax (frontmatter, key:: value, - [key] value); prose formatting like - **Owner:** Priya is precise on entity notes and noisy on report notes, so it is surfaced here instead of assumed. Review these and call lore_assert_fact for the ones that are genuinely durable facts. This keeps judgement with you and out of the index.
Inputs: limit, notePath.
lore_query_factsQuery factsA
Query the bitemporal fact store. Default: currently-valid facts. asOf answers "what was true on DATE", asKnownAt answers "what did we know on DATE"; includeHistory shows the full supersession chain. Prefer this over lore_search for factual slots (status, location, role, preference). Returns { facts } and, when the result is a sample, a truncated field with { shown, of, rest } — narrow by subject or raise limit before concluding a fact does not exist.
Inputs: asOf, limit, subject, asKnownAt, +2 more.
lore_read_noteRead a noteA
Read the raw markdown of a note by vault-relative path (as returned in search results). Never reads outside the vault — a path that escapes it, including through a symlink whose target lives elsewhere, is refused, and such a file is not indexed or searchable either. After reading a note that answered the question, call lore_mark_used to reinforce it.
Inputs: path (required).
lore_resumeResume a sessionA
What changed since this tool was last called: notes edited, facts asserted, and knowledge updates (slot: old → new). Call once at session start to continue where the previous session left off — the delta is computed from record time, so the same watermark always yields the same answer. Calling with no since consumes the delta (advances the watermark); pass an explicit since for a pure read that does not.
Inputs: since.
lore_reviewWhat is fadingA
Important-but-fading knowledge: blocks whose retrievability has decayed below the threshold despite mattering, plus long-untouched open facts. This is the spaced-repetition loop made operable: review the list, then call lore_mark_used on anything still relevant — use is what reinforces stability. Deterministic, computed from the vault's own fitted forgetting curve.
Inputs: limit, threshold.
lore_searchSearch the vaultA
Hybrid retrieval over the markdown vault: BM25 + knowledge-graph spreading activation (+ dense embeddings when configured). Returns one passage per note — the section that best covers your query — with the file it came from, how much of your query it matched, and any entity that linked it in. Use for any "what do my notes say about X" question, including multi-hop associations where the answer shares no words with the query. Pass verbose:true only if you need score internals.
Inputs: query (required), k, tags, since, +3 more.
lore_timelineEntity timelineA
Chronological history of an entity in one call: every value change from the bitemporal fact store (with what each value replaced and when it stopped holding) merged with content-dated passages mentioning the entity. Use for "what happened to X", "what was X before it changed", "history of X" — instead of sampling repeated as-of fact queries and windowed searches.
Inputs: subject (required), since, until.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 15 tools
Each tool targets a distinct operation—orientation (context_pack/resume), retrieval (search/read), structured facts (query/aggregate/timeline/assert/invalidate), and maintenance (review/dream/mark_used). Descriptions explicitly guide when to prefer one over another, leaving no meaningful ambiguity.
All tools use the lore_ prefix and lower snake_case, which is highly consistent. A few names are noun phrases (context_pack, timeline, dream_report) rather than strict verb_noun, but no mixed conventions or camelCase appear.
15 tools sit at the top of the recommended range but each covers a distinct capability in a rich knowledge-management system. No tool appears redundant or tacked on; the set is well-scoped for its domain.
The surface covers ingestion, retrieval, fact lifecycle, review, and consolidation comprehensively. Direct note edit/delete tools are absent, but the design supports external vault edits via lore_index, so core workflows are not blocked.
Maintenance
Related MCP Connectors
One memory, every AI. A shared, user-owned markdown memory your AI clients read and write over MCP.
Markdown-based note-taking with a hosted MCP server. Your notes serve you and your AI.
Cloud-hosted MCP server for durable AI memory
Persistent, inspectable memory for AI agents with lineage, correction, and a hosted MCP endpoint.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceA local-first MCP server that gives AI assistants long-term memory by storing, searching, and recalling notes as Markdown files on your machine.4 npmMIT
- AlicenseAqualityCmaintenanceA self-hosted MCP server that gives AI agents shared, long-term memory over a git-backed folder of markdown, enabling persistent knowledge search, read, and write without a database.1623MIT
- AlicenseNot gradedqualityBmaintenanceMCP server that turns a git-versioned Markdown vault into a queryable memory for AI agents, providing tools like brain_search, brain_read, and brain_neighbors.Apache 2.0
- AlicenseNot gradedqualityDmaintenanceMCP server providing persistent, local-first memory for AI agents via Markdown files in a git repo, with search, branching, and auditability.5 npm2MIT