ClickHouse Loom

MCP文档知识

提供方 未标注

文档知识 未标注 会话登录 社区 / 第三方 ClaudeCursorVS CodeCline

为 AI 智能体提供数据平面,支持共享内存、文档搜索和代码智能。提供 Claude Code 和 Codex 插件、MCP 服务器及 SDK。

一句话选型结论

按资料字段整理

ClickHouse Loom 属于文档知识类 MCP 服务器,传输方式未标注,会话登录,可直接接入 Claude、Cursor、VS Code 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

未标注 会话登录
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

知识库读写

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

内容整理

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

选择建议

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

值得选的地方

  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
ClickHouse Loom当前 未标注 未标注 未标注 无 2026-11-20
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

服务器档案

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

详细介绍

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

ClickHouse Loom

Shared memory, document search and code intelligence for AI agents.

For Claude Code, Codex, Cursor and your own agents.

English · 简体中文 · 日本語 · 한국어 · Português (Brasil) · Español

What Loom is for ·
Benchmarks ·
Get started ·
Capabilities ·
Integrations ·
Documentation

Loom is an open-source, self-hosted MCP server that gives your agents long-term, shared
memory: what one agent learns in a session, the next agent or tool can find.
In an authenticated team deployment, each agent uses a token scoped to namespaces and
read or write roles. Check shared memory and denied access.

Agents connect through MCP, HTTP, Python or TypeScript. Self-host with Docker or
on Kubernetes with the Helm chart; agent context and
index data live in ClickHouse, and a
deployment can choose Postgres at first boot for live
memory and knowledge state. The dashboard brings memories, repositories, tasks and runs
into one place.

What Loom is for

  • Long-term memory shared across your coding agents, with plugins that load context
    at session start and capture the session as it runs.
    Agent memory ·
    Connect a coding agent
  • Memory for an agent application, per user, from the Python or TypeScript
    SDK. Your first agent
  • A multi-user MCP memory server with namespaces, roles and tokens.
    Multi-user mode ·
    Namespaces and sharing
  • A code index of your repositories that coding agents query for definitions,
    callers and change impact. Code index ·
    Language support and limits
  • Memories linked to the code they are about, which follow it through refactors, are
    flagged when it changes and appear when an agent reads or edits it.
    Memory linked to code
  • Lower model cost for coding agents, as measured below.
    Coding-agent cost
  • Document search with citations (RAG), including PDF, .docx and .pptx files the
    extractor service converts. Document search
  • Shared context for multi-agent workflows: shared memory, task inboxes and
    decisions. Multi-agent
  • Memory, recall, audit and erasure for autonomous agents.
    Autonomous agents
  • A record of agent work, with searchable conversations (when recording is on),
    session briefs to resume from, runs with their goals, outcomes and model costs when
    supplied, and PR and tracker history.
    Runs and PR history

Memory for a software factory. Loom gives implementation and review agents shared
lessons, issue context and source provenance across sessions. Scope each principal's
access with tokens, await required writes and task handoffs in your application, and
recheck code-linked lessons against the current source before review. The same service
supports multi-agent workflows and autonomous bots; your orchestration runs the agents,
tests and approvals. Offering a tool does not guarantee the model uses it.
Multi-agent workflow ·
Autonomous-agent memory

Every use case, and when another tool fits better: use cases.

Read Choosing memory for a software factory
for memory architecture choices, data ownership and operating responsibilities.

Loom is not an in-process library for one agent's short-lived memory, nor an agent
framework. When Loom does not fit

Measured results

Evaluation With Loom Without Loom Efficiency gain Scope
Coding-agent answer quality 0.84 0.78 20% lower model cost 24 questions × 3 paired runs
Coding-agent file localization 96.4% 91.4% 21% lower model cost 36 questions × 10 paired runs
Memory vs full-history answers 94% 90% 91% fewer reader prompt tokens 100 paired LongMemEval-S questions

Both coding setups use Claude Code (claude-sonnet-5) on the ClickHouse codebase;
cost is the whole session's model bill, excluding Loom's server-side model calls, hosting
and indexing. Answer quality
measures coverage of a verified answer's key points, with a contradiction penalty.
File localization counts whether the right file is among the up to three files the agent is
asked to name at the end of its answer.

