Local Rag

MCP文档知识

提供方 TheWinci

文档知识 未标注 API Key 社区 / 第三方 ClaudeCursorVS CodeWindsurf
查看接入方式

Semantic code search for AI agents — hybrid vector + BM25 with cross-encoder reranking, AST-aware chunking for 14 languages, conversation memory, code annotations, and search analytics. Zero config, zero API keys. Just bunx.

一句话选型结论

按资料字段整理

Local Rag 属于文档知识类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude、Cursor、VS Code 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

raglocalknowledge

安装与配置

未标注 API Key
上游未给出传输方式
brew install sqlite

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

  1. 1
    准备运行环境

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

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

知识库读写

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

内容整理

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

选择建议

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

值得选的地方

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

先想清楚的地方

  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

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

同类对比

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

服务器档案

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

详细介绍

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

MIMIRS

Named after Mímir, the Norse god of wisdom and knowledge.

Persistent project memory for AI coding agents. One command to set up, nothing to maintain.

Your agent starts every session blind — guessing filenames, grepping for keywords, burning context on irrelevant files, and forgetting everything you discussed yesterday.

On one real project, a typical prompt was burning 380K tokens and ~12 seconds end-to-end.

After indexing with mimirs: 91K tokens, ~3 seconds — a 76% drop on that codebase. Your numbers will vary with repo size, query, and model.

No API keys. No cloud. No Docker.
Just bun and SQLite.

Semantic Search  ·
Auto-generated Wiki

Cross-session Memory  ·
Dependency Graphs  ·
Annotations

Works with: Claude Code · Cursor · Windsurf · JetBrains (Junie) · GitHub Copilot · any MCP client

Quick start

1. Prerequisites

