# How to Use kimi-cli for Code Generation: A Complete Guide to AI-Assisted Programming

> Master code generation with kimi-cli a Python AI agent. Learn to stream requests to LLMs via CLI for REPL sessions and file persistence. Boost your programming workflow today.

- Repository: [Moonshot AI/kimi-cli](https://github.com/MoonshotAI/kimi-cli)
- Tags: how-to-guide
- Published: 2026-07-19

---

**kimi-cli is a Python-based interactive agent that streams code generation requests directly to large language models via the command line, supporting one-shot prompts, interactive REPL sessions, and automatic file persistence through built-in tools.**

The **kimi-cli** tool from MoonshotAI transforms your terminal into an AI-powered coding assistant capable of writing, refactoring, and explaining code in any programming language. By leveraging the `KimiLLM` wrapper and YAML-based agent specifications, you can execute complex **kimi-cli code generation** workflows without leaving your shell environment. This guide covers the complete workflow from installation to persisting generated files, based on the actual implementation in the MoonshotAI/kimi-cli repository.

## Installing kimi-cli from Source

To begin using **kimi-cli for code generation**, you must install the tool directly from the GitHub repository. The project requires Python 3.12 or higher and uses `uv` for dependency management.

Run the following commands to clone and prepare the environment:

```bash
git clone https://github.com/MoonshotAI/kimi-cli.git
cd kimi-cli
make prepare

```

The `make prepare` command, defined in the root `Makefile`, synchronizes dependencies using the `uv` package manager and installs necessary git hooks. Once complete, the `kimi` binary becomes available in your environment.

## One-Shot Code Generation

The fastest way to generate code with **kimi-cli** is through one-shot prompts passed directly as command arguments.

### Basic Syntax

Execute a single generation request by wrapping your prompt in quotes:

```bash
kimi "Write a Python function that returns the nth Fibonacci number"

```

This command invokes the default "code" agent, which immediately forwards your text to the LLM through the `KimiLLM.generate` method (implemented in [`src/kimi_cli/llm.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/llm.py), lines 66-102). The response streams directly to your terminal in real-time.

### How the Generation Pipeline Works

When you submit a prompt, the CLI executes a specific call chain:

1. **Entry Point**: Typer parses the command in [`src/kimi_cli/__main__.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/__main__.py) and routes it through the lazy command group loader ([`src/kimi_cli/cli/_lazy_group.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/cli/_lazy_group.py)).
2. **Application Bootstrap**: `KimiCLI.create` (in [`src/kimi_cli/app.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/app.py)) loads configuration and initializes the Agent based on YAML specifications.
3. **LLM Execution**: The `KimiLLM` class abstracts provider-specific SDKs (via the `kosong` library) and streams tokens back through the `generate` method.

No additional tools are invoked for simple code generation; the LLM response prints directly to stdout.

## Interactive Code Development with kimi shell

For multi-turn conversations or iterative refinement, use the interactive REPL mode.

### Starting an Interactive Session

Launch the shell with:

```bash
kimi shell

```

Inside the REPL, you can chain requests to evolve code incrementally:

```

> Write a Rust struct representing a binary tree.
> Can you add a method to compute its depth?
> Show a unit test for the depth method.

```

### Session Persistence and Context

Each line entered in the shell creates a separate turn in a `Session` object (defined in [`src/kimi_cli/session.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/session.py)). The session preserves full conversation history in memory, enabling the LLM to reference previous code blocks when generating new content.

The CLI automatically generates a human-readable session title after your first turn. This logic resides in [`src/kimi_cli/web/api/sessions.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/web/api/sessions.py) (lines 749-795), where the system analyzes the initial prompt to create descriptive metadata.

## Persisting Generated Code to Disk

While one-shot generation prints to stdout, the interactive shell provides built-in tools to write files directly.

### Using the File Write Tool

Invoke the file tool via slash commands:

```

> Write a Go program that prints "Hello, world!".
> /file:write path=hello.go content=<<CODE>>

```

The `file:write` tool implementation lives in [`src/kimi_cli/tools/file/write.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/tools/file/write.py), accessed through the generic tool loader ([`src/kimi_cli/toolset.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/toolset.py)). This tool receives the generated content and writes it to the specified path on your local filesystem without requiring manual copy-paste operations.

## Configuring LLM Providers

**kimi-cli** supports multiple LLM providers through the `kosong` library, including OpenAI, Anthropic, and Gemini.

### Environment Variable Configuration

Override the default LLM by setting the `KIMI_LLMS` environment variable:

```bash
KIMI_LLMS=openai kimi "Generate a Bash script that backs up /home"

```

### Command-Line Provider Selection

Alternatively, pass the `--provider` flag during invocation:

```bash
kimi --provider=anthropic "Create a TypeScript interface for a user database"

```

Provider selection logic is handled in `KimiLLM.__init__` (see [`src/kimi_cli/llm.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/llm.py), lines 41-55), which initializes the appropriate client SDK based on your configuration.

## Summary

- **kimi-cli** provides both one-shot generation (`kimi "prompt"`) and interactive REPL modes (`kimi shell`) for AI-assisted coding.
- Code generation flows through `KimiLLM.generate` in [`src/kimi_cli/llm.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/llm.py), streaming responses from any provider supported by the `kosong` library.
- Interactive sessions maintain context using `Session` objects ([`src/kimi_cli/session.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/session.py)) and auto-generate titles via logic in [`src/kimi_cli/web/api/sessions.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/web/api/sessions.py).
- Use `/file:write` slash commands to persist generated code directly to disk through the tool system ([`src/kimi_cli/tools/file/write.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/tools/file/write.py)).
- Configure alternative LLM providers using the `KIMI_LLMS` environment variable or `--provider` command-line flag.

## Frequently Asked Questions

### How does kimi-cli handle multi-file code generation?

The CLI handles multi-file generation through the interactive shell's tool system. While the LLM generates code in the conversation stream, you can use the `/file:write` command multiple times to create separate files. The agent specification in [`src/kimi_cli/agentspec.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/agentspec.py) defines which tools are available, and the tool loader in [`src/kimi_cli/toolset.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/toolset.py) resolves these requests dynamically.

### Can I use kimi-cli with my own OpenAI API key?

Yes. The `KimiLLM` class supports provider-specific authentication through environment variables or configuration files. Set `KIMI_LLMS=openai` and ensure your `OPENAI_API_KEY` is exported in your environment. The initialization logic in [`src/kimi_cli/llm.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/llm.py) (lines 41-55) handles the SDK client setup based on these parameters.

### What is the difference between `kimi` and `kimi shell` commands?

The base `kimi` command executes one-shot code generation requests that print to stdout and exit immediately, using the default agent defined in the YAML specs under `src/kimi_cli/agents/`. The `kimi shell` command (registered via [`src/kimi_cli/cli/_lazy_group.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/cli/_lazy_group.py)) starts a persistent REPL that maintains conversation history in a `Session` object, enabling iterative refinement and access to file system tools.

### Where does kimi-cli store conversation history?

Conversation history is maintained in memory during the active session through the `Session` class ([`src/kimi_cli/session.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/session.py)). The session tracks messages, metadata, and title generation flags. While the CLI does not automatically persist chat history to disk between invocations, the web API components in [`src/kimi_cli/web/api/sessions.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/web/api/sessions.py) demonstrate how session data structures handle metadata storage for potential future retrieval.