knowmind
You can use knowmind as a persistent, bitemporal knowledge-graph memory for AI tools: store facts and documents, recall them semantically, and manage typed entities and relations.
Recall memories with hybrid keyword/vector/graph search for current answers, including relevance scores and provenance.
Recall as of a past time to answer what was valid or known on a given date.
Store short memories/facts with titles, tags, domains, sources, memory types, and inline typed relations.
Upload longer documents for chunking, embedding, searchable ingestion, and title-based supersede/dedup behavior.
Update or end facts without deleting history: supersede changed facts or set an end time for facts that no longer apply.
Manage the knowledge graph: create/update typed entities, link or unlink entities with evidence and confidence, and inspect an entry’s relations.
Review inferred relations by confirming, rejecting, or undoing them.
Inspect the workspace: list recent entries, view schema, get corpus statistics, and check service health.
Use deprecated tool aliases until 2027-03-31; they still answer unchanged.
Integrates with GitHub Copilot via VS Code to provide long-term memory and knowledge graph capabilities, allowing AI agents to store and retrieve contextual information during development.
knowmind
Persistent memory for your AI tools. Store something once, and it is available in Claude Code, Cursor, and any other MCP client that runs a local (stdio) server — as a typed knowledge graph with provenance, confidence, and a bitemporal history for every fact. Hosted in Germany (Hetzner, Nuremberg data center); the CLI and MCP server in this repository are Apache-2.0.
The free tier is permanently free and requires no payment details. The API, CLI, and MCP server are included in every tier.
Connect your AI tool in three steps
Create a free account at knowmind.de and generate an access token: Dashboard → API tokens.
Store the token locally:
npx -y knowmind login --token kmt_xxxxxxxxWire up your client:
Claude Code (one command)
claude mcp add knowmind --env KNOWMIND_TOKEN=kmt_xxx -- npx -y knowmind mcpCursor (~/.cursor/mcp.json) — the same mcpServers block works for Claude Desktop, Windsurf and Gemini CLI in their config files; Zed expects it under context_servers:
{
"mcpServers": {
"knowmind": {
"command": "npx",
"args": ["-y", "knowmind", "mcp"],
"env": { "KNOWMIND_TOKEN": "kmt_xxx" }
}
}
}Any other MCP client: knowmind is a standard MCP server over stdio (npx -y knowmind mcp). On Windows, npx -y knowmind install <ide> is the better way: if pythonw.exe from Python 3.10 to 3.14 sits in its default location (%LOCALAPPDATA%\Programs\Python\Python3… or C:\Python3…), the entries it writes start the server without a console window; Codex and the printed Claude Code command use npx directly. If you configure by hand and npx does not start directly, use "command": "cmd", "args": ["/c", "npx", "-y", "knowmind", "mcp"]; clients without a console of their own then open a window with each tool call.
npx -y knowmind install <ide> writes this configuration for you, for example cursor, vscode, windsurf, zed, claude-desktop, gemini or codex; npx -y knowmind install list shows all clients. For Claude Code it prints the claude mcp add command instead, and --project writes .mcp.json in the current folder.
Clients that cannot read the token from the environment get a placeholder to replace with your token. Running install again updates only the knowmind entry and keeps a token you entered; before it changes a file, it saves a copy next to it.
npx -y knowmind init sets up memory hygiene in your client: a Claude Code hook that recalls before every prompt (init asks whether in this project only, the default, or in all projects; --global/--project decide without asking, --uninstall-hook turns it off), the same recall as a BeforeAgent hook in Gemini CLI 0.26.0 or later (--client gemini-cli, same scope choice: ./.gemini/settings.json by default, ~/.gemini/settings.json with --global; Gemini CLI runs project hooks only in trusted folders), and hooks that, when a turn contained something worth keeping (a deploy or commit, a new rule, an architecture decision, changed code or configuration) and nothing was stored yet, ask the model to store it before the turn ends, a rule file in Cursor, and a block in AGENTS.md that tells Codex when to ask knowmind and what to keep. Since 0.4.10 Codex gets the same recall as a UserPromptSubmit hook (./.codex/hooks.json by default, ~/.codex/hooks.json with --global); Codex runs a new hook only after you approve it once with /hooks. The recall hooks send the header X-Knowmind-Herkunft: automatisch with each recall, CLI commands send X-Knowmind-Herkunft: cli, so knowmind can tell automatic recalls from deliberate ones; the header carries no identifier.
Related MCP server: Memory Nexus MCP
How knowmind stores facts
Bitemporal history. Every fact carries two time axes: when it was true and when it was recorded. Corrections never overwrite the original; the old statement stays queryable with the date it stopped being valid, so you can reconstruct what the system knew on any given day.
Provenance and confidence per fact. New facts require a confidence level and keep a link to their source. Older facts without a confidence level are marked as such.
Typed knowledge graph. Entities and relations use a restricted set of edge types; catch-all relations are rejected at write time.
Operated in the EU, isolated per tenant. The service runs on Hetzner in Nuremberg, Germany, with tenant isolation, a public data processing agreement, and a subprocessor list at knowmind.de/legal/avv. Access logs are hash-chained and externally timestamped (RFC 3161).
knowmind is a hosted service; there is no self-hosted community edition. If you need self-hosting, one of the projects below will serve you better. knowmind is built for the people and teams that need an operated memory service with an audit trail in the EU.
Pricing
Tier | Price | For whom |
Free | €0 | individuals and evaluation |
Pro | €15/month or €150/year | individual professionals |
Team | €99/month | teams with shared memory |
Business | €349/month | larger teams |
Enterprise | from €1,000/month | organizations with on-premise requirements |
The free tier includes 2,500 memories, 1 user, and a 30-day access log.
How that compares (vendor pricing pages, checked 2026-09-05):
Product | Free tier | First paid tier | Self-hosting |
knowmind | 2,500 memories | €15/month | no (Enterprise on-premise option) |
Mem0 | 10,000 entries, 1,000 retrievals/month | $19/month | yes (Apache-2.0) |
Zep | 10,000 credits/month | $125/month | Graphiti open source; Zep as BYOC |
cognee | 1M tokens, 1 workspace | $2.50 per 1M tokens | yes |
Letta | limited agents, own keys | $20/month | yes (per vendor) |
Supermemory | ~$5 usage included | $19/month | from Scale tier |
Details and current prices: knowmind.de/pricing.
Commands
npx -y knowmind search "Where does the staging deploy run?"
npx -y knowmind upload notes.md --title "Meeting notes 2026-05-12"
npx -y knowmind stats
npx -y knowmind health
npx -y knowmind status --line # one-line status for your AI tool's statusline
npx -y knowmind sync ./openwiki # pages in Open Knowledge Format keep their review dataKnowledge in Open Knowledge Format
knowmind sync reads folders in the Open Knowledge Format (OKF 0.1 and 0.2),
such as the openwiki/ folder that OpenWiki creates in a repository.
Every search hit then carries the page's status (stable if the page sets
none), its trust tier as defined by OKF (trust: unverified,
machine-confirmed or human-reviewed) and how many sources it lists. If the
page provides them, the hit also carries who or what generated the page
(generated), its last five verifications (verified), the time after which
it counts as stale (stale_after) and its first ten sources (sources). The
full header stays part of the document.
Inside a bundle, directory listings (index.md) and logs (log.md) are not
imported. knowmind recognizes a bundle by okf_version in its root index.md or by the
files OpenWiki keeps there. If it finds neither, --okf treats the folder you
sync as a bundle.
Available Tools
Fifteen tools over MCP. Every one works against your own workspace; the server never sees another tenant's data.
Reading
knowmind_recall_memories — Search your memory and get the passages that answer a
question, ranked. Combines keyword search, vector similarity and the knowledge
graph, then reranks with a cross-encoder.
query (string, required) · k (integer, default 5, max 20) · hops (integer,
default 2 — how far to follow graph edges from a hit)
Usage: your AI tool asks "Which database does the billing service use?" before
answering, instead of guessing.
Errors: returns an empty result set when nothing matches — never an invented
answer.
knowmind_recall_at_time — The same search, but as your memory stood on a
given date. Facts superseded after that date are excluded; facts that were valid
then are returned even if they are no longer true.
query (string, required) · as_of (ISO date or timestamp, required in
practice) · k (integer, default 5)
Usage: "What was our pricing in March?" — answers from the state of that day,
not today's.
Difference from knowmind_recall_memories: use recall for what is true now, and
recall_at_time for what was true then. Asking recall about the past returns
today's facts.
knowmind_list_recent — The most recently added entries, newest first.
k (integer, default 10)
Usage: a quick look at what landed in memory during this session.
knowmind_list_relations — All typed edges attached to one entry, in both
directions.
memory_id (string, required)
Usage: "What does this contract connect to?" before changing or superseding it.
Errors: unknown id returns an error, not an empty list.
knowmind_get_schema — The entity classes and relation types this workspace
accepts. No parameters.
Usage: call it before knowmind_upsert_entity or knowmind_link_entities to use a type the
server will accept, rather than inventing one.
knowmind_list_inferred — Relations that wait for a human decision: relations knowmind
inferred from a text, and relations that start from a document although their type needs a
person, organisation or similar. Each comes with its review state, both connected entries, its
source and the entry that supports it.
status (open, confirmed or rejected, optional) · limit (integer, default 50, max 200) ·
offset (integer, default 0)
Usage: review what the graph learned on its own. Open relations do not feed the derivation
rules until someone confirms them.
knowmind_get_stats — Size of the corpus: documents, chunks, entities, edges.
No parameters.
knowmind_get_health — Whether the service and its stores are reachable. No
parameters.
Usage: a status line, or a check before a long ingest.
Writing
knowmind_store_memory — Store a short fact, decision or note. Stays as one
unit; it is not split.
content (string, required) · title (string) · memory_type (string, e.g.
semantic, episodic) · tags (array of strings) · source (string) ·
domain (string) · relations (array — edges to create along with the entry)
Usage: "We decided to keep the monolith until Q3" after a meeting.
Errors: rejected with 422 when the text contains what looks like a password or
an access key. Store a pointer instead, not the secret.
knowmind_upload_document — Store a longer text as a document. It is split
into passages, embedded, and becomes searchable through knowmind_recall_memories.
content (string, required) · title (string) · source (string) ·
relations (array)
Usage: meeting minutes, a specification, a handbook chapter.
Difference from knowmind_store_memory: one sentence you want back verbatim is
a memory; a page you want searched is a document. A long text stored as a memory
is retrieved as one block, which crowds out other results.
knowmind_update_fact — Supersede a fact that has changed. The old version
keeps its validity window and stays auditable; nothing is deleted.
target_id (string, required) · new_title (string, required) · new_content
(string, required) · update_reason (string)
Usage: a price, a deadline or a responsibility changed. Never overwrite —
supersede, so "what did we believe in July" stays answerable.
Errors: unknown target_id is rejected.
knowmind_upsert_entity — Create or update a typed entity (a person, a company, a
product) with aliases.
name (string, required) · entity_class (string, required — see
knowmind_get_schema) · description (string) · aliases (array of strings)
Usage: give "ACME Ltd." its aliases so a question about "ACME" finds it.
Errors: a class outside the schema is rejected.
knowmind_link_entities — Create a typed edge between two entries, with a confidence
value.
from_id (string, required) · to_id (string, required) · rel_type (string,
required — see knowmind_get_schema) · confidence (number 0–1)
Usage: connect a contract to the client it belongs to. The inverse edge is
created for you.
knowmind_unlink_entities — Remove a typed edge.
from_id, to_id, rel_type (all required)
Usage: an edge created in error. The entries themselves stay.
knowmind_review_inferred — Record a decision on one relation from
knowmind_list_inferred. confirm lets it feed the derivation rules; reject ends the
relation, its reverse and every relation derived from it (valid_to is set, nothing is
deleted); undo takes a rejection back.
edge_id (string, required) · decision (confirm, reject or undo, required) ·
evidence (string, optional — id of the entry that supports the decision)
Usage: after reviewing the list. Returns the state before and after and how many reverse and
derived relations were affected.
On deleting
There is no delete tool, and that is deliberate. Facts are superseded
(knowmind_update_fact), edges are removed (knowmind_unlink_entities), and the history
stays auditable. Deleting an entire workspace including its data is a
self-service action in the web interface at
knowmind.de — it is not something an agent should be able
to do by calling a tool.
Older tool names
Seven tools were renamed on 12 September 2026 so that every name follows
knowmind_<verb>_<object> and says whether it reads or writes. The previous
names keep answering unchanged until 31 March 2027 and still appear in
discovery, marked as deprecated:
until now | from now on |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
knowmind_entity became upsert, not get: it creates the node or returns
the existing one. Nothing else about the tools changed — same parameters,
same behaviour.
Discovery
GET https://knowmind.de/api/mcp/v1 returns name, version, protocol version and
the full tool list with input schemas — without a token. Directory crawlers and
inspectors can read the complete surface anonymously; only tools/call requires
a key.
Links
Documentation · Pricing · Data processing agreement · Privacy
Die deutsche Fassung steht in README.de.md.
Available Tools
23 toolsknowmind_end_factAIdempotent
End an entry that no longer applies and that nothing replaces (a project closed, a source withdrawn): the entry gets valid_to (now, or the given time) and drops out of knowmind_recall, while knowmind_recall_at_time before that time still finds it. Nothing is deleted and no new entry is created. When a newer statement replaces the entry, use knowmind_update_fact instead. Calling it again changes nothing. Requires write scope.
Inputs: target_id (required), reason, valid_to.
knowmind_entityAIdempotent
DEPRECATED, removed on 2027-03-31: use knowmind_upsert_entity. This name keeps answering unchanged until then. Create the node for a thing the corpus talks about - a person, an organisation, an application, a host, a technology - or return the existing one. THE GRAPH NEEDS THESE: memories are texts, and two texts mentioning the same server stay unconnected until that server exists as its own node. Create an entity when a name recurs across memories or when you are about to link something that has no node yet, then connect it with knowmind_link. Same name, same class and same tenant always return the same id, so calling twice creates no duplicate. Give the entity its plain proper name ("PostgreSQL", not "the database we use"), and pick the class from the catalogue in knowmind_schema. Requires write scope.
Inputs: name (required), entity_class (required), aliases, description.
knowmind_get_healthARead-onlyIdempotent
Return the health of the knowmind backend (Postgres, memory service, graph). Use before a batch of writes or when calls fail, to tell an outage apart from an empty result. Returns a status object per component. Read scope suffices; takes no parameters.
Inputs: no named parameters.
knowmind_get_schemaARead-onlyIdempotent
Return the relation catalogue of this tenant's knowledge graph: every allowed edge type with its subject and object classes and an explanation of when to use it. Call this before building edges with knowmind_link, so you pick the right predicate instead of the nearest-sounding one. Read scope suffices.
Inputs: no named parameters.
knowmind_get_statsARead-onlyIdempotent
Return current counts for the tenant corpus: memories, graph edges and vector chunks. Use to gauge how much has been stored; for the actual entries use knowmind_list_recent or knowmind_recall. Read scope suffices; takes no parameters.
Inputs: no named parameters.
knowmind_healthARead-onlyIdempotent
DEPRECATED, removed on 2027-03-31: use knowmind_get_health. This name keeps answering unchanged until then. Return the health of the knowmind backend (Postgres, memory service, graph). Use before a batch of writes or when calls fail, to tell an outage apart from an empty result. Returns a status object per component. Read scope suffices; takes no parameters.
Inputs: no named parameters.
knowmind_linkAIdempotent
DEPRECATED, removed on 2027-03-31: use knowmind_link_entities. This name keeps answering unchanged until then. Create a typed relation between two memory nodes (a knowledge-graph edge). THIS IS HOW THE GRAPH IS BUILT: after storing memories, connect them - a corpus without edges answers only what a single note already says. The server checks the edge against the ontology's shapes before writing it: the subject and object must belong to the classes the predicate requires (for entries without a class the check only warns), entity names must carry no role or suffix, and the edge must name its evidence - the id of the entry that states the relation. A rejected edge returns the violated rule. The inverse edge is materialized automatically, and derived edges (RUNS_ON, WORKS_FOR_CLIENT, HOST_SERVES_CLIENT, DEPENDS_ON_SUPPLIER) are computed by the server - never set them by hand. Get both node IDs via knowmind_recall first, and call knowmind_schema for the full catalogue with explanations. Allowed rel_type values: ABOUT (Contract|Document|FileResource → Topic), ASSIGNED_TO (ActionRecord|Task → Agent|Organization|Person|SoftwareAgent), CLIENT_OF (Agent|Organization|Person|SoftwareAgent → Organization), CONTACT_PERSON_FOR (Person → Organization), COVERED_BY (Topic → Contract|Document|FileResource), DELIVERED_AS (Application → Product), DELIVERED_BY (Product → Application), DEPENDS_ON (Application → Application), DEPLOYED_TO (Application → Container), DEVELOPED_BY (Application → Agent|Organization|Person|SoftwareAgent), DEVELOPS (Agent|Organization|Person|SoftwareAgent → Application), ENABLES (Application → Application), FOR_CLIENT (Project → Agent|Organization|Person|SoftwareAgent), HAS_ASSIGNED_TASK (Agent|Organization|Person|SoftwareAgent → ActionRecord|Task), HAS_CHILD (Person → Person), HAS_CLIENT (Organization → Agent|Organization|Person|SoftwareAgent), HAS_CONTACT_PERSON (Organization → Person), HAS_EMPLOYEE (Organization → Person), HAS_OPERATED_APPLICATION (Agent|Organization|Person|SoftwareAgent → Application), HAS_PARENT (Person → Person), HAS_PREDECESSOR (ActionRecord|Project|Task → ActionRecord|Project|Task), HAS_PROJECT (Agent|Organization|Person|SoftwareAgent → Project), HAS_ROLE (Person → Role), HAS_SIBLING (Person → Person), HAS_SKILL (Agent|Organization|Person|SoftwareAgent → Skill), HAS_SUCCESSOR (ActionRecord|Project|Task → ActionRecord|Project|Task), HOSTED_ON (Container → Host), HOSTS (Host → Container), HOSTS_APPLICATION (Container → Application), INFRASTRUCTURE_PROVIDED_BY (Host → Organization), INTEGRATES_WITH (Application → Application), IS_LED_BY (Organization → Person), KNOWS (Person → Person), LEADS (Person → Organization), OPERATED_FOR (Application → Agent|Organization|Person|SoftwareAgent), PAID_BY (Agent|Organization|Person|SoftwareAgent → Agent|Organization|Person|SoftwareAgent), PARTNER_OF (Organization → Organization), PAYS (Agent|Organization|Person|SoftwareAgent → Agent|Organization|Person|SoftwareAgent), PRODUCED_BY (Contract|Document|FileResource → Project), PRODUCES (Project → Contract|Document|FileResource), PROVIDES_INFRASTRUCTURE (Organization → Host), ROLE_OF (Role → Person), SERVED_UNDER (Application → Domain), SERVES (Domain → Application), SKILL_OF (Skill → Agent|Organization|Person|SoftwareAgent), SPOUSE_OF (Person → Person), SUPPLIED_BY (Agent|Organization|Person|SoftwareAgent → Organization), SUPPLIES (Organization → Agent|Organization|Person|SoftwareAgent), SUPPLIES_TECHNOLOGY (Organization → Technology), SUPPORTED_BY (Contract|Document|FileResource → Contract|Document|FileResource), SUPPORTS (Contract|Document|FileResource → Contract|Document|FileResource), TECHNOLOGY_SUPPLIED_BY (Technology → Organization), TECHNOLOGY_USED_BY (Technology → Application), USES_TECHNOLOGY (Application → Technology), WORKED_ON_BY (Project → Agent|Organization|Person|SoftwareAgent), WORKS_FOR (Person → Organization), WORKS_ON (Agent|Organization|Person|SoftwareAgent → Project). Requires write scope.
Inputs: to_id (required), from_id (required), evidence (required), rel_type (required), +1 more.
knowmind_link_entitiesAIdempotent
Create a typed relation between two memory nodes (a knowledge-graph edge). THIS IS HOW THE GRAPH IS BUILT: after storing memories, connect them - a corpus without edges answers only what a single note already says. The server checks the edge against the ontology's shapes before writing it: the subject and object must belong to the classes the predicate requires (for entries without a class the check only warns), entity names must carry no role or suffix, and the edge must name its evidence - the id of the entry that states the relation. A rejected edge returns the violated rule. The inverse edge is materialized automatically, and derived edges (RUNS_ON, WORKS_FOR_CLIENT, HOST_SERVES_CLIENT, DEPENDS_ON_SUPPLIER) are computed by the server - never set them by hand. Get both node IDs via knowmind_recall first, and call knowmind_schema for the full catalogue with explanations. Allowed rel_type values: ABOUT (Contract|Document|FileResource → Topic), ASSIGNED_TO (ActionRecord|Task → Agent|Organization|Person|SoftwareAgent), CLIENT_OF (Agent|Organization|Person|SoftwareAgent → Organization), CONTACT_PERSON_FOR (Person → Organization), COVERED_BY (Topic → Contract|Document|FileResource), DELIVERED_AS (Application → Product), DELIVERED_BY (Product → Application), DEPENDS_ON (Application → Application), DEPLOYED_TO (Application → Container), DEVELOPED_BY (Application → Agent|Organization|Person|SoftwareAgent), DEVELOPS (Agent|Organization|Person|SoftwareAgent → Application), ENABLES (Application → Application), FOR_CLIENT (Project → Agent|Organization|Person|SoftwareAgent), HAS_ASSIGNED_TASK (Agent|Organization|Person|SoftwareAgent → ActionRecord|Task), HAS_CHILD (Person → Person), HAS_CLIENT (Organization → Agent|Organization|Person|SoftwareAgent), HAS_CONTACT_PERSON (Organization → Person), HAS_EMPLOYEE (Organization → Person), HAS_OPERATED_APPLICATION (Agent|Organization|Person|SoftwareAgent → Application), HAS_PARENT (Person → Person), HAS_PREDECESSOR (ActionRecord|Project|Task → ActionRecord|Project|Task), HAS_PROJECT (Agent|Organization|Person|SoftwareAgent → Project), HAS_ROLE (Person → Role), HAS_SIBLING (Person → Person), HAS_SKILL (Agent|Organization|Person|SoftwareAgent → Skill), HAS_SUCCESSOR (ActionRecord|Project|Task → ActionRecord|Project|Task), HOSTED_ON (Container → Host), HOSTS (Host → Container), HOSTS_APPLICATION (Container → Application), INFRASTRUCTURE_PROVIDED_BY (Host → Organization), INTEGRATES_WITH (Application → Application), IS_LED_BY (Organization → Person), KNOWS (Person → Person), LEADS (Person → Organization), OPERATED_FOR (Application → Agent|Organization|Person|SoftwareAgent), PAID_BY (Agent|Organization|Person|SoftwareAgent → Agent|Organization|Person|SoftwareAgent), PARTNER_OF (Organization → Organization), PAYS (Agent|Organization|Person|SoftwareAgent → Agent|Organization|Person|SoftwareAgent), PRODUCED_BY (Contract|Document|FileResource → Project), PRODUCES (Project → Contract|Document|FileResource), PROVIDES_INFRASTRUCTURE (Organization → Host), ROLE_OF (Role → Person), SERVED_UNDER (Application → Domain), SERVES (Domain → Application), SKILL_OF (Skill → Agent|Organization|Person|SoftwareAgent), SPOUSE_OF (Person → Person), SUPPLIED_BY (Agent|Organization|Person|SoftwareAgent → Organization), SUPPLIES (Organization → Agent|Organization|Person|SoftwareAgent), SUPPLIES_TECHNOLOGY (Organization → Technology), SUPPORTED_BY (Contract|Document|FileResource → Contract|Document|FileResource), SUPPORTS (Contract|Document|FileResource → Contract|Document|FileResource), TECHNOLOGY_SUPPLIED_BY (Technology → Organization), TECHNOLOGY_USED_BY (Technology → Application), USES_TECHNOLOGY (Application → Technology), WORKED_ON_BY (Project → Agent|Organization|Person|SoftwareAgent), WORKS_FOR (Person → Organization), WORKS_ON (Agent|Organization|Person|SoftwareAgent → Project). Requires write scope.
Inputs: to_id (required), from_id (required), evidence (required), rel_type (required), +1 more.
knowmind_list_inferredARead-onlyIdempotent
List relations that wait for a human decision, each with its review state (open, confirmed, rejected) and its reason: inferred_from_text (knowmind inferred it from a text) or starts_from_document (it starts from a document although its kind needs a person, organisation or similar). Per relation also the two connected entries, where it came from (source), the entry that supports it (evidence), and the counts per state. Open relations do not feed the derivation rules until someone confirms them. Use to review what the graph learned on its own; record a decision with knowmind_review_inferred. Read scope suffices.
Inputs: limit, offset, status.
knowmind_list_recentARead-onlyIdempotent
List the most recently created documents/memories in the tenant corpus, newest first (by created_at). Same corpus that recall searches. Use to review what was just stored or confirm a write landed; use knowmind_recall when you already know what you are looking for. Graph-only entities without a timestamp do not appear, so this count intentionally differs from stats.memories. Read scope suffices.
Inputs: k.
knowmind_list_relationsARead-onlyIdempotent
List all relations of one memory (incoming and outgoing), each with its edge type and the connected node. Use to inspect how an entity is connected before adding or removing edges with knowmind_link/knowmind_unlink; find the memory_id first via knowmind_recall. Read scope suffices.
Inputs: memory_id (required).
knowmind_recallARead-onlyIdempotent
DEPRECATED, removed on 2027-03-31: use knowmind_recall_memories. This name keeps answering unchanged until then. Retrieve relevant knowledge before answering anything that benefits from prior context - decisions, preferences, project state, people, deadlines, past conversations. Hybrid recall (BM25 + pgvector + knowledge graph) over the tenant corpus; returns the top-k memory chunks, each with a relevance score and source reference. Suitable whenever earlier context would improve the answer; use knowmind_recall_at_time when you need what was valid at a past point in time. Passages from pages in Open Knowledge Format carry metadata.review_flags: stale once stale_after is reached, unverified when no verification is recorded, superseded when the page's status is deprecated or superseded or its valid_to is reached, drifted when code cited by the page's claims changed or was removed since the page was written; an empty list means none applies. When kein_belastbarer_treffer is true, the corpus most likely holds no answer; unless the hits clearly answer the question, say so. Read scope suffices.
Inputs: query (required), k, hops.
knowmind_recall_at_timeARead-onlyIdempotent
Time-travel recall: return only memories that were valid at a given instant (valid_from <= as_of <= valid_to, or still open). Answers 'what did the agent know on March 14?'. Use instead of knowmind_recall when the point in time matters; otherwise use knowmind_recall for the current truth. Passages from pages in Open Knowledge Format carry metadata.review_flags (stale, unverified, superseded, drifted); stale and superseded are judged against as_of. When kein_belastbarer_treffer is true, the corpus as of as_of most likely holds no answer; it is judged on the hits visible at as_of. Unless they clearly answer the question, say so. Read scope suffices.
Inputs: query (required), k, as_of.
knowmind_recall_memoriesARead-onlyIdempotent
Retrieve relevant knowledge before answering anything that benefits from prior context - decisions, preferences, project state, people, deadlines, past conversations. Hybrid recall (BM25 + pgvector + knowledge graph) over the tenant corpus; returns the top-k memory chunks, each with a relevance score and source reference. Suitable whenever earlier context would improve the answer; use knowmind_recall_at_time when you need what was valid at a past point in time. Passages from pages in Open Knowledge Format carry metadata.review_flags: stale once stale_after is reached, unverified when no verification is recorded, superseded when the page's status is deprecated or superseded or its valid_to is reached, drifted when code cited by the page's claims changed or was removed since the page was written; an empty list means none applies. When kein_belastbarer_treffer is true, the corpus most likely holds no answer; unless the hits clearly answer the question, say so. Read scope suffices.
Inputs: query (required), k, hops.
knowmind_review_inferredA
Record a human decision on one inferred relation from knowmind_list_inferred. confirm: the relation counts as checked and feeds the derivation rules from now on. reject: the relation, its reverse relation and every relation derived from it get valid_to=now; nothing is deleted. undo: takes a rejection back and restores the reverse and derived relations. Pass the edge_id from the list and, if there is one, the id of the entry that supports the decision as evidence. Returns the state before and after and the number of reverse and derived relations affected. Requires write scope.
Inputs: edge_id (required), decision (required), evidence.
knowmind_schemaARead-onlyIdempotent
DEPRECATED, removed on 2027-03-31: use knowmind_get_schema. This name keeps answering unchanged until then. Return the relation catalogue of this tenant's knowledge graph: every allowed edge type with its subject and object classes and an explanation of when to use it. Call this before building edges with knowmind_link, so you pick the right predicate instead of the nearest-sounding one. Read scope suffices.
Inputs: no named parameters.
knowmind_statsARead-onlyIdempotent
DEPRECATED, removed on 2027-03-31: use knowmind_get_stats. This name keeps answering unchanged until then. Return current counts for the tenant corpus: memories, graph edges and vector chunks. Use to gauge how much has been stored; for the actual entries use knowmind_list_recent or knowmind_recall. Read scope suffices; takes no parameters.
Inputs: no named parameters.
knowmind_store_memoryA
Store durable insights the moment they arise - decisions, preferences, facts, results, appointments. Persists one memory entry in the tenant corpus (Postgres + vector index + graph node), afterwards findable via knowmind_recall and knowmind_list_recent. Always creates a new entry; an earlier entry with the same title stays valid, because titles do not identify entries here (to supersede, use knowmind_update_fact, or knowmind_upload_document, which replaces by title); sha-identical content is detected as idempotent (unchanged). Returns the new memory id. Use for a single short fact; for long or multi-fact text use knowmind_upload_document. GIVE THE EDGES ALONG: whatever the text says about people, organisations, projects, hosts or technologies belongs into relations in THIS call - name the counterpart, the server creates its node and the edge, no second call needed. A memory without edges is a note; with edges it becomes a graph that answers questions nobody wrote down. Use knowmind_link separately only to connect two entries that already exist. ENTRIES ARE NEVER HARD-DELETED, they are superseded: correct a fact with knowmind_update_fact, remove an edge with knowmind_unlink_entities. Both keep the history auditable, which is the point of this store - what was true when, and when that changed. Requires write scope.
Inputs: content (required), tags, title, domain, +3 more.
knowmind_unlinkADestructiveIdempotent
DEPRECATED, removed on 2027-03-31: use knowmind_unlink_entities. This name keeps answering unchanged until then. End a relation between two memories; inverse and inferred edges end with it. It stays in history, where knowmind_recall_at_time finds it. Repeating it does nothing. Fixes a wrong knowmind_link. Requires write scope.
Inputs: to_id (required), from_id (required), rel_type (required).
knowmind_unlink_entitiesADestructiveIdempotent
End a relation between two memories; inverse and inferred edges end with it. It stays in history, where knowmind_recall_at_time finds it. Repeating it does nothing. Fixes a wrong knowmind_link. Requires write scope.
Inputs: to_id (required), from_id (required), rel_type (required).
knowmind_update_factA
Supersede a known fact without losing history: the existing memory gets valid_to=now, a new memory with valid_from=now is created and linked via SUPERSEDES. Use this instead of knowmind_store_memory when a fact CHANGES (address moved, contract renewed) - old statements are marked outdated, not deleted, so the timeline stays auditable and queryable via knowmind_recall_at_time. Returns the new memory id. Requires write scope.
Inputs: new_title (required), target_id (required), new_content (required), update_reason.
knowmind_upload_documentADestructive
Ingest a longer text as one document into the tenant corpus: chunk splitting, embeddings, vector chunks and graph nodes. Upsert-by-title (server default): if a valid document with the same title exists in the same domain, the new version supersedes it; the old version stays retrievable via knowmind_recall_at_time, and the superseded ids come back in replaced_document_ids. If the same text already exists in another valid document of the same domain, no new document is created and the response carries deduplicated. Use for long-form or multi-fact content (a report, a page, a doc); for a single short fact use knowmind_store_memory. Returns the document id and the number of chunks written. AFTER INGESTING: extract the facts the text states about people, organisations, projects, products, technologies and hosts, and create the corresponding edges via knowmind_link. Requires write scope.
Inputs: content (required), title, source, replace, +1 more.
knowmind_upsert_entityAIdempotent
Create the node for a thing the corpus talks about - a person, an organisation, an application, a host, a technology - or return the existing one. THE GRAPH NEEDS THESE: memories are texts, and two texts mentioning the same server stay unconnected until that server exists as its own node. Create an entity when a name recurs across memories or when you are about to link something that has no node yet, then connect it with knowmind_link. Same name, same class and same tenant always return the same id, so calling twice creates no duplicate. Give the entity its plain proper name ("PostgreSQL", not "the database we use"), and pick the class from the catalogue in knowmind_schema. Requires write scope.
Inputs: name (required), entity_class (required), aliases, description.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 23 tools
The functional tools are carefully delineated (recall vs recall_at_time, store_memory vs upload_document, update_fact vs end_fact vs unlink_entities all have explicit 'use X instead of Y' guidance). However, seven tools are exact duplicate aliases (health, recall, stats, entity, link, schema, unlink) that shadow their replacements, so an agent must disambiguate between two identically-described tools on nearly every call.
The active surface follows a clean knowmind_verb_noun snake_case pattern (get_health, store_memory, link_entities, recall_at_time). The deprecated aliases break that convention with bare single-word names (health, entity, link, schema, unlink, stats, recall), leaving two naming styles side by side. Readable, but not the single predictable pattern a 5 requires.
23 tools is at the heavy end, and 7 of them are deprecated duplicates retained for a year, so the effective surface is ~16 with 7 legacy clones inflating the count. The functional set is reasonably scoped for a memory/graph store, but the aliases make it feel bloated.
Coverage is strong: write (store, upload, update, end), graph build (upsert entity, link, unlink), review lifecycle (list_inferred, review_inferred), and read (recall, recall_at_time, list_recent, list_relations, stats, health, schema). Minor gaps exist — no direct get-by-id for a single memory or entity, and no way to look up an entity by name other than the idempotent upsert — but these are workable.
Maintenance
Related MCP Connectors
Team memory for AI agents: shared notes, reviewed proposals, knowledge gaps. Hosted in Germany.
Persistent memory for AI agents. EU-hosted, privacy-first, hybrid recall, contradiction detection.
Persistent business-intelligence memory for AI agents.
Memory for AI agents that knows what is still true. Typed bi-temporal facts, EU-hosted.
Related MCP Servers
- FlicenseNot gradedqualityCmaintenanceLong-term Memory for AI. On Device. Secure. Coding tools, AI Agents. Instant Recall. Precise.-
- AlicenseAqualityDmaintenanceEnables AI agents with persistent semantic memory, including semantic recall, knowledge graphs, and instant domain expertise via pre-built Intelligence Packs.1052 npmMIT
- AlicenseNot gradedqualityBmaintenancePrivacy Agent Memory with best performance and security38MIT
- AlicenseAqualityAmaintenancePersistent AI agents memory for Claude, Codex, Cursor... that is always current.29227 npm111Apache 2.0