Cursor10x MCP

🚀 开发上下文（DevContext） - AI 开发上下文的下一次进化

DevContext 是一个前沿的模型上下文协议（MCP）服务器，它为开发者提供持续的、以项目为中心的上下文感知能力，能够更深入地理解你的代码库。它由 Cursor10x 升级而来，具有更强大的功能和更高效的性能，能将 AI 开发提升到一个新的水平。

🚀 快速开始

Cursor10x 内存系统为 AI 助手（特别是 Claude）创建了一个持久的内存层，使其能够保留和回忆以下信息：

• 最近的消息和对话历史
• 当前正在处理的活动文件
• 重要的项目里程碑和决策
• 技术要求和规范
• 按时间顺序排列的操作和事件序列（情节）
• 代码库中的代码片段和结构
• 基于向量嵌入的语义相似内容
• 通过语义相似性关联的代码片段
• 包含函数和变量关系的文件结构

这个内存系统弥补了无状态 AI 交互和持续开发工作流程之间的差距，实现更高效且具有上下文感知的辅助。

✨ 主要特性

• 持久上下文：跨多个会话保持对话和项目上下文。
• 基于重要性的存储：根据可配置的重要性级别对信息进行优先级排序。
• 多维内存：结合短期、长期、情节和语义内存系统。
• 全面检索：从所有内存子系统提供统一的上下文。
• 健康监测：内置诊断和状态报告功能。
• 横幅生成：为对话开始创建信息丰富的上下文横幅。
• 数据库持久化：使用 Turso 数据库在会话间进行持久存储。
• 向量嵌入：将文本和代码转换为数值表示，以进行语义搜索。
• 高级向量存储：利用 Turso 的 F32_BLOB 和向量函数进行高效的嵌入存储。
• 近似最近邻搜索（ANN）：支持快速的相似性匹配。
• 代码索引：自动检测和索引代码结构（函数、类、变量）。
• 语义搜索：根据含义而非精确文本匹配查找相关内容。
• 相关性评分：根据与当前查询的相关性对上下文项进行排名。
• 代码结构检测：识别和提取多种语言的代码组件。
• 自动嵌入生成：为索引内容自动创建向量嵌入。
• 交叉引用检索：在不同文件和组件中查找相关代码。

📦 安装指南

前提条件

• Node.js 18 或更高版本
• npm 或 yarn 包管理器
• Turso 数据库账户

设置步骤

1. 配置 Turso 数据库：

# 安装 Turso CLI
curl -sSfL https://get.turso.tech/install.sh | bash

# 登录 Turso
turso auth login

# 创建数据库
turso db create cursor10x-mcp

# 获取数据库 URL 和令牌
turso db show cursor10x-mcp --url
turso db tokens create cursor10x-mcp

或者，你可以访问 Turso 进行注册，创建数据库并获取相应的凭证。免费套餐足以满足你的项目内存需求。

2. 配置 Cursor MCP： 在项目目录中更新 .cursor/mcp.json 文件，添加数据库 URL 和 Turso 认证令牌：

{
  "mcpServers": {
    "cursor10x-mcp": {
      "command": "npx",
      "args": ["cursor10x-mcp"],
      "enabled": true,
      "env": {
        "TURSO_DATABASE_URL": "your-turso-database-url",
        "TURSO_AUTH_TOKEN": "your-turso-auth-token"
      }
    }
  }
}

💻 使用示例

优化对话开始

// 使用单个工具调用初始化对话
// 这取代了对话开始时的三个单独调用
const result = await mcp_cursor10x_initConversation({
  content: "I need help implementing authentication in my React app",
  importance: "high",
});

// 向用户显示横幅
console.log("Memory System Status:", result.display.banner);

// 内部使用上下文（不向用户显示）
const context = result.internal.context;
// 使用上下文提供更明智的辅助

开始新会话（替代方法）

// 在开始时生成内存横幅
mcp_cursor10x_generateBanner({});

// 获取全面上下文
mcp_cursor10x_getComprehensiveContext({});

// 存储用户消息
mcp_cursor10x_storeUserMessage({
  content: "I need help with authentication",
  importance: "high",
});

跟踪用户活动

// 跟踪活动文件
await mcp_cursor10x_trackActiveFile({
  filename: "src/auth/jwt.js",
  action: "edit",
});

📚 详细文档

系统工具

mcp_cursor10x_initConversation

通过一次操作存储用户消息、生成横幅并检索上下文来初始化对话。这个统一的工具取代了在每次对话开始时分别调用 generateBanner、getComprehensiveContext 和 storeUserMessage 的需求。 参数：

