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 39 tools, a VS Code extension, and a persistent memory layer. AI agents get structured code understanding instead of grepping through files.
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-0.14.0.vsix
The extension starts the server automatically and registers all tools as Language Model Tools for Copilot.
Configuration
MCP Server flags
| Flag |
Default |
Description |
--workspace <path> |
current dir |
Directories to index (repeatable for multi-project) |
--exclude <dir> |
— |
Directories to skip (repeatable) |
--embedding-model <model> |
bge-small |
bge-small (384d, fast) or jina-code-v2 (768d, 6x slower) |
--max-files <n> |
5000 |
Maximum files to index |
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.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.
All community tools are free and open source. No license required.
Code Analysis (5)
| Tool |
What it does |
get_ai_context |
Primary context tool. Intent-aware (explain/modify/debug/test) with token budgeting. Returns source, related symbols, imports, siblings, debug hints. |
get_edit_context |
Everything needed before editing: source + callers + tests + memories + git history |
get_curated_context |
Cross-codebase context for a natural language query ("how does auth work?") |
analyze_impact |
Blast radius prediction — what breaks if you modify, delete, or rename |
analyze_complexity |
Cyclomatic complexity with breakdown (branches, loops, nesting, exceptions, early returns) |
Code Navigation (13)
| Tool |
What it does |
symbol_search |
Find symbols by name or natural language (hybrid BM25 + semantic search) |
get_callers / get_callees |
Who calls this? What does it call? (with transitive depth) |
get_detailed_symbol |
Full symbol info: source, callers, callees, complexity |
get_symbol_info |
Quick metadata: signature, visibility, kind |
get_dependency_graph |
File/module import relationships with depth control |
get_call_graph |
Function call chains (callers and callees) |
find_by_imports |
Find files importing a module |
find_by_signature |
Search by param count, return type, modifiers |
find_entry_points |
Main functions, HTTP handlers, CLI commands, event handlers |
find_implementors |
Find all functions registered as ops struct callbacks |
find_related_tests |
Tests that exercise a given function |
traverse_graph |
Custom graph traversal with edge/node type filters |
Indexing (3)
| Tool |
What it does |
reindex_workspace |
Full or incremental workspace reindex |
index_files |
Add/update specific files without full reindex |
index_directory |
Add directory to graph alongside existing data |
Memory (7)
Persistent AI context across sessions — debugging insights, architectural decisions, known issues.
| Tool |
What it does |
memory_store / memory_get / memory_search |
Store, retrieve, search memories (BM25 + semantic) |
memory_context |
Get memories relevant to a file/function |
memory_list / memory_invalidate / memory_stats |
Browse, retire, monitor |
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.
Stellarion Pro adds 11 advanced tools for security analysis, 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 14-day free trial starts automatically when you first use the Pro server. No signup required.
Security & Architecture (3)
| Tool |
What it does |
scan_security |
Scan for vulnerabilities: dangerous calls, weak crypto, hardcoded secrets, unsafe patterns, architectural layer violations. 40+ rules across 13 languages. |
analyze_coupling |
Module coupling metrics: afferent/efferent coupling, instability scores, dependency graph |
find_unused_code |
Dead code detection with confidence scoring and framework-aware heuristics |
Code Similarity (4)
Powered by semantic code embeddings — works across languages.
| Tool |
What it does |
find_duplicates |
Detect duplicate/near-duplicate functions across the codebase |
find_similar |
Find functions most similar to a given function |
cluster_symbols |
Group functions into semantic clusters by purpose |
compare_symbols |
Deep comparison of two functions: similarity score, structural diff, shared callers |
Cross-Project Search (1)
| Tool |
What it does |
cross_project_search |
Search for symbols across all other indexed projects in the shared graph database |
Git History Mining (3)
| Tool |
What it does |
mine_git_history |
Mine commit history to bootstrap project knowledge |
mine_git_history_for_file |
Mine git history for a specific file |
search_git_history |
Semantic + keyword search over git commit history |
| Feature |
Community |
Pro |
| Tools |
28 |
39 (28 + 11 Pro) |
| Languages |
17 |
17 |
| Multi-project indexing |
Yes |
Yes |
| Persistent memory |
Yes |
Yes |
| Security scanning |
— |
40+ rules, 13 languages |
| Code similarity |
— |
Embedding-based, cross-language |
| Dead code detection |
— |
Confidence-scored, framework-aware |
| Cross-project search |
— |
Shared graph database |
| Git history mining |
— |
Semantic commit search |
| License |
Apache-2.0 |
stellarion.ai/pro |
Community edition is fully functional for single and multi-project code intelligence. Pro adds advanced analysis tools. A 14-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.
Building from Source
git clone https://github.com/stellarion-ai/stellarion
cd stellarion
cargo build --release -p stellarion-server # Rust server
cd vscode-stellarion && npm install && npm run esbuild # VS Code extension
npx @vscode/vsce package # VSIX
Requires Rust stable, Node.js 18+, VS Code 1.90+.
License
Apache-2.0
