Facthouse

MCP文档知识

提供方 未标注

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

任何AI工具都可使用的本地记忆引擎。

一句话选型结论

按资料字段整理

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

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

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
npx -y @facthouse/mcp facthouse init

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

  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 服务器工具数传输方式部署方式安装命令最后核验
Facthouse当前 未标注 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 · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

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

Facthouse

Facthouse is a local memory engine for AI tools. Most “memory” products index chat logs. Facthouse takes agent activity - messages, tool use, and other MCP traffic - and applies neuroscience-inspired consolidation so it moves through Data (what happened in the session) → Information (extracted facts) → Knowledge (integrated beliefs on an entity graph). During this process, Facthouse links entities, drops duplicates, reconciles conflicts, and supersedes what is out of date. Vector embeddings add optional semantic search on top of that graph. The store is a SQLite file on your disk.

Quick Start

Needs Node 22.5 or 24+.```bash
npx -y @facthouse/mcp
facthouse init


`facthouse init --web` is the same setup as a browser form — it prints a 127.0.0.1 URL and does not open a browser.

Press Enter to accept each default (copy = Claude Code, Cursor or Grok Build session logs on disk; type record if the assistant should save facts). If you picked copy, init asks whether to copy existing logs, then whether to extract and integrate. Init prints an MCP snippet as soon as the store is written — add it to the client's MCP config while copy/extract run. Restart the client when init finishes.

In the client, state something durable in ordinary conversation — there is no remember command.

Ask it back in the next session, or `facthouse search`. That is the store.

Copy from Claude Code, Cursor or Grok Build logs, or record from any MCP client: How conversations get in. Replay: facthouse.dev/demo.html. CLI: below.

## What you get

- **Local SQLite.** Optional Postgres. Isolation is the directory, not a column.
- **Entity graph.** People, organisations, projects, places, products — extracted, typed and linked.
- **Hybrid search.** BM25 + structured domain + entity-graph paths, merged via Reciprocal Rank Fusion. An embedding provider adds meaning as a fourth list; off by default.
- **In-session memory.** `get_session_context` is the same briefing as `memory://briefing`. Tools-only clients should call it at session start.
- **Immutable history.** Facts are never deleted, only superseded.

## How it works

One SQLite database. Three tables in it, not three databases: **Data** (what happened in the session) → **Information** (extracted facts) → **Knowledge** (integrated beliefs).

- **D** (`session_events`) — what was said (copied transcripts, or what the assistant records)
- **I** (`session_facts`) — what was just extracted, or `capture_fact`
- **K** (`facts`) — integrated knowledge

FTS5 (words) and optional embeddings (meaning) are indexes of **K**. They are not a second store. Semantic search is off unless you turn it on: `search "shellfish"` finds a shellfish fact, `search "food"` does not, until you choose an embedding model — a model is an opinion about what “similar” means.

Two speeds. **Copy** tails named transcripts into Data. **Extract** turns new transcript lines into self-contained facts (D→I). **Integrate** fits them into what the store already knows: domains, entities, duplicates, contradictions, the graph (I→K). `consolidate` is the umbrella: copy, extract, and integrate together. Extract is capped at 50 lines per run, so a first backfill is never spent on the lot; when extract runs, it takes the oldest 50 lines. Consolidation does not invent a sentence nobody said.

A hook cannot call MCP tools — those exist only on the assistant’s connection — and it must not wait for a model pass. So it does not invoke `consolidate`. It runs `facthouse notify …`, which tells the **already-running** server that a moment happened and returns at once. `consolidate` is the pipeline verb (MCP tool or CLI); the caller waits. `notify compaction` is that verb asked of the live server, asynchronously. `notify threshold` is a different policy (extract only, if due).

**Automatic**

| When | Copy | Extract (D→I) | Integrate (I→K) |
|------|------|---------------|-----------------|
| Facthouse MCP server starts | yes | yes (cap 50) | yes |
| A Facthouse tool or resource is called | yes, if sources named and JSONL grew | no | no |
| Facthouse MCP process exits | no | no | yes |