The memory row compares retrieved memories with full conversation history using
the same gpt-5 reader. Token savings exclude memory construction; the 94% vs 90%
accuracy difference is descriptive, not statistically established.

Separately, Loom's memory.ask configuration scored 96.6% answer accuracy on all
500 LongMemEval-S questions.
This is a product evaluation with its own configured
answer models, not the fixed-reader comparison above.

Results are specific to the tested workloads.

Protocols and reproducible artifacts ·
detailed results ·
evaluate on your workload

Get started

1. Choose your Docker setup

  • Personal use—the default: no login, localhost-only access and a dev/local
    namespace. One person can connect multiple agents.
  • Team use: authenticated accounts and namespace access controls.
    Start in multi-user mode from the first boot.

Both modes support the same Loom features, including configured LLMs and embeddings.
Single-user is not a reduced-feature edition. You can also
switch an existing installation without deleting its data;
grant new accounts access to the existing namespaces.

To try it with nothing installed, open it in a codespace:

(what it runs and who can reach it)

For the default personal installation, with Docker installed (on Windows, in a WSL 2
terminal where docker works: Docker Desktop with its WSL integration on, or Docker Engine
installed in the distribution):```bash
curl -fsSL https://github.com/ClickHouse/loom/releases/latest/download/install.sh -o loom-install.sh && sh loom-install.sh && rm loom-install.sh


Run it from your home directory, or another
directory only you can write to.
The installer starts Loom and ClickHouse, applies migrations and prints the dashboard URL:
**http://localhost:7777/**; on a new install it then checks that a memory saves and reads
back. On a terminal it also offers to connect the coding agents it finds (Claude Code, Codex,
VS Code) and, on a new install, opens the dashboard. The image includes the server,
workers, dashboard and Python, TypeScript and Go compiler indexers, plus the C++ one on
`amd64`; TypeScript dependencies are prepared automatically. Quickstart and pinned releases

The installation lives in `~/.loom` (`LOOM_INSTALL_DIR` chooses another directory): the
Compose file and the startup settings in `~/.loom/.env`. Running the install command again
upgrades in place and keeps your `.env` settings.

Keep single-user mode localhost-only. For shared access, follow the
team deployment guide, including TLS.

### 2. Configure models and API keys

**The stock installation boots without keys or network.** Storage, the dashboard,
structural code indexing and semantic search work, on a small local embedding model the
image carries; the fake LLM gives no AI-generated answers.

| Component  | Configure for real use                             | Without configuration                                                       |
| ---------- | -------------------------------------------------- | --------------------------------------------------------------------------- |
| Embeddings | Provider, embedding model, dimensions and API key. | `local` (bge-small on CPU): semantic retrieval, weaker than a hosted model. |
| LLM        | Provider, model and API key.                       | `fake-echo-1`: no meaningful extraction, summaries or answers.              |

Open **Settings → Models & keys**, choose both providers and models, enter their
keys, then click **Test & apply**. No Docker restart is needed; changing the embedding
space rebuilds the existing index. The dashboard's embedding choices are hosted
providers: to keep `local` and add an LLM, set the LLM lines in `~/.loom/.env` instead
(Models and keys).

**One OpenAI API key can serve both roles.** Claude needs a separate embedding provider.
OpenAI, Gemini and OpenAI-compatible embedding endpoints are supported. Your agent's
CLI login or subscription does not supply Loom's provider keys.

Prefer environment configuration? Edit `~/.loom/.env`, then recreate the server:```bash
docker compose --project-directory "$HOME/.loom" up -d --force-recreate loom

A key alone does not change the pinned models (the local embedder and the fake LLM); set
the provider and model too.
Saved dashboard settings take precedence over .env. Follow
models and API keys for provider recipes
and health checks.

Everything else is in one file. loom.example.yaml lists
every setting with its default and what it does, by area: the ClickHouse connection,
timeouts and budgets, rate limits, workers, and the *_enabled switches that turn
features on and off. Set any of them as LOOM_ in ~/.loom/.env and recreate the
server; a deployment that mounts a config file can set them in a copy of this file
instead (how settings are read). One marked
live also changes while Loom runs: loom settings set, or Admin → Deployment
settings. loom settings list --changed shows what differs from the defaults and
where each value came from (runtime settings).

