ModelAtlas

Google for open-source AI models. Search by what you mean, not by keywords.

29,892 models · 180 semantic anchors · <100ms queries · No embeddings · No GPU

You want a small code model with tool-calling.

HuggingFace gives you the biggest, most popular code models:

Qwen2.5-Coder-32B-Instruct          32B   1,996 likes
Qwen3-Coder-480B-A35B-Instruct     480B   1,315 likes

480B parameters. Not small. HF sorts by popularity. It can't express "small" as a direction.

ModelAtlas gives you what you actually asked for:

navigate_models(efficiency=-1, capability=+1, quality=+1,
                require_anchors=["code-generation"],
                prefer_anchors=["tool-calling", "high-downloads"])

Qwen3-Coder-Next-AWQ-4bit        3B  | code, tool-calling, trending     0.79
LocoOperator-4B                   4B  | code, tool-calling, GGUF         0.63
Qwen2.5-Coder-0.5B-Instruct    0.5B  | code, high-downloads             0.37

Every result is small, code-focused, tool-calling, and popular. One tool call. ~500 tokens. <100ms.

Three levels of comparison

All queries run against both systems, March 2026. HuggingFace uses its API with pipeline_tag filters + sort-by-likes. ModelAtlas uses navigate_models with quality=+1. All results are real.

Level 1: ModelAtlas matches HuggingFace

Common queries where HF works well. The baseline test — can ModelAtlas reproduce the known-good answers?

Both systems return the right models. This is the most important result. Anyone can build a niche search tool. Building one that also matches the incumbent beat-for-beat on common queries is what makes it a replacement, not a toy.

Level 2: ModelAtlas exceeds HuggingFace

Queries with direction ("small"), intent ("fast"), or domain specificity ("medical classifier") — concepts that don't map to a single HF tag.

HuggingFace starts returning noise. "Small" matches models with "small" in the name. "Fast" returns nothing. "Medical classifier" returns a reasoning verifier. ModelAtlas returns what you meant, not what you typed.

Level 3: ModelAtlas finds the unfindable

Multi-constraint queries with direction + domain + negation. HuggingFace cannot express these at all.

A 100-million-parameter TTS model. A genomics classifier with 7 anchors. A 0.8B model distilled from Claude Opus. These models exist on HuggingFace but they are invisible to keyword search. ModelAtlas finds them because biology-domain + classification + encoder-only is a precise intersection in a coordinate system, not a string match.

The pattern: Simple queries → both work. Directional queries → MA wins. Multi-constraint queries → HF returns nothing; MA finds exactly what you need. The harder the question, the wider the gap.

Related MCP server: Local Search MCP Server

What the LLM gets

This is an MCP tool. An LLM calls it during conversation. One tool call returns:

{
  "model_id": "ibm-granite/granite-3b-code-instruct-128k",
  "score": 0.86,
  "score_breakdown": {"bank_alignment": 1.0, "anchor_relevance": 0.86},
  "positions": {"CAPABILITY": "+3", "EFFICIENCY": "-1", "DOMAIN": "+1"},
  "anchors": ["code-generation", "tool-calling", "long-context", "math", "consumer-GPU-viable"]
}

From this, the LLM immediately knows: small, code-focused, tool-calling, math-capable, consumer hardware, 128K context. The anchors are a vibe. The positions are a profile. The score explains why this model and not another.

Without ModelAtlas, the LLM guesses from stale training data. With it, the LLM has live, structured awareness of 29,892 models for ~500 tokens — less than the cost of a follow-up question.

How it works

Eight signed dimensions. Each has a zero state — the thing most queries assume by default.

ARCHITECTURE    zero = transformer decoder       →  +novel (Mamba, MoE)
CAPABILITY      zero = general language model     →  +rich (code, tools, reasoning)
EFFICIENCY      zero = ~7B parameters             →  +larger  / -smaller
COMPATIBILITY   zero = PyTorch + transformers     →  +specific (GGUF, MLX)
LINEAGE         zero = base/foundational model    →  +derived (fine-tune, quant)
DOMAIN          zero = general knowledge           →  +specialized (code, medical)
QUALITY         zero = established mainstream      →  +trending  / -legacy
TRAINING        zero = standard supervised (SFT)  →  +complex (RLHF, DPO) / -simpler

On top of coordinates, models share anchors — 180 semantic labels like tool-calling, GGUF-available, Llama-family. Similarity is emergent from shared labels, weighted by rarity (IDF). Every score traces back to specific anchors. Nothing is an opaque embedding.

Scoring: bank_alignment × anchor_relevance × seed_similarity. Multiplicative — a model that nails efficiency but misses capability gets zero, not fifty percent. Wrong-direction models decay hyperbolically. Avoided anchors stack exponentially (each halves the score). Required anchors are hard filters. The result is a scoring surface that strongly favors precise matches and rapidly eliminates mismatches, without binary cutoffs. Full scoring math →

Extraction runs in three tiers: deterministic (API fields, parameter math) → pattern matching (tags, names, configs) → LLM classification (small local model, once per model at ingestion). At query time, it's multiplication and set intersection. Math — not inference.

