Prerequisites for kimi-cli: Complete Installation Guide

To install and run kimi-cli, you need Python 3.12 or newer, the uv package manager, Git, and Make installed on your system.

The kimi-cli repository from MoonshotAI is a modern Python-based AI terminal agent that requires specific tooling to build from source or run in development mode. Understanding the prerequisites for kimi-cli ensures you can execute the make prepare and uv run commands documented in the README. This guide covers every required and optional dependency based on the project's pyproject.toml and build configuration.

Core Prerequisites

These four components are mandatory for cloning, building, and running kimi-cli from the GitHub repository.

Python 3.12 or Newer

The codebase requires Python 3.12+ to run, with the project tooling currently configured for Python 3.14 as specified in pyproject.toml. The core logic uses modern Python features that are not available in earlier versions.

Install Python via the official installer or use a version manager like pyenv. Verify your version before proceeding:

python --version  # Must output 3.12.x or higher

uv Package Manager

uv handles all dependency management for this project. According to the source code, the make prepare command executes uv sync to install dependencies, and the README instructs users to run uv run … for executing CLI commands.

Install uv via pip or follow the official Astral documentation:

pip install uv

Git and Make

Git is required to clone the repository (git clone https://github.com/MoonshotAI/kimi-cli.git), while Make provides the build automation targets defined in the project's Makefile. The README references make prepare, make test, and make format commands for development workflows.

On macOS and Linux, Make is usually pre-installed. Windows users should use WSL or install GNU Make.

Optional Prerequisites

These components are only necessary for specific features or development tasks.

Node.js and npm

You only need Node.js and npm if you intend to rebuild the web UI. The make build-web target requires a Node-based build step to compile the frontend assets. This is not required for standard CLI usage.

Install Node.js from the official website or via your package manager.

Zsh Shell

If you want shell-mode integration, install the zsh-kimi-cli plugin. This requires the Zsh shell and a plugin manager like Oh My Zsh. This integration is optional and only affects the interactive shell experience.

Installation Workflow

Once you have the core prerequisites for kimi-cli installed, follow these steps to set up the development environment:

1. Clone the repository:

git clone https://github.com/MoonshotAI/kimi-cli.git
cd kimi-cli

2. Prepare the environment:

make prepare

This command executes uv sync to install all Python dependencies defined in pyproject.toml.

3. Run the CLI:

uv run kimi

Alternatively, if you added the entry point to your PATH, you can run kimi directly.

PyPI Installation (No Development)

If you only need the binary without cloning the repository:

pip install uv
uv pip install kimi-cli
kimi --help

Key Source Files

Understanding these files helps verify that your environment meets the prerequisites for kimi-cli:

• pyproject.toml: Declares the Python version requirement (3.12+) and defines the CLI entry point as [tool.poetry.scripts] kimi = "kimi_cli.__main__:main".
• src/kimi_cli/cli/__init__.py: Contains the Typer-based CLI entry point that parses flags and dispatches to the KimiCLI class.
• src/kimi_cli/app.py: Handles core application bootstrap logic, loading configuration and selecting the LLM provider.
• Makefile: Defines build targets including prepare, format, test, and build-web.

Verifying Your Setup

Confirm all components are correctly installed:

python --version    # Check for 3.12+

uv --version        # Verify uv installation

git --version       # Confirm Git availability

make --version      # Check Make installation

If all commands return version numbers, your system satisfies the prerequisites for running kimi-cli.

Summary

• Python 3.12 or newer is mandatory, with tooling configured for Python 3.14 in the repository.
• The uv package manager is required for dependency synchronization via uv sync and execution via uv run.
• Git and Make are necessary for cloning the repository and running build commands like make prepare.
• Node.js is only required if rebuilding the web UI via make build-web.
• Entry point configuration in pyproject.toml maps the kimi command to kimi_cli.__main__:main.

Frequently Asked Questions

Do I need Python 3.12 specifically, or will older versions work?

You need Python 3.12 or newer. The source code in pyproject.toml explicitly requires Python 3.12+, and the project tooling is configured for Python 3.14. Earlier versions will fail to run the CLI due to dependencies on modern Python features.

Can I use pip instead of uv to install kimi-cli?

While you can install the pre-built package from PyPI using pip install kimi-cli, the development workflow requires uv. The make prepare command specifically calls uv sync to manage dependencies, and the README recommends uv run … for executing the CLI in development mode.

Is Node.js required to use the basic CLI functionality?

No. Node.js and npm are only required if you want to rebuild the web UI using the make build-web command. The core kimi CLI functionality works without any Node.js installation.

How do I check if all prerequisites for kimi-cli are installed correctly?

Run python --version, uv --version, git --version, and make --version in your terminal. All commands should return version numbers indicating 3.12+ for Python. If these succeed, you can run make prepare in the repository directory to verify the full toolchain works together.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}