Cursor10x MCP

---

Resumen

El Sistema de Memoria Cursor10x crea una capa de memoria persistente para asistentes de IA (específicamente Claude), permitiéndoles retener y recordar:

• Mensajes recientes e historial de conversaciones
• Archivos activos en los que se está trabajando actualmente
• Hitos y decisiones importantes del proyecto
• Requisitos técnicos y especificaciones
• Secuencias cronológicas de acciones y eventos (episodios)
• Fragmentos de código y estructuras de tu base de código
• Contenido semánticamente similar basado en incrustaciones vectoriales
• Fragmentos de código relacionados mediante similitud semántica
• Estructuras de archivos con relaciones de funciones y variables

Este sistema de memoria cierra la brecha entre las interacciones de IA sin estado y los flujos de trabajo de desarrollo continuos, permitiendo una asistencia más productiva y consciente del contexto.

Arquitectura del Sistema

El sistema de memoria se basa en cuatro componentes principales:

1. Servidor MCP: Implementa el Protocolo de Contexto de Modelo para registrar herramientas y procesar solicitudes
2. Base de Datos de Memoria: Utiliza la base de datos Turso para almacenamiento persistente entre sesiones
3. Subsistemas de Memoria: Organiza la memoria en sistemas especializados con propósitos distintos
4. Incrustaciones Vectoriales: Transforma texto y código en representaciones numéricas para búsqueda semántica

Tipos de Memoria

El sistema implementa cuatro tipos de memoria complementarios:

1. Memoria a Corto Plazo (STM)

   • Almacena mensajes recientes y archivos activos
   • Proporciona contexto inmediato para interacciones actuales
   • Prioriza automáticamente por actualidad e importancia

2. Memoria a Largo Plazo (LTM)

   • Almacena información permanente del proyecto como hitos y decisiones
   • Mantiene el contexto arquitectónico y de diseño
   • Preserva información de alta importancia indefinidamente

3. Memoria Episódica

   • Registra secuencias cronológicas de eventos
   • Mantiene relaciones causales entre acciones
   • Proporciona contexto temporal para el historial del proyecto

4. Memoria Semántica

   • Almacena incrustaciones vectoriales de mensajes, archivos y fragmentos de código
   • Permite la recuperación de contenido basada en similitud semántica
   • Indexa automáticamente estructuras de código para recuperación contextual
   • Rastrea relaciones entre componentes de código
   • Proporciona búsqueda basada en similitud en toda la base de código

Características

• Contexto Persistente: Mantiene el contexto de conversación y proyecto a través de múltiples sesiones
• Almacenamiento Basado en Importancia: Prioriza información según niveles de importancia configurables
• Memoria Multidimensional: Combina sistemas de memoria a corto plazo, largo plazo, episódica y semántica
• Recuperación Integral: Proporciona contexto unificado de todos los subsistemas de memoria
• Monitoreo de Salud: Incluye diagnósticos integrados e informes de estado
• Generación de Banners: Crea banners de contexto informativos para el inicio de conversaciones
• Persistencia en Base de Datos: Almacena todos los datos de memoria en la base de datos Turso con creación automática de esquemas
• Incrustaciones Vectoriales: Crea representaciones numéricas de texto y código para búsqueda de similitud
• Almacenamiento Vectorial Avanzado: Utiliza F32_BLOB y funciones vectoriales de Turso para almacenamiento eficiente de incrustaciones
• Búsqueda ANN: Soporta búsqueda de Vecinos Más Cercanos Aproximados para coincidencia rápida de similitud
• Indexación de Código: Detecta e indexa automáticamente estructuras de código (funciones, clases, variables)
• Búsqueda Semántica: Encuentra contenido relacionado basado en significado en lugar de coincidencias exactas de texto
• Puntuación de Relevancia: Clasifica elementos de contexto por relevancia a la consulta actual
• Detección de Estructura de Código: Identifica y extrae componentes de código en múltiples lenguajes
• Generación Automática de Incrustaciones: Crea automáticamente incrustaciones vectoriales para contenido indexado
• Recuperación de Referencias Cruzadas: Encuentra código relacionado en diferentes archivos y componentes

Instalación