**Callable**

| Call | From | Copy | Extract (D→I) | Integrate (I→K) |
|------|------|------|---------------|-----------------|
| `consolidate` | MCP tool or CLI. Caller waits. | yes | yes (cap 50) | yes |
| `facthouse notify compaction` | Other process (recommended PreCompact; we do not install). Does not wait. | yes | yes (cap 50) | yes |
| `facthouse notify threshold` | Other process. Does not wait. Not a copy-store hook. | no | yes, if due (cap 50) | no |

On a default copy store with no extra hooks, only the automatic table runs: Facthouse starts (all three), copy on each Facthouse tool or resource call if named sources grew, and integrate on a clean process exit. Closing a chat window may skip the exit row; the next start still consolidates. Due on threshold means at least 10 unexamined lines and two minutes since the last gated run. `consolidate --all` lifts the extract cap. Compaction is recommended PreCompact (`notify compaction`): same three steps as `consolidate`, on the running server, without waiting. We do not install the hook. Not a Stop hook. `record` wakes threshold extract on a record store — do not install record hooks on a copy store.

Storage needs Node. Intelligence needs a language model. By default that is the Claude Code CLI on your existing subscription. Without it, consolidation falls back to a built-in heuristic that **does not extract facts from transcripts**. `capture_fact` still stores facts, with no entities and no domain routing.

## How conversations get in

Two ways. Pick one per store.

| | Copy from transcripts | The assistant records |
|---|---|---|
| Who | Claude Code, Cursor or Grok Build (session logs on disk, under the client home) | Any MCP client with no log on disk (Desktop, …) |
| How | Name a source; Facthouse copies new lines from those logs into the store | Empty `sources`; the assistant calls `capture_fact` |
| First run | TTY walk-through, pick **copy**, set cwd; init asks whether to copy existing logs, then whether to extract and integrate | TTY walk-through, pick **record** |

