¿Por qué Cursor olvida las reglas de mi proyecto?

Cursor olvida las reglas de tu proyecto porque las reglas se añaden al prompt como texto estático y compiten con el contexto de código por un presupuesto finito. Las reglas de ámbito glob solo se aplican cuando la ruta del archivo coincide, y las reglas alwaysApply aún pierden peso a medida que el prompt se llena con código recuperado. El formato legado .cursorrules también está siendo descontinuado a favor de .cursor/rules/*.mdc. La solución es hacer que las reglas sean consultables en lugar de texto embebido en el prompt.

El sistema de Reglas de Cursor, especialmente el nuevo formato .cursor/rules/*.mdc con frontmatter YAML (descripción, globs, alwaysApply), es un verdadero intento de proporcionar orientación escalable por proyecto. Sin embargo, los mecanismos aún tienen fugas.

1. Las reglas comparten el presupuesto de prompt con el código. Cada regla que se aplica se antepone al prompt. Cuantos más archivos Cursor incorpora como contexto, menos espacio efectivo tienen las reglas. La orientación importante termina al principio del prompt, donde los modelos le dan menos peso que al código reciente al final.

2. El ámbito glob es silencioso. Una regla con globs: src/components/**/*.tsx no se aplicará cuando edites un archivo .stories.tsx en la misma carpeta a menos que amplíes el glob. La regla está técnicamente presente en el repositorio, simplemente ausente de este prompt, y Cursor no te advertirá.

3. Las sesiones largas desalojan contexto. Una vez que una sesión carga muchos archivos, el contexto de trabajo efectivo del modelo disminuye, y las instrucciones anteriores, incluidas las reglas, pierden peso frente al código reciente. La deriva de estilo y reglas en refactorizaciones más grandes es un patrón bien documentado en los comentarios de los usuarios de Cursor.

4. El formato legado está desapareciendo. .cursorrules en la raíz del proyecto aún es compatible, pero está marcado para descontinuación a favor de .cursor/rules/*.mdc. Los proyectos que no han migrado terminan con reglas que se cargan de manera inconsistente.

El resultado: una configuración de reglas reflexiva que funciona en tareas pequeñas y falla en las más grandes.

Cada fallo de regla te cuesta tiempo de revisión, y el costo se acumula en una base de código real:

• Las barandillas arquitectónicas caen. "No llamadas directas a la base de datos desde componentes de React" se viola tres archivos en un refactor, y solo lo notas en la revisión.
• Las reglas de seguridad se deslizan. "Nunca registrar cuerpos de solicitud" se rompe en una nueva utilidad de registro porque el glob no coincidió.
• La aplicación de convenciones se suaviza. "Usa el envoltorio compartido useQuery, no fetch en crudo" se ignora porque el archivo de reglas perdió peso tarde en un prompt largo.

La solución no es "hacer que cada regla siempre se aplique." Eso solo empuja más texto en cada prompt y acelera el problema de desalojo. La solución es hacer que las reglas sean recuperables bajo demanda, limitadas al cambio en cuestión, en lugar de ser estáticamente añadidas.

Cursor ha implementado maquinaria real aquí. Ninguna de ellas cierra completamente la brecha.

*Reglas de Proyecto (`.cursor/rules/.mdc)** soportan frontmatter con description, globs, y alwaysApply, para que puedas limitar las reglas por ruta de archivo y decidir si cada regla se aplica cada vez o solo en coincidencia. Este es el formato moderno recomendado y una clara mejora sobre el archivo legado .cursorrules`.

Recuerdos generan automáticamente reglas cortas a partir del historial de chat y las limitan al proyecto. Son útiles como base, pero son resúmenes de preferencias inferidas, no contratos autoritativos.

Soporte nativo de MCP permite a Cursor extraer contexto de servidores externos a través de .cursor/mcp.json o la interfaz de usuario de Configuración. Esta es la salida más limpia, porque MCP devuelve contexto bajo demanda en lugar de consumir presupuesto de prompt por adelantado.

Puedes leer la propia documentación de Cursor sobre Reglas en la documentación oficial de Cursor.

Para un uso ligero, las Reglas y los Recuerdos lo manejan. Para bases de código densas y ricas en reglas, los nativos se desvían.

El problema más profundo es que las reglas en una base de código real están estratificadas: reglas de arquitectura, reglas de marco, reglas de seguridad, convenciones del equipo y decisiones tomadas en la revisión de código la semana pasada. Meter todas ellas en archivos estáticos .mdc y esperar que el presupuesto de prompt se mantenga es frágil. También bloquea las reglas dentro de Cursor cuando muchos equipos ahora ejecutan Cursor, Claude Code, Cline y variantes de Copilot en paralelo.

Eso es lo que una capa de memoria entre herramientas soluciona: un almacén de reglas, recuperado bajo demanda, limitado al cambio, y compartido entre cada editor de IA en el equipo.

MemoryLake es una capa de memoria entre modelos que se sitúa entre tú y cada IA que usas. En lugar de depender solo de los archivos de Reglas, almacenas reglas en un Proyecto de MemoryLake, y Cursor recupera la porción correcta por edición a través de MCP.

• Recuperado bajo demanda, no embebido en el prompt. Cursor llama al endpoint de MCP de MemoryLake por turno y obtiene solo las reglas relevantes para el archivo en edición, por lo que las reglas dejan de competir con el código por el presupuesto de prompt.
• Versionado y auditable. El control de versiones estilo Git de MemoryLake rastrea cada cambio de regla, quién lo hizo y por qué, lo cual es importante cuando una regla rompe el comportamiento y el equipo necesita retroceder.
• Portable a cualquier otra herramienta de codificación de IA. El mismo conjunto de reglas funciona en Claude Code, Cline, Windsurf y cualquier editor compatible con MCP. Cuando un compañero de equipo cambia de herramienta, las reglas lo siguen.

MemoryLake obtuvo un 94.03% en el benchmark de contexto largo de LoCoMo, el mejor resultado publicado hasta 2026, con recuperación en milisegundos y cifrado de extremo a extremo AES-256.

1. Crea un proyecto y carga tus reglas. Inicia sesión en MemoryLake, abre Gestión de Proyectos, haz clic en Crear Proyecto y nómbralo según el repositorio (por ejemplo, "Cursor - reglas del servicio de pagos"). Importa tus archivos .cursor/rules/*.mdc en el Document Drive, y escribe tus reglas de mayor valor como entradas estructuradas en la pestaña de Recuerdos para que sean recuperables por tema.
2. Genera un endpoint de servidor MCP. Abre la pestaña de Servidores MCP dentro de tu proyecto, haz clic en Agregar Servidor MCP, nómbralo "integración de Cursor", y haz clic en Generar. MemoryLake devuelve un ID de clave API, secreto y URL de endpoint. Copia el secreto inmediatamente, ya que solo se muestra una vez.
3. Conecta Cursor. Cursor ha tenido soporte nativo de MCP desde 2025, lo que hace que este sea el camino más limpio. Agrega una entrada de servidor de MemoryLake a .cursor/mcp.json en la raíz del repositorio (o conéctalo a través de Configuración de Cursor > Funciones > MCP), pega la URL del endpoint y el token Bearer, y recarga Cursor. Tus reglas .mdc pueden permanecer en su lugar como base; MemoryLake proporciona el almacén de reglas más profundo y recuperable bajo demanda.