rmcp memex

MCP搜索检索

提供方 vetcoders

搜索检索 未标注 无需鉴权 社区 / 第三方 Claude DesktopClaude

rmcp-memex 是一个自定义的 Rust MCP 内核,通过 LanceDB 为 AI 代理提供 RAG 和长期记忆功能。

一句话选型结论

按资料字段整理

rmcp memex 属于搜索检索类 MCP 服务器,传输方式未标注,无需鉴权,可直接接入 Claude Desktop、Claude,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

RAGRust本地部署长期记忆AI代理语义搜索向量存储

安装与配置

未标注 无需鉴权
上游未给出传输方式
  1. 1
    准备运行环境

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

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

    连接成功后客户端会列出约 13 个工具,随便调一个只读工具确认能返回结果。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
联网搜索取证

让模型查最新资料并给出出处。

资料聚合

把一个主题的网页、文档集中抓回来整理。

情报与竞品检索

按关键词持续检索行业动态和竞品信息。

选择建议

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

值得选的地方

  • 资料标注 13 个工具,覆盖面较广,能满足多种调用。
  • 已适配 Claude Desktop、Claude,换客户端不用重新研究配置。
  • 资料标注无需鉴权,装好就能连。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
rmcp memex当前 13 未标注 未标注 无 2026-05-17
Brave Search 433812ff 2 未标注 未标注 无 2026-05-17
Sequentialthinking 1 SSE · 服务端推送 远程部署 有 2026-05-18
Baidu Netdisk 未标注 未标注 未标注 无 2026-05-17
ragflow 未标注 stdio · 本地进程 本地部署 有 2026-04-11
mindsdb (430e18) 未标注 未标注 未标注 有 2026-05-17

服务器档案

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

详细介绍

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

rmcp内存

rmcp-memex 是一个定制的Rust MCP内核,通过LanceDB为AI代理提供RAG和长期内存功能。

它揭示了来自单个规范曲面的两种显式传输模式:

  1. stdio (标准MCP):本地代理的本地MCP集成(例如Claude Desktop)。
  2. HTTP/SSE (多代理守护程序):一种中央守护进程模式,允许并发AI代理通过网络访问同一内存池,解决了LanceDB的独占锁约束。

> 关于别名的说明: 已发布的包和主要入口点是 rmcp-memex。为了操作方便,它安装了别名 rust-memex, rmmx,以及 rmemex。这些都是严格意义上的便利链接 rmcp-memex 内核,而不是单独的产品。

概述

作为MCP(模型上下文协议)服务器, rmcp-memex 提供:

  • RAG(检索增强生成) -文档索引与语义搜索
  • 混合搜索 -BM25关键字+语义向量搜索(基于Tantivy)
  • 矢量存储器 -文本块的语义存储与检索
  • 命名空间隔离 -命名空间中的数据隔离
  • 安全 -基于令牌的受保护命名空间访问控制
  • 洋葱片建筑 -层次嵌入(OUTER→中间→INNER→CORE)
  • 预处理 -对话导出中的自动噪声过滤(减少约36-40%)
  • 精确匹配重复数据删除 -基于SHA256的重复导出数据消除

建筑```

┌─────────────────────────────────────────────────────────────┐
│ rmcp-memex │
├─────────────────────────────────────────────────────────────┤
│ MCP Server (JSON-RPC over stdio) │
│ ├── handlers/mod.rs - Request routing & validation │
│ ├── security/mod.rs - Namespace access control │
│ └── rag/mod.rs - RAG pipeline │
├─────────────────────────────────────────────────────────────┤
│ Storage Layer │
│ ├── LanceDB - Vector embeddings │
│ ├── Tantivy - BM25 keyword index │
│ └── moka - In-memory cache │
├─────────────────────────────────────────────────────────────┤
│ Embeddings (External Providers) │
│ ├── Ollama - Local models (recommended) │
│ ├── MLX Bridge - Apple Silicon acceleration │
│ └── OpenAI-compatible - Any compatible endpoint │
└─────────────────────────────────────────────────────────────┘


## 特性

### RAG工具

|工具|说明|
|------|-------------|
| `rag_index` |从文件中索引文档|
| `rag_index_text` |索引原始文本|
| `rag_search` |语义搜索文档(支持 `auto_route`) |

### 内存工具

|工具|说明|
|------|-------------|
| `memory_upsert` |在命名空间中添加/更新块|
| `memory_get` |按ID获取块|
| `memory_search` |在命名空间中进行语义搜索(支持 `auto_route`) |
| `memory_delete` |删除块|
| `memory_purge_namespace` |删除命名空间中的所有块|
| `dive` |对所有洋葱层(外层/中层/内层/核心)进行深入探索|

### 安全工具

|工具|说明|
|------|-------------|
| `namespace_create_token` |为命名空间创建访问令牌|
| `namespace_revoke_token` |撤销令牌(命名空间变为公共)|
| `namespace_list_protected` |列出受保护的命名空间|
| `namespace_security_status` |安全系统状态|

## 图书馆使用情况

`rmcp-memex` 可以用作Rust应用程序中的库。它提供了一个高层次 `MemexEngine` 用于矢量存储操作的API。

### 添加到Cargo.toml```toml
# Full library with CLI
rmcp-memex = "0.4"

