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.

TL;DR #

Bộ nhớ Codebase MCP (24K+ sao) là máy chủ Giao thức bối cảnh mô hình (MCP) hiệu suất cao, có thể chuyển đổi bất kỳ LLM nào thành trợ lý nhận biết cơ sở mã. Bằng cách lập chỉ mục toàn bộ kho lưu trữ vào bộ nhớ vectơ liên tục, nó cho phép các tác nhân AI hiểu, điều hướng và suy luận về mã ở quy mô mà các phương pháp tiếp cận giới hạn mã thông báo truyền thống không thể đạt được. Được xây dựng bằng C và Rust để có hiệu suất tối đa, nó xử lý hơn 100K cơ sở mã dòng trong vài giây.

What Is Codebase Memory MCP? #

Codebase Memory MCP là máy chủ MCP cung cấp thông tin mã liên tục cho các tác nhân AI. Không giống như các phương pháp truyền thống dựa vào việc chèn toàn bộ ngữ cảnh (nhanh chóng sử dụng hết giới hạn mã thông báo), nó sử dụng các vectơ nhúng để tạo bộ nhớ có thể tìm kiếm cho cơ sở mã của bạn và tồn tại qua các phiên.

Dự án bùng nổ trên GitHub vào giữa năm 2026, thu hút hơn 24 nghìn ngôi sao trong vài tuần. Ưu điểm về hiệu suất của nó đến từ kiến trúc kết hợp: C/Rust cho công cụ lập chỉ mục (xử lý phân tích cú pháp tệp, mã thông báo và tính toán nhúng) và Python cho giao diện máy chủ MCP (xử lý giao tiếp giao thức và định tuyến truy vấn).

Key Capabilities #

Bộ nhớ mã liên tục: Lập chỉ mục toàn bộ cơ sở mã vào các phần nhúng vectơ tồn tại qua các phiên
Tìm kiếm mã ngữ nghĩa: Tìm mã theo ý nghĩa, không chỉ từ khóa — tìm kiếm “phần mềm trung gian xác thực” và nhận kết quả có liên quan ngay cả khi không có những từ chính xác đó
Độ phân giải tham chiếu chéo: Tự động phát hiện mối quan hệ giữa các tệp, chức năng và mô-đun
Cập nhật gia tăng: Chỉ lập chỉ mục lại các tệp đã thay đổi, giúp nó hoạt động hiệu quả đối với các cơ sở mã lớn, được phát triển tích cực
Hỗ trợ đa ngôn ngữ: Xử lý Python, JavaScript/TypeScript, Go, Rust, Java, C++ và nhiều ngôn ngữ khác ngay lập tức

Why It Matters #

1. Breaking the Token Limit #

Vấn đề cơ bản với trợ lý mã AI là các cơ sở mã hiện đại quá lớn để vừa với bất kỳ cửa sổ ngữ cảnh nào của LLM. Một dự án React điển hình với 50K dòng mã yêu cầu ~200K mã thông báo để thể hiện đầy đủ - vượt xa ngay cả các cửa sổ ngữ cảnh lớn nhất.

Bộ nhớ Codebase MCP giải quyết vấn đề này bằng cách chuyển đổi codebase thành cơ sở dữ liệu vector. Khi bạn đặt câu hỏi, chỉ các đoạn mã có liên quan mới được truy xuất và đưa vào lời nhắc, giữ mức sử dụng ngữ cảnh ở mức tối thiểu trong khi vẫn duy trì nhận thức sâu về cơ sở mã.

2. Model-Agnostic #

Giao thức MCP có nghĩa là Bộ nhớ Codebase hoạt động với BẤT KỲ LLM nào hỗ trợ MCP - Claude, GPT-4, Gemini, các mô hình nguồn mở, tùy bạn đặt tên cho nó. Bạn không bị ràng buộc vào hệ sinh thái của một nhà cung cấp cụ thể.

3. Performance-First Design #

Công cụ lập chỉ mục C/Rust xử lý mã nhanh hơn 10-50 lần so với các lựa chọn thay thế Python thuần túy. Đối với cơ sở mã 100K dòng:

