Julie

Code intelligence that gives your AI agent its memory back.

Context Window 0 tokens
See How It Works View on GitHub

Token Savings

Measured across real projects (Rust, TypeScript, Python, JavaScript). Same tasks. Dramatically less context consumed.

Task Without Julie With Julie Savings
Understand a file's API ~3,000 tokens ~300 tokens ~90%
Find a function definition ~4,000+ tokens ~100 tokens ~97%
Investigate before modifying ~5,000+ tokens ~200 tokens ~96%
Orient on new area ~10,000+ tokens ~800 tokens ~92%
Edit a function ~3,000+ tokens ~500 tokens ~80%

How It Works

Three steps. Zero configuration.

🌳
Step 1

Parse

Tree-sitter extracts symbols, relationships, and types from 33 languages

📦
Step 2

Index

Tantivy full-text search + SQLite graph + KNN embeddings

⚡
Step 3

Query

Agent asks a question, gets exactly what it needs — no file reads

Reference Graph

Julie doesn't just find symbols — it understands how they connect.

Callers Callees Types handle_checkout retry_payment batch_processor process_payment validate_card charge_gateway emit_event PaymentRequest → PaymentResult

Graph showing process_payment at center. Called by handle_checkout, retry_payment, and batch_processor. Calls validate_card, charge_gateway, and emit_event. Transforms PaymentRequest into PaymentResult.

$ deep_dive("process_payment", overview)
→ Callers: handle_checkout, retry_payment, batch_processor
→ Callees: validate_card, charge_gateway, emit_event
→ Types: PaymentRequest → PaymentResult
→ ~400 tokens. Zero file reads.

One call. Full picture. Zero file reads.

Test Intelligence

Every test rated by quality. Know which tests actually protect your code.

// Test Quality Analysis
Tests: 3 found
  ✓ test_process_payment  (thorough — 8 assertions, error paths)
  ✓ test_payment_validation  (adequate — 4 assertions)
  ○ test_payment_retry  (thin — 1 assertion, no error paths)

Computed at index time. Every test scored automatically.

Skills

11 pre-built workflows that combine tools into higher-level capabilities.

/editing
Zero-read editing: understand and modify without reading files
$ /editing
deep_dive → edit_symbol (dry_run)
@@ -42,5 +42,5 @@
-fn validate(t: &str) -> bool
+fn validate(t: &str) -> Result
/architecture
Architecture overview with entry points and dependency flow
$ /architecture
Entry points: 15 high-centrality symbols
Modules: 8 groups by responsibility
→ Reading order: handler.rs → tools/ → database/
/metrics
Session performance and context efficiency report
$ /metrics
21 calls | avg 10ms
Source examined: 529KB
492KB NOT injected into context

Also included: /explore-area, /call-trace, /logic-flow, /impact-analysis, /dependency-graph, /type-flow, /web-research, /search-debug

/web-research extends Julie's token efficiency to web content: fetch documentation or articles as markdown, index locally, then read selectively with Julie tools instead of dumping entire pages into context.

Semantic Embeddings

Find what you mean, not just what you typed.

// Keyword Search
$ fast_search("handle user login")
→ handle_user_login  (exact match)
→ login_handler  (partial match)
// Semantic Similarity
$ deep_dive("authenticate") → Related:
→ verify_credentials  (0.92 similarity)
→ validate_session  (0.87 similarity)
→ check_permissions  (0.81 similarity)

GPU-accelerated embeddings. Works with CUDA, MPS, and DirectML. Falls back to CPU gracefully.

Tools

10 tools. Each one replaces dozens of file reads.

fast_search
Full-text code search with code-aware tokenization
$ fast_search("UserService", definitions)
Definition found: UserService
  src/services.rs:42 (struct, public)
  3ms
~150 tokens
get_context
Token-budgeted context for a concept or task
$ get_context("payment processing")
Pivots (3): process_payment, PaymentService, charge_gateway
Neighbors (8): signatures + types
  Token budget: 2000 · Used: 1847
~1,000 tokens
deep_dive
Progressive-depth symbol investigation
$ deep_dive("process_payment", overview)
Callers (3) · Callees (3) · Types (2)
Centrality: 0.82
  ~400 tokens
~400 tokens
fast_refs
Find all references to a symbol
$ fast_refs("UserService")
12 references across 8 files
  api.rs:15, handler.rs:42, tests.rs:8, ...
