ontomics MCP Server
io.github.EtienneChollet/ontomics
Index your codebase's domain knowledge. 20x fewer tokens, 10x faster.
What is the ontomics MCP server?
The ontomics MCP server builds a semantic index of your codebase's domain concepts, clustering related symbols, detecting naming conventions, and embedding function bodies by behavioral similarity. It enables AI agents to understand your project's vocabulary and architecture in a single tool call instead of dozens, reducing token usage by ~20x and query time by ~10x.
ontomics gives coding agents instant knowledge of your codebase by creating a semantic index of domain concepts, naming conventions, and behavioral patterns. Instead of making dozens of search and symbol-lookup calls, agents can query the index once to understand what terms mean, how concepts relate, which functions behave similarly, and how the vocabulary has evolved. It works entirely offline on your machine with no API keys required.
How to install ontomics
Copy-paste configuration for popular MCP clients.
Tools & capabilities
Tools this server exposes to the agent.
query_concept— Find all variants, related concepts, and occurrences of a termlocate_concept— Find the key signatures, classes, and files for a conceptdescribe_symbol— Get the signature, docstring, and relationships for a function or classtrace_concept— Trace how a concept flows through the codebase via call chainslist_concepts— List the top domain concepts by frequencylist_conventions— List all detected naming patterns (prefixes, suffixes, conversions)list_entities— List code entities (classes, functions) filtered by concept, role, or kindcheck_naming— Check an identifier against project conventions; suggests the canonical formsuggest_name— Generate an identifier name that fits the project's vocabularyvocabulary_health— Measure convention coverage, naming consistency, and cluster cohesionontology_diff— Show new, changed, or removed domain concepts since a git refexport_domain_pack— Export domain knowledge as portable YAML for use in other reposfind_similar_logic— Find functions with behaviorally similar implementations, ranked by embedding similaritydescribe_logic— Get the behavioral description, body text, and logic cluster membership for a functioncompact_context— Assemble tiered context (concepts + logic) for a symbol, optimized for LLM consumptiondescribe_file— Overview of a file's entities, concepts, and relationshipsconcept_map— Show which modules contain which domain conceptstype_flows— Show dominant types and how data flows through the codebasetrace_type— Trace how a specific type propagates across files and call sites
Use cases
- Understand domain concepts and naming conventions in an unfamiliar codebase with a single query instead of dozens of searches
- Find functions with similar behavior regardless of their names using semantic embeddings
- Detect naming inconsistencies and suggest canonical names that fit project conventions
- Track how domain vocabulary has evolved between git releases using ontology_diff
- Generate context-aware variable and function names that match your project's established patterns
ontomics MCP server FAQ
ontomics is an MCP server that builds a semantic index of your codebase's domain concepts, naming conventions, and function behaviors. It lets AI agents understand your project's vocabulary and architecture in one tool call instead of dozens, reducing tokens by ~20x and query time by ~10x.
Yes, ontomics is open-source and free. It runs entirely on your machine with no API keys or external services required.
Install the binary via npm (`npm install -g @ontomics/ontomics`), Homebrew, or from source. Then register it with Claude Code (`claude mcp add -s user ontomics -- ontomics`) or Cursor/Codex using their respective MCP add commands. Alternatively, add an `.mcp.json` file to your repo root.
Python, TypeScript, JavaScript, and Rust. The server auto-detects languages from file extensions.
No. ontomics runs entirely offline on your machine. It requires only a git repository (`.git/` directory) and will auto-detect and index your codebase on first run.
Search finds where strings appear; LSP finds where symbols are defined. ontomics answers semantic questions: what are the domain concepts, how do they relate, what naming conventions exist, and which functions behave similarly regardless of their names. It uses semantic embeddings and behavioral clustering to surface relationships that naming and call graphs alone cannot reveal.
README (reference)
Source of truth, from the repository.
ontomics
ontomics gives any coding agent instant knowledge of your codebase. One tool call instead of 19. ~20x fewer tokens.
https://github.com/user-attachments/assets/01afa8a0-1bc2-4686-94d7-965fef7610c3
Visualization for the voxelmorph project -- a library for unsupervised learning in image registration
Benchmark
Tested with Claude Sonnet — same question, with and without ontomics.
"What does 'transform' mean in this codebase?" on voxelmorph (full transcript):
| With ontomics | Without | |
|---|---|---|
| Tool calls | 1 | 19 |
| Tokens | ~3.7k | ~76k |
| Time | 5s | 1m 15s |
| Answer quality | Complete | Complete |
"What are the main domain concepts in this codebase?" on ScribblePrompt (full transcript):
| With ontomics | Without | |
|---|---|---|
| Tool calls | 1 | 26 |
| Tokens | ~3.7k | ~61.6k |
| Time | ~5s | 56s |
| Answer quality | Complete | Complete |
Both conditions produced complete, correct answers. ontomics got there in one call.
What it does that search can't
Search tells you where a string appears. An LSP tells you where a symbol is defined and referenced. Neither answers: what are the domain concepts in this codebase? How do they relate? What naming conventions emerged? What changed in the domain vocabulary since last release? Which functions behave similarly, regardless of what they're named?
ontomics builds a semantic index of your project's domain — clustering related symbols into concepts, detecting naming conventions from usage frequency, resolving abbreviations, grouping functions by behavioral similarity, and tracking how the vocabulary evolves over time. That index can be exported as a portable artifact to bootstrap conventions in other repos.
Behavioral similarity
Beyond naming and concepts, ontomics embeds raw function bodies using CodeRankEmbed (768-dim, contrastive code retrieval) and clusters them by behavioral similarity. This surfaces relationships that neither naming nor call graphs expose:
❯ What functions behave like spatial_transform()?
random_transform() nn/functional.py:352 0.80
spatial_transform() functional.py:596 0.69
random_transform() functional.py:1399 0.67
random_disp() nn/functional.py:275 0.65
integrate_disp() functional.py:764 0.65
compose() nn/functional.py:216 0.63
disp_to_trf() functional.py:343 0.62
The result also reveals that random_transform appears at two locations with different similarity scores — a sign of implementation duplication that concept-level search would miss entirely.
Install
Install once, available in every project. No configuration needed — ontomics auto-detects the repo and indexes it on first run.
ontomics requires a git repository (.git/ directory). It will refuse to index home, root, or temp directories. To index a non-git directory, pass --force.
1. Install the binary
npm (macOS/Linux):
npm install -g @ontomics/ontomics
macOS (Homebrew):
brew install EtienneChollet/tap/ontomics
Shell installer (macOS/Linux):
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/EtienneChollet/ontomics/releases/latest/download/ontomics-installer.sh | sh
From source:
git clone https://github.com/EtienneChollet/ontomics.git
cd ontomics
cargo build --release
2. Register with your harness
Claude Code:
claude mcp add -s user ontomics -- ontomics
Codex:
codex mcp add ontomics -- ontomics
OpenClaw:
openclaw mcp set ontomics '{"command":"ontomics"}'
pi-coding-agent:
pi install npm:@ontomics/ontomics
Share with your team — drop an .mcp.json in your repo root:
{
"mcpServers": {
"ontomics": {
"command": "npx",
"args": ["-y", "@ontomics/ontomics", "--repo", "."]
}
}
}
Supported languages
Python, TypeScript, JavaScript, Rust. Auto-detected from file extensions.
Tools
Concepts and vocabulary
| Tool | What it does |
|---|---|
query_concept | Find all variants, related concepts, and occurrences of a term |
locate_concept | Find the key signatures, classes, and files for a concept |
describe_symbol | Get the signature, docstring, and relationships for a function or class |
trace_concept | Trace how a concept flows through the codebase via call chains |
list_concepts | List the top domain concepts by frequency |
list_conventions | List all detected naming patterns (prefixes, suffixes, conversions) |
list_entities | List code entities (classes, functions) filtered by concept, role, or kind |
check_naming | Check an identifier against project conventions; suggests the canonical form |
suggest_name | Generate an identifier name that fits the project's vocabulary |
vocabulary_health | Measure convention coverage, naming consistency, and cluster cohesion |
ontology_diff | Show new, changed, or removed domain concepts since a git ref |
export_domain_pack | Export domain knowledge as portable YAML for use in other repos |
Behavioral similarity
| Tool | What it does |
|---|---|
find_similar_logic | Find functions with behaviorally similar implementations, ranked by embedding similarity |
describe_logic | Get the behavioral description, body text, and logic cluster membership for a function |
compact_context | Assemble tiered context (concepts + logic) for a symbol, optimized for LLM consumption |
Codebase structure
| Tool | What it does |
|---|---|
describe_file | Overview of a file's entities, concepts, and relationships |
concept_map | Show which modules contain which domain concepts |
type_flows | Show dominant types and how data flows through the codebase |
trace_type | Trace how a specific type propagates across files and call sites |
Resources
| Resource | What it does |
|---|---|
ontomics://briefing | Session briefing: top conventions, abbreviations, key concepts, contrastive pairs, and vocabulary warnings. Also available via ontomics briefing CLI. |
How it works
ontomics runs a multi-stage pipeline entirely on your machine — no API keys required:
- Parse — tree-sitter extracts every identifier, signature, and call site from your source files
- Analyze — TF-IDF scoring identifies domain-specific concepts and detects naming conventions
- Embed (concepts) — BGE-small (384-dim) clusters related concepts by semantic similarity
- Embed (logic) — CodeRankEmbed (768-dim) embeds raw function bodies and clusters them by behavioral similarity
- Centrality — PageRank scores entities by structural importance
Both embedding models are downloaded once on first run and cached locally. The index lives at <repo>/.ontomics/index.db — subsequent startups load from cache and watch for file changes.
Configuration via .ontomics/config.toml in the repo root. All fields have sensible defaults. See SPEC.md for the full design contract.
Related MCP servers
Confidential coprocessor — compute on encrypted data via FHE. Server never sees plaintext.
View repository →Introductions network: your AI agent flags people privately, theirs flags back, two humans decide.

Local-first MCP server: Claude searches, asks & drafts from your Obsidian vault. 21 tools, no keys.

io.github.EverMint-app/evermint-mcp
Mint tamper-evident receipts for AI agent actions. The notary layer for agent-to-agent transactions.
Search Upsalt venues, check availability, and book, view, or cancel a reservation.
Cited search over SEC filings, earnings transcripts and EU regulation, with fetch mode. 14 tools.