Requisitos Previos

• Node.js 18 o superior
• Gestor de paquetes npm o yarn
• Cuenta de base de datos Turso

Pasos de Configuración

1. Configurar la Base de Datos Turso:

# 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

O puedes visitar Turso y registrarte para proceder a crear la base de datos y obtener las credenciales adecuadas. El plan gratuito cubrirá más que suficiente la memoria de tu proyecto.

2. Configurar Cursor MCP:

Actualiza .cursor/mcp.json en el directorio de tu proyecto con la URL de la base de datos y el token de autenticación de 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"
      }
    }
  }
}

Documentación de Herramientas

Herramientas del Sistema

mcp_cursor10x_initConversation

Inicializa una conversación almacenando el mensaje del usuario, generando un banner y recuperando contexto en una sola operación. Esta herramienta unificada reemplaza la necesidad de llamadas separadas a generateBanner, getComprehensiveContext y storeUserMessage al inicio de cada conversación.

Parámetros:

• content (cadena, obligatorio): Contenido del mensaje del usuario
• importance (cadena, opcional): Nivel de importancia ("low", "medium", "high", "critical"), por defecto "low"
• metadata (objeto, opcional): Metadatos adicionales para el mensaje

Devuelve:

• Objeto con dos secciones:
  • display: Contiene el banner que se mostrará al usuario
  • internal: Contiene el contexto integral para el uso del agente

Ejemplo:

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

Finaliza una conversación combinando múltiples operaciones en una sola llamada: almacenar el mensaje final del asistente, registrar un hito de lo logrado y registrar un episodio en la memoria episódica. Esta herramienta unificada reemplaza la necesidad de llamadas separadas a storeAssistantMessage, storeMilestone y recordEpisode al final de cada conversación.

Parámetros:

• content (cadena, obligatorio): Contenido del mensaje final del asistente
• milestone_title (cadena, obligatorio): Título del hito a registrar
• milestone_description (cadena, obligatorio): Descripción de lo logrado
• importance (cadena, opcional): Nivel de importancia ("low", "medium", "high", "critical"), por defecto "medium"
• metadata (objeto, opcional): Metadatos adicionales para todos los registros

Devuelve:

• Objeto con estado y resultados de cada operación

Ejemplo:

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

Verifica la salud del sistema de memoria y su conexión a la base de datos.

Parámetros:

• Ninguno requerido

Devuelve:

• Objeto con estado de salud y diagnósticos

Ejemplo:

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

Recupera estadísticas detalladas sobre el sistema de memoria.

Parámetros:

• Ninguno requerido

Devuelve:

• Objeto con estadísticas integrales de memoria

Ejemplo:

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

Recupera un contexto unificado de todos los subsistemas de memoria, combinando memoria a corto plazo, largo plazo y episódica.

Parámetros:

• Ninguno requerido

Devuelve:

• Objeto con contexto consolidado de todos los sistemas de memoria

Ejemplo:

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

Herramientas de Memoria a Corto Plazo

mcp_cursor10x_storeUserMessage

Almacena un mensaje del usuario en el sistema de memoria a corto plazo.

Parámetros:

• content (cadena, obligatorio): Contenido del mensaje
• importance (cadena, opcional): Nivel de importancia ("low", "medium", "high", "critical"), por defecto "low"
• metadata (objeto, opcional): Metadatos adicionales para el mensaje

Devuelve:

• Objeto con estado y marca de tiempo

Ejemplo:

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

Almacena un mensaje del asistente en el sistema de memoria a corto plazo.

Parámetros:

• content (cadena, obligatorio): Contenido del mensaje
• importance (cadena, opcional): Nivel de importancia ("low", "medium", "high", "critical"), por defecto "low"
• metadata (objeto, opcional): Metadatos adicionales para el mensaje

Devuelve:

• Objeto con estado y marca de tiempo

Ejemplo:

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

Rastrea un archivo activo que está siendo accedido o modificado por el usuario.

Parámetros:

• filename (cadena, obligatorio): Ruta al archivo que se está rastreando
• action (cadena, obligatorio): Acción realizada sobre el archivo (open, edit, close, etc.)
• metadata (objeto, opcional): Metadatos adicionales para el evento de rastreo

