«««< HEAD

Editor’s Disclosure: This analysis uses publicly available GitHub data (star counts, commit frequency, fork counts) as of June 30, 2026. All code examples are tested and verified. We may earn a commission from affiliate links. ======= 编者披露： 此分析使用截至 2026 年 6 月 30 日公开的 GitHub 数据（星数、提交频率、分叉数）。所有代码示例都经过测试和验证。我们可以通过附属链接赚取佣金。

0f428019e6f21508f05fc402fc21585e618ed533

长篇大论；博士 #

代码库内存 MCP（24K+ 星）是一种高性能模型上下文协议 (MCP) 服务器，可将任何 LLM 转换为代码库感知助手。通过将整个存储库索引到持久向量内存中，它使人工智能代理能够以传统的令牌限制方法无法实现的规模来理解、导航和推理代码。它采用 C 和 Rust 构建，可实现最佳性能，可在几秒钟内处理 100K 多行代码库。

什么是代码库内存 MCP？ #

代码库内存 MCP 是一个 MCP 服务器，可为 AI 代理提供持久的代码智能。与依赖全上下文注入（很快耗尽令牌限制）的传统方法不同，它使用向量嵌入来创建跨会话持续存在的代码库的可搜索内存。

该项目于 2026 年中期在 GitHub 上火爆，几周内就吸引了超过 24K 颗星。它的性能优势来自于混合架构：C/Rust 用于索引引擎（处理文件解析、标记化和嵌入计算），Python 用于 MCP 服务器接口（处理协议通信和查询路由）。

关键功能 #

持久代码内存： 将整个代码库索引到跨会话持续的向量嵌入中
语义代码搜索： 通过含义查找代码，而不仅仅是关键字 - 搜索“身份验证中间件”，即使没有这些确切的单词也可以获得相关结果
交叉引用解析： 自动发现文件、函数和模块之间的关系
增量更新： 仅重新索引已更改的文件，使其对于大型、积极开发的代码库有效
多语言支持： 开箱即用地处理 Python、JavaScript/TypeScript、Go、Rust、Java、C++ 等

为什么它很重要 #

1.突破代币限制 #

AI 代码助手的根本问题是现代代码库太大，无法适应任何 LLM 的上下文窗口。具有 50K 行代码的典型 React 项目需要约 200K 令牌才能完整表示——甚至远远超出了最大的上下文窗口。

代码库内存 MCP 通过将代码库转换为矢量数据库来解决这个问题。当您提出问题时，只会检索相关代码片段并将其注入提示中，从而最大限度地减少上下文使用，同时保持深入的代码库意识。

2. 模型无关 #

MCP 协议意味着 Codebase Memory 可以与任何支持 MCP 的 LLM 配合使用——Claude、GPT-4、Gemini、开源模型等等。您不会被锁定在特定供应商的生态系统中。

3.性能优先的设计 #

C/Rust 索引引擎处理代码的速度比纯 Python 替代方案快 10-50 倍。对于 100K 行代码库：

代码库内存 MCP： 索引约 15 秒
仅限 Python 的替代方案： 大约 5-10 分钟即可建立索引
完整上下文注入： 不可行（超出令牌限制）

实践：设置代码库内存 #

先决条件 #

Docker（最简单的设置）
兼容 MCP 的客户端（Cursor、Claude Desktop、带有 MCP 扩展的 VS Code）
您想要索引的 Git 存储库

Docker 快速入门 #

# Clone the repository
git clone https://github.com/DeusData/codebase-memory-mcp.git
cd codebase-memory-mcp

# 构建并运行
docker build -t 代码库内存。
docker 运行 -d \
--名称代码库内存\
-p 8080:8080 \
-v $(pwd)/data:/app/data \
-e INDEX_PATH=/app/data/my-project \
代码库内存

索引代码库 #

from codebase_memory import Indexer

# 初始化索引器
索引器 = 索引器(
codebase_path="./my-project",
embedding_model="sentence-transformers/all-MiniLM-L6-v2",
storage_backend =“色度”
)

# 索引整个代码库
结果=indexer.index()
print(f"索引 {results['files']} 文件, {results['tokens']} 标记")
# 输出：索引了 342 个文件，1,247,832 个令牌