On a copy store, capture_fact is a correction for every MCP client, not only the one that writes JSONL. To use Claude Code and Grok Build on one store, name a `claude-code` source and a `grok` source with the same `cwd`: both copy in, and neither is asked to record. Do not also install record hooks on that store.```bash
facthouse init

Pick copy, set cwd. Init asks whether to copy existing logs, then whether to extract and integrate (Enter = all copied lines; a selection of 500 or more asks you to type the choice again). Decline extract to do that later with facthouse consolidate (--all takes remaining unexamined lines, not ones skipped as outside a 7-day or 30-day window). After that, the server copies new lines when it handles a Facthouse call. Extract and integrate follow the table in How it works.

Compact (recommended): facthouse notify compaction — we do not install the hook. Not a turn-end Stop hook.

MCP

Works with any MCP-compatible tool. Default store: ~/.facthouse. A different path is "env": { "FACTHOUSE_DATA": "/absolute/path" } on the MCP snippet. JSON accepts forward slashes on Windows.

Cursor consumes tools but not resources until a later adapter exists — search_knowledge and get_entity still work there; call get_session_context at session start.

Resources are context the client loads automatically — no tool call. Tools only help if the assistant remembers to reach for them; resources are simply present.

  • memory://briefing — Everything worth knowing right now: profile, what was learned in the last consolidation, open threads, and recent knowledge. Markdown, kept to roughly a screenful.
  • memory://profile — Core identity facts, most important first.

Both are read-only views over the same database the tools query. Clients that never load resources (Cursor, Windsurf, Grok) get the same briefing by calling get_session_context at the start of a conversation. No second profile schema.

Tools

Session

  • log_event — Log conversation events (messages, artifacts).
  • get_events — Retrieve events from current or previous session.
  • get_session_context — Working briefing (the same markdown as memory://briefing) plus facts captured in this session. Call at the start of every conversation if the client does not load resources.

Reading

  • get_entity — Everything known about any named subject — person, organisation, project, place, product — and how it connects. When several rows share the name under different types, facts from all of them come back. Hyphens, underscores, and stray punctuation count as the same letters only when that does not join two names already stored as separate rows. If there is no entity by that name, facts that mention the wording still come back rather than an empty miss.
  • get_context — Everything relevant to a topic (search + entity traversal)
  • search_knowledge — Hybrid search across integrated knowledge

Writing

  • capture_fact — Store a fact. On a copy store this is a correction for something extraction missed; on a store with empty sources it is how facts get in. The description the assistant sees is generated from that same rule.
  • consolidate — Integrate pending facts into long-term knowledge. Extracts entities, resolves duplicates, detects contradictions, builds the knowledge graph.
  • Inference tools — Opt-in, off by default (inferences.enabled in config.json). A hypothesis cites existing fact ids and stays pending until confirmed. Those tools are not registered until you turn the gate on. Consolidate never invents a sentence nobody said.

Meta

  • get_schemas — Available domains and structure
  • get_stats — Fact count, entity count, domain distribution, extract backlog, intelligence spend

CLI

The MCP JSON starts the server via npx and does not need a global install. npm install -g puts facthouse on PATH for init, settings, stats, and inspect. The same CLI without PATH is npx -y -p "@facthouse/mcp" -- facthouse — pin the version; quote the package so PowerShell does not splat. -p and -- stop an older global binary winning. npx -y @facthouse/mcp with no -p / facthouse is the server; do not run it as a shell command for init, settings, or stats. The MCP paste starts the server. It does not put facthouse on PATH. To inspect the file from a terminal, see CLI below.

These CLI commands work in bash, zsh, and PowerShell. Quote @facthouse/mcp in PowerShell. Git Bash /c/... paths are not PowerShell; use C:/... and pass --data instead of cd or export. In Git Bash, quote a backslash path or write C:/... — unquoted \ is an escape. ~/ is expanded on every platform. WSL uses /mnt/c/.... FACTHOUSE_DATA on an MCP snippet applies only to that server process. A terminal facthouse command needs --data, FACTHOUSE_DATA in the environment that shell inherits, or a .facthouse store in this project. Hooks do not see mcp.json env.```bash
npm install -g @facthouse/mcp@0.31.0
facthouse init --yes


If npm install -g fails because a command named mcp already exists, remove that leftover command and retry.```bash
npx -y -p "@facthouse/mcp@0.31.0" -- facthouse init --yes
npx -y -p "@facthouse/mcp@0.31.0" -- facthouse settings --json
npx -y -p "@facthouse/mcp@0.31.0" -- facthouse stats
npx -y -p "@facthouse/mcp@0.31.0" -- facthouse inspect
Job Use
MCP server (what the client starts) The JSON snippet: npx with args -y and a pinned @facthouse/mcp@…. No global install.
facthouse on PATH npm install -g @facthouse/mcp@… (same pin). Update it when you bump the snippet.
Change extra knobs later facthouse settings (or settings --data). Does not reset the file.
One CLI command, no PATH npx -y -p "@facthouse/mcp@…" -- facthouse …

facthouse init [dir]

The walk-through is how a human first-run writes config.json. Skip it and the server still creates the directory on first MCP boot.

On a terminal, init asks data directory, copy transcripts vs assistant records (default copy), semantic search, and More settings. --yes never prompts and leaves sources empty. --web prints a 127.0.0.1 URL and does not open a browser; --yes refuses --web. On a terminal, --force still asks those questions, then replaces the whole file; --yes --force is the silent reset. --force does not merge with the previous file.```bash
facthouse init --yes
bash facthouse init --yes ~/my-memorybash
facthouse init --yes --force


The generated `config.json` is where you change consolidation behaviour — most notably `intelligence.provider` (`cli` by default; `heuristic` for a zero-dependency regex fallback, or `FACTHOUSE_PROVIDER=heuristic` at runtime). Init does not ask that field.