~400 tokens
get_symbols
Smart file reading with 70-90% token savings
$ get_symbols("src/services.rs", structure)
struct UserService (pub)
  fn new() → Self
  fn authenticate(&self, ...) → Result
  500 lines → 20 line overview
~150 tokens
edit_file
Edit files without reading them first
$ edit_file("src/auth.rs", old_text, new_text, dry_run)
@@ -42,5 +42,5 @@
-fn validate(token: &str) -> bool {
+fn validate(token: &str) -> Result<Claims> {
  Fuzzy matched (trimmed-line)
~200 tokens
edit_symbol
Edit a symbol by name without reading the file
$ edit_symbol("AuthService::validate", replace, dry_run)
@@ -42,8 +42,10 @@
-fn validate(&self, ...) -> bool {
+fn validate(&self, ...) -> Result<Claims> {
  Symbol found in src/auth.rs:42
~250 tokens
rename_symbol
Workspace-wide rename with dry-run preview
$ rename_symbol("UserService", "AccountService", dry_run)
Preview: 15 files, 23 replacements
  services.rs:42  UserService → AccountService
  handler.rs:15   UserService → AccountService
~500 tokens
manage_workspace
Index, add, remove, refresh workspaces
$ manage_workspace(index)
Indexed: 1,247 symbols from 89 files
Languages: Rust, TypeScript, Python
  1.8s
~100 tokens
query_metrics
Session performance stats and context efficiency
$ query_metrics(category="session")
fast_search 12 calls avg 4.1ms
Source examined: 214KB
NOT injected: 206KB
~300 tokens

33 Languages

Full symbol extraction, reference graphs, and code intelligence across all of them.

Core (11)
Rust TypeScript JavaScript Python Java C# PHP Ruby Swift Kotlin Scala
Systems (5)
C C++ Go Lua Zig
Functional (1)
Elixir
Specialized (12)
GDScript Vue QML R Razor SQL HTML CSS Regex Bash PowerShell Dart
Documentation (4)
Markdown JSON TOML YAML
Search
<100MB
Memory
<2s
Startup

After initial indexing, only changed files are re-processed — keeping your index fresh in seconds, not minutes.

Observatory Dashboard

A built-in web dashboard for monitoring your Julie daemon.

Intelligence
Codebase analytics: top symbols by centrality, symbol kind distribution, file hotspots, and story cards
Top Symbols
1. process_payment fn (0.92)
2. UserService struct (0.87)
3. handle_request fn (0.81)
Search Playground
Live search across all indexed workspaces with scoring details and centrality badges
$ search "authenticate"
verify_credentials score: 42.1
validate_session score: 38.7
2 workspaces searched
Projects
Workspace overview with language distribution bars, symbol counts, and indexing status
my-app Ready
1,247 symbols | 89 files
Metrics
Tool call performance, session stats, success rates, and context efficiency across workspaces
fast_search 142 calls avg 3.8ms
deep_dive 67 calls avg 8.2ms
Context saved: 1.2MB

The daemon starts automatically when your MCP client connects. Visit http://localhost:7890 to explore.

Installation

Get started in 30 seconds.

# Install the plugin (recommended)
$ /plugin marketplace add anortham/julie-plugin
$ /plugin install julie@julie-plugin
// .vscode/mcp.json
{
  "servers": {
    "Julie": {
      "type": "stdio",
      "command": "/path/to/julie-server",
      "env": {
        "JULIE_WORKSPACE": "${workspaceFolder}"
      }
    }
  }
}
// opencode.json
{
  "mcp": {
    "julie": {
      "type": "local",
      "command": ["/path/to/julie-server"],
      "enabled": true
    }
  }
}
// MCP config (Cursor, Windsurf, etc.)
{
  "mcpServers": {
    "julie": {
      "command": "/path/to/julie-server"
    }
  }
}
# GEMINI.md (project root)
# Julie MCP server is configured separately
# in ~/.gemini/settings.json
# Add to ~/.gemini/settings.json:
{
  "mcpServers": {
    "julie": {
      "command": "/path/to/julie-server"
    }
  }
}
# codex.json or ~/.codex/config.toml
{
  "mcpServers": {
    "julie": {
      "command": "/path/to/julie-server"
    }
  }
}

Julie indexes your workspace automatically on first connection (~2-5s for most projects).