3. Connect your agents

If the installer connected your agent, skip the commands below. On the machine running a
personal installation, the plugins need no token:```bash

Claude Code

claude plugin marketplace add ClickHouse/loom
claude plugin install loom@loom

Codex

codex plugin marketplace add ClickHouse/loom
codex plugin add loom@loom
```

Start a new session; the first one connects to http://localhost:7777. In Codex, run
codex interactively once and approve the plugin's hooks; until then only the tools
work. Tell the agent something worth keeping, then ask about it in the next session.

For Cursor, on a Teams or Enterprise plan, a team admin can import this repository as a
team marketplace; its Cursor plugin,
untested in Cursor, installs the MCP entry and Loom's skills. On the machine running a
personal installation, the button below adds the local MCP
entry, which needs no token:

For VS Code agent mode on the machine running a personal installation, the buttons below
add the local MCP entry,
which needs no token:

For a team server, pass --config server_url=… --config token=… to Claude Code, or
point Codex at it as described in
connect a coding agent. Create
tokens in Settings → Tokens. Cursor and other MCP clients, and
the SDK, are covered there too.

Why Loom

  • Memory that carries forward. Share decisions and findings across agents and
    sessions. Each fact records who wrote it, version history and conflict review make
    corrections traceable, and a namespace can be rolled back to any point in time.
    Memory
  • Code intelligence with evidence. Find definitions, callers, change impact and
    relevant tests; connect code to commits, pull requests and issues. Use source
    locations, completeness signals and per-tier freshness to check a result.
    Code index
  • Grounded retrieval. Search permitted memories, documents, conversations and
    tracker records. Answers cite their sources; low-confidence retrieval can abstain.
    Retrieval
  • Multi-agent handoffs. Assign work through durable task inboxes with leases,
    retries, review rules and outcomes. Your agents execute the workflow; Loom
    preserves the handoffs. Task queues
  • Control over agent data. Manage namespace access, provenance, retention, audit
    records and verified erasure. Context remains queryable in ClickHouse.
    Security

Integrations

Integration What it connects
Langfuse Request traces, model costs, retrieval scores and prompt-version attribution.
ClickStack / HyperDX OpenTelemetry traces, logs and metrics in ClickHouse.

Langfuse and ClickStack are optional integrations, not bundled services in the Docker stack.

Benchmark details

Detailed retrieval, reader and code-search results

Evaluation Result
LongMemEval-S evidence retrieval (500 questions) 98.6% of questions with at least one supporting session in the first 30 memories.
LongMemEval-S fixed gpt-5 reader (500 questions) 92.0% answer accuracy from the top 200 memories.
LoCoMo (all 10 conversations) 89.6% answer accuracy; 90.8% correct abstentions on adversarial questions.
MemoryAgentBench fact-question sample (500 questions) 99.0% SubEM; 95.7% token-overlap F1 on generated answers.
Conceptual code search (36 questions) Gold-file recall 91.2% at 5 / 97.2% at 10; MRR 0.91.
SWE-bench Verified file localization (200 issues) Issues with a changed file in the first 10: 82% vs 57% for BM25; 76.5% in the first 5.
Tracker duplicate detection (104 pairs) Recorded older duplicate ranked first 87.5% of the time.

These measure different tasks, not one aggregate score. SWE-bench measures
file localization, not issue resolution. The results ledger
includes scoring definitions, small-sample evaluations, weaker and negative findings,
and the full protocols, models and artifacts.

Methodology ·
coverage and known gaps ·
run the benchmarks

Documentation and contributing

For shared agent context, code intelligence and permissioned retrieval, start with the
documentation. For deployment requirements, see the
prerequisites.

Deployment · FAQ ·
Contributing · Security reporting ·
llms.txt ·
llms-full.txt

Apache-2.0 · License · Notice

常见问题

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

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

ClickHouse Loom 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

ClickHouse Loom 收费吗?

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

ClickHouse Loom 需要 API Key 吗?

资料标注需要会话登录认证,使用前准备好对应凭据,并按最小权限配置。

ClickHouse Loom 支持哪些客户端?

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

ClickHouse Loom 能提供哪些能力?

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

热门专题

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

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