# Library only (no CLI dependencies)
rmcp-memex = { version = "0.4", default-features = false }

基本用法```rust

use rmcp_memex::{MemexEngine, MemexConfig, MetaFilter, StoreItem};
use serde_json::json;

[tokio::main]

async fn main() -> anyhow::Result<()> {
// Quick setup for any application
let engine = MemexEngine::for_app("my-app", "documents").await?;

// Store a document
engine.store(
"doc-1",
"Patient presented with lethargy and decreased appetite",
json!({"patient_id": "P-123", "visit_type": "checkup"})
).await?;

// Search semantically
let results = engine.search("lethargy symptoms", 10).await?;
for r in &results {
println!("{}: {} (score: {:.2})", r.id, r.text, r.score);
}

// Get by ID
if let Some(doc) = engine.get("doc-1").await? {
println!("Found: {}", doc.text);
}

// Delete
engine.delete("doc-1").await?;

Ok(())
}


### Vista集成

对于Vista PIMS,请使用优化的构造函数:```rust
use rmcp_memex::MemexEngine;

// Vista-optimized: 1024 dims, qwen3-embedding:0.6b model
let engine = MemexEngine::for_vista().await?;

// Store visit notes
engine.store(
&quot;visit-456&quot;,
&quot;SOAP note: Feline diabetes mellitus diagnosis...&quot;,
json!({&quot;patient_id&quot;: &quot;P-789&quot;, &quot;doc_type&quot;: &quot;soap_note&quot;})
).await?;

批量操作```rust

use rmcp_memex::{MemexEngine, StoreItem};
use serde_json::json;

let engine = MemexEngine::for_app("my-app", "notes").await?;

let items = vec![
StoreItem::new("doc-1", "First document").with_metadata(json!({"type": "note"})),
StoreItem::new("doc-2", "Second document").with_metadata(json!({"type": "note"})),
StoreItem::new("doc-3", "Third document").with_metadata(json!({"type": "note"})),
];

let result = engine.store_batch(items).await?;
println!("Stored {} documents", result.success_count);


### GDPR合规删除```rust
use rmcp_memex::{MemexEngine, MetaFilter};

let engine = MemexEngine::for_app(&quot;my-app&quot;, &quot;patients&quot;).await?;

// Delete all documents for a specific patient
let filter = MetaFilter::for_patient(&quot;P-123&quot;);
let deleted = engine.delete_by_filter(filter).await?;
println!(&quot;Deleted {} documents&quot;, deleted);

混合搜索(BM25+矢量)```rust

use rmcp_memex::{MemexEngine, SearchMode};

let engine = MemexEngine::for_app("my-app", "documents").await?;

// Hybrid search with BM25 + vector fusion (recommended)
let results = engine.search_hybrid("dragon mac studio", 10).await?;
for r in &results {
println!("{}: {} (combined: {:.2}, vector: {:.2}, bm25: {:.2})",
r.id, r.document, r.combined_score, r.vector_score, r.bm25_score);
}

// Explicit mode selection
let results = engine.search_with_mode("exact keyword", 10, SearchMode::Keyword).await?;
let results = engine.search_with_mode("semantic concept", 10, SearchMode::Vector).await?;
let results = engine.search_with_mode("best of both", 10, SearchMode::Hybrid).await?;


### 代理工具API

对于MCP兼容的AI代理:```rust
use rmcp_memex::{MemexEngine, tool_definitions, memory_store, memory_search};
use serde_json::json;

let engine = MemexEngine::for_app(&quot;agent&quot;, &quot;memory&quot;).await?;

