# How to Use the Chat Command in Kimi CLI: Interactive and Print Modes Explained

> Master the Kimi CLI's chat functionality. Learn to launch interactive sessions or execute one-off queries using the --print and --prompt flags for efficient AI communication.

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

---

**Kimi CLI does not expose a standalone `chat` subcommand; instead, you launch an interactive session by running `kimi` alone or execute a one-off query using the `--print` flag combined with `--prompt`.**

The MoonshotAI/kimi-cli repository provides a unified interface for interacting with large language models through your terminal. While many CLI tools implement a dedicated `chat` subcommand, Kimi CLI takes a different approach by offering two distinct entry points—an interactive shell and a print mode—both backed by the same agent architecture in [`src/kimi_cli/soul/kimisoul.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/soul/kimisoul.py).

## Chat Interface Modes

Kimi CLI offers two primary ways to engage in conversation with the AI, depending on whether you need an ongoing dialogue or a single response.

### Interactive Shell Mode (Default)

Running the CLI without arguments launches the full-screen TUI where you can type messages back-and-forth with the agent. This mode maintains conversation context and supports multi-turn interactions.

```bash
kimi

```

Once executed, the terminal transforms into an interactive interface where you can type queries, receive streaming responses, and continue the conversation thread.

### One-Off Print Mode

For scripting or quick queries that require only the final answer without UI overhead, use the print mode. This mode sends a single prompt to the LLM, prints the assistant's response, and immediately exits.

```bash
kimi --print --prompt "Explain the difference between async and threading in Python."

```

You can also use the short form flags:

```bash
kimi -p "Summarize the latest Kimi CLI release notes."

```

## Internal Implementation of Chat Functionality

Understanding how Kimi CLI processes chat requests requires examining the codebase path from argument parsing to response generation.

### Argument Parsing and Mode Selection

The Typer callback in [`src/kimi_cli/cli/__init__.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/cli/__init__.py) handles the `--print` (aliased as `--output-format`) and `--prompt` options. Lines 70-78 define how the CLI distinguishes between interactive and print modes based on these flags. When `--print` is detected, the `ui` variable is set to `"print"`, bypassing the TUI initialization.

### Executing Single Requests

In [`src/kimi_cli/app.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/app.py), the `KimiCLI` class implements the `run_print` method (lines 62-69). This method executes a single turn with the supplied prompt and returns only the final message content, avoiding the overhead of the interactive shell. The implementation ensures that once the LLM returns a response, the process terminates cleanly.

### Chat Provider Abstraction

The actual communication with language model APIs occurs through the abstraction layer defined in [`src/kimi_cli/llm.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/llm.py) (lines 10-20). The `ChatProvider` class standardizes interactions across different backends—including OpenAI, Anthropic, and Kimi—allowing the CLI to route requests to the configured provider without changing the interface logic.

### Core Agent Loop

The underlying agent logic resides in [`src/kimi_cli/soul/kimisoul.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/soul/kimisoul.py). In print mode, this module bypasses the interactive input loop and directly processes the single-turn request, returning the assistant's reply to the `run_print` caller.

## Practical Usage Examples

The following patterns cover common scenarios for interacting with Kimi CLI's chat functionality.

**1. Start an interactive session**

```bash
kimi

```

**2. Execute a one-off query with full flags**

```bash
kimi --print --prompt "What is the capital of France?"

```

**3. Quick queries using short flags**

```bash
kimi -p "Refactor this Python function to use list comprehensions" < function.py

```

**4. Pipe JSON input for advanced scripting**

```bash
echo '{"messages":[{"role":"user","content":"What is a monad?"}]}' | kimi --print --input-format stream-json

```

This approach allows you to construct complex message histories programmatically and pipe them directly into the CLI.

## Key Source Files for Chat Operations

| File | Role in Chat Workflow |
|------|----------------------|
| [`src/kimi_cli/cli/__init__.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/cli/__init__.py) | Defines the Typer CLI interface, parses `--print`/`--prompt` flags, and selects the UI mode based on arguments. |
| [`src/kimi_cli/app.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/app.py) | Implements the `run_print` method that processes single chat requests and returns the final message. |
| [`src/kimi_cli/llm.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/llm.py) | Contains the `ChatProvider` abstraction that standardizes communication with various LLM services. |
| [`src/kimi_cli/soul/kimisoul.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/soul/kimisoul.py) | Houses the core agent loop; in print mode, bypasses interactive shells to return direct responses. |
| [`src/kimi_cli/config.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/config.py) | Loads configuration parameters including model selection and API keys required by the chat provider. |

## Summary

- **Kimi CLI has no dedicated `chat` subcommand**—functionality is accessed through the default interactive shell or print mode flags.
- **Use `kimi` alone** to start the full-screen TUI for multi-turn conversations.
- **Use `kimi --print --prompt "..."`** (or `-p`) for single queries that return only the final answer.
- **Implementation spans multiple modules**: argument parsing in [`cli/__init__.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/cli/__init__.py), execution logic in [`app.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/app.py), and provider abstraction in [`llm.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/llm.py).
- **JSON piping is supported** via `--input-format stream-json` for programmatic integration.

## Frequently Asked Questions

### Is there a dedicated `chat` subcommand in Kimi CLI?

No. According to the source code in [`src/kimi_cli/cli/__init__.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/cli/__init__.py), Kimi CLI does not implement a separate `chat` subcommand. The functionality is integrated into the main entry point, with behavior determined by the presence of flags like `--print` and `--prompt`.

### How do I run a single query without launching the interactive UI?

Append the `--print` (or `-p`) flag combined with `--prompt` followed by your query. This invokes the `run_print` method in [`src/kimi_cli/app.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/app.py), which processes the request once and exits without initializing the TUI.

### What file handles the chat provider abstraction?

The `ChatProvider` class defined in [`src/kimi_cli/llm.py`](https://github.com/MoonshotAI/kimi-cli/blob/main/src/kimi_cli/llm.py) (lines 10-20) handles the abstraction. This class standardizes interactions across different LLM backends, allowing the CLI to support multiple providers through a unified interface.

### Can I pipe input to kimi-cli for automated scripts?

Yes. You can pipe JSON-formatted message arrays to the CLI using the `--input-format stream-json` flag alongside `--print`. This enables integration with shell scripts and other automation tools that need to process LLM responses programmatically.