Engram

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 未标注 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

自托管MCP服务器,为AI代理提供持久记忆——Markdown作为事实来源,混合BM25+嵌入搜索,类型化图关系。

一句话选型结论

按资料字段整理

Engram 属于文档知识类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式stdio · 本地进程 鉴权未标注 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
claude mcp add --transport stdio inkwell -- \ docker run -i --rm -v ./knowledge:/knowledge foreigndmitryi/inkwell-memory

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Engram当前 未标注 stdio · 本地进程 本地部署 有 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

25.3 KB
来自项目仓库与上游目录的原文,未做删改

Inkwell — Persistent Knowledge Base MCP Server

Inkwell is a self-hosted Model Context Protocol server that gives AI agents persistent memory across sessions and projects. Three things set it apart from the other memory servers: plain Markdown files are the source of truth (the index is a throwaway cache you can delete and rebuild), entries are connected by a typed kb:// graph rather than dumped into a flat pile, and updates are bi-temporal — superseding a fact keeps the old version readable instead of overwriting it.

Docker Hub: foreigndmitryi/inkwell-memory · Website: veronchenko.github.io/inkwell-memory

> Formerly Engram. Renamed in 0.14.0 — there are a dozen unrelated projects called "Engram" and the name had stopped being findable. Not affiliated with any of them, nor with the Engram keyboard layout. See the changelog for what the rename breaks.

Table of Contents

  • Concept
  • Features
  • Comparison
  • Measured Against a Plain Markdown Wiki
  • Design Patterns
  • Architecture
  • Quick Start
  • Search
  • Tools
  • Dashboard
  • Graph Relations
  • Usage Examples
  • Prompt Your Agent
  • Configuration
  • Storage Format
  • Development
  • License

Concept

Agent conversations end and take their context with them. Inkwell is the piece that survives: a knowledge base an agent searches before acting and writes to after resolving something non-obvious, so the next session — same project or a different one — starts with what was already learned instead of re-deriving it.

It deliberately stores zero discoverable information. If a fact can be pulled from code, git history, config files, or existing docs, it does not belong in Inkwell — that's what greps and re-reads are for. What belongs is the kind of knowledge a conversation would otherwise lose: a decision and the alternatives it ruled out, a bug's root cause and fix, a procedure learned the hard way, a preference stated once that should hold from then on.

Two things keep the base usable as it grows:
- Atomicity — one entry, one fact. remember warns (non-blocking) on Markdown headers, more than 3 paragraphs, or content past 512 B/1 KB, pushing multi-fact dumps back into separate linked entries instead of a wall of text no search will rank well.
- The graph, not a pile — entries link to each other via kb://uuid#type references, so related facts (a hub project, its features, a diagnostic tied to one of them) stay navigable both ways instead of living as isolated rows.

Features

  • Hybrid search — SQLite FTS5 (BM25, Porter stemming) fused with cosine similarity over local Model2Vec embeddings and an IDF-weighted exact-match channel over title/tags via Reciprocal Rank Fusion; finds entries by meaning or by a literal proper noun BM25/embeddings alone would dilute among lexically-similar distractors, with zero cloud dependency
  • Typed graph relations — kb://uuid#type links between entries, resolved both directions (outgoing + backlinks) on every recall, with an optional second hop (hops=2) to see how two entries connect through an intermediate one
  • Schema-enforced entry types — hub, decision, diagnostic, feature, procedure, integration, pattern, snippet, preference, idea — declared in schema.json and exposed to the client as an enum, so an invalid type can't be written; filterable on search/list
  • doctor integrity pass — one schema-driven check over the Markdown files for dangling and superseded links, undeclared types, missing template fields, supernodes, and tag/type collisions
  • part_of structural membership — links a detail entry (decision, diagnostic, feature, procedure, integration, ...) to its hub, enforced per type by the schema; filterable on search/list, grouped alongside kb:// back-links in a hub's recall digest
  • Bi-temporal versioning — remember(..., supersede=True) creates a new version instead of overwriting; old versions stay in history (include_superseded=True) instead of being lost
  • Duplicate detection & link suggestions — remember matches near-identical titles to avoid duplicate entries, and returns suggested_links (embedding-similarity matches) so related facts get cross-referenced instead of orphaned
  • Atomicity guardrails — non-blocking warnings on structural anti-patterns (headers, >3 paragraphs, oversized content) so the base stays one-fact-per-entry as it scales
  • Web dashboard — force-directed graph view, hybrid search, and a CRUD panel over the same knowledge base the MCP tools use (see Dashboard)
  • Three transports — stdio (agent-managed), SSE, streamable-http — so the same server works for a single local agent or a shared multi-agent deployment
  • Markdown as source of truth — the SQLite index is a rebuildable cache; delete it and rebuild, no data is ever lost