// Get tool definitions for MCP registration
let tools = tool_definitions();
for tool in &amp;tools {
println!(&quot;Tool: {} - {}&quot;, tool.name, tool.description);
}

// Use tool functions
let result = memory_store(
&amp;engine,
&quot;mem-1&quot;.to_string(),
&quot;Important information to remember&quot;.to_string(),
json!({&quot;source&quot;: &quot;conversation&quot;}),
).await?;
assert!(result.success);

let results = memory_search(&amp;engine, &quot;important&quot;.to_string(), 5, None).await?;

功能标志

功能 描述 默认值
cli CLI二进制文件、TUI向导、进度条 是
provider-cascade Ollama/OpenAI兼容嵌入 是
# Build library only (no CLI)
cargo build --no-default-features

# Build with CLI
cargo build --features cli

配置指南

将rmcp-memex作为库集成到任何Rust项目中的完整指南。

先决条件

奥拉玛 (推荐)或任何与OpenAI兼容的嵌入API:```bash

Install Ollama

curl -fsSL https://ollama.com/install.sh | sh

Pull an embedding model (choose based on your needs)

ollama pull qwen3-embedding:0.6b # 1024 dims, ~600MB (fast, good quality)
ollama pull qwen3-embedding:8b # 4096 dims, ~4GB (best quality)
ollama pull nomic-embed-text # 768 dims, ~274MB (lightweight)

Verify it's running

curl http://localhost:11434/api/tags


### 环境变量

通过配置 `.env` 或环境:```bash
# =============================================================================
# EMBEDDING PROVIDER CONFIGURATION
# =============================================================================

# Ollama (default, recommended)
OLLAMA_BASE_URL=http://localhost:11434
EMBEDDING_MODEL=qwen3-embedding:0.6b
EMBEDDING_DIMENSION=1024

# Database storage (auto-created)
MEMEX_DB_PATH=~/.rmcp-servers/myapp/lancedb

# Optional: BM25 keyword search index
MEMEX_BM25_PATH=~/.rmcp-servers/myapp/bm25

# =============================================================================
# ADVANCED: Multiple providers (fallback cascade)
# =============================================================================

# Remote embedding server fallback
# DRAGON_BASE_URL=http://your-server.local
# DRAGON_EMBEDDER_PORT=12345

# MLX embedder for Apple Silicon
# EMBEDDER_PORT=12300
# MLX_MAX_BATCH_CHARS=32000
# MLX_MAX_BATCH_ITEMS=16
# DISABLE_MLX=1  # Set to disable MLX fallback

快速启动(自动配置)```rust

use rmcp_memex::MemexEngine;
use serde_json::json;

// Auto-configures from defaults + environment
let engine = MemexEngine::for_app("my-app", "default").await?;

engine.store("doc-1", "Document content...", json!({"type": "note"})).await?;
let results = engine.search("content", 10).await?;


### 自定义配置```rust
use rmcp_memex::{MemexConfig, MemexEngine};
use rmcp_memex::embeddings::{EmbeddingConfig, ProviderConfig};