• content（字符串，必需）：用户消息的内容
• importance（字符串，可选）：重要性级别（"low", "medium", "high", "critical"），默认为 "low"
• metadata（对象，可选）：消息的附加元数据

返回值：

• 包含两个部分的对象：
  • display：包含要显示给用户的横幅
  • internal：包含供代理使用的全面上下文

示例：

// 初始化对话
const result = await mcp_cursor10x_initConversation({
  content: "I need to implement a login system for my app",
  importance: "medium",
});
// 结果: {
//   "status": "ok",
//   "display": {
//     "banner": {
//       "status": "ok",
//       "memory_system": "active",
//       "mode": "turso",
//       "message_count": 42,
//       "active_files_count": 3,
//       "last_accessed": "4/15/2023, 2:30:45 PM"
//     }
//   },
//   "internal": {
//     "context": { ... 全面上下文数据 ... },
//     "messageStored": true,
//     "timestamp": 1681567845123
//   }
// }

mcp_cursor10x_endConversation

通过一次调用组合多个操作来结束对话：存储助手的最终消息、记录已完成的里程碑并在情节内存中记录一个情节。这个统一的工具取代了在每次对话结束时分别调用 storeAssistantMessage、storeMilestone 和 recordEpisode 的需求。 参数：

• content（字符串，必需）：助手的最终消息内容
• milestone_title（字符串，必需）：要记录的里程碑标题
• milestone_description（字符串，必需）：已完成事项的描述
• importance（字符串，可选）：重要性级别（"low", "medium", "high", "critical"），默认为 "medium"
• metadata（对象，可选）：所有记录的附加元数据

返回值：

• 包含每个操作的状态和结果的对象

示例：

// 结束对话并完成收尾步骤
const result = await mcp_cursor10x_endConversation({
  content:
    "I've implemented the authentication system with JWT tokens as requested",
  milestone_title: "Authentication Implementation",
  milestone_description:
    "Implemented secure JWT-based authentication with refresh tokens",
  importance: "high",
});
// 结果: {
//   "status": "ok",
//   "results": {
//     "assistantMessage": {
//       "stored": true,
//       "timestamp": 1681568500123
//     },
//     "milestone": {
//       "title": "Authentication Implementation",
//       "stored": true,
//       "timestamp": 1681568500123
//     },
//     "episode": {
//       "action": "completion",
//       "stored": true,
//       "timestamp": 1681568500123
//     }
//   }
// }

mcp_cursor10x_checkHealth

检查内存系统及其数据库连接的健康状况。 参数：

• 无

返回值：

• 包含健康状态和诊断信息的对象

示例：

// 检查内存系统健康状况
const health = await mcp_cursor10x_checkHealth({});
// 结果: {
//   "status": "ok",
//   "mode": "turso",
//   "message_count": 42,
//   "active_files_count": 3,
//   "current_directory": "/users/project",
//   "timestamp": "2023-04-15T14:30:45.123Z"
// }

mcp_cursor10x_getMemoryStats

检索有关内存系统的详细统计信息。 参数：

• 无

返回值：

• 包含全面内存统计信息的对象

示例：

// 获取内存统计信息
const stats = await mcp_cursor10x_getMemoryStats({});
// 结果: {
//   "status": "ok",
//   "stats": {
//     "message_count": 42,
//     "active_file_count": 3,
//     "milestone_count": 7,
//     "decision_count": 12,
//     "requirement_count": 15,
//     "episode_count": 87,
//     "oldest_memory": "2023-03-10T09:15:30.284Z",
//     "newest_memory": "2023-04-15T14:30:45.123Z"
//   }
// }

mcp_cursor10x_getComprehensiveContext

从所有内存子系统检索统一的上下文，结合短期、长期和情节内存。 参数：

• 无

返回值：

• 包含所有内存系统合并上下文的对象

示例：

// 获取全面上下文
const context = await mcp_cursor10x_getComprehensiveContext({});
// 结果: {
//   "status": "ok",
//   "context": {
//     "shortTerm": {
//       "recentMessages": [...],
//       "activeFiles": [...]
//     },
//     "longTerm": {
//       "milestones": [...],
//       "decisions": [...],
//       "requirements": [...]
//     },
//     "episodic": {
//       "recentEpisodes": [...]
//     },
//     "system": {
//       "healthy": true,
//       "timestamp": "2023-04-15T14:30:45.123Z"
//     }
//   }
// }

短期内存工具

mcp_cursor10x_storeUserMessage

将用户消息存储在短期内存系统中。 参数：

• content（字符串，必需）：消息的内容
• importance（字符串，可选）：重要性级别（"low", "medium", "high", "critical"），默认为 "low"
• metadata（对象，可选）：消息的附加元数据