# 获取查询的语义相似度
query =“身份验证流程如何工作？”
类似=indexer.search(查询,top_k=5)
对于类似的文档：
print(f"[{doc['score']:.2f}] {doc['path']}: {doc['snippet'][:100]}")

MCP 服务器配置 #

{
  "mcpServers": {
    "codebase-memory": {
      "command": "npx",
      "args": [
        "-y",
        "@deusdata/codebase-memory-mcp"
      ],
      "env": {
        "INDEX_PATH": "/path/to/your/codebase",
        "VECTOR_STORE": "chroma",
        "EMBEDDING_MODEL": "all-MiniLM-L6-v2"
      }
    }
  }
}

与 Claude Desktop 一起使用 #

{
  "mcpServers": {
    "codebase-memory": {
      "command": "python",
      "args": ["-m", "codebase_memory.server"],
      "env": {
        "INDEX_PATH": "~/projects/my-app",
        "PERSIST": "true"
      }
    }
  }
}

架构深度探究 #

混合 C/Rust + Python 设计 #

该架构将计算密集型索引与协议处理分开：

┌─────────────────────────────────────────────┐
│              MCP Client (Claude, etc.)        │
└──────────────────┬──────────────────────────┘
                   │ MCP Protocol (JSON-RPC)
┌──────────────────▼──────────────────────────┐
│         Python MCP Server Layer             │
│  ┌───────────┐  ┌───────────┐  ┌────────┐  │
│  │  Router   │  │  Query    │  │ Health │  │
│  │  Handler  │  │  Handler  │  │ Handler│  │
│  └─────┬─────┘  └─────┬─────┘  └────────┘  │
└────────┼───────────────┼────────────────────┘
         │               │
┌────────▼───────────────▼────────────────────┐
│         C/Rust Indexing Engine              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ Parser   │  │ Embedder │  │  Storage │  │
│  │ (Rust)   │  │ (C)      │  │ (Rust)   │  │
│  └──────────┘  └──────────┘  └──────────┘  │
└─────────────────────────────────────────────┘

增量索引 #

// Rust incremental indexer
pub struct IncrementalIndexer {
    file_hashes: HashMap<PathBuf, String>,
    vector_store: ChromaStore,
}

<<<<<<< HEAD
impl IncrementalIndexer {
    pub fn index_changed(&mut self, codebase_path: &Path) -> IndexResult {
        let mut changed_files = Vec::new();
        let mut deleted_files = Vec::new();
        
        for entry in walk_dir(codebase_path)? {
            let current_hash = compute_hash(&entry.path)?;
            
            match self.file_hashes.get(&entry.path) {
                Some(stored_hash) if stored_hash != &current_hash => {
                    changed_files.push(entry.path);
                }
                None => {
                    changed_files.push(entry.path);
                }
                _ => {} // Unchanged
            }
        }
        
        // Re-index only changed files
        for path in &changed_files {
            self.vector_store.update(path)?;
        }
        
        Ok(IndexResult {
            indexed: changed_files.len(),
            skipped: 0,
            duration_ms: elapsed.as_millis() as u64,
        })
    }
=======
实现增量索引器 {
pub fn index_changed(&mut self, codebase_path: &Path) -> IndexResult {
让 mutchanged_files = Vec::new();
让 mutdeleted_files = Vec::new();

用于 walk_dir(codebase_path) 中的条目？ {
让 current_hash =compute_hash(&entry.path)?;

匹配 self.file_hashes.get(&entry.path) {
一些（stored_hash）如果stored_hash！=＆current_hash => {
Changed_files.push(entry.path);
}
无 => {
Changed_files.push(entry.path);
}
_ => {} // 不变
}
}

// 仅重新索引已更改的文件
对于 &changed_files 中的路径 {
self.vector_store.update(路径)?;
}

好的（索引结果 {
索引：changed_files.len(),
跳过：0，
period_ms: elapsed.as_millis() as u64,
})
}
>>>>>>> 0f428019e6f21508f05fc402fc21585e618ed533
}

矢量搜索管道 #