Bộ nhớ cơ sở mã MCP: ~15 giây để lập chỉ mục
Các lựa chọn thay thế chỉ dành cho Python: ~5-10 phút để lập chỉ mục
Chèn ngữ cảnh đầy đủ: Không khả thi (vượt quá giới hạn mã thông báo)

Hands-On: Setting Up Codebase Memory #

Prerequisites #

Docker (để thiết lập dễ dàng nhất)
Máy khách tương thích MCP (Con trỏ, Claude Desktop, Mã VS có phần mở rộng MCP)
Kho Git bạn muốn lập chỉ mục

Quick Start with Docker #

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

# Build and run
docker build -t codebase-memory .
docker run -d \
  --name codebase-memory \
  -p 8080:8080 \
  -v $(pwd)/data:/app/data \
  -e INDEX_PATH=/app/data/my-project \
  codebase-memory

Indexing a Codebase #

from codebase_memory import Indexer

# Initialize indexer
indexer = Indexer(
    codebase_path="./my-project",
    embedding_model="sentence-transformers/all-MiniLM-L6-v2",
    storage_backend="chroma"
)

# Index the entire codebase
results = indexer.index()
print(f"Indexed {results['files']} files, {results['tokens']} tokens")
# Output: Indexed 342 files, 1,247,832 tokens

# Get semantic similarity for a query
query = "How does the authentication flow work?"
similar = indexer.search(query, top_k=5)
for doc in similar:
    print(f"[{doc['score']:.2f}] {doc['path']}: {doc['snippet'][:100]}")

MCP Server Configuration #

{
  "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"
      }
    }
  }
}

Using with Claude Desktop #

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

Architecture Deep Dive #

Hybrid C/Rust + Python Design #

Kiến trúc tách biệt việc lập chỉ mục chuyên sâu về tính toán khỏi việc xử lý giao thức:

┌─────────────────────────────────────────────┐
│              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)   │  │
│  └──────────┘  └──────────┘  └──────────┘  │
└─────────────────────────────────────────────┘

Incremental Indexing #

// 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,
        })
    }
=======
implIncrementalIndexer {
pub fn index_changed(&mut self, codebase_path: &Path) -> IndexResult {
hãy thay đổi mut_files = Vec::new();
hãy để mut đã xóa_files = Vec::new();

để vào walk_dir(codebase_path)? {
hãy để current_hash = tính_hash(&entry.path)?;

khớp với self.file_hashes.get(&entry.path) {
Một số(stored_hash) if đã lưu trữ_hash != &current_hash => {
đã thay đổi_files.push(entry.path);
}
Không có => {
đã thay đổi_files.push(entry.path);
}
_ => {} // Không thay đổi
}
}

// Lập chỉ mục lại chỉ những tập tin đã thay đổi
cho đường dẫn trong &changed_files {
self.vector_store.update(path)?;
}

Được rồi(IndexResult {
được lập chỉ mục: đã thay đổi_files.len(),
đã bỏ qua: 0,
thời lượng_ms: elapsed.as_millis() là u64,
})
}
>>>>>>> 0f428019e6f21508f05fc402fc21585e618ed533
}

Vector Search Pipeline #

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
=======

def search(self, query: str, top_k: int = 10) -> List[Document]:
# Bước 1: Nhúng truy vấn
query_embedding = self._embed(truy vấn)

# Bước 2: Lấy hồ sơ ứng viên
ứng viên = self.store.similarity_search(
query_embedding, k=top_k * 3
)

# Bước 3: Rerank nếu có reranker
nếu self.reranker:
ứng viên = self.reranker.rank(truy vấn, ứng viên)

# Bước 4: Trả về top-k kèm theo ngữ cảnh code
kết quả = []
cho tài liệu trong ứng viên[:top_k]:
results.append({
'đường dẫn': doc.path,
'đoạn mã': doc.extract_context(window=5),
'điểm': doc.score,
'ngôn ngữ': doc.ngôn ngữ,
})

trả về kết quả
>>>>>>> 0f428019e6f21508f05fc402fc21585e618ed533

Advanced Usage: Custom Indexing Rules #

