The Goals of SDL-MCP and where it is headed next...

[GlitterKill]

SDL-MCP is built for coding agent users who want to keep context clean and stretch subscription tokens further than any other solution. Those two goals drive every decision I make on this project.

At its core, SDL-MCP is a codegraph solution built around a policy system designed to minimize token use. It started on SQLite, but I hit its limitations quickly, so I researched alternatives and refactored for Ladybug (the successor to Kuzu).

The releases should be production quality at this point. The fundamental code retreival tools (symbolsearch, hotpath, skeletons, and windows) have been rock solid for well over a month now. All tools continue to receive polish and optimization through continued testing as new features are expanded. I use SDL-MCP heavily while developing and I am picky. :) Expect more and more polish as things progress.

Completed

• Ladybug Hybrid Retrieval. The DB and its relationship queries still carry structure and logic inherited from SQLite. Reworking how the DB operates will be a significant refactor, but it should bring performance gains and open the door to more advanced graph features.
• Code clean up to remove legacy code related to sqlite features.
• SCIP Index. An added layer of code intelligence that will greatly improve relational information and semantic capabilities.
• High-End CPU Optimization. CPU concurrency currently defaults to 4 cores and caps at 10. The new plan expands support for higher core counts to keep CPUs like the 9950X3D and Threadrippers busy. CPU capabilities will be auto-detected and concurrency scaled to match, with Rust-level optimizations (SIMD + mmap).
• Indexing overhaul for speed and polish.
• Semantic indexing/processing system overhaul.
• Observability Dashboard. Shows the internals of SDL by showing stats/functions and performance diagnostics. (More work being done)
• Add support for LSP enrichment when a supported language does not have a SCIP index. This will allow SDL-MCP to accurately cover a wide range of languages.
• Creating a separate app to handle the automated install or removal of all available lsp language servers. A solution was chosen for each language based on code info accuracy and the smallest installed footprint.
• Extensive tool testing with Codex and Claude with included generated hooks that force these two harnesses to only use SDL tools for tasks, but allows native tools for internal work (memories, skill loading, etc).

Upcoming Development (In Order)

• Expand Observability Dashboard to include SDL-MCP configuration panels to make setup and config changes easier. (IN PROGRESS)
• Add language support for Swift, Ruby, and Lua.
• Knowledge Persistence. Currently, when the DB is reindexed, LLM-generated semantic summaries and embedded summaries are discarded. This system will preserve that data so it can be built upon and remain durable across reindexes.
• Visual Graph. Likely deck.gl based for WebGL2 and WebGPU to show real-time visualizations of database activity as well as codebase discovery for developers.
• Coordination Ledger. Provides protection that prevents (or warns) an agent when it's working with code inside the blast radius of changes being made in another file. This adds a layer of safety to ensure agents are always seeing the latest version of a file they're touching.
  MORE TO COME

[GlitterKill]

Release v0.10.0 https://github.com/GlitterKill/sdl-mcp/releases/tag/v0.10.0 is a major refactor that opens the door to more advanced/useful tools. Improved token savings and features for the Runtime tool, full migration to Node 24, Token Meter, augmented heuristic summaries and many small improvements to function and stability.

I always try to do a good amount of testing before a new release, but sometimes things are realized or discovered during regular use. I always use the previous version to develop the current one. It extends my subscriptions (the entire reason I created it) so it is in my best interest for it to work and be stable. :)

Versioning going forward: Major changes like a new big feature, or refactor will get major version number changes (0.9.0, 0.10.0, etc) and smaller improvements/bugfixes will get minor ones (0.10.1, 0.10.2, etc.). Once a new major version is released, I do not plan to create new minor versions of the previous major version. Releases are intended to be stable. I cannot guarantee a working state if installing via cloning the repo. All of my commits are not safe, and may break some functionality, since I am aiming to iterate fast. I HIGHLY recommend using NPM installed releases.

[GlitterKill]

Today's v0.10.3 release brings substantial improvements to the features and ergonomics of all tools through repeat/iterative testing and improvement. I spent a lot of time (maybe an excessive amount :) ) getting feedback from LLMs to identify friction points in their use, which were then eliminated. The server itself is more stable than ever. I have had instances running for 48 hours under heavy use with zero issues leading up to this release. There has been a serious investment in query optimization and Etag caching to keep the server performant under load. The semantic engine now includes Jina embeddings v2 base-code model for improved relationship ranking.

The two models (Nomic and Jina) work together in different ways to rank symbols when finding relevant code through semantic search. Even with this addition, the accuracy is not where I want it to be. The next planned version is v0.11.0, with integrated SCIP indexes which will bring things up where I want them to be.

[GlitterKill]

Today's 10.4 release includes the addition of SCIP index support. Until now, SDL-MCP was closer to a graph-like code indexer than a true code graph. The addition of SCIP index data pushes it solidly into being a true code graph. SCIP indexes contain compiler quality knowledge of the code in your repo. SDL-MCP will still run great without SCIP indexes, but adding them improves overall code context. https://github.com/GlitterKill/sdl-mcp/blob/main/docs/feature-deep-dives/scip-integration.md

The issue with them is that you normally need to install the packages to run the compiler for that specific language to generate an index and then ingest that file; and there are numerous ones for different languages with each having different methods for installation. Sounds like a big pain in the ass. To help make implementing these indexes painless, I created a separate tool that can be used with SDL-MCP to auto detect repo languages, auto install the compilers for them, auto index the repo and then merge them into a single index file. That file is then automatically ingested as part of the indexing process. https://github.com/GlitterKill/scip-io