# Ontomics

> Extract domain knowledge from codebases to reduce LLM token consumption by 20x and time in agentic search by 10x — gathers and makes concepts, naming conventions, and vocabulary queryable via MCP.

- **Type:** MCP server
- **Install:** `agentstack add mcp-etiennechollet-ontomics`
- **Verified:** Pending review
- **Seller:** [EtienneChollet](https://agentstack.voostack.com/s/etiennechollet)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.2.3
- **License:** MIT
- **Upstream author:** [EtienneChollet](https://github.com/EtienneChollet)
- **Source:** https://github.com/EtienneChollet/ontomics

## Install

```sh
agentstack add mcp-etiennechollet-ontomics
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# ontomics

[](https://registry.modelcontextprotocol.io/)
[](https://glama.ai/mcp/servers/EtienneChollet/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](https://github.com/voxelmorph/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](https://github.com/voxelmorph/voxelmorph) ([full transcript](doc/benchmarks/transform-voxelmorph.md)):

|                | 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](https://github.com/halleewong/ScribblePrompt) ([full transcript](doc/benchmarks/concepts-scribbleprompt.md)):

|                | 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](https://huggingface.co/nomic-ai/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):**
```bash
npm install -g @ontomics/ontomics
```

**macOS (Homebrew):**
```bash
brew install EtienneChollet/tap/ontomics
```

**Shell installer (macOS/Linux):**
```bash
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/EtienneChollet/ontomics/releases/latest/download/ontomics-installer.sh | sh
```

**From source:**
```bash
git clone https://github.com/EtienneChollet/ontomics.git
cd ontomics
cargo build --release
```

### 2. Register with your harness

**Claude Code:**
```bash
claude mcp add -s user ontomics -- ontomics
```

**Codex:**
```bash
codex mcp add ontomics -- ontomics
```

**OpenClaw:**
```bash
openclaw mcp set ontomics '{"command":"ontomics"}'
```

**pi-coding-agent:**
```bash
pi install npm:@ontomics/ontomics
```

**Share with your team** — drop an `.mcp.json` in your repo root:
```json
{
  "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:

1. **Parse** — tree-sitter extracts every identifier, signature, and call site from your source files
2. **Analyze** — TF-IDF scoring identifies domain-specific concepts and detects naming conventions
3. **Embed (concepts)** — BGE-small (384-dim) clusters related concepts by semantic similarity
4. **Embed (logic)** — CodeRankEmbed (768-dim) embeds raw function bodies and clusters them by behavioral similarity
5. **Centrality** — PageRank scores entities by structural importance

Both embedding models are downloaded once on first run and cached locally. The index lives at `/.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.

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [EtienneChollet](https://github.com/EtienneChollet)
- **Source:** [EtienneChollet/ontomics](https://github.com/EtienneChollet/ontomics)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.2.3 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.2.3** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-etiennechollet-ontomics
- Seller: https://agentstack.voostack.com/s/etiennechollet
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.