Comparison

Inkwell Mem0 Zep / Graphiti LangMem
Source of truth Markdown files on disk Vector DB / managed API Temporal knowledge graph Vector store (LangChain-backed)
Search BM25 + local Model2Vec embeddings (RRF fusion) Vector similarity Graph traversal + embeddings Vector similarity
Relations Explicit kb://uuid#type links, agent-authored Implicit (LLM-extracted facts) Auto-extracted temporal graph edges None built-in
Temporal model Bi-temporal valid_at/supersede on write Fact overwrite Native temporal graph (bi-temporal edges) None built-in
Deployment Self-hosted, single Docker image, no cloud dependency Hosted API or self-hosted + vector DB Self-hosted, needs Neo4j Library, no server
Design center Deliberately minimal — zero discoverable info, agent decides what's worth keeping Automatic fact extraction from conversations Automatic entity/relationship extraction Composable memory primitives for LangGraph agents

Inkwell trades automatic extraction (Mem0, Zep) for an agent-curated, atomic, explicitly-linked knowledge base — no LLM-driven ingestion pipeline, no graph database dependency, and the on-disk Markdown stays human-readable and diffable.

Measured Against a Plain Markdown Wiki

Inkwell was benchmarked against the same knowledge base packaged as an ordinary Markdown wiki — one file per topic, organized in folders by project and category (decision, diagnostic, feature, procedure, ...), each project with an index page and cross-links between related pages, browsed with Read/Grep/Glob/Bash. Same content, two ways of finding it — for equivalent fact coverage, Inkwell's search/recall used:

Inkwell Wiki Improvement
Tool calls 104 186 -44%
Total tokens 3.87M 5.91M -35%
Cost $1.31 $1.62 -19%
Wall time (sum) 577s 760s -24%
Fact rate 1.000 0.964 +3.7%

32 questions (single-hop, multi-hop, negative, cross-lingual, supersede) over 5,070 entries — 70 curated facts across 4 fictional projects plus 5,000 real-text distractor entries, so retrieval has to work at a scale that doesn't fit in an agent's context:```
wiki/
├── Ledgerbird/ )
├── Pipewren/ ) 4 curated projects — 70 real
├── Snipfox/ ) decisions/diagnostics/features/
├── Featherstore/ ) procedures/integrations/snippets
│ ├── README.md <- project index page, links to every entry below
│ ├── decision/
│ │ ├── offline-engine-duckdb-over-spark.md
│ │ ├── online-value-serialization-msgpack.md
│ │ └── ... (2 more)
│ ├── diagnostic/
│ │ ├── redis-memory-doubling-from-ttl-less-deprecated-feature-groups.md
│ │ └── training-serving-skew-from-tz-naive-event-timestamps.md
│ ├── feature/ (4 entries)
│ ├── integration/ (2 entries)
│ ├── procedure/ (1 entry)
│ └── snippet/ (1 entry)
├── _shared/ cross-project patterns & preferences
└── haystack-project-00000.../00199/ 200 distractor projects x 25 pages
│ = 5,000 real-text (Wikipedia) pages
├── README.md <- same index-page shape as a real project
├── decision/ (2 entries)
├── feature/ (3 entries)
├── idea/ (7 entries)
├── pattern/ (4 entries)
├── procedure/ (1 entry)
└── snippet/ (2 entries)


Every category folder is a flat list of one-file-per-entry, and every project folder (real or distractor) has its own `README.md` index page linking to all of them — structurally identical, so the wiki arm can&#x27;t tell curated fact from distractor by shape alone.

An agent that already knows *where* to look doesn&#x27;t need to `grep`, re-read, and re-`grep` its way there — the efficiency edge holds for equivalent fact coverage. Retrieval ranking has also been improving: adding an IDF-weighted exact-match channel (below) moved MRR from 0.851 to 0.857 and recall@5 from 0.851 to 0.869, with no regression across any language.

## Design Patterns

- **Reciprocal Rank Fusion** — BM25 and embedding rankings are computed independently and merged by rank position rather than raw score, avoiding the need to normalize incomparable similarity metrics.
- **Rebuildable cache over source of truth** — the SQLite index is fully derived from the Markdown files (`rebuild` regenerates it from scratch); the database is never the only copy of a fact.
- **Bi-temporal versioning** — `supersede` writes a new entry and points the old one at it via `superseded_by`, instead of overwriting in place, so history stays queryable (`include_superseded`).
- **HATEOAS-style graph traversal** — every `recall` response carries its own outgoing/incoming `kb://` links, so navigating the knowledge graph doesn&#x27;t require a separate query per hop.
- **Shared domain layer, two transports** — the dashboard&#x27;s REST API and the MCP tools both call the same `KnowledgeBase`/`SQLiteBackend` methods, so there is exactly one code path for writes regardless of which surface triggered them.

