Skip to main content
Glama

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.

npm · knowmind.de

Connect your AI tool in three steps

  1. Create a free account at knowmind.de and generate an access token: Dashboard → API tokens.

  2. Store the token locally:

npx -y knowmind login --token kmt_xxxxxxxx
  1. Wire up your client:

Claude Code (one command)

claude mcp add knowmind --env KNOWMIND_TOKEN=kmt_xxx -- npx -y knowmind mcp

Cursor (~/.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 data

Knowledge 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_recall

knowmind_recall_memories

knowmind_health

knowmind_get_health

knowmind_stats

knowmind_get_stats

knowmind_schema

knowmind_get_schema

knowmind_entity

knowmind_upsert_entity

knowmind_link

knowmind_link_entities

knowmind_unlink

knowmind_unlink_entities

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.

Documentation · Pricing · Data processing agreement · Privacy


Die deutsche Fassung steht in README.de.md.

Available Tools

23 tools
knowmind_end_factA
Idempotent

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_entityA
Idempotent

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_healthA
Read-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_schemaA
Read-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_statsA
Read-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_healthA
Read-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_list_inferredA
Read-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_recentA
Read-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_relationsA
Read-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_recallA
Read-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_timeA
Read-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_memoriesA
Read-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_schemaA
Read-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_statsA
Read-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_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_documentA
Destructive

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_entityA
Idempotent

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

    A4.1/5.0

    Scored across 23 tools

    Disambiguation3/5

    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.

    Naming Consistency3/5

    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.

    Tool Count3/5

    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.

    Completeness4/5

    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

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers