Mint is a local-first AI assistant built with Tauri v2, Rust, React, and TypeScript. The desktop application and native CLI share the same Rust domain layer, so chat, memory, knowledge, tools, safety policies, and integrations behave consistently across both interfaces.
Mint is a local-first AI assistant running on your machine, capable of handling tasks via either the desktop application or the terminal interface (CLI):
- Connect to Gemini, OpenAI, Anthropic (Claude), Ollama (Local), Hugging Face, and LM Studio.
- Run private local LLMs inside your machine using Ollama or connect to leading cloud APIs.
- Supports system instructions, temperature adjustments, voice replies, and image analysis (Multimodal).
- An interactive anime avatar (Shiroko) displayed right on your desktop with gaze tracking (eye/face follows your mouse pointer).
- Toggle expression changes and cycle through character accessories dynamically.
- Custom interaction zones (Head, Cheek, Hands, Body) that trigger unique animations and message toasts.
- Run code agent loops via
/code <task>or the terminal commandmint code agent "<task>". - Scan your project workspace, build multi-file implementation plans, fix test suite errors, and write edits automatically.
- Run local tests, cargo checks, and shell commands.
Important
Safety First: Risky actions and file writes require your explicit terminal approval first.
- Persistent conversation memory stored locally in SQLite. Manage user profile memory with
/memory set/getor CLI commands. - Index local directories, text files, and documentation to build your private searchable knowledge base.
- Support Model Context Protocol (MCP) to connect tools like Google/Brave Search, Filesystem servers, and GitHub context.
- Local plugins for Spotify playback control, Google Calendar, Gmail drafts, and Notion workspace reading.
- Bridge your local AI assistant to messaging services: Telegram, Discord Gateway, Discord RPC, Slack, LINE, and WhatsApp.
- Host local chatbot webhooks that relay chat traffic into your configured LLM.
Tip
Headless Background Execution: Enabled bridges automatically run in the background when you launch either the desktop application OR the local API/Web server (mint api / mint web). This allows you to chat with Mint from anywhere without needing the desktop GUI window open.
- Capture screen snapshots for instant visual analysis by the AI.
- Real-time continuous overlay translation of specific screen regions.
- Multi-provider chat with Gemini, OpenAI, Anthropic, Ollama, Hugging Face, and local OpenAI-compatible endpoints.
- Native streaming responses, SQLite-backed memory, tasks, searchable local knowledge, skills, and semantic code search.
- Desktop dashboard with a Live2D assistant, model interaction areas, pictures, screen capture, continuous translation, spotlight, tray, widget, and proactive suggestions.
- Native code-agent workflow for workspace inspection, planning, editing, shell execution, and verification with explicit approval for risky actions.
- MCP servers, local plugins, custom workflows, weather, web search, and optional external services.
- Telegram, Discord Gateway, Discord RPC, Slack Socket Mode, LINE, and WhatsApp Cloud API integrations.
- Signed Tauri update checks with an explicit approval step before installation.
| Desktop assistant | Settings |
|---|---|
 |
 |