Devuelve:

• Objeto con estado, nombre de archivo, acción y marca de tiempo

Ejemplo:

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

Recupera mensajes recientes de la memoria a corto plazo.

Parámetros:

• limit (número, opcional): Número máximo de mensajes a recuperar, por defecto 10
• importance (cadena, opcional): Filtrar por nivel de importancia

Devuelve:

• Objeto con estado y matriz de mensajes

Ejemplo:

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

Recupera archivos activos de la memoria a corto plazo.

Parámetros:

• limit (número, opcional): Número máximo de archivos a recuperar, por defecto 10

Devuelve:

• Objeto con estado y matriz de archivos activos

Ejemplo:

// 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"}
//     },
//     ...
//   ]
// }

Herramientas de Memoria a Largo Plazo

mcp_cursor10x_storeMilestone

Almacena un hito del proyecto en la memoria a largo plazo.

Parámetros:

• title (cadena, obligatorio): Título del hito
• description (cadena, obligatorio): Descripción del hito
• importance (cadena, opcional): Nivel de importancia, por defecto "medium"
• metadata (objeto, opcional): Metadatos adicionales para el hito

Devuelve:

• Objeto con estado, título y marca de tiempo

Ejemplo:

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

Almacena una decisión del proyecto en la memoria a largo plazo.

Parámetros:

• title (cadena, obligatorio): Título de la decisión
• content (cadena, obligatorio): Contenido de la decisión
• reasoning (cadena, opcional): Razonamiento detrás de la decisión
• importance (cadena, opcional): Nivel de importancia, por defecto "medium"
• metadata (objeto, opcional): Metadatos adicionales para la decisión

Devuelve:

• Objeto con estado, título y marca de tiempo

Ejemplo:

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

Almacena un requisito del proyecto en la memoria a largo plazo.

Parámetros:

• title (cadena, obligatorio): Título del requisito
• content (cadena, obligatorio): Contenido del requisito
• importance (cadena, opcional): Nivel de importancia, por defecto "medium"
• metadata (objeto, opcional): Metadatos adicionales para el requisito

Devuelve:

• Objeto con estado, título y marca de tiempo

Ejemplo:

// 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
// }

Herramientas de Memoria Episódica

mcp_cursor10x_recordEpisode

Registra un episodio (acción) en la memoria episódica.

Parámetros:

• actor (cadena, obligatorio): Actor que realiza la acción (usuario, asistente, sistema)
• action (cadena, obligatorio): Tipo de acción realizada
• content (cadena, obligatorio): Contenido o detalles de la acción
• importance (cadena, opcional): Nivel de importancia, por defecto "low"
• context (cadena, opcional): Contexto del episodio

Devuelve:

• Objeto con estado, actor, acción y marca de tiempo

Ejemplo:

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

Recupera episodios recientes de la memoria episódica.

Parámetros:

• limit (número, opcional): Número máximo de episodios a recuperar, por defecto 10
• context (cadena, opcional): Filtrar por contexto

Devuelve:

• Objeto con estado y matriz de episodios

Ejemplo:

// 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"
//     },
//     ...
//   ]
// }

Herramientas de Memoria Basada en Vectores

mcp_cursor10x_manageVector

Herramienta unificada para gestionar incrustaciones vectoriales con operaciones de almacenar, buscar, actualizar y eliminar.

Parámetros:

• operation (cadena, obligatorio): Operación a realizar ("store", "search", "update", "delete")
• contentId (número, opcional): ID del contenido que representa este vector (para store, update, delete)
• contentType (cadena, opcional): Tipo de contenido ("message", "file", "snippet", etc.)
• vector (matriz, opcional): Datos vectoriales como matriz de números (para store, update) o vector de consulta (para search)
• vectorId (número, opcional): ID del vector a actualizar o eliminar
• limit (número, opcional): Número máximo de resultados para la operación de búsqueda, por defecto 10
• threshold (número, opcional): Umbral de similitud para la operación de búsqueda, por defecto 0.7
• metadata (objeto, opcional): Información adicional sobre el vector

Devuelve:

• Objeto con estado y resultados de la operación