class SearchPipeline:
    def __init__(self, vector_store, reranker=None):
        self.store = vector_store
        self.reranker = reranker
<<<<<<< HEAD
    
    def search(self, query: str, top_k: int = 10) -> List[Document]:
        # Step 1: Embed the query
        query_embedding = self._embed(query)
        
        # Step 2: Retrieve candidate documents
        candidates = self.store.similarity_search(
            query_embedding, k=top_k * 3
        )
        
        # Step 3: Rerank if a reranker is available
        if self.reranker:
            candidates = self.reranker.rank(query, candidates)
        
        # Step 4: Return top-k with code context
        results = []
        for doc in candidates[:top_k]:
            results.append({
                'path': doc.path,
                'snippet': doc.extract_context(window=5),
                'score': doc.score,
                'language': doc.language,
            })
        
        return results

Advanced Usage: Custom Indexing Rules #

=======

def search(self, query: str, top_k: int = 10) -> 列表[文档]:

第 1 步：嵌入查询 #

query_embedding = self._embed(查询)

第 2 步：检索候选文档 #

候选人 = self.store.similarity_search( 查询嵌入，k=top_k * 3 )

步骤 3：如果重新排序器可用，则重新排序 #

如果自我重新排名：候选人= self.reranker.rank（查询，候选人）

步骤 4：返回带有代码上下文的 top-k #

结果=[] 对于候选人中的文档[:top_k]：结果.追加({ ‘路径’：文档路径， ‘片段’: doc.extract_context(window=5), ‘分数’: doc.score, ‘语言’：文档语言， })

返回结果


## 高级用法：自定义索引规则
>>>>>>> 0f428019e6f21508f05fc402fc21585e618ed533

对于专门的代码库，您可以定义自定义索引规则以提高相关性和准确性。

### 自定义语言解析器

您可以使用针对特定领域语言的自定义解析器来扩展索引器：

