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. 语义内存
   • 存储消息、文件和代码片段的向量嵌入。
   • 基于语义相似性实现内容检索。
   • 自动索引代码结构以进行上下文检索。
   • 跟踪代码组件之间的关系。
   • 在代码库中提供基于相似性的搜索。

数据库架构

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

🔧 故障排除

常见问题

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 许可证。