On this tutorial, we configure and function Kimi CLI as a completely non-interactive AI coding agent. We set up the CLI by uv with an remoted Python 3.13 setting, configure Moonshot API authentication by a TOML-based supplier and mannequin definition, and construct a reusable Python wrapper for executing non-interactive CLI instructions. We then apply Kimi to a practical mission workflow wherein we examine a codebase, establish implementation dangers, autonomously modify supply recordsdata, generate unit assessments, execute validation instructions, and iterate till the mission passes its take a look at suite. We additionally discover structured JSONL occasion streams, persistent multi-turn classes, plan mode, mannequin choice, Ralph loops, MCP integrations, session export, and web-based entry, giving us a sensible basis for embedding Kimi CLI into automated improvement and agentic engineering pipelines.
Setting Setup and Kimi CLI Set up
import os, subprocess, textwrap, json, getpass, pathlib, shutil
HOME = pathlib.Path.house()
def sh(cmd, examine=True, env=None, cwd=None):
"""Run a shell command, stream its output, return CompletedProcess."""
print(f"n$ {cmd}")
e = {**os.environ, **(env or {})}
r = subprocess.run(cmd, shell=True, env=e, cwd=cwd,
capture_output=True, textual content=True)
if r.stdout: print(r.stdout)
if r.stderr: print(r.stderr[-2000:])
if examine and r.returncode != 0:
elevate RuntimeError(f"Command failed ({r.returncode}): {cmd}")
return r
print("=" * 70, "nPART 1: Putting in uv + Kimi CLIn", "=" * 70)
sh("curl -LsSf https://astral.sh/uv/set up.sh | sh")
UV_BIN = str(HOME / ".native" / "bin")
os.environ["PATH"] = f"{UV_BIN}:{os.environ['PATH']}"
sh("uv device set up --python 3.13 kimi-cli")
sh("kimi --version")
We start by importing the required Python modules and defining a reusable shell-command helper for managed subprocess execution. We set up uv, add its binary listing to the setting path, and use it to provision Kimi CLI with an remoted Python 3.13 runtime. We then confirm the set up by querying the put in Kimi CLI model.
Configuring Moonshot API Authentication and Mannequin Entry
print("=" * 70, "nPART 2: Configuring API accessn", "=" * 70)
strive:
from google.colab import userdata
API_KEY = userdata.get("MOONSHOT_API_KEY")
print("Loaded key from Colab Secrets and techniques.")
besides Exception:
API_KEY = getpass.getpass("Paste your Moonshot API key (hidden): ")
BASE_URL = "https://api.moonshot.ai/v1"
MODEL_NAME = "kimi-k2-0711-preview"
kimi_dir = HOME / ".kimi"
kimi_dir.mkdir(exist_ok=True)
(kimi_dir / "config.toml").write_text(textwrap.dedent(f"""
default_model = "kimi-k2"
[providers.moonshot]
kind = "kimi"
base_url = "{BASE_URL}"
api_key = "{API_KEY}"
[models.kimi-k2]
supplier = "moonshot"
mannequin = "{MODEL_NAME}"
max_context_size = 131072
"""))
print("Wrote ~/.kimi/config.toml")
We securely retrieve the Moonshot API key from Google Colab Secrets and techniques or request it by way of a hidden enter immediate. We outline the Moonshot API endpoint and goal Kimi mannequin, then create the required .kimi configuration listing. We write the supplier, mannequin, context window, and default mannequin settings to config.toml for non-interactive authentication.
Constructing a Reusable Non-Interactive Kimi Execution Wrapper
def kimi(immediate, work_dir=".", yolo=False, cont=False, quiet=True,
stream_json=False, further="", timeout=600):
"""Run one headless Kimi CLI flip and return its stdout."""
flags = []
if stream_json:
flags.append("--print --output-format stream-json")
elif quiet:
flags.append("--quiet")
else:
flags.append("--print")
if yolo: flags.append("--yolo")
if cont: flags.append("--continue")
flags.append(f'-w "{work_dir}"')
if further: flags.append(further)
cmd = f'kimi {" ".be a part of(flags)} -p "{immediate}"'
print(f"n$ {cmd}n" + "-" * 60)
r = subprocess.run(cmd, shell=True, capture_output=True,
textual content=True, timeout=timeout)
out = r.stdout.strip()
print(out if out else r.stderr[-1500:])
return out
We outline a Python wrapper that executes Kimi CLI prompts programmatically with out requiring an interactive terminal session. We dynamically assemble flags for quiet output, streamed JSON occasions, autonomous device approval, session continuation, working-directory isolation, and step limits. We seize the command output, show the ultimate response or error particulars, and return the consequence for additional processing.
Creating and Analyzing a Practical Pattern Challenge
print("=" * 70, "nPART 4: Demo A — codebase Q&An", "=" * 70)
proj = pathlib.Path("/content material/demo_project")
if proj.exists(): shutil.rmtree(proj)
(proj / "app").mkdir(dad and mom=True)
(proj / "app" / "stock.py").write_text(textwrap.dedent("""
class Stock:
def __init__(self):
self.gadgets = {}
def add(self, title, qty):
self.gadgets[name] = self.gadgets.get(title, 0) + qty
def take away(self, title, qty):
# BUG: permits unfavourable inventory and KeyError on lacking gadgets
self.gadgets[name] = self.gadgets[name] - qty
def complete(self):
return sum(self.gadgets.values())
"""))
(proj / "app" / "fundamental.py").write_text(textwrap.dedent("""
from stock import Stock
inv = Stock()
inv.add("widget", 10)
inv.take away("widget", 3)
print("Whole inventory:", inv.complete())
"""))
(proj / "README.md").write_text("# Demo: a tiny stock servicen")
kimi("Summarize this mission's construction and objective in beneath 120 phrases, "
"then record any bugs or design dangers you possibly can spot in stock.py.",
work_dir=str(proj))
We create a small stock administration mission that features a Python module, an executable script, and a README file. We deliberately embody implementation defects to allow Kimi to examine the repository construction and establish purposeful and design dangers. We then run a read-only mission evaluation immediate within the mission listing and request a concise technical evaluation.
Automating Code Restore, Testing, and Unbiased Validation
print("=" * 70, "nPART 5: Demo B — Kimi fixes the bug & provides testsn", "=" * 70)
kimi("Repair the bugs in app/stock.py: take away() should elevate KeyError->ValueError "
"for unknown gadgets and by no means enable unfavourable inventory. Then create assessments.py at "
"the mission root utilizing unittest masking add/take away/complete and edge circumstances, "
"run it with 'python -m unittest assessments -v', and iterate till all assessments cross. "
"Lastly print the take a look at outcomes.",
work_dir=str(proj), yolo=True, further="--max-steps-per-turn 30")
print("n--- Recordsdata after Kimi's edits ---")
for f in sorted(proj.rglob("*.py")):
print(f"n### {f.relative_to(proj)} ###n{f.read_text()}")
sh("python -m unittest assessments -v", cwd=str(proj), examine=False)
We enable Kimi to switch the mission autonomously, right the stock logic, generate unit assessments, and execute the take a look at suite. We configure a most agent-step restrict so the mannequin can iteratively diagnose failures and refine its implementation till validation succeeds. We examine the ensuing Python recordsdata and independently rerun the assessments to substantiate that the generated modifications work accurately.
Exploring Structured JSONL, Periods, and Superior Options
print("=" * 70, "nPART 6: Demo C — machine-readable JSONL eventsn", "=" * 70)
uncooked = kimi("In a single sentence, what does app/fundamental.py print when run?",
work_dir=str(proj), stream_json=True, quiet=False)
print("nParsed occasion varieties:")
for line in uncooked.splitlines():
strive:
evt = json.hundreds(line)
print(" •", evt.get("kind", "?"), "-",
str(evt)[:100].change("n", " "))
besides json.JSONDecodeError:
cross
print("=" * 70, "nPART 7: Demo D — conversational memoryn", "=" * 70)
kimi("Keep in mind this: our launch codename is BLUE-FALCON.", work_dir=str(proj))
kimi("What's our launch codename? Reply with simply the codename.",
work_dir=str(proj), cont=True)
print("=" * 70, "nPART 8: Energy-user referencen", "=" * 70)
print(textwrap.dedent("""
# Plan mode — read-only exploration, produces an implementation plan:
kimi --quiet --plan -w /content material/demo_project -p "Plan including SQLite persistence"
# Choose a special mannequin at runtime (should exist in config.toml):
kimi --quiet -m kimi-k2 -p "good day"
# Considering mode (if the mannequin helps it):
kimi --quiet --thinking -p "Show sqrt(2) is irrational"
# Ralph loop — feed the identical immediate repeatedly for one huge job
# till the agent outputs STOP or the restrict hits:
kimi --print --yolo --max-ralph-iterations 5 -w /content material/demo_project
-p "Hold bettering take a look at protection; STOP when the whole lot is roofed."
# MCP instruments — give Kimi further capabilities by way of an MCP config file:
# /content material/mcp.json -> {"mcpServers": {"context7":
# {"url": "https://mcp.context7.com/mcp",
# "headers": {"CONTEXT7_API_KEY": "YOUR_KEY"}}}}
kimi --quiet --mcp-config-file /content material/mcp.json -p "Use context7 to ..."
# Export a session (context.jsonl, wire.jsonl, state.json) for debugging:
kimi export --yes
# Internet UI (wants a tunnel on Colab, e.g. cloudflared/ngrok, because it
# binds regionally): kimi internet --no-open --port 5494
"""))
print("Tutorial full ✔ — Kimi CLI is put in, authenticated, and has "
"explored, mounted, examined, and remembered an actual mission headlessly.")
We execute Kimi with streamed JSON output and parse every JSONL occasion to examine machine-readable response varieties. We show persistent multi-turn reminiscence by storing a launch codename and retrieving it throughout an ongoing session in the identical working listing. We conclude by reviewing superior instructions for planning, mannequin switching, considering mode, Ralph loops, MCP instruments, session export, and internet entry.
In conclusion, we established an end-to-end Kimi CLI workflow that runs solely with out counting on an interactive terminal session. We moved from setting provisioning and API configuration to mission evaluation, autonomous code restore, take a look at era, structured output parsing, and session continuation. We additionally independently verified the agent’s modifications, which helps us distinguish generated output from precise execution outcomes and improves the reliability of the workflow. With the reusable wrapper and reference instructions in place, we are able to now lengthen the identical structure to bigger repositories, CI-style validation duties, MCP-enabled toolchains, iterative software program enchancment loops, and different programmable AI-assisted improvement workflows.
Take a look at the Full Code right here. Additionally, be at liberty to comply with us on Twitter and don’t overlook to hitch our 150k+ML SubReddit and Subscribe to our E-newsletter. Wait! are you on telegram? now you possibly can be a part of us on telegram as nicely.
Must accomplice with us for selling your GitHub Repo OR Hugging Face Web page OR Product Launch OR Webinar and so forth.? Join with us
Sana Hassan, a consulting intern at Marktechpost and dual-degree scholar at IIT Madras, is keen about making use of expertise and AI to handle real-world challenges. With a eager curiosity in fixing sensible issues, he brings a recent perspective to the intersection of AI and real-life options.
