Improve AI Context Management with Structured Data Storage

[jezweb]

If there was some kind of build in simple database available, doesnt have to be a RAG, but like SQLite that could have an inbuilt mcp, that we knew would be there and be functional without installing anything that could be a big performance improvement for doing something like ingesting context of a framework for modes to interact with?

I don't know enough about how this would work technical so I had a discussion with gemini and this is where we arrived:

Proposal:

Currently, Roo Code appears to manage AI context and information potentially through mechanisms like reading various project files or using simple text files. While functional, this approach can become inefficient as projects grow or the complexity of the required context increases. We propose enhancing how Roo Code stores and retrieves this context by implementing a more structured data storage solution, such as storing structured data files (e.g., JSON) in a dedicated directory managed by VS Code, or potentially leveraging a lightweight embedded database like SQLite.

Problem:

1. Inefficient Context Retrieval: Relying on the AI to re-read or re-process potentially many source code or disparate text files every time context is needed is slow and resource-intensive. This is significantly slower than accessing pre-organized data.
2. Difficulty Managing Complex Context: As the AI's capabilities grow, it may need to store and relate various pieces of information (e.g., function definitions, variable usages across files, user interaction history, previously generated code snippets, links between documentation and code). Simple text files make managing these relationships and querying specific information challenging.
3. Scalability Issues: Performance can degrade in larger projects or when a significant amount of context needs to be maintained and accessed.

Proposed Solution:

Utilize VS Code's built-in storage APIs to create a dedicated location for structured context data.

1. Primary Recommendation (Lower Complexity): Use ExtensionContext.storageUri to obtain a workspace-specific directory path. Store the AI's context and relevant information in structured file formats within this directory, such as:

   • JSON files: Ideal for hierarchical or object-based data.
   • Potentially other formats like YAML or a custom format if suitable.

2. Alternative/Future Enhancement (Higher Complexity, More Power): Integrate a lightweight, embedded database engine like SQLite. The SQLite database file (.db) would also be stored within the directory provided by ExtensionContext.storageUri.

Benefits:

1. Faster Context Retrieval: By storing context in a structured, readily accessible format (whether in structured files or a database), the extension can retrieve the necessary information much faster than re-scanning source code or parsing unstructured text files. This directly addresses the performance concern of "getting an AI to read each file manually."
2. Improved Performance: Reduces redundant file I/O and processing overhead.
3. Enhanced Data Management: Provides a more organized way to store, update, and maintain AI context.
   • With structured files, data can be logically grouped and accessed.
   • With SQLite, complex relationships between different pieces of context can be easily defined and queried using SQL.
4. Increased AI Capability: A well-managed, structured context store enables the AI to build a richer, more nuanced understanding of the project and user interactions, potentially leading to more accurate and helpful suggestions or actions.
5. Better Scalability: Handles larger amounts of context and more complex data structures more efficiently.
6. Reliable Storage: Using ExtensionContext.storageUri ensures the context is stored in a stable, VS Code-managed location, tied to the specific workspace.

Technical Considerations:

• Structured Files: Requires implementing logic within the extension to serialize/deserialize data to/from the chosen file format (e.g., JSON.stringify/JSON.parse). Retrieval would involve loading the file and querying the in-memory data structure or implementing basic indexing.
• SQLite: Requires adding a Node.js SQLite library (like sqlite3 or better-sqlite3) as a dependency. Note that sqlite3 has native components which can add complexity to the build process for cross-platform compatibility, although tools exist to help manage this (electron-rebuild, vsce packaging). better-sqlite3 is often cited as simpler and faster but is synchronous. This option offers full SQL query capabilities.

Conclusion:

Implementing a structured data storage approach using ExtensionContext.storageUri and either structured files (like JSON) or an embedded database (like SQLite) would be a significant improvement for Roo Code's context management. It directly addresses performance bottlenecks and lays the groundwork for handling more complex AI interactions and larger projects efficiently. We believe this feature would greatly enhance the user experience and the capabilities of the Roo Code AI.

[BradKML]

The problem is that there are so many ways to store data, from graphs of task/function relationships, to just abusing RAG to oblivion. Memory banks are kinda non-trivial