// Read from your app&#x27;s environment
let ollama_url = std::env::var(&quot;OLLAMA_BASE_URL&quot;)
.unwrap_or_else(|_| &quot;http://localhost:11434&quot;.to_string());
let model = std::env::var(&quot;EMBEDDING_MODEL&quot;)
.unwrap_or_else(|_| &quot;qwen3-embedding:0.6b&quot;.to_string());
let dimension: usize = std::env::var(&quot;EMBEDDING_DIMENSION&quot;)
.unwrap_or_else(|_| &quot;1024&quot;.to_string())
.parse()
.unwrap_or(1024);
let db_path = std::env::var(&quot;MEMEX_DB_PATH&quot;)
.unwrap_or_else(|_| &quot;~/.rmcp-servers/myapp/lancedb&quot;.to_string());

let config = MemexConfig {
app_name: &quot;my-app&quot;.to_string(),
namespace: &quot;default&quot;.to_string(),
db_path: Some(db_path),
dimension,
embedding_config: EmbeddingConfig {
required_dimension: dimension,
providers: vec![ProviderConfig {
name: &quot;ollama&quot;.to_string(),
base_url: ollama_url,
model,
priority: 1,
endpoint: &quot;/v1/embeddings&quot;.to_string(),
}],
..EmbeddingConfig::default()
},
enable_bm25: false,
bm25_config: None,
};

let engine = MemexEngine::new(config).await?;

提供者级联(多次回退)

配置多个提供程序-库按优先级顺序尝试它们:```rust
use rmcp_memex::embeddings::{EmbeddingConfig, ProviderConfig};

let config = EmbeddingConfig {
required_dimension: 1024,
providers: vec![
// Priority 1: Local Ollama (fastest)
ProviderConfig {
name: "ollama-local".to_string(),
base_url: "http://localhost:11434".to_string(),
model: "qwen3-embedding:0.6b".to_string(),
priority: 1,
endpoint: "/v1/embeddings".to_string(),
},
// Priority 2: Remote server fallback
ProviderConfig {
name: "remote-server".to_string(),
base_url: "http://your-server:8080".to_string(),
model: "text-embedding-3-small".to_string(),
priority: 2,
endpoint: "/v1/embeddings".to_string(),
},
// Priority 3: OpenAI API fallback
ProviderConfig {
name: "openai".to_string(),
base_url: "https://api.openai.com".to_string(),
model: "text-embedding-3-small".to_string(),
priority: 3,
endpoint: "/v1/embeddings".to_string(),
},
],
..EmbeddingConfig::default()
};


### 命名空间策略

**建议:每个应用程序一个命名空间,使用元数据进行筛选:**```rust
// ✅ CORRECT: Single namespace, filter by user_id/entity_id in metadata
let engine = MemexEngine::for_app(&quot;my-app&quot;, &quot;default&quot;).await?;

// Store with entity IDs in metadata
engine.store(&quot;doc-1&quot;, &quot;Document content...&quot;, json!({
&quot;user_id&quot;: &quot;U-123&quot;,      // For multi-tenant filtering
&quot;project_id&quot;: &quot;P-456&quot;,   // For project-level filtering
&quot;doc_type&quot;: &quot;note&quot;,
&quot;created_at&quot;: &quot;2024-12-28&quot;
})).await?;

// Search within user context
let filter = MetaFilter::default().with_custom(&quot;user_id&quot;, &quot;U-123&quot;);
let results = engine.search_filtered(&quot;query&quot;, filter, 10).await?;

// GDPR deletion: remove all user data
let deleted = engine.delete_by_filter(
MetaFilter::default().with_custom(&quot;user_id&quot;, &quot;U-123&quot;)
).await?;

嵌入模型参考

型号 尺寸 大小 用例
qwen3-embedding:0.6b 1024 ~600MB 速度快,质量好(推荐)
qwen3-embedding:8b 4096 ~4GB 质量最好,速度较慢
nomic-embed-text 768 ~274MB 轻便、快速
all-minilm 384 ~46MB 非常快,质量较低

故障排除

错误:“没有可用的嵌入提供程序”```bash

Check if Ollama is running

curl http://localhost:11434/api/tags

Start Ollama

ollama serve

Pull model if missing

ollama pull qwen3-embedding:0.6b


**错误:“尺寸不匹配”**

- 创建后,每个表的LanceDB维度都是固定的
- 使用不同的 `db_path` 不同尺寸
- 删除旧数据库以更改维度

**错误:“连接被拒绝”**```bash
# Linux
systemctl status ollama
systemctl start ollama

# macOS
brew services info ollama
brew services start ollama

# Or run manually
ollama serve

性能调整:```bash

Larger batches (requires more VRAM)

MLX_MAX_BATCH_CHARS=64000
MLX_MAX_BATCH_ITEMS=32


______________________________________________________________________

## 快速开始

### 安装

**快速安装(推荐):**```bash
curl -LsSf https://raw.githubusercontent.com/VetCoders/rmcp-memex/main/install.sh | sh

来源:```bash
cargo install --path .


### 跑步```bash
# Default mode (all features)
rmcp-memex serve

# Memory-only mode (no filesystem access)
rmcp-memex serve --mode memory

# With security enabled
rmcp-memex serve --security-enabled

# With HTTP/SSE server for multi-agent access
rmcp-memex serve --http-port 6660

# HTTP-only daemon mode (no MCP stdio)
rmcp-memex serve --http-port 6660 --http-only

HTTP/SSE服务器(多代理访问)

LanceDB使用独占文件锁——一次只能有一个进程访问数据库。
HTTP/SSE服务器通过为多个代理提供一个中央接入点来解决这个问题。

建筑```

┌─────────────────────────────────────────────────────────────┐
│ rmcp-memex daemon │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ MCP Server │ │ HTTP/SSE │ │
│ │ (stdio) │ │ (port 6660) │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
│ └──────────┬───────────┘ │
│ ▼ │
│ ┌─────────────┐ │
│ │ RAGPipeline │ ← Single lock holder │
│ └──────┬──────┘ │
│ ▼ │
│ ┌─────────────┐ │
│ │ LanceDB │ │
│ └─────────────┘ │
└─────────────────────────────────────────────────────────────┘
▲ ▲
│ │
Claude Desktop HTTP Agents
(MCP stdio) (curl, fetch)


### HTTP端点

|端点|方法|描述|
|----------|--------|-------------|
| `/health` |GET |健康检查(状态、db_path、embedding_provider)|
| `/search` |POST |带可选层过滤器的矢量搜索|
| `/sse/search` |GET|SSE流媒体搜索(实时结果)|
| `/upsert` |POST |添加/更新文档|
| `/index` |POST |使用洋葱片进行完整管道索引|
| `/expand/{ns}/{id}` |GET |扩大洋葱片(带孩子)|
| `/parent/{ns}/{id}` |GET |钻取父切片|
| `/get/{ns}/{id}` |GET |按ID获取文档|
| `/delete/{ns}/{id}` |POST |删除文档|
| `/ns/{namespace}` |DELETE |清除整个命名空间|

### SSE端点上的MCP(克劳德代码兼容性)

|端点|方法|描述|
|----------|--------|-------------|
| `/sse/` |GET|SSE流-发送 `endpoint` 带有消息URL的事件|
| `/messages/` |POST | JSON-RPC消息 `?session_id=xxx` |

在中配置 `~/.claude.json`:```json
{
&quot;mcpServers&quot;: {
&quot;rmcp-memex&quot;: {
&quot;type&quot;: &quot;sse&quot;,
&quot;url&quot;: &quot;http://localhost:6660/sse/&quot;
}
}
}

用法示例```bash

Start daemon

rmcp-memex serve --http-port 6660 --http-only --db-path ~/.ai-memories/lancedb &

Health check

curl http://localhost:6660/health

Store document

curl -X POST http://localhost:6660/upsert \
-H "Content-Type: application/json" \
-d '{"namespace": "agent1", "id": "mem1", "content": "Important context..."}'

Search

curl -X POST http://localhost:6660/search \
-H "Content-Type: application/json" \
-d '{"query": "context", "namespace": "agent1", "limit": 10}'

SSE streaming search

curl -N "http://localhost:6660/sse/search?query=context&namespace=agent1&limit=5"


### 多主机数据库路径

对于具有多台机器的设置(例如dragon、mgbook16),请使用每台主机的数据库路径:```bash
# Per-host paths (each machine gets own database)
rmcp-memex serve --db-path ~/.ai-memories/lancedb.$(hostname -s)

# Or use the wizard for machine-agnostic configuration
rmcp-memex wizard

TUI向导自动检测主机名并提供:

  • 共享模式: ~/.ai-memories/lancedb (到处都是同一条路)
  • 每台主机模式: ~/.ai-memories/lancedb.dragon, ~/.ai-memories/lancedb.mgbook16等等。

配置(TOML)```toml

~/.rmcp-servers/config/rmcp-memex.toml

mode = "full"
db_path = "~/.rmcp-servers/rmcp-memex/lancedb"
cache_mb = 4096
log_level = "info"

Whitelist of allowed paths

allowed_paths = [
"~",
"/Volumes/ExternalDrive/data"
]

Security

security_enabled = true
token_store_path = "~/.rmcp-servers/rmcp-memex/tokens.json"


## 文档

- 01_安全.md -安全系统(命名空间令牌)
- 02_configuration.md -配置和CLI选项

## 洋葱片建筑

rmcp memex提供了分层的“洋葱片”,而不是传统的扁平分块:```
┌─────────────────────────────────────────┐
│  OUTER (~100 chars)                     │  ← Minimum context, maximum navigation
│  Keywords + ultra-compression           │
├─────────────────────────────────────────┤
│  MIDDLE (~300 chars)                    │  ← Key sentences + context
├─────────────────────────────────────────┤
│  INNER (~600 chars)                     │  ← Expanded content
├─────────────────────────────────────────┤
│  CORE (full text)                       │  ← Complete document
└─────────────────────────────────────────┘

哲学: “最少信息→ 最大导航路径”

QueryRouter和自动路由

用于自动搜索模式选择的智能查询意图检测:```bash

Auto-detect query intent and select optimal mode

rmcp-memex search -n memories -q "when did we buy dragon" --auto-route

Output: Query intent: temporal (confidence: 0.70)

Selects: hybrid mode with date boosting

Structural queries suggest loctree

rmcp-memex search -n code -q "who imports main.rs" --auto-route

Output: Query intent: structural (confidence: 0.80)

Consider: loctree query --kind who-imports --target main.rs

Deep exploration with all onion layers

rmcp-memex dive -n memories -q "dragon" --verbose


**意图类型:**

|意图|触发关键字|推荐模式|
|--------|-----------------|------------------|
|时间|时间,日期,昨天,前,2024 |混合(日期增强)|
|结构化|导入、依赖、模块、谁使用|BM25+loctree建议|
|语义|相似、相关、解释|矢量|
|精确|“引号字符串”|BM25|
|混合|(默认)|矢量+BM25融合|

### CLI命令```bash
# Index with onion slicing (default)
rmcp-memex index -n memories /path/to/data/ --slice-mode onion

# Index with progress bar and ETA
rmcp-memex index -n memories /path/to/data/ --progress

# Index with flat chunking (backward compatible)
rmcp-memex index -n memories /path/to/data/ --slice-mode flat

# Search in namespace
rmcp-memex search -n memories -q &quot;best moments&quot; --limit 10

# Search only in specific layer
rmcp-memex search -n memories -q &quot;query&quot; --layer outer

# Drill down in hierarchy (expand children)
rmcp-memex expand -n memories -i &quot;slice_id_here&quot;

# Get chunk by ID
rmcp-memex get -n memories -i &quot;chunk_abc123&quot;

# RAG search (cross-namespace)
rmcp-memex rag-search -q &quot;search term&quot; --limit 5

# List namespaces with stats
rmcp-memex namespaces --stats

# Export namespace to JSON
rmcp-memex export -n memories -o backup.json --include-embeddings

预处理(噪声滤波)

自动消除对话输出中约36-40%的噪音:

  • MCP工具工件(,等等)
  • CLI输出(git状态、货物构建、npm安装)
  • 元数据(UUID、时间戳→ 占位符)
  • 空/样板内容```bash

Index with preprocessing

rmcp-memex index -n memories /path/to/export.json --preprocess


### 精确匹配重复数据删除

基于SHA256的重叠导出数据消除(例如,包含6个月数据的季度导出):```bash
# Dedup enabled (default)
rmcp-memex index -n memories /path/to/data/

# Disable dedup
rmcp-memex index -n memories /path/to/data/ --no-dedup

统计输出:```
Indexing complete:
New chunks: 234
Files indexed: 67
Skipped (duplicate): 33
Deduplication: enabled


## 代码结构```
rmcp-memex/
├── src/
│   ├── lib.rs              # Public API &amp; ServerConfig
│   ├── bin/
│   │   └── rmcp-memex.rs   # CLI binary (serve, index, search, get, expand, etc.)
│   ├── handlers/
│   │   └── mod.rs          # MCP request handlers
│   ├── security/
│   │   └── mod.rs          # Namespace access control
│   ├── rag/
│   │   └── mod.rs          # RAG pipeline + OnionSlice architecture
│   ├── preprocessing/
│   │   └── mod.rs          # Noise filtering for conversation exports
│   ├── storage/
│   │   └── mod.rs          # LanceDB + Tantivy (schema v3 with content_hash)
│   ├── embeddings/
│   │   └── mod.rs          # MLX/FastEmbed bridge
│   └── tui/
│       └── mod.rs          # Configuration wizard
└── Cargo.toml

Claude/MCP集成

添加 ~/.claude.json:json { &quot;mcpServers&quot;: { &quot;rmcp-memex&quot;: { &quot;command&quot;: &quot;rmcp-memex&quot;, &quot;args&quot;: [&quot;serve&quot;, &quot;--security-enabled&quot;] } } }


VetCoders与人工智能代理共同创建Vibecraft(c)2025 LibraxisAI团队
合著者: 马修 & 克劳迪

常见问题

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

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

rmcp memex 怎么在 Claude Desktop、Claude 里配置?

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

rmcp memex 收费吗?

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

rmcp memex 需要 API Key 吗?

资料标注为无需认证,装好就能连;如果实际调用时报鉴权错误,按官方文档补上凭据。

rmcp memex 支持哪些客户端?

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

rmcp memex 能提供哪些能力?

资料显示约 13 个工具;能力标签包括 RAG、搜索、Rust、Claude。具体工具清单以官方文档为准。

热门专题

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

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