返回值：

• 包含状态和时间戳的对象

示例：

// 存储用户消息
const result = await mcp_cursor10x_storeUserMessage({
  content: "We need to implement authentication for our API",
  importance: "high",
  metadata: {
    topic: "authentication",
    priority: 1,
  },
});
// 结果: {
//   "status": "ok",
//   "timestamp": 1681567845123
// }

mcp_cursor10x_storeAssistantMessage

将助手消息存储在短期内存系统中。 参数：

• content（字符串，必需）：消息的内容
• importance（字符串，可选）：重要性级别（"low", "medium", "high", "critical"），默认为 "low"
• metadata（对象，可选）：消息的附加元数据

返回值：

• 包含状态和时间戳的对象

示例：

// 存储助手消息
const result = await mcp_cursor10x_storeAssistantMessage({
  content: "I recommend implementing JWT authentication with refresh tokens",
  importance: "medium",
  metadata: {
    topic: "authentication",
    contains_recommendation: true,
  },
});
// 结果: {
//   "status": "ok",
//   "timestamp": 1681567870456
// }

mcp_cursor10x_trackActiveFile

跟踪用户正在访问或修改的活动文件。 参数：

• filename（字符串，必需）：要跟踪的文件的路径
• action（字符串，必需）：对文件执行的操作（open, edit, close 等）
• metadata（对象，可选）：跟踪事件的附加元数据

返回值：

• 包含状态、文件名、操作和时间戳的对象

示例：

// 跟踪活动文件
const result = await mcp_cursor10x_trackActiveFile({
  filename: "src/auth/jwt.js",
  action: "edit",
  metadata: {
    changes: "Added refresh token functionality",
  },
});
// 结果: {
//   "status": "ok",
//   "filename": "src/auth/jwt.js",
//   "action": "edit",
//   "timestamp": 1681567900789
// }

mcp_cursor10x_getRecentMessages

从短期内存中检索最近的消息。 参数：

• limit（数字，可选）：要检索的最大消息数，默认为 10
• importance（字符串，可选）：按重要性级别过滤

返回值：

• 包含状态和消息数组的对象

示例：

// 获取最近的高重要性消息
const messages = await mcp_cursor10x_getRecentMessages({
  limit: 5,
  importance: "high",
});
// 结果: {
//   "status": "ok",
//   "messages": [
//     {
//       "id": 42,
//       "role": "user",
//       "content": "We need to implement authentication for our API",
//       "created_at": "2023-04-15T14:30:45.123Z",
//       "importance": "high",
//       "metadata": {"topic": "authentication", "priority": 1}
//     },
//     ...
//   ]
// }

mcp_cursor10x_getActiveFiles

从短期内存中检索活动文件。 参数：

• limit（数字，可选）：要检索的最大文件数，默认为 10

返回值：

• 包含状态和活动文件数组的对象

示例：

// 获取最近的活动文件
const files = await mcp_cursor10x_getActiveFiles({
  limit: 3,
});
// 结果: {
//   "status": "ok",
//   "files": [
//     {
//       "id": 15,
//       "filename": "src/auth/jwt.js",
//       "last_accessed": "2023-04-15T14:30:45.123Z",
//       "metadata": {"changes": "Added refresh token functionality"}
//     },
//     ...
//   ]
// }

长期内存工具

mcp_cursor10x_storeMilestone

将项目里程碑存储在长期内存中。 参数：

• title（字符串，必需）：里程碑的标题
• description（字符串，必需）：里程碑的描述
• importance（字符串，可选）：重要性级别，默认为 "medium"
• metadata（对象，可选）：里程碑的附加元数据

返回值：

• 包含状态、标题和时间戳的对象

示例：

// 存储项目里程碑
const result = await mcp_cursor10x_storeMilestone({
  title: "Authentication System Implementation",
  description:
    "Implemented JWT authentication with refresh tokens and proper error handling",
  importance: "high",
  metadata: {
    version: "1.0.0",
    files_affected: ["src/auth/jwt.js", "src/middleware/auth.js"],
  },
});
// 结果: {
//   "status": "ok",
//   "title": "Authentication System Implementation",
//   "timestamp": 1681568000123
// }

mcp_cursor10x_storeDecision

将项目决策存储在长期内存中。 参数：

• title（字符串，必需）：决策的标题
• content（字符串，必需）：决策的内容
• reasoning（字符串，可选）：决策背后的推理
• importance（字符串，可选）：重要性级别，默认为 "medium"
• metadata（对象，可选）：决策的附加元数据

返回值：

• 包含状态、标题和时间戳的对象

示例：