#### `facthouse settings`

Change extra knobs on an existing `config.json` (CLI model, timeout, optional local extract). Does not reset the rest of the file. Refuses if there is no `config.json` (this command does not create a store). `--json` / not a terminal prints the current knobs and does not write. `--web` is the same knobs on a local page (print URL, no auto-open).```bash
facthouse settings
``````bash
facthouse settings --data ~/my-memory

facthouse record

Inserts events directly into the database (no running server needed). Supported for demos and for stores that have no named source. Not the Claude Code or Cursor default — that is sources plus facthouse consolidate.```bash

From a hook (reads JSON payload from stdin):

echo '{"hook_event_name":"UserPromptSubmit","prompt":"hello"}' | facthouse record --role user

With explicit content:

facthouse record --role user --event-type message --content "hello world"

Options:

--role user | assistant | system | tool (default: user)

--event-type message | tool_call | tool_result | artifact (default: message)

--content-type text | json | image | audio | binary (default: text)

--content Event content (or pipe via stdin)

--speaker Named participant when the transcript has one

--session-id Target session (default: most recent)

--data Data directory (default: FACTHOUSE_DATA, a .facthouse store in this project, or ~/.facthouse)


#### `facthouse consolidate`

Copy new lines from `config.sources`, extract candidate facts from them, and integrate the pending facts into knowledge. The one command that spends model calls:```bash
facthouse consolidate
facthouse consolidate --copy            # copy only; spends nothing
facthouse consolidate --integrate       # pending facts to knowledge; no extract pass
facthouse consolidate --all             # extract the whole backlog now
facthouse consolidate --limit 200       # extract the oldest 200

# Steps — named steps run, in order; none named means all three:
#   -c, --copy       copy new transcript lines into the store
#   -e, --extract    turn new lines into candidate facts (the model call)
#   -i, --integrate  classify, link, dedupe, supersede, embed
# Extract is capped at 50 lines per run so a first backfill is never spent on
# the lot; the run says how many remain. --all lifts the cap, --limit N sets it.
#   --json           print the result object instead of the summary
#   --data           Data directory (default: FACTHOUSE_DATA, a .facthouse store in this project, or ~/.facthouse)

Honours the configured provider (by default claude -p). Empty sources makes the copy step a no-op. Set cwd on the source unless you intend to copy every project group. Do not also run record hooks on a store with named sources.

facthouse notify

Tell the running MCP server that a moment happened. The server decides what to run and does it in the background, so a hook returns at once:```bash
facthouse notify compaction # client about to compact: copy new JSONL, extract, integrate (does not wait)
facthouse notify threshold # events arrived: extract if the threshold is due

Options:

--data Data directory (default: FACTHOUSE_DATA, a .facthouse store in this project, or ~/.facthouse)


No server listening is not an error: the command says so and exits 0, and the next session start covers it. This is what the PreCompact hook calls.

#### `facthouse search````bash
facthouse search "coffee"
facthouse search "coffee" --domain preferences
facthouse search "coffee" --json

# Options:
#   --domain   Prioritise a domain. Biases ranking; does not filter
#   --limit    Maximum results (default: 20)
#   --json     Emit the raw search payload
#   --data     Data directory (default: FACTHOUSE_DATA, a .facthouse store in this project, or ~/.facthouse)

--domain biases ranking rather than filtering. A hard filter would hide a fact filed under a near-synonym.

`facthouse stats````bash

facthouse stats
facthouse stats --json


Facts are immutable — superseded facts are kept — so the current count and the total legitimately differ once anything has been superseded. `--json` includes the answering binary's package version. Intelligence spend is calls, tokens, and elapsed time for extract / classify / entities / reconcile / supersede / summarise, with provider and model per stage. Embeddings are not that number.

#### `facthouse inspect`

Sample D, I, K, entities, and the graph. Writes a local HTML file under the data directory (not the cwd). Prints the path. Does not open a browser. The file is a memory export — treat it like `stats --json`. The same page also shows intelligence spend (Graph / Spend).```bash
facthouse inspect
facthouse inspect --graph
facthouse inspect --layer k
facthouse inspect --json
facthouse inspect --entity Helios --limit 20 --output ~/inspect.html