Bun (curl -fsSL https://bun.sh/install | bash) and, on macOS, a modern SQLite — Apple's bundled one doesn't support extensions:```bash
brew install sqlite


Linux and Windows ship with a compatible SQLite already.

### 2. Set up your editor (automatic)```bash
bunx mimirs init --ide claude   # or: cursor, windsurf, copilot, jetbrains, all

This creates the MCP server config, editor rules, .mimirs/config.json, and .gitignore entry. Run with --ide all to set up every supported editor at once.

init covers Claude Code, Cursor, Windsurf, Copilot, and JetBrains (Junie). For everything else — Codex, Zed, custom clients — copy one of the snippets below.

3. Set up your editor (manual reference)

The mimirs MCP server runs over stdio. Every client needs the same three things: a command (bunx), args (["mimirs@^1", "serve"]), and a RAG_PROJECT_DIR env var pointing at your project root.

> Why @^1 and not @latest? The range keeps you on 1.x, so bug fixes and new features still arrive automatically, but a future 2.0 with breaking changes never lands without you asking for it. To move up a major, edit the arg or re-run bunx mimirs init. If you already have mimirs@latest in a config, re-running bunx mimirs init rewrites it to mimirs@^1.

> "command not found: bunx" / server fails to start (but bunx works in your terminal)? Editors launched from the Dock or a desktop launcher don't load your shell profile, so ~/.bun/bin isn't on their PATH. Use the absolute path from which bunx as the command instead of the bare bunx in the snippets below. bunx mimirs init writes the absolute path automatically (re-run it to fix an existing config), and bunx mimirs doctor detects the problem.

Claude Code — .mcp.json in project root```json
{
"mcpServers": {
"mimirs": {
"command": "bunx",
"args": ["mimirs@^1", "serve"],
"env": {
"RAG_PROJECT_DIR": "/absolute/path/to/your/project"
}
}
}
}


Cursor — .cursor/mcp.json in project root```json
{
  "mcpServers": {
    "mimirs": {
      "command": "bunx",
      "args": ["mimirs@^1", "serve"],
      "env": {
        "RAG_PROJECT_DIR": "/absolute/path/to/your/project"
      }
    }
  }
}

Windsurf — ~/.codeium/windsurf/mcp_config.json (global)

Windsurf reads MCP servers from your home directory, not the project. JetBrains plugin variant uses ~/.codeium/mcp_config.json.```json
{
"mcpServers": {
"mimirs": {
"command": "bunx",
"args": ["mimirs@^1", "serve"],
"env": {
"RAG_PROJECT_DIR": "/absolute/path/to/your/project"
}
}
}
}


JetBrains (Junie) — .junie/mcp.json in project root```json
{
  "mcpServers": {
    "mimirs": {
      "command": "bunx",
      "args": ["mimirs@^1", "serve"],
      "env": {
        "RAG_PROJECT_DIR": "/absolute/path/to/your/project"
      }
    }
  }
}

GitHub Copilot — .vscode/mcp.json in project root

VS Code's Copilot uses a servers map (not mcpServers) and a type field.```json
{
"servers": {
"mimirs": {
"type": "stdio",
"command": "bunx",
"args": ["mimirs@^1", "serve"],
"env": {
"RAG_PROJECT_DIR": "/absolute/path/to/your/project"
}
}
}
}


Codex — ~/.codex/config.toml (global)

Codex uses TOML, not JSON, and reads from `~/.codex/config.toml`. One block per project — pick a unique table name if you wire up multiple repos (`mimirs-frontend`, `mimirs-api`, etc).```toml
[mcp_servers.mimirs]
command = "bunx"
args = ["mimirs@^1", "serve"]
env = { RAG_PROJECT_DIR = "/absolute/path/to/your/project" }

Or, equivalently, with an expanded env table:```toml
[mcp_servers.mimirs]
command = "bunx"
args = ["mimirs@^1", "serve"]

[mcp_servers.mimirs.env]
RAG_PROJECT_DIR = "/absolute/path/to/your/project"


Read-only project directory? Redirect the index

If the project lives in a read-only mount, set `RAG_DB_DIR` to a writable location. The index lives there instead of `/.mimirs/`.```json
{
  "mcpServers": {
    "mimirs": {
      "command": "bunx",
      "args": ["mimirs@^1", "serve"],
      "env": {
        "RAG_PROJECT_DIR": "/read/only/project",
        "RAG_DB_DIR": "/home/me/.cache/mimirs/myproject"
      }
    }
  }
}

4. First index

The MCP server indexes lazily on the first query, so once it's wired up you can just ask your agent something. To force a full index up front (useful for large repos):```bash
bunx mimirs index # current directory
bunx mimirs status # how many files, chunks, embeddings


### 5. Try the demo (optional)```bash
bunx mimirs demo

Manual workflow (without init)

init is a convenience: it wires up your editor (MCP config, agent rules, .gitignore, .mimirs/config.json). It does not build the index, and nothing below needs it — the index and a default config are created automatically the first time you index or query.

1. Add the MCP server by hand. Drop the snippet for your client from the manual reference above: command: "bunx", args: ["mimirs@^1", "serve"], and RAG_PROJECT_DIR pointing at your project root. That is the entire MCP setup.

> Without init there's no agent-rules file, so your assistant won't know the tools exist. Either mention mimirs in your prompt, or copy the tool list from CLAUDE.md into your editor's rules.

2. Build the index. The MCP server indexes lazily on the first tool call, so through an agent you can skip this step. To index up front (recommended for large repos, and required before the CLI search/read below):```bash
bunx mimirs index # current directory
bunx mimirs index /path/to/repo # a specific directory
bunx mimirs index --patterns "src//.ts,.md" # restrict to globs
bunx mimirs status # files, chunks, embeddings


No `init` and no config file required — defaults are applied and the index is written to `/.mimirs/`.

**3. Query from the CLI.** Two read commands, both running against the index in the current directory (use `--dir` to point elsewhere):```bash
# Where is it? — ranked file paths + snippet previews
bunx mimirs search "where is auth handled" --top 10

# What is it? — the actual matching code chunks (functions, classes, sections)
bunx mimirs read "jwt validation" --top 8 --threshold 0.3

Scope either with --ext .ts,.tsx, --in src,packages/core, or --exclude tests. Note: the CLI search/read do not auto-index — run mimirs index first (only the MCP server indexes on demand).

Claude Code plugin

For deeper integration, mimirs is also available as a Claude Code plugin. In a Claude Code session:/plugin marketplace add https://github.com/TheWinci/mimirs.git /plugin install mimirs

The plugin wires the MCP server, three hooks — SessionStart (context summary), PostToolUse (auto-reindex on edit), SessionEnd (auto-checkpoint) — and a set of workflow skills that orchestrate the tools for common jobs: explore, plan, review, debug, research, recall, catch-up, handoff, doc-gaps, scout, and wiki.

Want the skills without the plugin? They're plain SKILL.md files under skills/. Copy any you like into your project's .claude/skills// (shared with the repo) or ~/.claude/skills// (all your projects) and Claude Code picks them up next session. Skills are a Claude Code feature, so they don't apply to other editors — but the MCP tools themselves work everywhere.

Search quality

89–97% Recall@10, 97–100% Recall@20, MRR 0.69–0.77. Benchmarked on four real codebases across three languages with stratified, difficulty-mixed query sets (72–120 queries each, ~⅓ hard), re-measured 2026-06-04 on the current pipeline. Full methodology in BENCHMARKS.md.

Codebase Language Files Queries Recall@10 MRR Zero-miss
mimirs TypeScript 244 74 95.3% 0.759 4.1%
Excalidraw TypeScript 693 72 90.3% 0.773 9.7%
Django Python 3,181 116 97.4% 0.727 2.6%
Kubernetes Go 8,792 120 89.2% 0.689 10.8%

The larger repos (Kubernetes, Excalidraw) are big enough that some correct files rank just past the top-10; recall reaches 97–100% by top-20, so set searchTopK: 15–20 on large repos.

vs coding agents (ContextBench)

We also ran mimirs on ContextBench (gold-context
retrieval on real repos), whose other entries are full coding agents — multi-step
explorers — not single-call tools. Given a focused query (what an LLM sends after reading
the issue), one mimirs retrieval call ranks like this against whole agent trajectories:

metric mimirs rank field
File coverage 0.799 #1 above OpenHands, SWE-agent, Agentless…
Line coverage 0.341 #1 above Agentless, mini-SWE…
Line precision 0.316 #2 behind only Agentless (0.376)
File precision 0.192 #6 low by design — recall-first

mimirs leads both coverage metrics as a single call. File precision is last on
purpose: a missed gold file is fatal (the LLM never sees the code to fix), an extra file
reference is cheap to filter — so mimirs maximizes recall and lets the model do the
precision pass. And that low file precision is mostly an artifact of the metric: ~86%
of the non-gold files mimirs returns are relevant context coupled to the fix (callers,
types, sibling implementations), not noise — measured against gold the precision is 0.19,
against relevance it is 0.87.

Same recall, a fraction of the cost. Head-to-head against a grep-only agent (raw issue,
no index, no peeking at the fix) localizing the same 15 issues: mimirs delivers the relevant
cluster in one ~15 ms call with zero LLM tokens; the agent took ~11.5 tool calls per
issue
(each an LLM step) to converge — and stopped at the primary file. On multi-file fixes
the agent reached 22% of the gold files, mimirs 56% in that single call — the
dependency graph surfaces the secondary files the issue never names.

n=15 sample vs the agents' 500-set — directional; agent tool-calls self-reported and capped.
Full leaderboards, caveats, relevance + cost tables in BENCHMARKS.md.

How it compares

mimirs No tool (grep + Read) Context stuffing Cloud RAG services
Setup One command Nothing Nothing API keys, accounts
Token cost ~91K/prompt ~380K/prompt Entire codebase Varies
Search quality 89–97% Recall@10 Depends on keywords N/A (everything loaded) Varies
Code understanding AST-aware (24 langs) Line-level None Usually line-level
Cross-session memory Conversations + checkpoints None None Some
Privacy Fully local Local Local Data leaves your machine
Price Free Free High token bills $10-50/mo + tokens

Why not an existing tool?

  • Continue.dev's @codebase — closest overlap (local RAG, open source), but retrieval lives inside the editor extension. Mimirs is a standalone MCP server with explicit tools (search, read_relevant, project_map, search_conversation, annotate) the agent can plan around, plus conversation tailing and a wiki generator built in.
  • Aider's repo-map — static tree-sitter summary of the repo, no embeddings. Clever and lightweight, but a summary isn't retrieval — mimirs ranks chunks per query with vector + BM25 and boosts by graph centrality.
  • Sourcegraph Cody / OpenCtx — excellent at code search, but indexing leans on cloud infra and an account. Mimirs is one bunx away and never leaves your machine.
  • llama-index / LangChain / roll-your-own — those are libraries. Mimirs is batteries-included: AST-aware chunking, hybrid retrieval, file watcher, conversation tail, and annotations already wired together.

How it works

  1. Parse & chunk — Splits content using type-matched strategies: function/class boundaries for code (via tree-sitter across 24 languages), headings for markdown, top-level keys for YAML/JSON. Chunks that exceed the embedding model's token limit are windowed and merged.

  2. Embed — Each chunk becomes a 384-dimensional vector using all-MiniLM-L6-v2 (in-process via Transformers.js + ONNX, no API calls). Vectors are stored in sqlite-vec.

  3. Build dependency graph — Import specifiers and exported symbols are captured during AST chunking, then resolved to build a file-level dependency graph and a symbol-level call graph. impact walks the transitive callers of a function (blast radius + tests to run); trace finds how one symbol reaches another; the mimirs affected CLI turns a git diff into the exact set of tests to run.

  4. Hybrid search — Queries run vector similarity and BM25 in parallel, combined by reciprocal-rank fusion (weighted, default 0.5) — robust to the two scorers' very different score scales. Identifiers are split (camelCase/snake_case) so a search for depends matches getDependsOn. Results are then boosted by dependency graph centrality and path heuristics. read_relevant returns individual chunks with entity names and exact line ranges (path:start-end).

  5. Watch & re-index — File changes are detected with a 2-second debounce. Changed files are re-indexed; deleted files are pruned.

  6. Conversation & checkpoints — Tails Claude Code's JSONL transcripts in real time. Agents can create checkpoints at important moments for future sessions to search.

  7. Annotations — Notes attached to files or symbols surface as [NOTE] blocks inline in read_relevant results.

  8. Analytics — Every query is logged. Analytics surface zero-result queries, low-relevance queries, and period-over-period trends.

Data handling

mimirs runs entirely on your machine. It indexes files your repo tracks plus
untracked-but-not-gitignored files (so a .env you forgot to gitignore could be
read — common secret patterns like .env, *.pem, *.key, and SSH keys are
excluded by default; add your own to exclude in .mimirs/config.json). File
content and embeddings are stored in /.mimirs/index.db, a local
SQLite file. Conversation indexing reads only the current project's transcripts
under ~/.claude/projects//.

The only network call is a one-time download of the embedding model
(Xenova/all-MiniLM-L6-v2) from huggingface.co, cached at
~/.cache/mimirs/models. Your code never leaves your machine — nothing is sent
to any server.

Supported languages

AST-aware chunking via bun-chunk with tree-sitter grammars:

TypeScript, JavaScript, Python, Go, Rust, Java, C, C++, C#, Ruby, PHP, Scala, Kotlin, Lua, Zig, Elixir, Haskell, OCaml, Dart, Bash/Zsh, TOML, YAML, HTML, CSS/SCSS/LESS

Also indexes: Markdown, JSON, XML, SQL, GraphQL, Protobuf, Terraform, Dockerfiles, Makefiles, and more. Files without a known extension fall back to paragraph splitting.

Documentation

  • Example tool outputs — what your agent actually receives over MCP
  • MCP tools, CLI & analytics
  • Configuration & examples
  • Benchmarks

Stack

Layer Choice
Runtime Bun (built-in SQLite, fast TS)
AST chunking bun-chunk — tree-sitter grammars for 24 languages
Embeddings Transformers.js + ONNX (in-process, no daemon)
Embedding model all-MiniLM-L6-v2 (~23MB, 384 dimensions) — configurable
Vector store sqlite-vec (single .db file)
MCP @modelcontextprotocol/sdk (stdio transport)
Plugin Claude Code plugin with skills + hooks

All data lives in .mimirs/ inside your project — add it to .gitignore.

常见问题

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

在客户端按下面的安装命令接入:brew install sqlite。装完在客户端配置里引用同一个包或端点。

Local Rag 怎么在 Claude、Cursor、VS Code 里配置?

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

Local Rag 收费吗?

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

Local Rag 需要 API Key 吗?

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

Local Rag 支持哪些客户端?

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

Local Rag 能提供哪些能力?

资料显示能力标签包括 rag、local、knowledge、memory。具体工具清单以官方文档为准。

Local Rag 需要什么运行环境?

运行时为 Cross-platform。

热门专题

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

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