whatmodel 0.0.1__tar.gz

whatmodel-0.0.1/.gitignore

@@ -0,0 +1,220 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+*.lcov
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# uv
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi/*
+!.pixi/config.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule*
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs/Zensical documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore that
+#   can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, you
+#   could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

whatmodel-0.0.1/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- `whatmodel <name>...` explains Ollama names, Hugging Face repos and GGUF file names in plain English.
+- Layer 1 reads the name offline: family and version, publisher, size, effective size, active parameters, tier, tuning, quantization, format, context, build stamps and hosting.
+- Unknown tokens are reported as unknown, and ambiguous tokens and name formats show every reading.
+- Layer 2 looks up quantization, context length, parameter count, architecture, tool, vision and thinking support, license and file size from the local Ollama API and the Hugging Face Hub API.
+- `whatmodel list` explains every model installed in local Ollama.
+- `whatmodel tokens` prints the token dictionary.
+- Flags `--json`, `--offline`, `--ollama-url`, `--verbose` and `--version`.
+- Library API: `parse()` and `explain()`.
+- Token dictionary in `whatmodel/tokens.yaml`, the only place token meanings live.
+- CI on Python 3.10 to 3.13 across Linux, macOS and Windows.
+- Release workflow that publishes to PyPI with Trusted Publishing when a GitHub Release is published.
+
+[Unreleased]: https://github.com/ShekharBhardwaj/whatmodel/commits/main

whatmodel-0.0.1/CONTRIBUTING.md

@@ -0,0 +1,110 @@
+# Contributing
+
+The most useful contribution is a new token. Every meaning whatmodel knows lives in [`whatmodel/tokens.yaml`](whatmodel/tokens.yaml), and adding one needs no Python.
+
+## Setup
+
+```bash
+git clone https://github.com/ShekharBhardwaj/whatmodel
+cd whatmodel
+uv sync
+uv run pytest
+```
+
+## Add a token in three steps
+
+1. Run the name that confused you and note what is reported as `Unknown`:
+
+   ```bash
+   uv run whatmodel olmo-2:7b --offline
+   ```
+
+2. Add an entry to `whatmodel/tokens.yaml`, next to the other entries of its category:
+
+   ```yaml
+   - pattern: olmo
+     category: family
+     label: OLMo
+     maker: Allen Institute for AI
+     explanation: The open language model family from the Allen Institute for AI.
+   ```
+
+3. Run the checks and look at the result:
+
+   ```bash
+   uv run pytest
+   uv run whatmodel olmo-2:7b --offline
+   ```
+
+Label the pull request `tokens` so it lands under "New tokens" in the release notes.
+
+## Entry fields
+
+| Field | Required | Meaning |
+|---|---|---|
+| `pattern` | yes | A literal, or a list of literals that mean the same thing. With `regex: true`, a regular expression. |
+| `category` | yes | One of the ids under `categories` at the top of the file. |
+| `label` | yes | The short phrase shown in the output. Keep it under 60 characters. |
+| `explanation` | yes | One plain-English sentence, ending in a full stop. |
+| `regex` | no | `true` when `pattern` is a regular expression. |
+| `examples` | for regex entries | Tokens the pattern must match. The tests check them, and `whatmodel tokens` prints them instead of the raw regex. |
+| `value` | no | The normalized value for JSON and the library, such as `4B` for `4b`. Defaults to the literal as written, or to the matched token for a regex. |
+| `after` | no | Match only directly after a token of the named category. |
+| `maker` | no | Family entries only: who makes the family. Shown as `Gemma 4 (Google)`. |
+| `implies` | no | A fact in another category that this token settles, such as `{architecture: moe}`. |
+
+`label`, `explanation` and `value` may use `{text}` (the matched token, lowercased) and any named regex group. Add `!u` to uppercase one: `{text!u}`.
+
+## How matching works
+
+- Case is ignored. `Q4_K_M` and `q4_k_m` are the same token.
+- `-`, `_` and `.` are all separators, and they are interchangeable. A dot between two digits is a decimal point, so `3.5` stays whole.
+- A pattern must match a whole token. `mini` does not match inside `minicpm`.
+- Multi-part patterns match across separators. Write literals the way they usually appear (`gpt-oss`). In a regex, write `_` wherever the name has a separator (`q4_k_m`).
+- When a name can be split more than one way, the split with the fewest unknown parts wins, then the one with the fewest tokens. That is why `mistral-small` beats `mistral` followed by `small`.
+- A known family glued to a version, as in `qwen3.5`, is split into the two. This only happens when the family is in the dictionary.
+
+## Regex entries
+
+Use a regex when a token carries a number:
+
+```yaml
+- pattern: '(?P<n>\d+(?:\.\d+)?)b'
+  regex: true
+  category: size
+  value: '{n}B'
+  label: '{n}B parameters'
+  explanation: About {n} billion parameters (learned weights), where more usually means more capable but slower and hungrier for memory.
+  examples: [4b, 12B, 1.5b]
+```
+
+Put the pattern in single quotes so YAML leaves the backslashes alone. Quote examples that look like numbers (`'2507'`).
+
+## Rules for entries
+
+These keep the output trustworthy. The test suite enforces most of them.
+
+- **Say only what the token always means.** If a token means different things in different names, either leave it out or add both meanings (see below).
+- **Never make whatmodel guess.** If two entries match the same token, it is reported as ambiguous with both readings. That is the right outcome for a token such as `base` (a model without chat tuning, or the standard size). It is the wrong outcome if it happens by accident, so the tests fail on any overlap that is not listed in `INTENDED_AMBIGUOUS` in `tests/test_dictionary.py`.
+- **One sentence per explanation**, in plain English. Explain jargon instead of repeating it.
+- **Use `after` for tokens that only make sense in context.** A bare number is a version only right after a family, so that entry has `after: family`.
+- **Use `implies` when a token settles something in another category.** `A3B` implies `architecture: moe`. A hosted-only family implies `hosting: cloud`. The implied token must be an entry in that category.
+- **Facts must be checkable.** For a family, name the maker. For a publisher who converts other teams' models, say so.
+
+## Adding a category
+
+Add it under `categories` with a `heading` and a one-sentence `description`. Categories that share a heading share an output row, and their order in the file is the display order. A category may also have a `default`, shown when no token in the name belongs to it.
+
+## Changing code
+
+```bash
+uv run ruff check
+uv run ruff format
+uv run pytest
+```
+
+- Token meanings never go in Python. If a change needs a new word of explanation, it belongs in `tokens.yaml`.
+- Tests must not use the network. `tests/conftest.py` blocks every socket, including localhost, so lookup tests use `httpx.MockTransport`.
+- Type hints are required everywhere; ruff checks this.
+
+Releases are described in [RELEASING.md](RELEASING.md).

whatmodel-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shekhar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

whatmodel-0.0.1/PKG-INFO

@@ -0,0 +1,270 @@
+Metadata-Version: 2.5
+Name: whatmodel
+Version: 0.0.1
+Summary: Explain LLM model names in plain English.
+Project-URL: Homepage, https://github.com/ShekharBhardwaj/whatmodel
+Project-URL: Repository, https://github.com/ShekharBhardwaj/whatmodel
+Project-URL: Issues, https://github.com/ShekharBhardwaj/whatmodel/issues
+Project-URL: Changelog, https://github.com/ShekharBhardwaj/whatmodel/blob/main/CHANGELOG.md
+Author: Shekhar
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,gguf,huggingface,llm,lm-studio,model-names,ollama
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# whatmodel
+
+Explain LLM model names in plain English: give it `gemma4:e2b-it-qat` and it tells you what each part means, plus the facts the name leaves out.
+
+It reads names from Ollama, Hugging Face and GGUF files. There are no LLM calls: every explanation comes from a plain data file and from model metadata.
+
+## Install
+
+```bash
+uv tool install whatmodel
+```
+
+Or run it once without installing:
+
+```bash
+uvx whatmodel qwen3.5:4b
+```
+
+`pip install whatmodel` works too. Python 3.10 or newer.
+
+## Examples
+
+The outputs below are pasted from real runs.
+
+### An Ollama name
+
+```console
+$ whatmodel gemma4:e2b-it-qat
+
+gemma4:e2b-it-qat
+┌──────────────┬────────────────────────────────────┬──────────────┐
+│ Field        │ Value                              │ Source       │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Family       │ Gemma 4 (Google)                   │ name         │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Size         │ effective 2B parameters            │ name         │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Tuning       │ instruction tuned (ready for chat) │ name         │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Compression  │ quantization-aware trained         │ name         │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Runs         │ locally                            │ name         │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Parameters   │ 4.6B                               │ local Ollama │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Compression  │ 4-bit (Q4_0)                       │ local Ollama │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Architecture │ dense                              │ local Ollama │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Context      │ 128k tokens                        │ local Ollama │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Tools        │ yes                                │ local Ollama │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Vision       │ yes                                │ local Ollama │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ Thinking     │ yes                                │ local Ollama │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ License      │ Apache License, Version 2.0        │ local Ollama │
+├──────────────┼────────────────────────────────────┼──────────────┤
+│ File size    │ 4.3 GB                             │ local Ollama │
+└──────────────┴────────────────────────────────────┴──────────────┘
+```
+
+The Source column says where each row came from: `name` rows are read from the name alone, and the rest are looked up, here from the Ollama running on the same machine.
+
+### A Hugging Face repo
+
+```console
+$ whatmodel bartowski/Qwen_Qwen3-30B-A3B-GGUF
+
+bartowski/Qwen_Qwen3-30B-A3B-GGUF
+┌──────────────┬────────────────────────────────────────────┬──────────────┐
+│ Field        │ Value                                      │ Source       │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Publisher    │ bartowski (community GGUF conversions)     │ name         │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Family       │ Qwen 3 (Alibaba)                           │ name         │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Size         │ 30B parameters, 3B active per token        │ name         │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Architecture │ mixture of experts                         │ name         │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Format       │ GGUF (for llama.cpp, Ollama and LM Studio) │ name         │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Runs         │ locally                                    │ name         │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Parameters   │ 30.5B                                      │ Hugging Face │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Context      │ 32k tokens                                 │ Hugging Face │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ Tools        │ yes (judged from the chat template)        │ Hugging Face │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ License      │ apache-2.0                                 │ Hugging Face │
+├──────────────┼────────────────────────────────────────────┼──────────────┤
+│ File size    │ 8.1 GB to 39.7 GB, 28 GGUF files           │ Hugging Face │
+└──────────────┴────────────────────────────────────────────┴──────────────┘
+```
+
+### A GGUF file name
+
+```console
+$ whatmodel Llama-3-8B-Instruct.Q4_K_M.gguf
+
+Llama-3-8B-Instruct.Q4_K_M.gguf
+┌─────────────┬────────────────────────────────────────────┬────────┐
+│ Field       │ Value                                      │ Source │
+├─────────────┼────────────────────────────────────────────┼────────┤
+│ Family      │ Llama 3 (Meta)                             │ name   │
+├─────────────┼────────────────────────────────────────────┼────────┤
+│ Size        │ 8B parameters                              │ name   │
+├─────────────┼────────────────────────────────────────────┼────────┤
+│ Tuning      │ instruction tuned (ready for chat)         │ name   │
+├─────────────┼────────────────────────────────────────────┼────────┤
+│ Compression │ 4-bit (Q4_K_M, the balanced variant)       │ name   │
+├─────────────┼────────────────────────────────────────────┼────────┤
+│ Format      │ GGUF (for llama.cpp, Ollama and LM Studio) │ name   │
+├─────────────┼────────────────────────────────────────────┼────────┤
+│ Runs        │ locally                                    │ name   │
+└─────────────┴────────────────────────────────────────────┴────────┘
+```
+
+A file name has nothing to look up, so every row comes from the name.
+
+## Usage
+
+```text
+whatmodel <name>              explain one name
+whatmodel <name> <name>...    explain several
+whatmodel list                explain every model installed in local Ollama
+whatmodel tokens              print the token dictionary
+```
+
+| Flag | What it does |
+|---|---|
+| `--json` | Print JSON. One name gives an object, several names give a list. |
+| `--offline` | Read the name only and make no network requests. |
+| `--ollama-url URL` | Where Ollama listens. Defaults to `http://localhost:11434`, or `OLLAMA_HOST` if set. |
+| `--verbose`, `-v` | Add a column with a one-sentence explanation of each row. |
+| `--version` | Print the version. |
+
+Accepted name formats:
+
+- Ollama: `[host/][namespace/]model[:tag]`, for example `qwen3.5:4b` or `hf.co/bartowski/Qwen_Qwen3-30B-A3B-GGUF:Q4_K_M`
+- Hugging Face: `org/repo`, or a pasted `https://huggingface.co/org/repo` link
+- File names: `Llama-3-8B-Instruct.Q4_K_M.gguf`, with or without a folder in front
+
+A model that happens to be called `list` or `tokens` can be explained with `whatmodel explain list`.
+
+### Unknown and ambiguous tokens
+
+whatmodel never guesses. A token that is not in its dictionary is reported as unknown. A token with two possible meanings is shown with both:
+
+```console
+$ whatmodel qwen-max-0725 --offline
+
+qwen-max-0725
+┌───────────┬───────────────────────────────────────┬────────┐
+│ Field     │ Value                                 │ Source │
+├───────────┼───────────────────────────────────────┼────────┤
+│ Family    │ Qwen (Alibaba)                        │ name   │
+├───────────┼───────────────────────────────────────┼────────┤
+│ Tier      │ max tier (the most capable option)    │ name   │
+├───────────┼───────────────────────────────────────┼────────┤
+│ Build     │ latest (the default build)            │ name   │
+├───────────┼───────────────────────────────────────┼────────┤
+│ Runs      │ locally                               │ name   │
+├───────────┼───────────────────────────────────────┼────────┤
+│ Ambiguous │ 0725: dated 07-25 (month-day) [build] │ name   │
+│           │ or released 2025-07 [build]           │        │
+└───────────┴───────────────────────────────────────┴────────┘
+```
+
+The same applies to a name such as `org/model` with no tag, which fits both a Hugging Face repo and an Ollama model. Both readings are named unless a lookup settles which one it is.
+
+### Where the facts come from
+
+The lookup step tries two sources in order and merges them:
+
+1. The local Ollama API (`/api/show` and `/api/tags`), for models you have installed.
+2. The Hugging Face Hub API, for names that contain `org/repo`.
+
+Timeouts are short. A source that is offline, slow, or does not know the model is skipped, and the name is still explained. In JSON every item carries a `source` of `name`, `ollama` or `huggingface`, and `lookups` reports what happened with each source.
+
+## Library
+
+```python
+from whatmodel import parse, explain
+
+parsed = parse("qwen3.5:4b")  # the name only, no network
+parsed.family, parsed.version, parsed.size  # ('qwen', '3.5', '4B')
+parsed.unknown  # tokens the dictionary does not know
+
+info = explain("qwen3.5:4b")  # the name plus lookups
+info.facts  # looked-up facts, each with its source
+info.to_dict()  # the same data --json prints
+```
+
+`explain(name, offline=True)` makes no requests at all.
+
+## What the name cannot tell you
+
+A model name is a label chosen by whoever published it. Even a fully understood name leaves these open, which is what the lookup step is for:
+
+- **The exact compression.** `qat` says how a model was trained, not how many bits it uses. A bare tag such as `:4b` says nothing about compression at all.
+- **What `latest` points to.** It is a moving pointer. The size and compression behind it can change.
+- **The real parameter count.** `4b` is a rounded label. The model above is called `e2b` and has 4.6 billion parameters.
+- **Context length.** Rarely in the name, and the usable value also depends on how the model is run.
+- **Capabilities.** Tool calling, vision and thinking are usually not in the name.
+- **The license.** Never in the name.
+- **Who trained it.** The publisher in `org/repo` is often a third party who converted the model.
+- **File size and memory needs.** These depend on compression and format. whatmodel reports file size when a source has it and does not estimate whether a model fits your hardware.
+
+And some things no lookup settles: a name does not tell you how good a model is.
+
+## Adding a token
+
+Every meaning whatmodel knows lives in one file, [`whatmodel/tokens.yaml`](whatmodel/tokens.yaml). No Python is needed to teach it a new token:
+
+```yaml
+- pattern: olmo
+  category: family
+  label: OLMo
+  maker: Allen Institute for AI
+  explanation: The open language model family from the Allen Institute for AI.
+```
+
+Then check it:
+
+```bash
+uv run pytest
+uv run whatmodel olmo-2:7b --offline
+```
+
+[CONTRIBUTING.md](CONTRIBUTING.md) covers patterns, regex entries and the rules entries must follow.
+
+## License
+
+MIT. See [LICENSE](LICENSE).