Kimi CLI: Полное руководство по созданию автономных AI-агентов для кодинга

В эпоху, когда искусственный интеллект перестал быть просто генератором текста и превратился в полноценного инженера-программиста, инструменты командной строки (CLI) становятся критически важными для интеграции AI в реальные рабочие процессы. Если вы когда-либо пытались автоматизировать разработку, вы знаете, что взаимодействие с LLM через веб-интерфейс — это тупик для масштабируемости. Настоящая магия происходит, когда AI-агент может самостоятельно исследовать кодовую базу, находить уязвимости, писать код, запускать тесты и исправлять ошибки без участия человека. Именно здесь на сцену выходит Kimi CLI от Moonshot AI.

В этой статье мы не просто посмотрим на синтаксис команды. Мы построим полноценный, воспроизводимый пайплайн «headless» (безинтерактивного) программирования. Мы установим среду, настроим аутентификацию через Moonshot API, создадим обертку на Python для управления агентом и, самое главное, запустим реальный сценарий: от анализа уязвимого проекта до его автономного исправления и генерации тестов. Это руководство для тех, кто хочет внедрить Agentic AI в свои CI/CD процессы или просто автоматизировать рутинную работу.

01Часть 1: Установка и настройка окружения

Первый шаг к созданию надежного AI-агента — это изолированная и воспроизводимая среда. Мы не будем использовать глобальный Python, так как это часто приводит к конфликтам зависимостей. Вместо этого мы воспользуемся uv — современным менеджером пакетов и виртуальных окружений, написанным на Rust, который работает молниеносно.

Процесс установки начинается с загрузки и запуска скрипта установки uv. После этого мы добавляем бинарный файл uv в переменную окружения PATH, чтобы система могла находить его из любой директории. Ключевой момент здесь — использование флага --python 3.13 при установке самого Kimi CLI. Это гарантирует, что агент будет работать в изолированном окружении с последней версией Python, что важно для совместимости с современными библиотеками и синтаксисом.

import os
import subprocess
import textwrap
import json
import getpass
import pathlib
import shutil

HOME = pathlib.Path.home()

def sh(cmd, check=True, env=None, cwd=None):
    """Run a shell command, stream its output, return CompletedProcess."""
    print(f"\n$ {cmd}")
    subprocess.run(
        cmd, shell=True, env={**os.environ, **env} if env else os.environ,
        cwd=cwd, capture_output=True, text=True
    )
    if check and subprocess.run(cmd, shell=True, env={**os.environ, **env} if env else os.environ, cwd=cwd, capture_output=True, text=True).returncode != 0:
        raise RuntimeError(f"Command failed ({subprocess.run(cmd, shell=True, env={**os.environ, **env} if env else os.environ, cwd=cwd, capture_output=True, text=True).returncode}): {cmd}")
    return subprocess.run(cmd, shell=True, env={**os.environ, **env} if env else os.environ, cwd=cwd, capture_output=True, text=True)

print("=" * 70 + "\nPART 1: Installing uv + Kimi CLI\n" + "=" * 70)
sh("curl -LsSf https://astral.sh/uv/install.sh | sh")
UV_BIN = str(HOME / ".local" / "bin")
os.environ["PATH"] = f"{UV_BIN}:{os.environ['PATH']}"
sh("uv tool install --python 3.13 kimi-cli")
sh("kimi --version")

После выполнения этих команд вы получите готовую к работе среду. Проверка версии через kimi --version подтверждает, что CLI-инструмент успешно установлен и готов принимать команды. Важно отметить, что мы используем обертку sh() для выполнения системных команд, что позволяет нам перехватывать stdout и stderr, что критически важно для отладки в дальнейшем.

02Часть 2: Аутентификация и конфигурация Moonshot API

Чтобы Kimi CLI мог взаимодействовать с моделями Moonshot, ему необходим доступ к API. Настройка происходит через файл конфигурации config.toml, который размещается в домашней директории пользователя в папке .kimi. Этот подход позволяет разделить логику аутентификации и логику приложения, делая конфигурацию переиспользуемой.

Мы создаем скрипт, который сначала пытается получить API-ключ из защищенного хранилища (например, userdata.get в Google Colab), а если это невозможно, запрашивает его у пользователя через скрытый ввод (getpass). Затем мы формируем структуру TOML, где определяем провайдер (Moonshot), базовый URL API, ключ и параметры модели, включая размер контекстного окна (131072 токенов для модели kimi-k2-0711-preview).

print("=" * 70 + "\nPART 2: Configuring API access\n" + "=" * 70)
try:
    from google.colab import userdata
    API_KEY = userdata.get("MOONSHOT_API_KEY")
    print("Loaded key from Colab Secrets.")
except 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]
   type = "kimi"
   base_url = "{BASE_URL}"
   api_key = "{API_KEY}"
   [models.kimi-k2]
   provider = "moonshot"
   model = "{MODEL_NAME}"
   max_context_size = 131072