## Architecture```
Markdown files  ---&gt;  Search index  ---&gt;  MCP  ---&gt;  Agent
(source of truth)     (SQLite FTS5 +      (server.py)  (Claude Code,
                        Model2Vec,                       ChatGPT, ...)
                        rebuildable cache)

Markdown files in /entries/ are the only source of truth. The SQLite index (search_backend.py) is a disposable cache built from them — BM25 + Model2Vec embeddings fused via Reciprocal Rank Fusion, plus the kb:// relation graph — and can always be regenerated with rebuild. server.py exposes that index to an agent as MCP tools (remember/recall/search/...); the dashboard is an alternate entry point at the same layer, hitting the same KnowledgeBase/index directly over REST instead of MCP, so remember/delete behave identically whether called by an agent or edited by hand in the browser.

  • src/server.py — MCP tool definitions (remember, recall, search, list, tags, forget, rebuild, doctor), one process, stdio/SSE/streamable-http transport
  • src/database.py — KnowledgeBase: Markdown + YAML frontmatter CRUD, UUID assignment, duplicate detection, bi-temporal supersede logic
  • src/schema.json + src/schema.py — the entry taxonomy and its per-type rules as data, plus the loader that turns them into the entry_type enum the MCP client validates against
  • src/doctor.py — the schema-driven integrity pass shared by the doctor tool, rebuild's warnings, and remember's conformance check
  • src/search_backend.py — SQLiteBackend: BM25 (FTS5) fused with Model2Vec cosine similarity via Reciprocal Rank Fusion, plus kb:// relation extraction/graph traversal; embeddings are computed lazily on write and stored as a BLOB column
  • src/dashboard/ — a second, optional process (app.py FastAPI REST + /api/graph, static/index.html vanilla-JS canvas graph, __main__.py its own uvicorn entry point) reusing the same KnowledgeBase
  • plugins/inkwell-hooks/ — a self-contained plugin installable in both Claude Code and Codex (.claude-plugin/plugin.json, SessionStart/SessionEnd + a PreToolUse search-before-remember gate, plus a Claude-Code-only inkwell-project-onboarder agent) that mechanically enforces the search-first, remember-after workflow instead of relying on a system prompt alone; listed as inkwell-hooks in both the repo-root .claude-plugin/marketplace.json (Claude Code) and plugins/marketplace.json (Codex)

In Docker, the MCP server and the dashboard run as two processes in one container (docker-entrypoint.sh), sharing the same /knowledge volume; the container exits if either process dies.

Quick Start

stdio

Your agent manages the server. Recommended for Claude Code, ChatGPT Desktop, Cursor.```bash
claude mcp add --transport stdio inkwell -- \
docker run -i --rm -v ./knowledge:/knowledge foreigndmitryi/inkwell-memory


### SSE

Persistent server on the network. Share knowledge across multiple agents.```bash
docker run -d --name inkwell \
  -p 8192 \
  -v ./knowledge:/knowledge \
  foreigndmitryi/inkwell-memory --transport sse

docker port inkwell 8192   # host port Docker assigned
claude mcp add --transport sse inkwell http://your-host:&lt;port&gt;/sse