Quick start

# 1. Clone and install
git clone https://github.com/rohanvinaik/ModelAtlas.git && cd ModelAtlas && uv sync

# 2. Download pre-built network (29K+ models, all extraction tiers applied)
mkdir -p ~/.cache/model-atlas
curl -L -o ~/.cache/model-atlas/network.db \
  https://github.com/rohanvinaik/ModelAtlas/releases/latest/download/network.db

# 3. Add to your MCP client config (Claude Code, Cursor, VS Code, etc.)

{
  "mcpServers": {
    "model-atlas": {
      "command": "uv",
      "args": ["--directory", "/path/to/ModelAtlas", "run", "model-atlas"]
    }
  }
}

Works with any MCP-compatible client. Your LLM can now see model space.

Tools

What this is not

• Not a vector store. No embeddings. Similarity comes from shared structure.

• Not a HuggingFace wrapper. HF is a data source. The value is the extracted structure HF doesn't expose.

• Not a ranking system. No "best model" score. Navigation, not leaderboard.

Enriching the network

Each phase writes at a confidence tier. Lower tiers cannot overwrite higher ones.

Phases A–B: Deterministic extraction (confidence 1.0 / 0.85). Fetch from HuggingFace, classify from config files and tags. No LLM.

python -m model_atlas.ingest --phase ab --min-likes 5

Phase C: Constrained LLM classification (confidence 0.5). A local model reads each model card and selects from the 180-anchor dictionary. It cannot invent labels — the output schema is the vocabulary.

python -m model_atlas.ingest --export-c2 4       # export shards
python scripts/phase_c_worker.py --input shard_0.jsonl --output results_0.jsonl  # run anywhere
python -m model_atlas.ingest --merge-c2 results_*.jsonl

Phase D: Audit and heal (confidence 0.6). Deterministic comparison of C2 anchors against Tier 1/2 ground truth. Mismatches get re-extracted.

python -m model_atlas.ingest --audit-c2
python -m model_atlas.ingest --export-d3 4 && python -m model_atlas.ingest --merge-d3 results_*.jsonl --run-id <id>

Phase E: Web enrichment (confidence 0.4). Phases A–D work from HuggingFace metadata. Phase E searches the open web for fuzzier, more qualitative signal — benchmark mentions, comparison articles, community impressions. Same constrained selection from the anchor vocabulary, but the source material is noisier, so the confidence tier is the lowest.

# One-time: self-hosted search (aggregates Google/Bing/DDG, no rate limits)
docker run -d --name searxng -p 8888:8080 \
  -v /path/to/settings.yml:/etc/searxng/settings.yml searxng/searxng

# Export → run → merge (same pattern as C/D)
python -m model_atlas.ingest --export-e 4 --export-e-banks CAPABILITY,QUALITY
python scripts/phase_e_worker.py --input shard_0.jsonl --output results_0.jsonl \
    --model qwen3.5:4b --searxng http://localhost:8888 --snippets-only --resume
python -m model_atlas.ingest --merge-e results_*.jsonl --merge-e-dry-run
python -m model_atlas.ingest --merge-e results_*.jsonl

All workers are standalone scripts — scp to any machine, --resume from any crash, shard across as many machines as you have. docs/pipeline.md has the full reference.

Operational discipline

Every write to a canonical table (models, model_positions, model_links, anchors) goes through one of two audit-logged primitives in src/model_atlas/admin.py:

• patch_field(table, pk, field, old, new, reason) — single-field update, dry-run by default, requires sourced rationale.

• insert_canonical(table, row, reason) — new row insert, same discipline.

Worker-driven JSONL ingestion routes through model_atlas.reconciler.reconcile_file() which dispatches via the same primitives with SHA-256 line-hash idempotency (safe to re-run any merge). Every successful write appends one line to data/patches.jsonl — currently ~38K entries, rotated past 5 MB.

# Health audit (read-only): bank orthogonality, NULL coverage, anchor orphans/oversaturation
python -m model_atlas.coherence

# Weekly hub-and-spoke sync: rsync from spokes → reconciler → audit → rotate log
./scripts/sync_and_reconcile.sh

See docs/admin.md, docs/reconciler.md, and docs/coherence.md for the discipline. Legacy write paths (ingest_phase_c_merge.py, phase_d_*, phase_e_postprocess.py) predate the primitives and write canonical tables directly — they are pre-existing, not sanctioned. New code MUST use the primitives.

Status

29,892 models. 180 anchors. 228K model-anchor links across 8 banks. 236K signed positions. 2,990 models web-enriched (Phase E, ongoing across 3 machines). 6,154 independently validated via Gemini. 700 corrected through audit/heal pipeline. 38K audit-log entries. Models with <10 likes are not yet indexed — the 30K represent the active, community-validated portion of HuggingFace. Periodic snapshot — tells you what to look at, not what's trending right now.

Part of a research program on structured navigation through constrained semantic spaces — the same paradigm applied to theorem proving and code quality supervision.

MIT — Rohan Vinaik