"""))
print("Wrote ~/.kimi/config.toml")

Такой подход к конфигурации обеспечивает гибкость: вы можете легко переключаться между моделями или провайдерами, просто редактируя TOML-файл, не меняя код приложения. Это особенно полезно в корпоративной среде, где доступ к разным моделям может регулироваться политиками безопасности.

03Часть 3: Создание обертки для неинтерактивного выполнения

Одной из главных проблем при работе с CLI-агентами является необходимость передавать им сложные промпты и управлять их поведением (например, разрешать ли им самостоятельно запускать команды или требовать подтверждения). Для этого мы создаем Python-функцию-обертку kimi().

Эта функция принимает промпт, рабочую директорию и ряд флагов, таких как yolo (разрешить автономное выполнение команд без подтверждения), cont (продолжить текущую сессию) и stream_json (выводить события в формате JSONL для парсинга). Внутри функции мы динамически собираем строку команды, вызываем subprocess.run и возвращаем результат. Это позволяет нам интегрировать Kimi CLI в более крупные Python-скрипты, создавая полноценных агентов.

def kimi(prompt, work_dir=".", yolo=False, cont=False, quiet=True, stream_json=False, extra="", timeout=600):
    """Run one headless Kimi CLI turn 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 extra:
        flags.append(extra)
    cmd = f'kimi {" ".join(flags)} -p "{prompt}"'
    print(f"\n$ {cmd}\n" + "-" * 60)
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
    out = result.stdout.strip()
    print(out if out else result.stderr[:1500])
    return out

04Часть 4: Демонстрация A — Анализ кодовой базы

Прежде чем просить AI исправить код, нужно убедиться, что он понимает структуру проекта. Мы создаем миниатюрный проект с намеренными багами. В файле inventory.py есть класс Inventory, метод remove которого не проверяет наличие элемента в словаре (что приведет к KeyError) и не запрещает отрицательные значения количества (что является логической ошибкой).

Мы передаем этот проект в Kimi CLI с промптом, требующим не только суммировать структуру, но и выявить риски. Это демонстрирует способность агента к «чтению» кода и анализу архитектурных решений.

print("=" * 70 + "\nPART 4: Demo A — codebase Q&A\n" + "=" * 70)
proj = pathlib.Path("/content/demo_project")
if proj.exists():
    shutil.rmtree(proj)
(proj / "app").mkdir(parents=True)
(proj / "app" / "inventory.py").write_text(textwrap.dedent("""\
   class Inventory:
       def __init__(self):
           self.items = {}
       def add(self, name, qty):
           self.items[name] = self.items.get(name, 0) + qty
       def remove(self, name, qty):
           # BUG: allows negative stock and KeyError on missing items
           self.items[name] = self.items[name] - qty
       def total(self):
           return sum(self.items.values())
"""))
(proj / "app" / "main.py").write_text(textwrap.dedent("""\
   from inventory import Inventory
   inv = Inventory()
   inv.add("widget", 10)
   inv.remove("widget", 3)
   print("Total stock", inv.total())
"""))
(proj / "README.md").write_text("# Demo: a tiny inventory service\n")

kimi(
    "Summarize this project's structure and purpose in under 120 words, "
    "then list any bugs or design risks you can spot in inventory.py.",
    work_dir=str(proj)
)

05Часть 5: Демонстрация B — Автономное исправление и тестирование

Это сердце нашего агента. Мы даем Kimi CLI инструкцию исправить баги в inventory.py, создать файл тестов tests.py с использованием unittest и запустить тесты. Ключевые параметры здесь: yolo=True (разрешить запуск тестов) и --max-steps-per-turn 30 (ограничение на количество шагов, чтобы избежать бесконечных циклов).

Агент должен самостоятельно: 1) найти баг, 2) написать исправленный код, 3) написать тесты, 4) запустить тесты, 5) если тесты падают — исправить код и повторить. Мы проверяем результат, выводя содержимое измененных файлов и запуская тесты вручную для верификации.

print("=" * 70 + "\nPART 5: Demo B — Kimi fixes the bug & adds tests\n" + "=" * 70)
kimi(
    "Fix the bugs in app/inventory.py: remove() must raise KeyError->ValueError "
    "for unknown items and never allow negative stock. Then create tests.py at "
    "the project root using unittest covering add/remove/total and edge cases, "
    "run it with 'python -m unittest tests -v', and iterate until all tests pass. "
    "Finally print the test results.",
    work_dir=str(proj),
    yolo=True,
    extra="--max-steps-per-turn 30"
)

print("\n--- Files 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 tests -v", cwd=str(proj), check=False)

06Часть 6: Демонстрация C и D — JSONL, память и продвинутые функции

Для интеграции в сложные системы важно понимать, как агент принимает решения. Флаг --output-format stream-json выводит каждый шаг агента в формате JSONL (JSON Lines). Это позволяет парсить события в реальном времени: видеть, когда агент читает файл, когда выполняет команду, когда думает. Это критически важно для отладки и аудита действий AI.