- Node.js and npm
- A Rust toolchain
- Tauri v2 native build dependencies for your operating system
On Debian, Ubuntu, or Linux Mint:
sudo apt-get install -y \
build-essential curl file pkg-config wget \
libdbus-1-dev libwebkit2gtk-4.1-dev \
libayatana-appindicator3-dev librsvg2-dev \
poppler-utils unzip patchelfSee the Tauri prerequisites guide for other platforms.
The easiest way to install Mint CLI is using our installation script:
For macOS & Linux:
curl -fsSL https://raw.githubusercontent.com/Pheem49/Mint/main/install.sh | bashFor Windows (PowerShell):
powershell -Command "iwr -useb https://raw.githubusercontent.com/Pheem49/Mint/main/install.ps1 | iex"mint onboard
mint setup
mint
mint web
mint chat "Hello"Most integrations can be configured from:
mint onboard
mint setup
mintCopy the template and configure your LLM credentials (Gemini, OpenAI, Anthropic, etc.):
cp .env.example .envOpen the .env file and insert your API keys (e.g. GEMINI_API_KEY=your_key_here).
Install the dependencies and start the application in development mode:
npm install
npm run tauri:devTo compile and build a production standalone desktop package:
npm run tauri:build(The Vite renderer output is generated in out/renderer and can be manually built via npm run build:web)
To install the mint command-line tool globally:
- Option A (Release Build - Recommended for speed):
cargo build --release -p mint-cli sudo cp target/release/mint /usr/local/bin/
- Option B (Cargo Install):
cargo install --path crates/mint-cli
- Option C (Development Shell Alias): If you are actively modifying code and want changes to reflect instantly, set up the alias under the Setting up the mint Shortcut section.
The desktop application provides:
- A streaming chat panel with provider selection and optional smart context.
- A Live2D model panel with gaze tracking, interaction zones, and visual area guides.
- Local conversation memory, tasks, searchable knowledge, and pictures.
- Screen capture and continuous screen translation.
- Spotlight, widget, tray, proactive glow, and background task queue windows.
- Settings for models, API keys, voice, automation, integrations, MCP servers, workflows, appearance, updates, and agent collaboration.
The sidebar, Live2D interaction state, and area-guide visibility are stored locally so the dashboard restores the previous UI state after restarting.
You can interact with Mint's Rust backend directly using the command line. If you set up the mint shortcut alias, you can run commands directly as mint <command>. Otherwise, you can fall back to running them through npm as npm run cli -- <command>.
You can choose one of the following methods to enable the global mint command:
Option 1: Using Shell Alias (For active development - updates instantly on code changes)
To run the commands using the prefix mint from anywhere in your workspace (automatically compiling your code updates on execution):
For Bash (~/.bashrc):
echo 'alias mint="cargo run --manifest-path /home/pheem49/vscode/Project/Mint-CLI/Cargo.toml -p mint-cli --"' >> ~/.bashrc
source ~/.bashrcFor Zsh (~/.zshrc):
echo 'alias mint="cargo run --manifest-path /home/pheem49/vscode/Project/Mint-CLI/Cargo.toml -p mint-cli --"' >> ~/.zshrc
source ~/.zshrcOption 2: Install via Cargo (For standard Rust installation)
This will compile the Rust CLI and install it inside your native Cargo binary directory:
cargo install --path crates/mint-cliNote: Make sure your ~/.cargo/bin is added to your shell's $PATH variable.
Option 3: Compile and Install Globally (For release binary - fastest run speed)
If you want to compile the project in release mode and install it directly to your system's global binaries directory (for the fastest startup time without cargo check overhead):
# Build the binary in release mode
cargo build --release -p mint-cli
# Copy it into your system binary directory
sudo cp target/release/mint /usr/local/bin/Once copied, you can run mint globally from any folder in your terminal!mint chat "Hello"
To start the interactive terminal AI chatbot assistant, simply run:
mint
# Or fallback: npm run cliThis opens the Mint interactive shell, where you can type prompts naturally or use /commands (like /help, /cd, /clear, /exit).
You can run individual subcommands by appending them after mint:
mint onboard
mint setup
mint status
mint web
mint api
mint chat "<message>"| Command | Purpose |
|---|---|
mint |
Start the interactive terminal chat assistant |
mint onboard |
Configure Mint for first use |
mint setup |
Interactively manage enabled agent tools |
mint web |
Launch the web UI and local API server |
mint api |
Start only the local API server |
mint status |
Show runtime status |
mint config init |
Create the local configuration file |
mint config path |
Print the configuration file path |
mint config show |
Print the current configuration |
mint config set <key> <value> |
Update a configuration value |
mint config doctor |
Validate the local setup |
mint providers |
List configured AI providers |
mint chat "<message>" |
Send one chat message |
mint memory recent |
Show recent conversation memory |
mint task list |
List all tasks (pending and completed) |
mint task pending |
List pending tasks |
mint knowledge add <path> |
Index a local document |
mint knowledge search "<query>" |
Search indexed knowledge |
mint plugin list |
List local plugins |
mint mcp list |
List configured MCP servers |
mint learn <path> |
Import a persistent learned skill file |
mint update --check |
Check for an available update |
Mint includes native workspace tools for code inspection, planning, editing, and execution:
mint code agent "inspect this repo and fix the failing tests"
mint code summary .
mint code search "shell approval flow" .
mint symbols .
mint semantic-code index .
mint semantic-code search "provider fallback"Inside interactive mode, use:
/code <task>
Code-related fixes, workspace inspection, and test requests are routed into the code-agent loop automatically. Shell commands and file edits require explicit terminal approval before Mint applies them.
mint files find README
mint safety path README.md
mint safety shell cargo test -p mint-core
mint run --approve -- cargo test -p mint-core
mint open README.md
mint open-app code
mint learn ./skill.mdAdd a local MCP server and call one of its tools:
mint mcp add filesystem npx \
--args -y \
--args @modelcontextprotocol/server-filesystem \
--args .
mint mcp list
mint mcp call filesystem list_directory \
--arguments '{"path":"."}'| Command | Purpose |
|---|---|
/help |
Show interactive help |
/fast [on|off] |
Toggle fast response mode |
/models [name] |
List or select a model |
/clear or /reset |
Clear the active conversation |
/cd <path> |
Change workspace directory |
/image <path> [prompt] |
Send an image with an optional prompt |
/paste [prompt] |
Use an image from the clipboard |
/learn <path> |
Import a local skill |
/memory list |
List stored memories |
/memory clear |
Clear stored memories |
/memory get <key> |
Read one memory value |
/memory set <key> <value> |
Store one memory value |
/stats |
Show session statistics |
/code <task> |
Start a code-agent task |
/exit or /quit |
Leave interactive mode |
Mint stores its local configuration in the platform config directory:
| Platform | Typical path |
|---|---|
| Linux | ~/.config/mint/mint-config.json |
| macOS | ~/Library/Application Support/mint/mint-config.json |
| Windows | %APPDATA%\mint\mint-config.json |
Create and inspect the configuration:
npm run cli -- config init
npm run cli -- config path
npm run cli -- config show
npm run cli -- config doctorConfiguration covers provider credentials, model preferences, browser context, voice and TTS, proactive suggestions, headless tasks, updates, workflows, MCP servers, and optional integrations such as Calendar, Gmail, Notion, Telegram, Discord, Slack, LINE, WhatsApp, Google Search, and Brave Search.
The optional browser smart-context helper can provide active-tab context from:
http://127.0.0.1:3212/context
Chromium automation uses the local debugging endpoint:
http://127.0.0.1:9222/json/list
LINE and WhatsApp webhook listeners bind to localhost by default. Read
docs/WEBHOOK_FORWARDING.md before exposing them
through a TLS tunnel.
Mint keeps high-risk behavior behind explicit policy checks:
- Shell commands are evaluated before execution.
- Code edits and update installation require approval.
- Sensitive directories such as
.ssh,.gnupg, and Mint's own config directory are protected by default. - Sensitive filenames such as
.envand private key files are blocked from routine workspace access. - LINE and WhatsApp webhook services listen locally unless you intentionally forward them.
Review the generated command or edit preview before approving an action.
Useful validation commands:
npm run build:web
cargo test -p mint-core -p mint-cli -p mint-desktop
cargo check -p mint-desktop
npm run tauri:build -- --debug --no-bundlecrates/mint-core Shared Rust domain logic
crates/mint-cli Native Rust CLI
src-tauri Tauri desktop backend and IPC commands
src/renderer React and TypeScript webview UI
docs Project documentation
out/renderer Generated Vite renderer output
Mint's historical Electron desktop runtime and Node CLI have been removed. The
active application is the native Tauri v2 and Rust implementation documented
above. See TAURI_MIGRATION.md for compatibility notes.
We welcome contributions from the community! Whether you want to fix a bug, add a new provider, or build a new integration, please check out our CONTRIBUTING.md guide for setup instructions, project architecture details, and our roadmap.
Mint is licensed under the AGPL-3.0-only license.
