Cursor X
    Cursor X

    Cursor X

    The Cursor10x MCP is a persistent multi-dimensional memory system for Cursor that enhances AI assistants with conversation context, project history, and code relationships across sessions.

    3.4

    GitHub Stats

    Stars

    50

    Forks

    10

    Release Date

    6/18/2025

    about two weeks ago

    Detailed Description

    devcontext - the next evolution in ai development context

    🚀 cursor10x is now devcontext 🚀

    cursor10x has evolved into devcontext - a more powerful, dedicated context system for developers

    🔥 devcontext takes ai development to the next level 🔥

    🔄 continuous context awareness - sophisticated retrieval methods focusing on what matters 📊 structured metadata - from repository structure down to individual functions 🧠 adaptive learning - continuously learns from and adapts to your development patterns 🤖 completely autonomous - self-managing context system that works in the background 📚 external documentation - automatically retrieves and integrates relevant documentation 📋 workflow integration - seamless task management workflow built-in

    👀 be on the lookout 👀

    the devcontext project generator is launching in the next couple days and will create a complete set up for your project to literally 10x your development workflow.

    devcontext is a cutting-edge model context protocol (mcp) server providing developers with continuous, project-centric context awareness that understands your codebase at a deeper level.


    overview

    the cursor10x memory system creates a persistent memory layer for ai assistants (specifically claude), enabling them to retain and recall:

    • recent messages and conversation history
    • active files currently being worked on
    • important project milestones and decisions
    • technical requirements and specifications
    • chronological sequences of actions and events (episodes)
    • code snippets and structures from your codebase
    • semantically similar content based on vector embeddings
    • related code fragments through semantic similarity
    • file structures with function and variable relationships

    this memory system bridges the gap between stateless ai interactions and continuous development workflows, allowing for more productive and contextually aware assistance.

    system architecture

    the memory system is built on four core components:

    1. mcp server: implements the model context protocol to register tools and process requests
    2. memory database: uses turso database for persistent storage across sessions
    3. memory subsystems: organizes memory into specialized systems with distinct purposes
    4. vector embeddings: transforms text and code into numerical representations for semantic search

    memory types

    the system implements four complementary memory types:

    1. short-term memory (stm)

      • stores recent messages and active files
      • provides immediate context for current interactions
      • automatically prioritizes by recency and importance
    2. long-term memory (ltm)

      • stores permanent project information like milestones and decisions
      • maintains architectural and design context
      • preserves high-importance information indefinitely
    3. episodic memory

      • records chronological sequences of events
      • maintains causal relationships between actions
      • provides temporal context for project history
    4. semantic memory

      • stores vector embeddings of messages, files, and code snippets
      • enables retrieval of content based on semantic similarity
      • automatically indexes code structures for contextual retrieval
      • tracks relationships between code components
      • provides similarity-based search across the codebase

    features

    • persistent context: maintains conversation and project context across multiple sessions
    • importance-based storage: prioritizes information based on configurable importance levels
    • multi-dimensional memory: combines short-term, long-term, episodic, and semantic memory systems
    • comprehensive retrieval: provides unified context from all memory subsystems
    • health monitoring: includes built-in diagnostics and status reporting
    • banner generation: creates informative context banners for conversation starts
    • database persistence: stores all memory data in turso database with automatic schema creation
    • vector embeddings: creates numerical representations of text and code for similarity search
    • advanced vector storage: utilizes turso's f32_blob and vector functions for efficient embedding storage
    • ann search: supports approximate nearest neighbor search for fast similarity matching
    • code indexing: automatically detects and indexes code structures (functions, classes, variables)
    • semantic search: finds related content based on meaning rather than exact text matches
    • relevance scoring: ranks context items by relevance to the current query
    • code structure detection: identifies and extracts code components across multiple languages
    • auto-embedding generation: automatically creates vector embeddings for indexed content
    • cross-reference retrieval: finds related code across different files and components

    installation

    prerequisites

    • node.js 18 or higher
    • npm or yarn package manager
    • turso database account

    setup steps

    1. configure turso database:
    # install turso cli
    curl -ssfl https://get.turso.tech/install.sh | bash
    
    # login to turso
    turso auth login
    
    # create a database
    turso db create cursor10x-mcp
    
    # get database url and token
    turso db show cursor10x-mcp --url
    turso db tokens create cursor10x-mcp
    

    or you can visit turso and sign up and proceed to create the database and get proper credentials. the free plan will more than cover your project memory.

    1. configure cursor mcp:

    update .cursor/mcp.json in your project directory with the database url and turso auth token:

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

    tool documentation

    system tools

    mcp_cursor10x_initconversation

    initializes a conversation by storing the user message, generating a banner, and retrieving context in one operation. this unified tool replaces the need for separate generatebanner, getcomprehensivecontext, and storeusermessage calls at the beginning of each conversation.

    parameters:

    • content (string, required): content of the user message
    • importance (string, optional): importance level ("low", "medium", "high", "critical"), defaults to "low"
    • metadata (object, optional): additional metadata for the message

    returns:

    • object with two sections:
      • display: contains the banner to be shown to the user
      • internal: contains the comprehensive context for the agent's use

    example:

    // initialize a conversation
    const result = await mcp_cursor10x_initconversation({
      content: "i need to implement a login system for my app",
      importance: "medium",
    });
    // result: {
    //   "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": { ... comprehensive context data ... },
    //     "messagestored": true,
    //     "timestamp": 1681567845123
    //   }
    // }
    

    mcp_cursor10x_endconversation

    ends a conversation by combining multiple operations in one call: storing the assistant's final message, recording a milestone for what was accomplished, and logging an episode in the episodic memory. this unified tool replaces the need for separate storeassistantmessage, storemilestone, and recordepisode calls at the end of each conversation.

    parameters:

    • content (string, required): content of the assistant's final message
    • milestone_title (string, required): title of the milestone to record
    • milestone_description (string, required): description of what was accomplished
    • importance (string, optional): importance level ("low", "medium", "high", "critical"), defaults to "medium"
    • metadata (object, optional): additional metadata for all records

    returns:

    • object with status and results of each operation

    example:

    // end a conversation with finalization steps
    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",
    });
    // result: {
    //   "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

    checks the health of the memory system and its database connection.

    parameters:

    • none required

    returns:

    • object with health status and diagnostics

    example:

    // check memory system health
    const health = await mcp_cursor10x_checkhealth({});
    // result: {
    //   "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

    retrieves detailed statistics about the memory system.

    parameters:

    • none required

    returns:

    • object with comprehensive memory statistics

    example:

    // get memory statistics
    const stats = await mcp_cursor10x_getmemorystats({});
    // result: {
    //   "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

    retrieves a unified context from all memory subsystems, combining short-term, long-term, and episodic memory.

    parameters:

    • none required

    returns:

    • object with consolidated context from all memory systems

    example:

    // get comprehensive context
    const context = await mcp_cursor10x_getcomprehensivecontext({});
    // result: {
    //   "status": "ok",
    //   "context": {
    //     "shortterm": {
    //       "recentmessages": [...],
    //       "activefiles": [...]
    //     },
    //     "longterm": {
    //       "milestones": [...],
    //       "decisions": [...],
    //       "requirements": [...]
    //     },
    //     "episodic": {
    //       "recentepisodes": [...]
    //     },
    //     "system": {
    //       "healthy": true,
    //       "timestamp": "2023-04-15t14:30:45.123z"
    //     }
    //   }
    // }
    

    short-term memory tools

    mcp_cursor10x_storeusermessage

    stores a user message in the short-term memory system.

    parameters:

    • content (string, required): content of the message
    • importance (string, optional): importance level ("low", "medium", "high", "critical"), defaults to "low"
    • metadata (object, optional): additional metadata for the message

    returns:

    • object with status and timestamp

    example:

    // store a user message
    const result = await mcp_cursor10x_storeusermessage({
      content: "we need to implement authentication for our api",
      importance: "high",
      metadata: {
        topic: "authentication",
        priority: 1,
      },
    });
    // result: {
    //   "status": "ok",
    //   "timestamp": 1681567845123
    // }
    

    mcp_cursor10x_storeassistantmessage

    stores an assistant message in the short-term memory system.

    parameters:

    • content (string, required): content of the message
    • importance (string, optional): importance level ("low", "medium", "high", "critical"), defaults to "low"
    • metadata (object, optional): additional metadata for the message

    returns:

    • object with status and timestamp

    example:

    // store an assistant message
    const result = await mcp_cursor10x_storeassistantmessage({
      content: "i recommend implementing jwt authentication with refresh tokens",
      importance: "medium",
      metadata: {
        topic: "authentication",
        contains_recommendation: true,
      },
    });
    // result: {
    //   "status": "ok",
    //   "timestamp": 1681567870456
    // }
    

    mcp_cursor10x_trackactivefile

    tracks an active file being accessed or modified by the user.

    parameters:

    • filename (string, required): path to the file being tracked
    • action (string, required): action performed on the file (open, edit, close, etc.)
    • metadata (object, optional): additional metadata for the tracking event

    returns:

    • object with status, filename, action and timestamp

    example:

    // track an active file
    const result = await mcp_cursor10x_trackactivefile({
      filename: "src/auth/jwt.js",
      action: "edit",
      metadata: {
        changes: "added refresh token functionality",
      },
    });
    // result: {
    //   "status": "ok",
    //   "filename": "src/auth/jwt.js",
    //   "action": "edit",
    //   "timestamp": 1681567900789
    // }
    

    mcp_cursor10x_getrecentmessages

    retrieves recent messages from the short-term memory.

    parameters:

    • limit (number, optional): maximum number of messages to retrieve, defaults to 10
    • importance (string, optional): filter by importance level

    returns:

    • object with status and array of messages

    example:

    // get recent high importance messages
    const messages = await mcp_cursor10x_getrecentmessages({
      limit: 5,
      importance: "high",
    });
    // result: {
    //   "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

    retrieves active files from the short-term memory.

    parameters:

    • limit (number, optional): maximum number of files to retrieve, defaults to 10

    returns:

    • object with status and array of active files

    example:

    // get recent active files
    const files = await mcp_cursor10x_getactivefiles({
      limit: 3,
    });
    // result: {
    //   "status": "ok",
    //   "files": [
    //     {
    //       "id": 15,
    //       "filename": "src/auth/jwt.js",
    //       "last_accessed": "2023-04-15t14:30:45.123z",
    //       "metadata": {"changes": "added refresh token functionality"}
    //     },
    //     ...
    //   ]
    // }
    

    long-term memory tools

    mcp_cursor10x_storemilestone

    stores a project milestone in the long-term memory.

    parameters:

    • title (string, required): title of the milestone
    • description (string, required): description of the milestone
    • importance (string, optional): importance level, defaults to "medium"
    • metadata (object, optional): additional metadata for the milestone

    returns:

    • object with status, title, and timestamp

    example:

    // store a project milestone
    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"],
      },
    });
    // result: {
    //   "status": "ok",
    //   "title": "authentication system implementation",
    //   "timestamp": 1681568000123
    // }
    

    mcp_cursor10x_storedecision

    stores a project decision in the long-term memory.

    parameters:

    • title (string, required): title of the decision
    • content (string, required): content of the decision
    • reasoning (string, optional): reasoning behind the decision
    • importance (string, optional): importance level, defaults to "medium"
    • metadata (object, optional): additional metadata for the decision

    returns:

    • object with status, title, and timestamp

    example:

    // store a project decision
    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",
      },
    });
    // result: {
    //   "status": "ok",
    //   "title": "jwt for authentication",
    //   "timestamp": 1681568100456
    // }
    

    mcp_cursor10x_storerequirement

    stores a project requirement in the long-term memory.

    parameters:

    • title (string, required): title of the requirement
    • content (string, required): content of the requirement
    • importance (string, optional): importance level, defaults to "medium"
    • metadata (object, optional): additional metadata for the requirement

    returns:

    • object with status, title, and timestamp

    example:

    // store a project requirement
    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"],
      },
    });
    // result: {
    //   "status": "ok",
    //   "title": "secure authentication",
    //   "timestamp": 1681568200789
    // }
    

    episodic memory tools

    mcp_cursor10x_recordepisode

    records an episode (action) in the episodic memory.

    parameters:

    • actor (string, required): actor performing the action (user, assistant, system)
    • action (string, required): type of action performed
    • content (string, required): content or details of the action
    • importance (string, optional): importance level, defaults to "low"
    • context (string, optional): context for the episode

    returns:

    • object with status, actor, action, and timestamp

    example:

    // record an episode
    const result = await mcp_cursor10x_recordepisode({
      actor: "assistant",
      action: "implementation",
      content: "created jwt authentication middleware with token verification",
      importance: "medium",
      context: "authentication",
    });
    // result: {
    //   "status": "ok",
    //   "actor": "assistant",
    //   "action": "implementation",
    //   "timestamp": 1681568300123
    // }
    

    mcp_cursor10x_getrecentepisodes

    retrieves recent episodes from the episodic memory.

    parameters:

    • limit (number, optional): maximum number of episodes to retrieve, defaults to 10
    • context (string, optional): filter by context

    returns:

    • object with status and array of episodes

    example:

    // get recent episodes in the authentication context
    const episodes = await mcp_cursor10x_getrecentepisodes({
      limit: 5,
      context: "authentication",
    });
    // result: {
    //   "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"
    //     },
    //     ...
    //   ]
    // }
    

    vector-based memory tools

    mcp_cursor10x_managevector

    unified tool for managing vector embeddings with operations for store, search, update, and delete.

    parameters:

    • operation (string, required): operation to perform ("store", "search", "update", "delete")
    • contentid (number, optional): id of the content this vector represents (for store, update, delete)
    • contenttype (string, optional): type of content ("message", "file", "snippet", etc.)
    • vector (array, optional): vector data as array of numbers (for store, update) or query vector (for search)
    • vectorid (number, optional): id of the vector to update or delete
    • limit (number, optional): maximum number of results for search operation, defaults to 10
    • threshold (number, optional): similarity threshold for search operation, defaults to 0.7
    • metadata (object, optional): additional info about the vector

    returns:

    • object with status and operation results

    example:

    // store a vector embedding
    const result = await mcp_cursor10x_managevector({
      operation: "store",
      contentid: 42,
      contenttype: "message",
      vector: [0.1, 0.2, 0.3, ...], // 128-dimensional vector
      metadata: {
        topic: "authentication",
        language: "en"
      }
    });
    // result: {
    //   "status": "ok",
    //   "operation": "store",
    //   "vectorid": 15,
    //   "timestamp": 1681570000123
    // }
    
    // search for similar vectors
    const searchresult = await mcp_cursor10x_managevector({
      operation: "search",
      vector: [0.1, 0.2, 0.3, ...], // query vector
      contenttype: "snippet", // optional filter
      limit: 5,
      threshold: 0.8
    });
    // result: {
    //   "status": "ok",
    //   "operation": "search",
    //   "results": [
    //     {
    //       "vectorid": 10,
    //       "contentid": 30,
    //       "contenttype": "snippet",
    //       "similarity": 0.92,
    //       "metadata": { ... }
    //     },
    //     ...
    //   ]
    // }
    

    database schema

    the memory system automatically creates and maintains the following database tables:

    • messages: stores user and assistant messages

      • id: unique identifier
      • timestamp: creation timestamp
      • role: message role (user/assistant)
      • content: message content
      • importance: importance level
      • archived: whether the message is archived
    • active_files: tracks file activity

      • id: unique identifier
      • filename: path to the file
      • action: last action performed
      • last_accessed: timestamp of last access
    • milestones: records project milestones

      • id: unique identifier
      • title: milestone title
      • description: detailed description
      • timestamp: creation timestamp
      • importance: importance level
    • decisions: stores project decisions

      • id: unique identifier
      • title: decision title
      • content: decision content
      • reasoning: decision reasoning
      • timestamp: creation timestamp
      • importance: importance level
    • requirements: maintains project requirements

      • id: unique identifier
      • title: requirement title
      • content: requirement content
      • timestamp: creation timestamp
      • importance: importance level
    • episodes: chronicles actions and events

      • id: unique identifier
      • timestamp: creation timestamp
      • actor: actor performing the action
      • action: type of action
      • content: action details
      • importance: importance level
      • context: action context
    • vectors: stores vector embeddings for semantic search

      • id: unique identifier
      • content_id: id of the referenced content
      • content_type: type of content (message, file, snippet)
      • vector: binary representation of the embedding vector
      • metadata: additional metadata for the vector
    • code_files: tracks indexed code files

      • id: unique identifier
      • file_path: path to the file
      • language: programming language
      • last_indexed: timestamp of last indexing
      • metadata: additional file metadata
    • code_snippets: stores extracted code structures

      • id: unique identifier
      • file_id: reference to the parent file
      • start_line: starting line number
      • end_line: ending line number
      • symbol_type: type of code structure (function, class, variable)
      • content: the code snippet content

    example workflows

    optimized conversation start

    // initialize conversation with a single tool call
    // this replaces the need for three separate calls at the start of the conversation
    const result = await mcp_cursor10x_initconversation({
      content: "i need help implementing authentication in my react app",
      importance: "high",
    });
    
    // display the banner to the user
    console.log("memory system status:", result.display.banner);
    
    // use the context internally (do not show to user)
    const context = result.internal.context;
    // use context for more informed assistance
    

    starting a new session (alternative method)

    // generate a memory banner at the start
    mcp_cursor10x_generatebanner({});
    
    // get comprehensive context
    mcp_cursor10x_getcomprehensivecontext({});
    
    // store the user message
    mcp_cursor10x_storeusermessage({
      content: "i need help with authentication",
      importance: "high",
    });
    

    tracking user activity

    // track an active file
    await mcp_cursor10x_trackactivefile({
      filename: "src/auth/jwt.js",
      action: "edit",
    });
    

    troubleshooting

    common issues

    1. database connection problems

      • verify your turso database url and authentication token are correct
      • check network connectivity to the turso service
      • verify firewall settings allow the connection
    2. missing data

      • check that data was stored with appropriate importance level
      • verify the retrieval query parameters (limit, filters)
      • check the database health with mcp_cursor10x_checkhealth()
    3. performance issues

      • monitor memory statistics with mcp_cursor10x_getmemorystats()
      • consider archiving old data if database grows too large
      • optimize retrieval by using more specific filters

    diagnostic steps

    1. check system health:

      const health = await mcp_cursor10x_checkhealth({});
      console.log("system health:", health);
      
    2. verify memory statistics:

      const stats = await mcp_cursor10x_getmemorystats({});
      console.log("memory stats:", stats);
      
    3. generate a status banner:

      const banner = await mcp_cursor10x_generatebanner({});
      console.log("memory banner:", banner);
      

    importance levels

    when storing items in memory, use appropriate importance levels:

    • low: general information, routine operations, everyday conversations
    • medium: useful context, standard work items, regular features
    • high: critical decisions, major features, important architecture elements
    • critical: core architecture, security concerns, data integrity issues

    license

    mit

    Star History

    Star History

    Apr 12Apr 18Apr 23Apr 28May 8May 14May 19May 28Jun 16Jul 3015304560
    Powered by MSeeP Analytics

    About the Project

    This app has not been claimed by its owner yet.

    Claim Ownership

    Receive Updates

    Security Updates

    Get notified about trust rating changes

    to receive email notifications.