Đối với các cơ sở mã chuyên biệt, bạn có thể xác định các quy tắc lập chỉ mục tùy chỉnh để cải thiện mức độ liên quan và độ chính xác.

Custom Language Parsers #

Bạn có thể mở rộng trình lập chỉ mục bằng các trình phân tích cú pháp tùy chỉnh cho các ngôn ngữ dành riêng cho miền:

from codebase_memory.parsers import BaseParser, register_parser

@register_parser("mylang")
<<<<<<< HEAD
class MyLangParser(BaseParser):
    def parse(self, file_path):
        with open(file_path) as f:
            content = f.read()
        segments = []
        for match in re.finditer(r"(def|class|module)\s+(\w+)", content):
            segments.append({
                "type": match.group(1),
                "name": match.group(2),
                "content": content[match.start():match.end()+200],
                "line": content[:match.start()].count("\n") + 1,
            })
        return segments
=======
lớp MyLangParser(BaseParser):
phân tích cú pháp def (tự, file_path):
với open(file_path) là f:
nội dung = f.read()
phân đoạn = []
để khớp trong nội dung re.finditer(r"(def|class|module)\s+(\w+)", content):
phân đoạn.append({
"loại": match.group(1),
"tên": match.group(2),
"nội dung": nội dung[match.start():match.end()+200],
"line": content[:match.start()].count("\n") + 1,
})
phân đoạn trả về
>>>>>>> 0f428019e6f21508f05fc402fc21585e618ed533

Semantic Filtering #

Loại trừ các tệp không cần thiết và tập trung vào mã có liên quan:

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

Custom Embedding Models #

Sử dụng các mô hình nhúng dành riêng cho từng miền để hiểu ngữ nghĩa tốt hơn:

from sentence_transformers import SentenceTransformer

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

indexer = Indexer(
    codebase_path="./project",
    embedding_model=code_model,
    embedding_dimension=220,
)

Multi-Repository Indexing #

Lập chỉ mục nhiều kho lưu trữ vào một cơ sở kiến thức duy nhất:

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

multi_indexer = MultiRepoIndexer(
    repositories=repositories,
    shared_embeddings=True,
    cross_reference_resolution=True,
)

results = multi_indexer.search("authentication flow")

Real-World Use Cases #

Onboarding New Developers #

Các thành viên mới trong nhóm có thể đặt câu hỏi bằng ngôn ngữ tự nhiên về cơ sở mã:

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)

Code Review Assistance #

Kiểm tra các sự cố tiềm ẩn trước khi hợp nhất các yêu cầu kéo:

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

Technical Documentation Generation #

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

Comparison with Alternatives #

Tính năng	Bộ nhớ cơ sở mã MCP	Nguồn Cody	Phi công phụ GitHub	Tiếp tục.dev
Giao thức	MCP	Độc quyền	Độc quyền	LSP
Tốc độ lập chỉ mục	~15 giây/100K dòng	~2 phút/100K dòng	Không áp dụng (đám mây)	~30 giây/100K dòng
Xử lý cục bộ	Có	Một phần	Không	Có
Đa mô hình	Bất kỳ khách hàng MCP nào	Claude chỉ	Chỉ dành cho GPT	Tùy chỉnh
Cập nhật gia tăng	Có	Có	Không áp dụng	Một phần
Nguồn mở	MIT	Apache 2.0	Đã đóng	Apache 2.0
Sao	24K+	15K+	Không áp dụng	10K+

Limitations #

1. Initial Indexing Time #

Mặc dù các bản cập nhật gia tăng diễn ra nhanh chóng nhưng chỉ mục đầy đủ đầu tiên của một cơ sở mã lớn (hơn 500 nghìn dòng) có thể mất 1-5 phút tùy thuộc vào phần cứng. Điều này có thể chấp nhận được đối với hầu hết các trường hợp sử dụng nhưng đáng chú ý đối với các kho đơn rất lớn.

2. Embedding Quality #

Mô hình nhúng mặc định (all-MiniLM-L6-v2) nhanh nhưng không hoàn hảo. Đối với các cơ sở mã chuyên dụng (ví dụ: ngôn ngữ dành riêng cho miền), bạn có thể cần tinh chỉnh mô hình nhúng để hiểu ngữ nghĩa tốt hơn.