Также мы демонстрируем многооборотную память. Используя флаг --continue и указывая ту же рабочую директорию, Kimi CLI сохраняет контекст предыдущих сообщений. Мы можем «запомнить» кодовое имя релиза в одном запросе и «вспомнить» его в следующем, что имитирует работу сессии в чате, но в программном интерфейсе.

print("=" * 70 + "\nPART 6: Demo C — machine-readable JSONL events\n" + "=" * 70)
raw = kimi(
    "In one sentence, what does app/main.py print when run?",
    work_dir=str(proj),
    stream_json=True,
    quiet=False
)
print("\nParsed event types:")
for line in raw.splitlines():
    try:
        evt = json.loads(line)
        print(f" • {evt.get('type', '?')}: {str(evt)[:100].replace('\n', ' ')}")
    except json.JSONDecodeError:
        pass

print("=" * 70 + "\nPART 7: Demo D — conversational memory\n" + "=" * 70)
kimi("Remember this: our release codename is BLUE-FALCON.", work_dir=str(proj))
kimi("What is our release codename? Answer with just the codename.", work_dir=str(proj), cont=True)

07Часть 7: Продвинутые возможности: Plan Mode, Ralph Loops и MCP

Kimi CLI предлагает ряд продвинутых режимов для опытных пользователей:

• Plan Mode (--plan): Агент не пишет код, а создает детальный план реализации. Это полезно для рефакторинга больших систем, где нужно сначала согласовать архитектуру.
• Ralph Loops: Режим, в котором агент повторяет один и тот же промпт до тех пор, пока не достигнет оптимального результата или не исчерпает лимит итераций. Идеально для задач, требующих постоянной оптимизации (например, улучшение покрытия тестами).
• MCP (Model Context Protocol): Позволяет подключать внешние инструменты и данные. Например, можно подключить базу знаний или API, чтобы агент мог использовать эти данные в своих рассуждениях.
• Web UI: Для отладки можно запустить веб-интерфейс, который визуализирует процесс работы агента, что удобно для визуального контроля.

print("=" * 70 + "\nPART 8: Power-user reference\n" + "=" * 70)
print(textwrap.dedent(""" 
 # Plan mode — read-only exploration, produces an implementation plan:
 kimi --quiet --plan -w /content/demo_project -p "Plan adding SQLite persistence"
 
 # Pick a different model at runtime (must exist in config.toml):
 kimi --quiet -m kimi-k2 -p "hello"
 
 # Thinking mode (if the model supports it):
 kimi --quiet --thinking -p "Prove sqrt(2) is irrational"
 
 # Ralph loop — feed the same prompt repeatedly for one big task
 # until the agent outputs STOP or the limit hits:
 kimi --print --yolo --max-ralph-iterations 5 -w /content/demo_project \\
      -p "Keep improving test coverage until everything is covered"
 
 # MCP tools — give Kimi extra capabilities via an MCP config file:
 #   /content/mcp.json -> {"mcpServers": {"context7": {"url": "https://mcp.context7.com/mcp", "headers": {"CONTEXT7_API_KEY": "YOUR_KEY"}}}}
 kimi --quiet --mcp-config-file /content/mcp.json "Use context7 to ..."
 
 # Export a session (context.jsonl, wire.jsonl, state.json) for debugging:
 kimi export --yes
 
 # Web UI (needs a tunnel on Colab, e.g. cloudflared/ngrok, since it
 # binds locally): kimi web --no-open --port 5494
"""))

08Что это значит на практике

Рассмотренный нами пайплайн — это не просто набор команд, это фундамент для создания автономных инженерных систем. Интеграция Kimi CLI в CI/CD позволяет автоматически запускать ревью кода, генерировать тесты для новых функций и даже исправлять простые баги до того, как код попадет в основную ветку. Использование JSONL-потоков дает прозрачность, необходимую для аудита, а поддержка MCP открывает путь к подключению корпоративных баз знаний и инструментов.

Для разработчиков в России и СНГ этот инструмент особенно актуален, так как Moonshot API предоставляет доступ к мощным моделям, которые могут быть интегрированы в локальные или гибридные облачные инфраструктуры. Возможность запуска агентов в изолированных окружениях (через uv) и контроль над контекстом (через сессии и рабочие директории) делают Kimi CLI надежным партнером для сложных задач разработки, где важна точность и воспроизводимость результатов.

Мы прошли путь от установки до создания агента, который сам себя тестирует. Следующий шаг — интеграция этого скрипта в ваши проекты, настройка триггеров для запуска при пул-реквестах и расширение функционала через MCP-серверы. Будущее программирования — за гибридными системами, где человек задает цель, а AI-агент, такой как Kimi, берет на себя рутину реализации и проверки.

Источник: MarkTechPost ↗