--layer health · d · i · k · entities · graph · all prints terminal tables (newest-first, capped). --graph (the default when no --layer / --json) writes inspect.html. --limit is 10 for tables and 50 for the canvas. --all draws every node — a hairball, explicit. Search and type filter in the page can still reach a node that was outside the cap.

Advanced

Another store

The store is this directory. Clients share it by using the same path. A second store is a second directory, not a second install. The default MCP server name is facthouse. Splitting is not a filter on which client wrote the row. Work and personal is one reason to split, not a required setup.

A non-default data directory prints a distinct MCP server name so two stores can share one mcp.json. Init against each extra directory prints that snippet. Example:```json
{
"mcpServers": {
"facthouse-personal": {
"command": "npx",
"args": ["-y", "@facthouse/mcp@0.31.0"],
"env": { "FACTHOUSE_DATA": "C:\Users\alex\.facthouse-personal" }
},
"facthouse-work": {
"command": "npx",
"args": ["-y", "@facthouse/mcp@0.31.0"],
"env": { "FACTHOUSE_DATA": "C:\Users\alex\.facthouse-work" }
}
}
}


Point each store's `sources.cwd` (or hook `--data`) at that store only. Two directories do not isolate anything if both copy the same home.

### Postgres (optional)

SQLite is the default and needs no extra software. To use Postgres instead, set `storage.provider` to `"postgres"` in that store's `config.json`, or `FACTHOUSE_STORAGE=postgres` on the MCP entry, and set `FACTHOUSE_POSTGRES_URL` to a `postgres://` (or `postgresql://`) URL. The password belongs in the environment, not in `config.json`. If the URL is missing or the server cannot be reached, Facthouse stops; it does not create a SQLite file.

The data directory is still the memory: `config.json` and the scheduler socket live there. Tables live at the URL. Two memories need two directories and two databases.

Init does not ask which engine to use. `facthouse init --yes` still writes sqlite.

Example — placeholders only; do not put a real password in a committed file:```json
{
  "mcpServers": {
    "facthouse": {
      "command": "npx",
      "args": ["-y", "@facthouse/mcp@0.31.0"],
      "env": {
        "FACTHOUSE_DATA": "C:\\Users\\alex\\.facthouse-work",
        "FACTHOUSE_STORAGE": "postgres",
        "FACTHOUSE_POSTGRES_URL": "postgres://USER:PASSWORD@localhost:5432/facthouse"
      }
    }
  }
}

Copy versus record

Choose one mechanism per store.

Recommended — copy. Name a claude-code, cursor or grok source (set cwd) and run facthouse consolidate from the CLI first. The MCP server also copies at session start and when it handles a call. Codex is a later adapter. Unknown kind values are rejected.```json
{
"sources": [
{
"kind": "claude-code",
"home": "~/.claude",
"cwd": "C:\dev\app"
}
]
}


`home` is the client config dir (`~/.claude` or `~/.cursor` — path examples, not extra discovery). Cursor is `"kind": "cursor"` and `home/projects/*/agent-transcripts/**/*.jsonl` only — not Composer SQLite. Cursor encodes `C:\\dev\\app` as `c-dev-app` (Claude Code uses `C--dev-app`). A first backfill of more than 50 lines takes several runs, or one `facthouse consolidate --all`.

**Alternative — record, no sources.** Leave `sources` empty. Pipe a client hook payload into `facthouse record` if you have one. MCP `log_event` / `capture_fact` keep working.

Do not install record hooks on this store — both write the same rows. Facthouse does not detect or rewrite existing hook configs.

### MCP-only record mode