-p 8192 (host port omitted) has Docker pick a free ephemeral host port
instead of failing when a fixed port like 8192 is already taken by
another container — check the actual assignment with docker port.
Use -p 8192:8192 instead if you need the host port to stay fixed.

HTTP

Stateless, load-balanceable.```bash
docker run -d --name inkwell \
-p 8192 \
-v ./knowledge:/knowledge \
foreigndmitryi/inkwell-memory --transport streamable-http

docker port inkwell 8192 # host port Docker assigned
claude mcp add --transport http inkwell http://your-host:<port>/mcp


### Multi-tenant

One server, several teams, each isolated to its own data folder and API key. Set `INKWELL_MULTI_TENANT=1` (requires `INKWELL_PUBLIC_URL` and `INKWELL_ADMIN_API_KEY`, and a network transport — never stdio); `src/app.py` then serves MCP, the admin UI, and the dashboard from one process. Provision a team with `inkwell add-team ` (run via `docker exec`, see `src/cli.py`) to get back its API key, then point each team&#x27;s agent at `/mcp` with that key as a bearer token:```bash
claude mcp add --transport http inkwell https://your-host/mcp \
  --header &quot;Authorization: Bearer &lt;TEAM_API_KEY&gt;&quot;

Or as a raw mcpServers config (Claude Desktop and other clients):```json
{
"mcpServers": {
"inkwell": {
"type": "http",
"url": "https://your-host/mcp",
"headers": {
"Authorization": "Bearer <TEAM_API_KEY>"
}
}
}
}


`TeamTokenVerifier` (`src/server.py`) hashes the token and looks it up in `admin.db` on every request — no caching, so a revoked key stops working immediately.

## Search

Hybrid: SQLite FTS5 (Porter stemming, BM25) fused with cosine similarity over local Model2Vec embeddings (`minishlab/potion-multilingual-128M`, no cloud dependency) via Reciprocal Rank Fusion — so a query that shares no literal words with an entry can still find it by meaning. Falls back to keyword-only if the embedding model can&#x27;t load. The index is still a single SQLite file you can query with standard SQL tools.

## Tools

| Tool | Description | Key Parameters |
|------|-------------|----------------|
| `remember` | Create or update an entry (upsert with duplicate detection, or version it via `supersede`). `entry_type` is required, and `part_of` (hub UUIDs) is required/optional/rejected per type per the schema&#x27;s `membership` rule. Returns `size`, non-blocking atomicity `warnings` (Markdown headers, &gt;3 paragraphs, &gt;512 B / &gt;1 KB), and `suggested_links` — near-duplicate/related entries (by embedding similarity) worth cross-referencing with a `kb://` link. | `title`, `content`, `tags`, `entry_type`, `entry_id`, `force`, `resource`, `supersede`, `part_of` |
| `recall` | Read an entry with its graph relations (outgoing + backlinks). Returns `size` and `last_modified`. High-degree types (hubs) return `in_digest` — back-links grouped by linking type, plus members grouped by `part_of` — instead of an arbitrarily truncated list. | `entry_id`, `relations_limit` |
| `search` | Hybrid keyword + semantic search, filterable by tags, exact `entry_type`, and/or `part_of` | `query`, `tags`, `limit`, `include_superseded`, `entry_type`, `part_of` |
| `list` | Browse entries sorted by title, filterable by tags, exact `entry_type`, and/or `part_of` | `tags`, `limit`, `include_superseded`, `entry_type`, `part_of` |
| `tags` | List all tags with entry counts | — |
| `forget` | Delete an entry (file and index). Warns when other entries still link to it. | `entry_id` |
| `rebuild` | Rebuild search index from Markdown files; also runs `doctor` | — |
| `doctor` | Check every entry against `schema.json`: dangling/superseded `kb://` targets, undeclared types, missing required frontmatter and template body fields, supernodes, tag/type collisions | — |

### Entry schema

The entry taxonomy and its per-type rules live in `schema.json`, not in Python: which frontmatter fields a type requires, which template body fields it should carry, whether search may boost it by usage, and whether `recall` digests its back-links. `entry_type` is exposed to the MCP client as an enum built from that schema, so an undeclared type is rejected before the call reaches the server.