// 存储项目决策
const result = await mcp_cursor10x_storeDecision({
  title: "JWT for Authentication",
  content: "Use JWT tokens for API authentication with refresh token rotation",
  reasoning:
    "JWTs provide stateless authentication with good security and performance characteristics",
  importance: "high",
  metadata: {
    alternatives_considered: ["Session-based auth", "OAuth2"],
    decision_date: "2023-04-15",
  },
});
// 结果: {
//   "status": "ok",
//   "title": "JWT for Authentication",
//   "timestamp": 1681568100456
// }

mcp_cursor10x_storeRequirement

将项目需求存储在长期内存中。 参数：

• title（字符串，必需）：需求的标题
• content（字符串，必需）：需求的内容
• importance（字符串，可选）：重要性级别，默认为 "medium"
• metadata（对象，可选）：需求的附加元数据

返回值：

• 包含状态、标题和时间戳的对象

示例：

// 存储项目需求
const result = await mcp_cursor10x_storeRequirement({
  title: "Secure Authentication",
  content:
    "System must implement secure authentication with password hashing, rate limiting, and token rotation",
  importance: "critical",
  metadata: {
    source: "security audit",
    compliance: ["OWASP Top 10", "GDPR"],
  },
});
// 结果: {
//   "status": "ok",
//   "title": "Secure Authentication",
//   "timestamp": 1681568200789
// }

情节内存工具

mcp_cursor10x_recordEpisode

在情节内存中记录一个情节（动作）。 参数：

• actor（字符串，必需）：执行动作的参与者（用户、助手、系统）
• action（字符串，必需）：执行的动作类型
• content（字符串，必需）：动作的内容或详细信息
• importance（字符串，可选）：重要性级别，默认为 "low"
• context（字符串，可选）：情节的上下文

返回值：

• 包含状态、参与者、动作和时间戳的对象

示例：

// 记录一个情节
const result = await mcp_cursor10x_recordEpisode({
  actor: "assistant",
  action: "implementation",
  content: "Created JWT authentication middleware with token verification",
  importance: "medium",
  context: "authentication",
});
// 结果: {
//   "status": "ok",
//   "actor": "assistant",
//   "action": "implementation",
//   "timestamp": 1681568300123
// }

mcp_cursor10x_getRecentEpisodes

从情节内存中检索最近的情节。 参数：

• limit（数字，可选）：要检索的最大情节数，默认为 10
• context（字符串，可选）：按上下文过滤

返回值：

• 包含状态和情节数组的对象

示例：

// 获取认证上下文中的最近情节
const episodes = await mcp_cursor10x_getRecentEpisodes({
  limit: 5,
  context: "authentication",
});
// 结果: {
//   "status": "ok",
//   "episodes": [
//     {
//       "id": 87,
//       "actor": "assistant",
//       "action": "implementation",
//       "content": "Created JWT authentication middleware with token verification",
//       "timestamp": "2023-04-15T14:45:00.123Z",
//       "importance": "medium",
//       "context": "authentication"
//     },
//     ...
//   ]
// }

基于向量的内存工具

mcp_cursor10x_manageVector

用于管理向量嵌入的统一工具，支持存储、搜索、更新和删除操作。 参数：

• operation（字符串，必需）：要执行的操作（"store", "search", "update", "delete"）
• contentId（数字，可选）：此向量表示的内容的 ID（用于存储、更新、删除）
• contentType（字符串，可选）：内容的类型（"message", "file", "snippet" 等）
• vector（数组，可选）：向量数据作为数字数组（用于存储、更新）或查询向量（用于搜索）
• vectorId（数字，可选）：要更新或删除的向量的 ID
• limit（数字，可选）：搜索操作的最大结果数，默认为 10
• threshold（数字，可选）：搜索操作的相似性阈值，默认为 0.7
• metadata（对象，可选）：关于向量的附加信息

返回值：

• 包含状态和操作结果的对象

示例：

// 存储向量嵌入
const result = await mcp_cursor10x_manageVector({
  operation: "store",
  contentId: 42,
  contentType: "message",
  vector: [0.1, 0.2, 0.3, ...], // 128 维向量
  metadata: {
    topic: "authentication",
    language: "en"
  }
});
// 结果: {
//   "status": "ok",
//   "operation": "store",
//   "vectorId": 15,
//   "timestamp": 1681570000123
// }

// 搜索相似向量
const searchResult = await mcp_cursor10x_manageVector({
  operation: "search",
  vector: [0.1, 0.2, 0.3, ...], // 查询向量
  contentType: "snippet", // 可选过滤器
  limit: 5,
  threshold: 0.8
});
// 结果: {
//   "status": "ok",
//   "operation": "search",
//   "results": [
//     {
//       "vectorId": 10,
//       "contentId": 30,
//       "contentType": "snippet",
//       "similarity": 0.92,
//       "metadata": { ... }
//     },
//     ...
//   ]
// }

