v0.9.0MCP server and CLI

: Local-First Retrieval for AI Agents.

Stop making your agent grep and guess. Eulix answers lookups directly from a structural index and returns ranked, token-budgeted context for your MCP client.

  • No embeddings or GPU required (with EHNAS).
  • Saves token context by returning structural graph data.
  • 100% local. Your code never leaves the machine.

Linux

$ bash <(curl -fsSL https://raw.githubusercontent.com/Nurysso/eulix/main/install.sh)
Where is analyze_and_build?locationno LLM
  • mainmain.rs
analyze_and_buildanalysis_pipeline.rs
  • find_entry_points
  • detect_patterns
  • build_call_graphv1
  • resolve_call_locationsv1
  • populate_called_byv1
  • build_call_graph_v2v2
  • populate_called_by_from_graphv2

eulix-parser/src/analysis_pipeline.rs:7

Eulix's own call graph: the parser's analysis pipeline. These answers come straight from the index, with no model involved.

One question, one ranked reply.

Claude Code asks Eulix how Flask stores its session cookie over MCP, then answers from the context it gets back.

  • 98.6%

    of PRISM's call edges are right

  • < 20 ms

    per warm query (p50)

  • < 90 MB

    MCP server memory

  • 53.9 s

    to parse the Linux kernel, call graph included

  • < 10 s

    to re-parse it incrementally

v2 on eight open-source projects, one per language, checked against each language's own compiler tooling. Queries: , v0.9.0, five open-source repos on a Ryzen 5 5600X. Kernel: 37.3M lines on 12 threads.

Validated on

  • Linux kernel
  • Go compiler
  • FFmpeg
  • Gecko / Firefox
  • Django
  • OpenStack Nova

You usually don't know where the answer is.

  1. grepfinds strings, not who calls them.
  2. an LSPresolves a symbol you already know the name of.
  3. an LLManswers confidently about code it has never seen.

Eulix covers the space in between: callers, dependencies, types, subsystems, implementation paths and the surrounding context that gives a symbol its meaning.

How Eulix compares with ripgrep, an IDE or LSP, and LLM chat
CapabilityripgrepIDE / LSPLLM chatEulix
Find exact textSupported: YesSupported: YesPartly: Context-dependentSupported: Indexed search
Navigate symbolsPartly: Text-basedSupported: YesPartly: Context-dependentSupported: Symbol index
Trace callers and calleesNot supported: NoPartly: PartialPartly: Context-dependentSupported: Call graph
Understand subsystemsNot supported: NoPartly: Manual explorationPartly: Requires contextSupported: Hybrid retrieval
Ground answers in repository codeSupported: MatchesSupported: Source referencesPartly: Depends on supplied contextSupported: Retrieved code context
Keep processing localSupported: YesSupported: YesPartly: Provider-dependentSupported: Local-first
Analyze repository-scale codeSupported: Text searchPartly: Tool-dependentPartly: Context limitsSupported: 37.3M lines in 57.2 s

Typical capabilities, not every tool or configuration. Remote LLM providers, when configured, may receive retrieved code context.

Lookups hit the index. Reasoning gets context.

A rule-based classifier routes every query automatically. Location, usage, call-graph and metrics questions are answered straight from the index. Questions that need reasoning take the LLM path, where the etiya engine builds a ranked, token-budgeted context window for your model.

Try a query

1 Raw query

"How does the MCP server release the context builder after being idle"

string~17 tokensno structure

2 Router

classifierrule-based, no model→ needs reasoning

Index no LLM

answered directly from .eulix/

  • location
  • usage
  • call graph
  • metrics

LLM path etiya

context window for your model

  1. embed query
  2. semantic + lexical channels
  3. call-graph expansion
  4. query MMR + budget

3 Returned

context windowengine: etiyaselector: query MMR

tokens≈5,819 / 5,987

chunks30 / 30 cap · 13 files

  1. 1eulix-cli/internal/mcp/strategy_memory.goL28–41
  2. 2eulix-cli/internal/mcp/server.goL179–269
  3. 3eulix-cli/internal/mcp/strategy.goL144–181
  4. 4eulix-cli/internal/mcp/strategy_lexical.goL48–54
  5. 5eulix-cli/internal/mcp/helpers.goL107–176
  6. 6eulix-cli/internal/mcp/server.goL53–77
  7. +24 more chunks

Filled to the token budget. → handed to your model.

Real queries against Eulix's own repository. Context windows are from an etiya evaluation run; token totals are estimated at four characters per token, the same estimator Eulix uses.

The retrieval stack.

One setting picks the engine. Both share the index, the lexical channels and the call graph. They differ in how they reach code that shares no words with your question.

Retrieval engines

eulix-clistablev0.9.0

Exact · Hierarchical · Node · Structure

  • 0 embeddings
  • 0 GPU
  • 0 network
  • Query expansion

    The top keyword hits vote on related terms, then a second pass runs on them.

  • Cross-language twins

    The same code in two languages is matched by structure, not by name.

  • Random walk

    Walkers move over symbol, call and keyword links from the strongest hits.

eulix analyze skips the embedding step entirely.

[project]
engine = "ehnas"
How works

Embedding-aware · Topological · Indexing for Your · Architecture

Embeds each question through the local embedding server and searches by meaning, alongside the same lexical channels.

Best for
Dense semantic matches: questions worded nothing like the code.
Search
Cosine over stored vectors, IVF-indexed above 50,000 chunks.
Selection
Query MMR: relevance to the question, minus overlap with what is already picked.
[project]
engine = "etiya"
How works

Embedders

eulix-embedstablev0.4.2used by etiya

ONNX Runtime

default

Downloaded at install time. Fast, local inference.

  • CPU
  • CUDA
  • ROCm
  • CoreML
[embeddings]
engine = "onnx"

PyTorch

optional

Optional backend. Model downloads happen at runtime.

  • CUDA
  • ROCm
  • MPS
  • CPU
[embeddings]
engine = "torch"

Index once. Ask as often as you like.

eulix analyze parses the repository into a knowledge base on disk. Every question after that is answered from it, on your machine.

01

Index

eulix analyze
libeulixRust + Tree-sitter
  • symbols and AST
  • relationships
  • indexes and metrics

.eulix/

  • kb.jsonsymbols, functions, classes, methods
  • kb_index.jsonlookup indexes
  • kb_call_graph.jsoncall graph and reverse call graph
  • kb_summary.jsonproject summary and metrics
  • embeddings.binSQ8-quantized embeddings · etiya only
  • vectors.binvector store · etiya only

Call relationships come from , an approximate resolver built for speed at repository scale rather than formal whole-program soundness.How works

02

Retrieve

eulix query
queryexplicit anchors + path gates
  • exactsymbols
  • lexicalBM25 / keywords
  • semanticIVF vectors
  1. merge and deduplicate
  2. subsystem signals
  3. scope and test-file demotion
  4. MMR with exact-first ranking
selected contextto you, your agent, or an optional LLM

Retrieval stays a ranking system, not a proof system. Naming a symbol or path narrows the search.Retrieval pipeline

When draws an edge, it's right.

v2 builds the call graph from syntax alone, with no build step and no type checker. Every edge was checked against the call sites each language's own compiler tooling resolves. When a name is too ambiguous to guess, leaves the edge out: a missing edge misleads retrieval less than a wrong one.

98.6%

of call edges correct · 87 wrong out of 6,355

v298.6%
v154.6%

Eight projects, one per language. v1 got 5,060 of 11,153 wrong.

Precision by language · v1 → v2 · 24 projects pooled

  • Java99.7%from 62.3%
  • Go100.0%from 67.5%
  • Python99.5%from 68.7%
  • Rust99.1%from 39.5%
  • TypeScript100.0%from 93.7%
  • C99.8%from 99.8%
  • JavaScript92.7%from 95.4%
  • C++75.3%from 64.6%

v2 precision v1 precision

All 24 projects · 97.7% precision across 18,199 edges
ProjectLanguageEdgesWrongPrecisionRecallF1
ginGo1,6030100.0%66.3%79.8%
chiGo5110100.0%57.3%72.9%
cobraGo1,3960100.0%91.4%95.5%
gsonJava1,0590100.0%97.3%98.7%
jsoupJava3,4551499.6%93.9%96.7%
commons-cliJava5750100.0%90.8%95.2%
flaskPython168398.2%74.0%84.4%
clickPython407199.8%76.5%86.6%
requestsPython2270100.0%90.8%95.2%
ripgrepRust1,6652098.8%34.3%50.9%
serde_jsonRust573299.7%49.0%65.7%
fdRust2820100.0%50.5%67.1%
class-validatorTypeScript3640100.0%90.3%94.9%
class-transformerTypeScript270100.0%39.1%56.2%
immerTypeScript1540100.0%82.3%90.3%
axiosJavaScript2952591.5%82.8%87.0%
markdown-itJavaScript620100.0%88.6%93.9%
mochaJavaScript2051692.2%49.4%64.3%
cJSONC8120100.0%99.8%99.9%
zlibC290797.6%86.8%91.9%
luaC2,7440100.0%81.1%89.6%
tinyxml2C++3893990.0%56.0%69.0%
pugixmlC++860100.0%54.8%70.8%
yaml-cppC++85028866.1%56.4%60.9%

Recall is the trade: skips calls whose receiver type isn't written in the source, so Rust and C++ miss more edges than they get wrong. Reference tools: go/types, javac, jedi, rust-analyzer, the TypeScript checker and libclang. PHP isn't measured. Reproduce with make bench-callgraph.

The Linux kernel, parsed in 54 seconds.

64,460 source files and 37.3 million lines on 12 threads with v2. Nothing failed and nothing was skipped. Re-runs reuse a parse cache and finish in under 10 seconds.

53.9s

parser total, 37,322,695 lines

Where the time goes

  • Parse48.69 s
  • Call graphs (PRISM v2)1.99 s
  • Summary and metrics0.26 s
  • Other2.91 s
  • ~693Klines / s

    End-to-end parser throughput on 12 threads.

  • 1.51Medges

    Call graph of 774,876 nodes, extracted with zero parse failures.

  • 837,531chunks

    Embedded locally in 26 min 27 s on one AMD Radeon RX 6700 XT, at 527.6 chunks / s.

  • ~3.7GB peak

    Spill-to-disk serialization cut peak memory from about 8 GB.

Local engineering runs. Results vary with hardware, repository state, parser configuration, embedding model and query shape. Embedding is the slow stage at scale; with the engine, eulix analyze skips it.

Parser benchmarks

One index, five ways in.

The CLI is one front end on a shared engine. Your terminal, your browser, your editor and your coding agent all read the same local index.

eulix

stablev0.9.0

The command line: query routing, retrieval, context building, the optional LLM layer and a chat UI.

  • init
  • analyze
  • chat
  • query
  • mcp
  • vizEulize
  • embed
  • history
The eulix chat interface answering how version 2 of the call graph is built, with a structured breakdown that cites functions and line ranges.

vizEulize

stable

A searchable call-graph explorer in your browser, served from 127.0.0.1. Focus a symbol, pick a direction and depth, filter by tags and categories.

$ eulix vizEulize
vizEulize showing two call graphs: a small neighbourhood around one function on the left, and a dense project-wide graph with a highlighted cluster on the right.

eulix mcp

stablev0.9.0

An MCP server over stdio. Claude Code, Windsurf, Cline, Continue and LM Studio can query any analyzed repository and get ranked source context back.

Claude Code

$ claude mcp add eulix -- eulix mcp --repo "$PWD"

Cursor, Windsurf, Cline and other clients

{
  "mcpServers": {
    "eulix": {
      "command": "eulix",
      "args": ["mcp"]
    }
  }
}
  • query
  • query_with_cot
  • query_without_cot
  • set_repo_path

libeulix

stablev0.9.0

The parsing, call-graph, indexing and metrics engine as a standalone Rust crate.

$ cargo add libeulix
crates.io/crates/libeulix

eulix-lsp

betav0.2.0

A multi-language language server built on libeulix.

  • outline
  • hover
  • go to definition
  • references
  • completion
  • rename
  • semantic tokens
  • call hierarchy
  • workspace symbols
  • diagnostics
eulix-lsp on GitHub

Every component

  • eulix-clistablev0.9.0
    GoThe eulix command: routing, retrieval, context building, the LLM layer and the MCP serversource
  • libeulixstablev0.9.0
    RustAnalysis engine on Tree-sitter: symbols, PRISM call graphs, indexes, metricssource
  • eulix-parserstablev0.9.0
    RustParser front end to libeulix; writes the knowledge base to .eulix/source
  • eulix-embedstablev0.4.2
    PythonStreaming embedding pipeline: PyTorch or ONNX, CPU or GPU, SQ8 quantizationsource
  • eulix-lspbetav0.2.0
    RustLanguage server built on libeulixsource
  • vizEulizestable
    HTML/JSSingle-file call-graph explorer, served locally by eulix vizEulizesource

Your code stays on your machine.

Parsing, indexing, retrieval and embedding all run on-device. The LLM stage is optional and cloud providers are opt-in. With a local provider such as Ollama, nothing leaves your environment.

Using a remote provider? The retrieved code context for each query is sent to it. Choose accordingly for proprietary repositories.

Nine languages, one index.

Each one is validated on real projects. Mixed-language monorepos are handled with subsystem detection and path gating.

  • C

    Limited by macro expansion

  • C++

    Limited by macro expansion

  • Go

    Validated on Kubernetes, gin-gonic

  • Python

    Validated on Django, OpenStack

  • Rust

    Validated on ripgrep, Zed

  • TypeScript

    Deno. No .tsx yet

  • JavaScript

    Express.js, Three.js. No .jsx yet

  • Java

    Validated on Tomcat, OpenJDK

  • PHP

    Validated on WordPress, Laravel, Symfony

C and C++ parsing may fall short of 100% because macros are not expanded. JSX and TSX files are not parsed yet.

Three steps to your first answer.

No cloud account and no API key. Linux needs bash and curl; Windows needs PowerShell and may need the Visual Studio C++ build tools.

  1. 1

    Install

    macOS binaries have not been tested yet.

    Linux

    $ bash <(curl -fsSL https://raw.githubusercontent.com/Nurysso/eulix/main/install.sh)
  2. 2

    Analyze a repository

    Once per repository.

    $ cd your-project
    $ eulix init# creates eulix.toml
    $ eulix analyze# parse and build the index
  3. 3

    Ask

    Interactive, or one question at a time.

    $ eulix chat# interactive
    $ eulix query "Who calls foo?"# one-shot

That's it. The index lives in .eulix/ next to your code.

Installation guide