Resolution order, first found wins: `/schema.json`, then the packaged `src/schema.json`. A user file **replaces** the packaged one outright — the two are never merged, so copy the default and edit it. The schema is read once at startup, so editing it requires restarting the server. Entries written by hand can still carry an undeclared type; `doctor` reports those.

## Dashboard

A web UI for visually exploring and hand-editing the same knowledge base the MCP tools use — no protocol duplication, every action goes through `KnowledgeBase`.

- **Force-directed graph** of all entries and their `kb://` relations — click a node to inspect it, click a legend chip to filter by type (matches stay lit, others dim)
- **Hybrid search** over the same BM25 + semantic index as the `search` MCP tool, with tag and `entry_type` filters
- **CRUD panel** to create, edit, supersede, or delete entries without touching Markdown files by hand — outgoing/incoming graph relations shown alongside the fields
- Dark, dense, no-chrome interface — a maintenance tool, not a consumer app (see `PRODUCT.md`/`DESIGN.md`)

Disabled by default (the container only runs the MCP server). Enable it as a second process in the same container:```bash
docker run -d --name inkwell \
  -e INKWELL_ENABLE_DASHBOARD=1 \
  -p 8192 -p 8193 \
  -v ./knowledge:/knowledge \
  foreigndmitryi/inkwell-memory --transport sse

docker port inkwell 8193   # dashboard host port

Or run it standalone locally: python -m dashboard (see Configuration for INKWELL_DASHBOARD_HOST/INKWELL_DASHBOARD_PORT).

Graph Relations

Link entries with kb://uuid#type URLs in Markdown content:```markdown
This service runs on Saturn
and depends on PostgreSQL.


`recall` returns both directions, plus size metadata:```json
{
  &quot;id&quot;: &quot;a1b2c3d4-...&quot;,
  &quot;title&quot;: &quot;My API Service&quot;,
  &quot;content&quot;: &quot;...&quot;,
  &quot;tags&quot;: [&quot;...&quot;],
  &quot;size&quot;: 1024,
  &quot;last_modified&quot;: &quot;2026-03-14&quot;,
  &quot;relations&quot;: {
    &quot;out&quot;: [{&quot;type&quot;: &quot;runs-on&quot;, &quot;id&quot;: &quot;e5f6...&quot;, &quot;title&quot;: &quot;Saturn&quot;}],
    &quot;in&quot;: [{&quot;type&quot;: &quot;depends-on&quot;, &quot;id&quot;: &quot;b7c8...&quot;, &quot;title&quot;: &quot;Frontend App&quot;}]
  }
}

Like HATEOAS for knowledge — every response carries the links to navigate the graph.

Usage Examples

Store knowledge

Ask your agent:

> "Remember that our API runs on port 8080 and depends on PostgreSQL 15."

Inkwell creates a Markdown file with a unique UUID, indexes it, and confirms. The agent can now recall this fact in any future session.

Search

> "What do we know about PostgreSQL?"

Inkwell searches across all entries by content, title, and tags. Results are ranked by relevance.

Navigate the graph

> "What depends on PostgreSQL?"

If entries link to the PostgreSQL article with kb://uuid#depends-on, Inkwell returns all backlinks — showing every service that depends on it, without the agent having to search for each one.

Share knowledge across agents

Start Inkwell with SSE or HTTP transport. Multiple agents — even from different providers (Claude, ChatGPT, Copilot) — connect to the same server. What one agent remembers, all others can recall.```
Agent A: "Remember that the deploy key rotates every 90 days."
Agent B: "When does the deploy key expire?"
→ Agent B finds the answer immediately.


## Prompt Your Agent