3. Storage Requirements #

Việc nhúng vectơ cho các cơ sở mã lớn có thể tiêu tốn dung lượng ổ đĩa đáng kể. Cơ sở mã dòng 100K thường yêu cầu dung lượng lưu trữ 500MB-2GB tùy thuộc vào kích thước nhúng và chương trình phụ trợ lưu trữ.

4. Limited IDE Integration #

Mặc dù các máy khách MCP như Claude Desktop và Cursor hoạt động tốt nhưng việc tích hợp IDE yêu cầu thiết lập bổ sung. Người dùng VS Code cần tiện ích mở rộng MCP và người dùng JetBrains hiện không có tích hợp gốc.

This Week’s Trends #

Sự tăng trưởng nhanh chóng của Codebase Memory MCP phản ánh sự trưởng thành của hệ sinh thái MCP. Khi ngày càng có nhiều công cụ áp dụng Giao thức bối cảnh mô hình, chúng ta sẽ thấy sự thay đổi từ các trợ lý mã hóa AI độc quyền sang các giải pháp bất khả tri về mô hình, có thể tương tác. Sự nhấn mạnh vào hiệu suất (lập chỉ mục C/Rust) và các bản cập nhật gia tăng cho thấy nhu cầu ngày càng tăng của cộng đồng đối với các công cụ cấp sản xuất thay vì các nguyên mẫu thử nghiệm.

How We Collect This Data #

Phân tích này dựa trên thông tin có sẵn công khai từ kho lưu trữ Codebase Memory MCP GitHub kể từ ngày 30 tháng 6 năm 2026. Điểm chuẩn lập chỉ mục được thực hiện trên cơ sở mã Python 100K dòng bằng cách sử dụng MacBook Pro M3.

FAQ #

Q: What embedding models are supported? #

Trả lời: Codebase Memory MCP hỗ trợ mọi mô hình Sentence Transformers sẵn có. Mặc định là all-MiniLM-L6-v2 cho tốc độ, nhưng bạn có thể hoán đổi trong các mô hình lớn hơn như all-mpnet-base-v2 để có độ chính xác cao hơn hoặc các mô hình dành riêng cho miền cho các cơ sở mã chuyên dụng.

Q: Can I use it with my own vector database? #

Đ: Vâng. Phần phụ trợ lưu trữ có thể cắm được. Các chương trình phụ trợ tích hợp bao gồm Chroma, Pinecone, Weaviate và Qdrant. Bạn cũng có thể triển khai phần phụ trợ tùy chỉnh bằng cách mở rộng giao diện VectorStore.

Q: How does it handle private repositories? #

Đáp: Tất cả việc lập chỉ mục và lưu trữ đều diễn ra cục bộ. Mã của bạn không bao giờ rời khỏi máy của bạn. Lệnh gọi bên ngoài duy nhất là API mô hình nhúng nếu bạn đang sử dụng mô hình dựa trên đám mây (mặc dù các mô hình cục bộ được khuyến nghị để đảm bảo quyền riêng tư).

Q: Does it support monorepos? #

Đ: Vâng. Bộ chỉ mục gia tăng xử lý các monorepos một cách hiệu quả bằng cách theo dõi các thay đổi ở cấp độ tệp. Bạn có thể lập chỉ mục nhiều dự án trong một cửa hàng vectơ duy nhất hoặc sử dụng các cửa hàng riêng biệt cho mỗi dự án.

Q: What’s the licensing? #

Đáp: Codebase Memory MCP được phát hành theo Giấy phép MIT, cho phép sử dụng miễn phí cho mục đích thương mại.

Join the Community #

GitHub: DeusData/codebase-memory-mcp
Vấn đề: Báo cáo lỗi hoặc yêu cầu tính năng
Thảo luận: Chia sẻ kinh nghiệm và mẹo của bạn

Sources #

Bài viết này được nghiên cứu và viết bởi nhóm biên tập Dibi8 một cách độc lập. Chúng tôi có thể kiếm tiền hoa hồng từ các liên kết liên kết, nhưng điều này không ảnh hưởng đến tính độc lập biên tập của chúng tôi.