Stellarion

Cross-language code intelligence for AI agents and developers.

Stellarion builds a semantic graph of your codebase — functions, classes, imports, call chains — and exposes it through 47 tools, a VS Code extension, and a persistent memory layer. AI agents get structured code understanding instead of grepping through files. EDA mode adds Quartus / Qsys / SDC analysis for hardware design teams.

Quick Start

MCP Server (Claude Code, Cursor, any MCP client)

Add to ~/.claude.json (or your MCP client config):

{
  "mcpServers": {
    "stellarion": {
      "command": "/path/to/stellarion-server",
      "args": ["--mcp"]
    }
  }
}

The server indexes the current working directory automatically.

VS Code Extension

Install the VSIX:

code --install-extension stellarion-2.0.4.vsix

The extension starts the server automatically and registers all tools as Language Model Tools for Copilot.

Configuration

MCP Server flags

VS Code settings

{
  "stellarion.indexOnStartup": true,
  "stellarion.indexPaths": ["/path/to/project-a", "/path/to/project-b"],
  "stellarion.excludePatterns": ["**/cmake-build-debug/**", "**/generated/**"],
  "stellarion.embeddingModel": "bge-small",
  "stellarion.maxFileSizeKB": 1024,
  "stellarion.maxFiles": 5000,
  "stellarion.debug": false
}

Index multiple projects by listing paths in indexPaths. All paths are merged into a single graph, enabling cross-file navigation and impact analysis across project boundaries.

Full-body embeddings are enabled by default. Function body text is captured at parse time with zero I/O overhead.

Built-in exclusions (always skipped): node_modules, target, dist, build, out, .git, __pycache__, vendor, DerivedData, tmp, coverage, logs.

License Activation

A 180-day free trial of all 47 tools (community + Pro + EDA) starts automatically — no signup, no credit card.

To activate a Pro license:

• Command palette (Cmd/Ctrl+Shift+P): Stellarion: Activate Pro License, then paste the key
• Manual: save the key to ~/.stellarion/license.key and reload VS Code

Check status anytime with Stellarion: Show License Status.

Get a Pro license at stellarion.ai/pro.

Tools

Community Tools (28)

All community tools are free to use. No license required.

Code Analysis (5)

Code Navigation (13)

Indexing (3)

Memory (7)

Persistent AI context across sessions — debugging insights, architectural decisions, known issues.

All tool names are prefixed with stellarion_ (e.g. stellarion_get_ai_context). Tools that target a specific symbol accept uri + line or nodeId from symbol_search results.

Pro Tools (16)

Stellarion Pro adds 16 advanced tools for architecture analysis, security scanning, code similarity, and git history mining. All Pro tools are visible in the tool list and marked with [Pro] — they require a Stellarion Pro license to invoke.

A 180-day free trial starts automatically when you first use the Pro server. No signup required.

Architecture & Quality (5)

Security & Coupling (3)

Code Similarity (4)

Powered by semantic code embeddings — works across languages.

Cross-Project Search (1)

Git History Mining (3)

EDA — Quartus / Qsys / SDC (3)

For hardware design teams. Activated by --mode eda (Pro / trial only). The TCL/SDC/UPF parser classifies commands into 40+ stage-aware categories (quartus_assignment, qsys_module, qsys_interface, qsys_instantiation, quartus_timing, query_clock, read_sdc, …).

EDA mode is additive only — it surfaces the three EDA-native tools above without hiding any general tools. EDA codebases are multi-language (HDL + Tcl + Python build scripts + C testbenches), so the generic tools (security scan, related tests, etc.) still apply on the non-HDL portions.

Community vs Pro

Community edition is fully functional for single and multi-project code intelligence. Pro adds advanced analysis tools. A 180-day trial of all Pro features starts automatically — no signup, no credit card.

Languages

17 languages parsed via tree-sitter — functions, imports, call graph, complexity metrics, dependency graphs, symbol search, and impact analysis:

TypeScript/JS, Python, Rust, Go, C, C++, Java, Kotlin, C#, PHP, Ruby, Swift, Tcl, Verilog/SystemVerilog, COBOL, Fortran

Architecture

MCP Client (Claude, Cursor, ...)        VS Code Extension
        |                                       |
    MCP (stdio)                            LSP Protocol
        |                                       |
        └───────────┐               ┌───────────┘
                    ▼               ▼
            ┌─────────────────────────────┐
            │       stellarion-server      │
            ├─────────────────────────────┤
            │  17 tree-sitter parsers     │
            │  Semantic graph engine      │
            │  AI query engine (BM25)     │
            │  Memory layer (RocksDB)     │
            │  Full-body embeddings (BGE) │
            │  HNSW vector index          │
            └─────────────────────────────┘

A single Rust binary serves both MCP and LSP protocols.

• Indexing: ~60 files/sec. Incremental re-indexing on file changes.
• Queries: Sub-100ms. Cross-file import and call resolution at index time.
• Embeddings: Full-body (function bodies captured at parse time, zero disk I/O). Auto-downloads model on first run.

Examples & Issue Tracker

Configuration templates and 14 architect-level slash commands (Claude Code + VS Code Copilot Chat) live at github.com/stellarion-repos/stellarion-ai. That's also the public bug tracker — open issues there for the extension, the MCP server, EDA classification, slash commands, or documentation.

For security disclosures: security@stellarion.ai (do not open a public issue).

License

Proprietary. See stellarion.ai/pro for Pro licensing.