To skip the wizard (record only — no transcript copy), paste this. The server creates `~/.facthouse` on first boot; you are not asked those questions.```json
{
  "mcpServers": {
    "facthouse": {
      "command": "npx",
      "args": ["-y", "@facthouse/mcp@0.31.0"]
    }
  }
}

Hooks

PreCompact notify compaction is the useful one: when the client is about to compact, a short-lived hook tells the running server, and the hook returns at once. The server copies new JSONL lines, then extracts and integrates — compaction does not delete the transcript, and the hook does not photocopy the live window. Init prints this JSON with --data filled in. Paste into Claude Code .claude/settings.json (user or project). We do not install it. Do not install a Stop hook. Do not install record hooks on this store — both write the same rows.

mcp.json env is not visible to hooks. Pass the same --data (or set FACTHOUSE_DATA in the environment the client itself inherits). The command must invoke the CLI (facthouse), never the server binary. npx -y @facthouse/mcp with no -p / facthouse starts the MCP server and hangs a hook. Pin the package version, quote it if the hook runs PowerShell, and put -- before facthouse so a globally installed older binary on PATH cannot win.

PreCompact hook JSON```json
{
"hooks": {
"PreCompact": [
{
"hooks": [
{
"type": "command",
"command": "npx -y -p @facthouse/mcp@0.31.0 -- facthouse notify compaction --data /absolute/path/to/the-same-store"
}
]
}
]
}
}


PreCompact `notify compaction` asks the running server to consolidate: copy the newest JSONL lines, extract, integrate. The hook returns at once; the server does the work. We do not install a turn-end Stop hook. On Windows the `--data` path is the same absolute directory you put in `FACTHOUSE_DATA` (for example `C:\\Users\\alex\\AppData\\Local\\Temp\\facthouse-try`).

Frequent incremental copying interleaves conversations on the global sequence: a long chat kept open is sliced between other chats. Extract progress is per conversation, so a timeout in one chat does not discard another. Shrinking `extraction.batch_size` means more extract calls (more chances of a timeout), not a store-wide hold-all. `facthouse stats` reports unextracted events against that extract watermark.

If the MCP server does not start, or lists no tools, check the package version the client actually spawned. A global `facthouse` on PATH can be years behind the pin in this README. Diagnose with `facthouse stats --data ` (the CLI prints whether the scheduler is listening) and by inspecting `serverInfo.version` from `initialize` plus `tools/list` over stdio. `0.2.x` answers `initialize` then throws on `tools/list`.

### Embeddings, model, timeout, bitemporal

Set `embedding.provider` in `config.json` to `"ollama"` (local, no API key) or `"voyage"` (hosted), run `facthouse consolidate`, and `search "food"` starts returning the allergy. Facts are embedded when they are consolidated. Voyage applies a **3 requests/minute** rate limit until a payment method is on the account.

Meaning-search is an exact scan of stored vectors when the set is small. When that set is large (default 32 MiB of the current model), an HNSW index of those vectors is used instead: in-process on SQLite, or a Postgres `vector` sidecar when the extension is enabled. Small stores stay exact. A missing engine keeps exact search and prints a warning; Facthouse does not install a native addon. `embedding.ann` is `null` (auto), `false` (never), or `true` (force when the engine allows). This does not turn embeddings on.

`intelligence.cli.model` and `intelligence.cli.timeout_ms` are extra knobs. First-run More settings (Y) can write them; later, `facthouse settings`. Init does not ask `intelligence.provider`; `FACTHOUSE_PROVIDER=heuristic` is the kill-switch. The heuristic fallback **does not extract facts from transcripts**.

Unnamed user-channel speech is attributed to the store's owner; a display name still does not create a person. Extra backing (assent, a tool observation, a different speaker restating) is recorded, not scored, unless the store sets `interlocutor` ranking weights in `config.json`. The engine ships none. Weight keys match the speaker string as stored, so two people with the same name share a key.

Set `temporal.mode` to `bitemporal` to record when the system retracted a belief, so search can answer what the store believed at an instant.