🔧 技术细节

系统架构

内存系统基于四个核心组件构建：

1. MCP 服务器：实现模型上下文协议，注册工具并处理请求。
2. 内存数据库：使用 Turso 数据库在会话间进行持久存储。
3. 内存子系统：将内存组织成具有不同用途的专用系统。
4. 向量嵌入：将文本和代码转换为数值表示，以进行语义搜索。

内存类型

系统实现了四种互补的内存类型：

1. 短期内存（STM）
   • 存储最近的消息和活动文件。
   • 为当前交互提供即时上下文。
   • 自动根据最近性和重要性进行优先级排序。
2. 长期内存（LTM）
   • 存储永久的项目信息，如里程碑和决策。
   • 维护架构和设计上下文。
   • 无限期保留高重要性信息。
3. 情节内存
   • 记录事件的时间顺序。
   • 维护动作之间的因果关系。
   • 为项目历史提供时间上下文。
4. 语义内存
   • 存储消息、文件和代码片段的向量嵌入。
   • 基于语义相似性实现内容检索。
   • 自动索引代码结构以进行上下文检索。
   • 跟踪代码组件之间的关系。
   • 在代码库中提供基于相似性的搜索。

数据库架构

内存系统自动创建和维护以下数据库表：

表名	描述	字段
messages	存储用户和助手消息	id（唯一标识符）, timestamp（创建时间戳）, role（消息角色）, content（消息内容）, importance（重要性级别）, archived（是否存档）
active_files	跟踪文件活动	id（唯一标识符）, filename（文件路径）, action（最后执行的操作）, last_accessed（最后访问时间戳）
milestones	记录项目里程碑	id（唯一标识符）, title（里程碑标题）, description（详细描述）, timestamp（创建时间戳）, importance（重要性级别）
decisions	存储项目决策	id（唯一标识符）, title（决策标题）, content（决策内容）, reasoning（决策推理）, timestamp（创建时间戳）, importance（重要性级别）
requirements	维护项目需求	id（唯一标识符）, title（需求标题）, content（需求内容）, timestamp（创建时间戳）, importance（重要性级别）
episodes	记录动作和事件	id（唯一标识符）, timestamp（创建时间戳）, actor（执行动作的参与者）, action（动作类型）, content（动作详细信息）, importance（重要性级别）, context（动作上下文）
vectors	存储向量嵌入以进行语义搜索	id（唯一标识符）, content_id（引用内容的 ID）, content_type（内容类型）, vector（嵌入向量的二进制表示）, metadata（向量的附加元数据）
code_files	跟踪索引的代码文件	id（唯一标识符）, file_path（文件路径）, language（编程语言）, last_indexed（最后索引时间戳）, metadata（文件的附加元数据）
code_snippets	存储提取的代码结构	id（唯一标识符）, file_id（父文件的引用）, start_line（起始行号）, end_line（结束行号）, symbol_type（代码结构类型）, content（代码片段内容）

🔧 故障排除

常见问题

1. 数据库连接问题
   • 验证你的 Turso 数据库 URL 和认证令牌是否正确。
   • 检查与 Turso 服务的网络连接。
   • 验证防火墙设置是否允许连接。
2. 数据缺失
   • 检查数据是否以适当的重要性级别存储。
   • 验证检索查询参数（限制、过滤器）。
   • 使用 mcp_cursor10x_checkHealth() 检查数据库健康状况。
3. 性能问题
   • 使用 mcp_cursor10x_getMemoryStats() 监控内存统计信息。
   • 如果数据库增长过大，考虑存档旧数据。
   • 使用更具体的过滤器优化检索。

诊断步骤

1. 检查系统健康状况：

const health = await mcp_cursor10x_checkHealth({});
console.log("System Health:", health);

2. 验证内存统计信息：

const stats = await mcp_cursor10x_getMemoryStats({});
console.log("Memory Stats:", stats);

3. 生成状态横幅：

const banner = await mcp_cursor10x_generateBanner({});
console.log("Memory Banner:", banner);

🔧 重要性级别

在将项目存储到内存中时，请使用适当的重要性级别：

• 低：一般信息、日常操作、日常对话
• 中：有用的上下文、标准工作项、常规功能
• 高：关键决策、主要功能、重要架构元素
• 关键：核心架构、安全问题、数据完整性问题

📄 许可证

本项目采用 MIT 许可证。