Add this to your system prompt or project instructions to make your agent use Inkwell as a reflex, not an afterthought:```
Inkwell is your persistent memory. Using it is mandatory, not optional.

Inkwell stores ZERO discoverable information. If you can derive it from
code, git history, configuration files, or existing documentation, it
does not belong in Inkwell. Inkwell captures decisions and their context,
diagnostics and their root causes, procedures learned the hard way —
the kind of knowledge that is lost when a conversation ends.

Before working on any topic: search Inkwell first. Always. Even if you think you know.
Before answering a question about infrastructure or architecture: search first.
Before proposing a solution: check if a past decision exists in Inkwell.

After resolving a diagnostic: remember the root cause and the fix.
After executing a procedure: remember the steps.
After making an architecture decision: remember the choice and the rationale.
After discovering something about the infrastructure: remember it.

A system prompt is easy to forget mid-session. plugins/inkwell-hooks/ ships a self-contained plugin (SessionStart, SessionEnd, PreToolUse handlers, plus a Claude-Code-only inkwell-project-onboarder agent) that mechanically nudges the agent to search Inkwell before starting work and denies remember until a search or recall has run, instead of relying on it recalling this section unprompted. Works in both Claude Code and Codex — install with /plugin marketplace add then /plugin install inkwell-hooks@inkwell-memory (Claude Code), or codex plugin marketplace add /plugins then codex plugin add inkwell-hooks@inkwell-memory (Codex) — see plugins/inkwell-hooks/README.md for what each hook does and the full install flow.

Disable Claude Code's built-in auto memory

Claude Code ships its own automatic memory (MEMORY.md under ~/.claude/projects//memory/, loaded every session). Running it alongside Inkwell means two systems writing overlapping notes and competing for the agent's attention, which gets in the way more than it helps. Turn it off in settings.json:```json
{
"autoMemoryEnabled": false
}


Or via environment variable (takes precedence over the setting and the `/memory` toggle): `CLAUDE_CODE_DISABLE_AUTO_MEMORY=1`. See Claude Code&#x27;s memory docs for details.

## Configuration

All options have `INKWELL_*` environment variable fallbacks. CLI args take priority.

| Option | Env var | Default | Description |
|--------|---------|---------|-------------|
| `--data-path` | `INKWELL_DATA_PATH` | `/knowledge` | Root path for knowledge data |
| `--transport` | `INKWELL_TRANSPORT` | `stdio` | MCP transport |
| `--host` | `INKWELL_HOST` | `0.0.0.0` | Listen address (SSE/HTTP) |
| `--port` | `INKWELL_PORT` | `8192` | Listen port (SSE/HTTP) |
| `--embedding-model` | `INKWELL_EMBEDDING_MODEL` | `minishlab/potion-multilingual-128M` | Model2Vec model for semantic search |
| — | `INKWELL_ENABLE_DASHBOARD` | unset (off) | Truthy (`1`/`true`/`yes`) starts the dashboard as a second process alongside the MCP server |
| `--host` (dashboard) | `INKWELL_DASHBOARD_HOST` | `0.0.0.0` | Dashboard listen address |
| `--port` (dashboard) | `INKWELL_DASHBOARD_PORT` | `8193` | Dashboard listen port (first free port at or above this is used) |
| — | `INKWELL_QUERY_LOG` | unset (off) | File path; when set, `search`/`recall` append a JSONL trace of each call for retrieval-quality analysis |

## Storage Format

Entries are Markdown files with YAML frontmatter in `/entries/`:```yaml
---
id: a1b2c3d4-e5f6-7890-abcd-ef1234567890
title: Entry Title
tags: [infrastructure, postgresql]
type: decision
resource: /path/to/relevant/file
---

Markdown content here...

type is required on every remember call (a dedicated field, not part of tags) — it classifies the entry (hub, decision, diagnostic, procedure, preference, snippet, ...) and is filterable via search/list. resource is optional: a canonical file/folder path the entry describes. Legacy entries written before these fields existed still read fine.

The search index is a rebuildable cache at /index/inkwell.db. Delete it and rebuild — no data is ever lost. rebuild also reports schema-conformance warnings (missing type, malformed resource) across existing entries.

Development```bash

Build

docker build -t inkwell .

Test (separate Dockerfile — pytest/tests/ never ship in the production image)

docker build -f tests/Dockerfile -t inkwell-test .
docker run --rm inkwell-test

Run locally (SSE)

docker run -d --name inkwell -p 8192 -v ./knowledge:/knowledge inkwell --transport sse
```

License

MIT

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Engram 怎么安装?

在客户端按下面的安装命令接入:claude mcp add --transport stdio inkwell -- \ docker run -i --rm -v ./knowledge:/knowledge foreigndmitryi/inkwell-memory。装完在客户端配置里引用同一个包或端点。

Engram 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Engram 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Engram 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

Engram 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Engram 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

Engram 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Engram 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。