Ejemplo:

// 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": { ... }
//     },
//     ...
//   ]
// }

Esquema de Base de Datos

El sistema de memoria crea y mantiene automáticamente las siguientes tablas de base de datos:

• messages: Almacena mensajes de usuario y asistente

  • id: Identificador único
  • timestamp: Marca de tiempo de creación
  • role: Rol del mensaje (usuario/asistente)
  • content: Contenido del mensaje
  • importance: Nivel de importancia
  • archived: Si el mensaje está archivado

• active_files: Registra la actividad de archivos

  • id: Identificador único
  • filename: Ruta al archivo
  • action: Última acción realizada
  • last_accessed: Marca de tiempo del último acceso

• milestones: Registra hitos del proyecto

  • id: Identificador único
  • title: Título del hito
  • description: Descripción detallada
  • timestamp: Marca de tiempo de creación
  • importance: Nivel de importancia

• decisions: Almacena decisiones del proyecto

  • id: Identificador único
  • title: Título de la decisión
  • content: Contenido de la decisión
  • reasoning: Razonamiento de la decisión
  • timestamp: Marca de tiempo de creación
  • importance: Nivel de importancia

• requirements: Mantiene requisitos del proyecto

  • id: Identificador único
  • title: Título del requisito
  • content: Contenido del requisito
  • timestamp: Marca de tiempo de creación
  • importance: Nivel de importancia

• episodes: Documenta acciones y eventos

  • id: Identificador único
  • timestamp: Marca de tiempo de creación
  • actor: Actor que realiza la acción
  • action: Tipo de acción
  • content: Detalles de la acción
  • importance: Nivel de importancia
  • context: Contexto de la acción

• vectors: Almacena incrustaciones vectoriales para búsqueda semántica

  • id: Identificador único
  • content_id: ID del contenido referenciado
  • content_type: Tipo de contenido (message, file, snippet)
  • vector: Representación binaria del vector de incrustación
  • metadata: Metadatos adicionales para el vector

• code_files: Registra archivos de código indexados

  • id: Identificador único
  • file_path: Ruta al archivo
  • language: Lenguaje de programación
  • last_indexed: Marca de tiempo de la última indexación
  • metadata: Metadatos adicionales del archivo

• code_snippets: Almacena estructuras de código extraídas

  • id: Identificador único
  • file_id: Referencia al archivo padre
  • start_line: Número de línea inicial
  • end_line: Número de línea final
  • symbol_type: Tipo de estructura de código (function, class, variable)
  • content: Contenido del fragmento de código

Flujos de Trabajo de Ejemplo

Inicio de Conversación Optimizado

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

Iniciar una Nueva Sesión (Método Alternativo)

// 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",
});

Seguimiento de la Actividad del Usuario

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

Solución de Problemas

Problemas Comunes

1. Problemas de Conexión a la Base de Datos

   • Verifique que la URL de su base de datos Turso y el token de autenticación sean correctos
   • Compruebe la conectividad de red con el servicio Turso
   • Verifique que la configuración del firewall permita la conexión

2. Datos Faltantes

   • Compruebe que los datos se almacenaron con el nivel de importancia adecuado
   • Verifique los parámetros de consulta de recuperación (límite, filtros)
   • Compruebe el estado de la base de datos con mcp_cursor10x_checkHealth()

3. Problemas de Rendimiento

   • Supervise las estadísticas de memoria con mcp_cursor10x_getMemoryStats()
   • Considere archivar datos antiguos si la base de datos crece demasiado
   • Optimice la recuperación utilizando filtros más específicos

Pasos de Diagnóstico

1. Compruebe el estado del sistema:

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

2. Verifique las estadísticas de memoria:

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

3. Genere un banner de estado:

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

Niveles de Importancia

Al almacenar elementos en la memoria, utilice los niveles de importancia adecuados:

• low: Información general, operaciones rutinarias, conversaciones cotidianas
• medium: Contexto útil, elementos de trabajo estándar, funciones habituales
• high: Decisiones críticas, funciones principales, elementos importantes de arquitectura
• critical: Arquitectura central, problemas de seguridad, problemas de integridad de datos

Licencia

MIT