### Intelligence spend

`facthouse stats` and `get_stats` report billed consolidation calls: tokens, elapsed time, and the provider plus model on each stage (extract, classify, entities, reconcile, supersede, summarise). A run that did not report tokens omits those fields rather than showing zero. Embeddings are a different API and are not this number.

Optional `intelligence.token_budget` caps billed extract per provider on rolling windows. Unset is unlimited. Over the cap, consolidate skips extract, holds the watermark, and does not fall back to the heuristic. Stats and inspect Spend show used and remaining on each cap, and when oldest usage in that window ages out (`resets`).```json
"intelligence": {
  "token_budget": {
    "cli": { "week": "10M" }
  }
}

hour, day, week, and month are rolling. Omit a scale to leave it unlimited. Remaining room is on facthouse stats, get_stats, and inspect Spend. Set the cap in this store's config.json — there is no budget command.

Optional local intelligence is a different switch from embeddings. Add intelligence.http on an OpenAI-compatible host. The protocol is POST /v1/chat/completions; only the port changes:

Host Typical URL
Ollama http://localhost:11434/v1 (the default if you omit the URL)
LM Studio http://localhost:1234/v1
vLLM http://localhost:8000/v1
llama.cpp http://localhost:8080/v1

The model string is whatever that host lists. GET {base_url}/models prints the names. nomic-embed-text is embed-only and will not extract. If the host is up and serves exactly one chat model, Facthouse uses it for this run and tells you to pin intelligence.http.model. If several chat models are listed, set that field; extract will not guess.

Extract and summarise then use that host; reconcile and supersede stay on the CLI unless you list intelligence.stages. Each stage can set on-fail to cli, http, or none (see the JSON below). HTTP extract defaults to retrying on the CLI (counts against the CLI token budget). Contradiction defaults to none — no provider switch. none holds the extract watermark — it does not fall through to the heuristic. First-run More settings (Y, after the recommended path) can set the host, model, and extract on-fail. Later, facthouse settings merges those knobs into an existing file without resetting it. facthouse inspect Spend shows the same knobs and copies JSON; it does not save config.json.

The live script npm run test:http-intelligence has passed on qwen2.5vl:7b.```json
"intelligence": {
"http": {
"base_url": "http://localhost:11434/v1",
"model": "qwen2.5vl:7b"
},
"stages": {
"extract": { "provider": "http", "on_fail": "cli" },
"summarise": { "provider": "http", "on_fail": "cli" },
"reconcile": { "provider": "cli", "on_fail": "none" },
"supersede": { "provider": "cli", "on_fail": "none" }
}
}


### CLI demo (no transcript source)

Throwaway store, not the capture path for a real Claude Code or Cursor home. These three lines are typed in.```bash
export FACTHOUSE_DATA=/tmp/facthouse-demo
om() { npx -y -p "@facthouse/mcp@0.31.0" -- facthouse "$@"; }

om init --yes

om record --role user --content "I prefer dark mode in every editor, and I never want telemetry enabled."
om record --role user --content "I am allergic to shellfish, so avoid seafood restaurants when booking anything."
om record --role user --content "My colleague Robin at Acme is leading the Atlas migration project this quarter."

om consolidate
om search "Atlas"
om stats
``````powershell
$env:FACTHOUSE_DATA = Join-Path $env:TEMP "facthouse-demo"
function om { npx -y -p "@facthouse/mcp@0.31.0" -- facthouse @args }
om init --yes

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

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

在客户端按下面的安装命令接入:npx -y @facthouse/mcp facthouse init。装完在客户端配置里引用同一个包或端点。

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

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

Facthouse 收费吗?

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

Facthouse 需要 API Key 吗?

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

Facthouse 支持哪些客户端?

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

Facthouse 能提供哪些能力?

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

Facthouse 需要什么运行环境?

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

Facthouse 是本地还是远程?

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

热门专题

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

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