{"slug": "everycli-natural-language-cli-assistant-that-runs-100-locally-rust-and-onnx", "title": "EveryCli: Natural-language CLI assistant that runs 100% locally (Rust and ONNX)", "summary": "EveryCli, a natural-language command-line assistant built in Rust and running on ONNX Runtime, performs all search locally with no API key and no network call, according to its project documentation. The tool retrieves matching shell commands from a local YAML corpus in English or French, never executes commands on the user's behalf, and requires confirmation for its --run flag. The daemon listens only on 127.0.0.1:51821, and prebuilt archives for Linux and Windows remove the need for Rust, Cargo or Python.", "body_md": "**Stop hunting for commands. Describe what you want to do.**\n\n**EveryCli** is a natural-language command-line assistant. You describe your intent — in English or French — and it retrieves the matching shell command from a local corpus. Search runs entirely on your machine: a native Rust daemon combines lexical matching with semantic reranking through ONNX Runtime, with no API key and no network call. The move from the historical Python/PyInstaller flow to this native Rust stack means end users no longer need Rust, Cargo or Python — a prebuilt archive is enough.\n\n🛟 **Safety first.** EveryCli **never** runs a command on your behalf. Results are shown for you to read; `--run` always asks for confirmation, and shell wrappers only place the command in an editable buffer.\n\nEveryCli grew out of a small daily friction. Whenever a CLI command slipped my mind, I'd ask an online LLM — and each lookup added two or three seconds of waiting. That delay sounds small, but it can be enough to break context: you switch to another tab, start another task, and later have to reconstruct what you were doing. Digital attention is not split without cost; rapid task switching increases the effort of resuming context and the risk of losing the thread [1](https://www.nngroup.com/articles/serial-task-switching/).\n\nThe idea was to keep that loop **inside the terminal** — describe the intent, get a command quickly from a *local* corpus, and gradually grow your **own** set of commands with `add` / `list` / `remove`. The goal is not to claim that a compact local model is universally better than a large remote one. It is to accept a smaller, controlled scope when that reduces latency, preserves context and avoids a detour to another tab. When local coverage is not enough, `everycli ask` remains available as an optional LLM assistant. The objective is simple: less waiting, fewer context switches, and continued control over what actually runs [1](https://www.nngroup.com/articles/serial-task-switching/).\n\n**In this setting, a model that is fast and available locally can be more useful than a heavier model that imposes a round-trip and breaks attention.**\n\n| Audience | What EveryCli offers | \n|---|---|\n| **Developers & power users** | Describe an intent instead of memorizing flags; bilingual EN/FR search | \n| **Privacy-conscious / offline users** | `search` works fully offline — no cloud, no API key, no telemetry | \n| **Linux & Windows users** | Prebuilt archives with one-command installers; no toolchain required | \n| **Release testers** | A reproducible install/search/uninstall runbook | \n| **Contributors & integrators** | A documented Rust workspace, daemon protocol and shell contract | \n\nEveryCli separates the user interface from the more expensive semantic computation. The Rust client receives your intent and communicates with a local daemon that keeps the model in memory and answers searches quickly. This avoids reloading the model for every command and helps you stay in the terminal on both Ubuntu/Linux and Windows.\n\n```\nUser\n  │\n  ▼\neverycli-rs  ── JSON/TCP localhost ──▶  everycli-daemon\n  │                                      ├── YAML corpus\n  │                                      ├── model.onnx\n  │                                      ├── tokenizer.json\n  │                                      └── native ONNX Runtime\n  └── local lexical fallback if the daemon is unavailable\n```\n\nThe daemon listens only on `127.0.0.1:51821`; it is not a public network API. It combines the YAML corpus, ONNX model and platform-native runtime. The client also keeps a local lexical fallback so search remains useful when the daemon is unavailable.\n\n📖 **Architecture deep dive:** components, daemon role, protocol, model, runtime, corpus and lifecycle → **[docs/explanation_architecture.md](https://github.com/HE11032006/EveryCli/blob/main/docs/explanation_architecture.md)**.\n\n- 🔎 **Natural-language search** — describe what you want to do instead of memorizing syntax, using a corpus organized by namespace (Git, Docker, Compose, npm, SSH, Python, Linux…).\n- 🧬 **Hybrid local ranking** — lexical matching and ONNX semantic reranking are fused on your machine to surface relevant commands without sending your query to the cloud.\n- 🌍 **Bilingual search** — write your request in English, French or a mixed query, without mentally translating a command or its description.\n- 🛰️ **Fast local daemon** — the model stays loaded on`127.0.0.1:51821` , allowing repeated searches to answer in a few hundred milliseconds after the first load on tested hardware, on Ubuntu/Linux and Windows, so you can stay in the work rhythm instead of waiting for a remote request.\n- ✍️ **Add your own commands** — with`add` ,`list` and`remove` , you gradually build a personal corpus; its files remain separate from the built-in corpus and survive updates.\n- 🤝 **Optional AI assistance** — when no local command matches sufficiently,`everycli ask` can request a proposal from an OpenAI-compatible API and add it to your corpus, so you do not need to repeat a remote lookup for the same need later.\n- 🛡️ **Review before execution** — Sentinel (`everycli plan` ) can review a retrieved command and flag risks before you decide whether to run it.\n- 🐚 **Shell integration** — the interactive picker,`--json` ,`--copy` and deterministic`--shell` protocol support human and scriptable workflows without automatic execution.\n- 📦 **No development dependencies for end users** — a prebuilt release includes the binaries, model, tokenizer, runtime and corpus; end users do not need Rust, Cargo or Python.\n\nThe simplest path is to run the installer directly from the `main` branch. It downloads the latest release, verifies its integrity and configures the client, daemon, model, runtime, corpus and background startup automatically. Rust, Cargo and Python are not required.\n\n**v1.2.1 or later**. The public `v1.2.0` release shipped an ONNX Runtime library that is too old for the `ort` crate version used by the daemon; it should not be presented as a working semantic installation.\n\n⚠️ Use the next corrected release,\n\n```\ncurl -fsSL https://raw.githubusercontent.com/HE11032006/EveryCli/main/install.sh | bash\n```\n\nThe installer asks for the language, places EveryCli in `~/.local/share/everycli`, creates links in `~/.local/bin` and configures the `systemd --user` service. At the end, reload your profile:\n\n```\nsource ~/.profile\neverycli search \"how to undo my last commit\"\n```\n\nIf `everycli` is not recognized yet, open a new terminal. The first start may take longer while the daemon loads the model and computes corpus embeddings; later searches benefit from the warm daemon and disk cache.\n\nIn **PowerShell**, run:\n\n```\nirm https://raw.githubusercontent.com/HE11032006/EveryCli/main/install.ps1 | iex\n```\n\nThe installer asks for the language, downloads the release, verifies its integrity and configures EveryCli in your user profile. The first path can be somewhat slow, especially during the download and first model load. Open a new terminal if needed for the `everycli` command to become available.\n\nTo inspect files before installation, download the matching archive from **[GitHub Releases](https://github.com/HE11032006/EveryCli/releases)**, extract it and run the installer without arguments from the extracted folder.\n\nOn Ubuntu/Linux:\n\n```\nmkdir everycli-linux-x86_64\ntar -xzf everycli-linux-x86_64.tar.gz -C everycli-linux-x86_64\ncd everycli-linux-x86_64\n./install.sh\nsource ~/.profile\n```\n\nOn Windows PowerShell:\n\n```\nExpand-Archive .\\everycli-windows-x86_64.zip .\\everycli-windows-x86_64\ncd .\\everycli-windows-x86_64\n.\\install.ps1\n```\n\nThe complete archive contains the client, daemon, `model.onnx`, `tokenizer.json`, the native ONNX Runtime library and the built-in corpus. To uninstall, use `./uninstall.sh` on Linux or `./uninstall.ps1` on Windows; personal data is preserved by default.\n\nmacOS is **compiled and tested by CI**, but no installable macOS archive is published yet — the native runtime and installer still need end-to-end validation.\n\n📖 **Full guide:** prerequisites, one-command installation, archive installation, checksum verification, uninstall and troubleshooting → **[docs/tutorial_installation.md](https://github.com/HE11032006/EveryCli/blob/main/docs/tutorial_installation.md)**.\n\nThe most useful everyday workflow is the interactive path:\n\n```\neverycli search \"how to undo my last commit\" --top 2 -i\n```\n\n⭐ **Recommended workflow.** `--top 2` limits the display to the two most relevant candidates and `-i` opens the interactive picker. After choosing, EveryCli shows the selected command instead of making you scan a longer result list. On **Windows**, the selected command is copied automatically to the clipboard, so you can paste it immediately with `Ctrl+V`. On **Linux**, automatic copying from the interactive workflow is not implemented yet; it is planned for a future update.\n\nThe simple form remains available:\n\n```\neverycli search \"describe your intent\"\n```\n\nCommon options:\n\n```\neverycli search \"query\" --top 3        # maximum number of candidates\neverycli search \"query\" -i             # choose with the keyboard\neverycli search \"query\" --copy         # copy the selected result\neverycli search \"query\" --run          # run after confirmation\neverycli search \"query\" --json         # machine-readable output\neverycli search \"query\" --no-daemon    # force the local lexical fallback\n```\n\nInteractive mode lets you review candidates before choosing. EveryCli never runs a command without explicit confirmation.\n\n**Add and maintain your own commands:**\n\n```\neverycli add\neverycli list\neverycli remove\n```\n\nThis turns a command found once into a reusable local shortcut. Personal commands live in `~/.everycli/commands` (Linux) or `%USERPROFILE%\\.everycli\\commands` (Windows), separate from the built-in corpus and preserved through a normal update or uninstall.\n\n`search` is the main **local** path — corpus + Rust daemon, no API key. Two optional companions exist:\n\n- **`everycli ask`** calls an**OpenAI-compatible API** to propose a command, explanation, warning and tags, then offers to save it to your personal corpus. It is*not* the local ranking of`search` .\n- **Sentinel** (`everycli plan` ) is a separate**Python** planner that reviews an already-retrieved command. It never executes a shell command for you.\n\nConfigure a key (stored privately, `0600` on Unix):\n\n```\neverycli config set api_key \"your-api-key\"\neverycli config show           # never prints the full key\neverycli ask \"compress the current directory\"\n```\n\nThe key may also come from `EVERYCLI_API_KEY`. Known prefixes are auto-detected, or set a provider explicitly (`everycli config set provider openai`, plus `api_url` / `api_model` for OpenAI-compatible endpoints). Without a key, `ask` reports a config error while `search` keeps working offline.\n\nEveryCli is driven by a handful of environment variables and a `~/.everycli/config.toml` file. The essentials:\n\n| Variable | Role | Dev default | \n|---|---|---|\n| `EVERYCLI_PORT` | Daemon TCP port | `51821` | \n| `EVERYCLI_MODEL_DIR` | Folder holding `model.onnx` +`tokenizer.json` | model dir | \n| `EVERYCLI_ONNXRUNTIME_DYLIB` | Native ONNX Runtime library | `.dll` /`.so` per OS | \n| `EVERYCLI_DATA_DIR` | Built-in YAML corpus | shipped corpus | \n| `EVERYCLI_USER_DATA_DIR` | Personal YAML corpus | `~/.everycli/commands` | \n| `EVERYCLI_API_KEY` | Key for `everycli ask` | *unset* | \n\nInstallers replace the dev defaults with absolute paths. A corpus entry is a YAML record with `id`, `description`, `tags`, per-platform `commands`, `explanation` and an optional `warning`.\n\n📖 **Full reference:** every variable, data paths, corpus schema and the JSON daemon protocol → **[docs/reference_config.md](https://github.com/HE11032006/EveryCli/blob/main/docs/reference_config.md)**.\n\nEveryCli separates the human interface from the wrapper protocol so a command is never executed by surprise. The `--shell` (`-s`) mode prints **only** the resolved command to `stdout` (no trailing newline), sends diagnostics to `stderr`, and does **not** confirm or run anything — ideal for Bash/Zsh/PowerShell wrappers that place the command in an editable buffer.\n\n```\neverycli search \"undo my last commit\" --shell\n```\n\nTo stay deterministic, `--shell` does not combine with `-i`, `--run`, `--copy`, `--error` or `--top` > 1.\n\n📖 **Full guide:** interactive mode, Bash/Zsh/PowerShell wrappers, execution-safety rules → **[docs/shell_integration.md](https://github.com/HE11032006/EveryCli/blob/main/docs/shell_integration.md)**.\n\nFor a prebuilt release you don't need this — it targets developers building a local bundle.\n\n```\n# Rust binaries\ncd rust\ncargo build --release -p everycli-rs -p everycli-daemon\n\n# Targeted tests\ncargo test -p everycli-rs\ncargo test -p everycli-core\ncargo test -p everycli-daemon\n```\n\nThe production ONNX artifact lives in [`Michelhe/everycli-minilm-ft-boosted-onnx`](https://huggingface.co/Michelhe/everycli-minilm-ft-boosted-onnx); CI pins a revision and verifies SHA-256 checksums. The `ort 2.0.0-rc.13` crate requires a native **ONNX Runtime 1.27.x+** library (the workflow pins 1.27.0).\n\n📖 **Full guide:** ONNX assets, native runtime, local staging, CI/release flow → **[docs/how_to_build.md](https://github.com/HE11032006/EveryCli/blob/main/docs/how_to_build.md)**.\n\nMeasurements are development observations, not universal guarantees. On the bilingual `eval/confusion_set.yaml` set the recorded ranking result was **58/66 queries (87.9%)**. An indicative Windows latency baseline: **~383 ms** for a full daemon search vs **~33 ms** for the local lexical fallback (a cold first load is much slower).\n\n```\npython tools/evaluate_confusion.py                 # hybrid path\npython tools/evaluate_confusion.py --matcher lexical  # lexical only\n```\n\n📖 **Full guide:** measurement rules, bundle validation, CI checks, regression reports → **[docs/benchmarking.md](https://github.com/HE11032006/EveryCli/blob/main/docs/benchmarking.md)**.\n\n| Area | Verified status | \n|---|---|\n| Rust client, Rust daemon and hybrid search | ✔️ Available | \n| Distributable `model.onnx` and tokenizer | ✔️ In validated CI bundles | \n| Windows install from a complete bundle | ✔️ Verified end to end | \n| Linux install from a complete bundle | ✔️ Verified under WSL (service, search, uninstall) | \n| Ubuntu & Windows CI | ✔️ Complete bundles with model checksums | \n| macOS | 🔧 CI build/tests only; no installer or public archive yet | \n| Model quantization | 🔭 To explore (current model is large float32) | \n| ANN index for very large corpora | 🔭 To explore | \n\nSee **[CHANGELOG.md](https://github.com/HE11032006/EveryCli/blob/main/CHANGELOG.md)** for factual change history and measurements.\n\n| Document | Audience | Scope | \n|---|---|---|\n| [Installation tutorial](https://github.com/HE11032006/EveryCli/blob/main/docs/tutorial_installation.md) | Users & testers | Install, usage, uninstall, troubleshooting | \n| [Architecture](https://github.com/HE11032006/EveryCli/blob/main/docs/explanation_architecture.md) | Curious developers | Client, daemon, model, ranking, lifecycle | \n| [Build & tests](https://github.com/HE11032006/EveryCli/blob/main/docs/how_to_build.md) | Developers | Rust builds, ONNX assets, staging, validation | \n| [Configuration reference](https://github.com/HE11032006/EveryCli/blob/main/docs/reference_config.md) | Integrators | Env vars, paths, YAML schema, daemon protocol | \n| [Shell integration](https://github.com/HE11032006/EveryCli/blob/main/docs/shell_integration.md) | Advanced users | `--shell` protocol, wrappers, execution safety | \n| [Benchmarks & validation](https://github.com/HE11032006/EveryCli/blob/main/docs/benchmarking.md) | Developers | Tests, ranking benchmark, latency, CI | \n| [Linux validation guide](https://github.com/HE11032006/EveryCli/blob/main/LINUX_TEST_GUIDE.md) | Release testers | Linux install/search/uninstall runbook | \n| [CONTRIBUTING.md](https://github.com/HE11032006/EveryCli/blob/main/CONTRIBUTING.md) | Contributors | Setup, tests, contribution rules | \n| [CHANGELOG.md](https://github.com/HE11032006/EveryCli/blob/main/CHANGELOG.md) | Technical readers | Factual change history | \n\n```\nEveryCli/\n├── everycli/                   # Sentinel Python component and historical data\n│   └── data/commands/          # Built-in YAML corpus\n├── rust/\n│   ├── everycli-core/          # Corpus loading and lexical search\n│   ├── everycli-inference/     # Semantic encoder and ONNX Runtime\n│   ├── everycli-daemon/        # Local TCP server\n│   └── everycli-rs/            # Rust CLI client\n├── docs/                       # Standalone technical guides\n├── scripts/                    # Platform staging scripts\n├── install.sh / install.ps1    # Linux / Windows installers\n├── uninstall.sh / uninstall.ps1\n└── .github/workflows/build.yml # Tests, builds and CI bundles\n```\n\n| Resource | Link | \n|---|---|\n| **Website** |  | \n| **Support** |  | \n\nCode is released under the **MIT License**; documentation under a **Creative Commons** license. See [LICENSE.md](https://github.com/HE11032006/EveryCli/blob/main/LICENSE.md).\n\n<sub>EveryCli — for developers who would rather describe an intent than memorize flags.</sub>", "url": "https://wpnews.pro/news/everycli-natural-language-cli-assistant-that-runs-100-locally-rust-and-onnx", "canonical_source": "https://github.com/HE11032006/EveryCli", "published_at": "2026-09-22 05:36:05+00:00", "updated_at": "2026-09-22 05:54:17.839368+00:00", "lang": "en", "topics": ["ai-tools", "developer-tools", "natural-language-processing", "ai-products"], "entities": ["EveryCli", "Rust", "ONNX Runtime", "PyInstaller", "Python", "Ubuntu", "Windows"], "alternates": {"html": "https://wpnews.pro/news/everycli-natural-language-cli-assistant-that-runs-100-locally-rust-and-onnx", "markdown": "https://wpnews.pro/news/everycli-natural-language-cli-assistant-that-runs-100-locally-rust-and-onnx.md", "text": "https://wpnews.pro/news/everycli-natural-language-cli-assistant-that-runs-100-locally-rust-and-onnx.txt", "jsonld": "https://wpnews.pro/news/everycli-natural-language-cli-assistant-that-runs-100-locally-rust-and-onnx.jsonld"}}