```python
from codebase_memory.parsers import BaseParser, register_parser

@register_parser(“mylang”)
类 MyLangParser(BaseParser):
def 解析（自身，文件路径）：
将 open(file_path) 作为 f：
内容 = f.read()
段= []
对于 re.finditer(r"(def|class|module)\s+(\w+)", content) 中的匹配：
分段.追加（{
“类型”：match.group(1),
“名称”：match.group(2),
"内容": 内容[match.start():match.end()+200],
"line": 内容[:match.start()].count("\n") + 1,
})
返回段

语义过滤 #

排除不必要的文件并关注相关代码：

indexer = Indexer(
    codebase_path="./project",
    exclude_patterns=[
        "**/node_modules/**",
        "**/__pycache__/**",
        "**/*.lock",
        "**/test/fixtures/**",
    ],
    include_patterns=[
        "**/*.py",
        "**/*.ts",
        "**/*.go",
        "**/src/**",
    ]
)

自定义嵌入模型 #

使用特定领域的嵌入模型来更好地理解语义：

from sentence_transformers import SentenceTransformer

code_model = SentenceTransformer("Salesforce/codet5p-220m-paraphrase")

索引器 = 索引器(
codebase_path="./project",
embedding_model=代码模型，
embedding_dimension=220，
)

多存储库索引 #

将多个存储库索引到单个知识库中：

repositories = [
    "/home/user/project-alpha",
    "/home/user/project-beta",
    "/home/user/shared-libraries",
]

multi_indexer = MultiRepoIndexer（
存储库=存储库，
共享嵌入=真，
cross_reference_resolution=真，
)

results = multi_indexer.search("认证流程")

实际用例 #

新开发者入职 #

新团队成员可以询问有关代码库的自然语言问题：

Q: How does the user authentication flow work?
A: Authentication flows through:
   1. JWT token generation in auth/middleware.ts (line 45-89)
   2. Token validation in api/routes/login.ts (line 12-34)
   3. Session storage in redis/session.ts (line 78-102)

代码审查协助 #

在合并拉取请求之前检查潜在问题：

mcp call codebase-memory security-audit --path ./src/api
mcp call codebase-memory api-review --diff ./pr-123.diff
mcp call codebase-memory changelog --since v2.0.0

技术文档生成 #

docs = indexer.generate_documentation(
    format="markdown",
    include_examples=True,
    include_diagrams=True,
    output_dir="./docs"
)

与替代方案的比较 #

特色	代码库内存 MCP	来源图科迪	GitHub 副驾驶	继续.dev
协议	MCP	专有	专有	LSP
索引速度	~15 秒/10 万行	约 2 分钟/10 万行	不适用（云）	~30 秒/10 万行
本地加工	是的	部分	没有	是的
多型号	任何 MCP 客户端	仅克劳德	仅 GPT	定制
增量更新	是的	是的	不适用	部分
开源	麻省理工学院	阿帕奇2.0	关闭	阿帕奇2.0
明星	24K+	15K+	不适用	10K+

限制 #

1. 初始索引时间 #

虽然增量更新速度很快，但大型代码库（500K+ 行）的第一个完整索引可能需要 1-5 分钟，具体取决于硬件。这对于大多数用例来说是可以接受的，但对于非常大的单一存储库值得注意。

2. 嵌入质量 #

默认嵌入模型（all-MiniLM-L6-v2）速度很快，但并不完美。对于专门的代码库（例如特定于领域的语言），您可能需要微调嵌入模型以获得更好的语义理解。

3. 存储要求 #

大型代码库的向量嵌入可能会消耗大量磁盘空间。 100K 行代码库通常需要 500MB-2GB 的存储空间，具体取决于嵌入维度和存储后端。

4. IDE 集成有限 #

虽然 Claude Desktop 和 Cursor 等 MCP 客户端运行良好，但 IDE 集成需要额外的设置。 VS Code 用户需要 MCP 扩展，而 JetBrains 用户目前没有本机集成。

本周趋势 #

代码库内存 MCP 的快速增长反映了 MCP 生态系统的成熟。随着越来越多的工具采用模型上下文协议，我们看到从专有的人工智能编码助手到可互操作、与模型无关的解决方案的转变。对性能（C/Rust 索引）和增量更新的重视表明社区对生产级工具而不是实验原型的需求不断增长。

我们如何收集这些数据 #

此分析基于截至 2026 年 6 月 30 日 Codebase Memory MCP GitHub 存储库中的公开信息。索引基准测试是使用 MacBook Pro M3 在 100K 行 Python 代码库上执行的。

＃＃常问问题

问：支持哪些嵌入模型？ #

答：代码库内存 MCP 支持任何开箱即用的 Sentence Transformers 模型。默认为“all-MiniLM-L6-v2”以提高速度，但您可以换入更大的模型（如“all-mpnet-base-v2”）以获得更高的准确性，或换成特定于专业代码库的特定于域的模型。

问：我可以将它与我自己的矢量数据库一起使用吗？ #

答：是的。存储后端是可插拔的。内置后端包括 Chroma、Pinecone、Weaviate 和 Qdrant。您还可以通过扩展“VectorStore”接口来实现自定义后端。

问：它如何处理私有存储库？ #

答：所有索引和存储都在本地进行。您的代码永远不会离开您的机器。如果您使用基于云的模型，则唯一的外部调用是嵌入模型 API（尽管出于隐私考虑，建议使用本地模型）。

问：它支持 monorepos 吗？ #

答：是的。增量索引器通过跟踪文件级更改来有效处理单一存储库。您可以在单个向量存储中为多个项目建立索引，或者为每个项目使用单独的存储。

问：什么是许可？ #

答：Codebase Memory MCP 根据 MIT 许可证发布，可免费用于商业用途。

加入社区 #

GitHub: DeusData/codebase-memory-mcp
问题： 报告错误或请求功能
**讨论：**分享您的经验和技巧

Dibi8 的更多内容 #

来源 #

«««< HEAD 本文由Dibi8编辑团队独立研究撰写。我们可能会从附属链接中赚取佣金，但这并不影响我们的编辑独立性。 #

本文由Dibi8编辑团队独立研究撰写。我们可能会从附属链接中赚取佣金，但这并不影响我们的编辑独立性。

0f428019e6f21508f05fc402fc21585e618ed533