### Install Kimchi CLI

Source: https://docs.kimchi.dev/docs

Download and run the installation script for the Kimchi CLI. This script initiates an interactive setup wizard to configure your environment.

```bash
curl -fsSL https://github.com/getkimchi/kimchi/releases/latest/download/install.sh | bash

```

--------------------------------

### Install GSD OpenCode (1.x)

Source: https://docs.kimchi.dev/docs

Install the Get Shit Done (GSD) multi-agent system for OpenCode version 1.x. This command initiates the installation process.

```bash
npx gsd-opencode

```

--------------------------------

### Install GSD for OpenCode

Source: https://docs.kimchi.dev/docs/model-apis-overview

Install the GSD (Get Shit Done) orchestrator for OpenCode (GSD 1.x) using npx.

```bash
npx gsd-opencode
```

--------------------------------

### Manual RTK Installation

Source: https://docs.kimchi.dev/docs/kimchi-cli

Install RTK using a package manager. Kimchi will use the installed binary if it's on the system's PATH.

```bash
brew install rtk    # macOS / Linux
```

--------------------------------

### Start OpenCode and Test Configuration

Source: https://docs.kimchi.dev/docs/opencode

Navigates to a project directory and starts OpenCode. Includes a sample prompt to verify the configuration and model connections.

```bash
cd ~/your-project
opencode
```

```text
What security risks can you identify in this project?
```

--------------------------------

### Install OpenCode

Source: https://docs.kimchi.dev/docs/opencode

Installs OpenCode using a curl command. Ensure you have curl installed on your system.

```bash
curl -fsSL https://opencode.ai/install | bash
```

--------------------------------

### Install WSL on Windows

Source: https://docs.kimchi.dev/docs/coding-getting-started

Install the Windows Subsystem for Linux (WSL) on Windows. This is a prerequisite for running Kimchi on Windows.

```powershell
wsl --install
```

--------------------------------

### Kimchi Configuration Example (OpenCode)

Source: https://docs.kimchi.dev/docs/kimchi-cli

Example JSON configuration for the OpenCode provider within Kimchi, specifying base URL, API key, and models.

```json
{
  "provider": {
    "kimchi": {
      "name": "Kimchi",
      "options": {
        "baseURL": "https://llm.kimchi.dev/openai/v1",
        "apiKey": "your-api-key"
      },
      "models": {
        "kimi-k2.6": { "reasoning": false },
        "minimax-m2.7": { "reasoning": false }
      }
    }
  }
}
```

--------------------------------

### Install Skill from Git Repository

Source: https://docs.kimchi.dev/docs/coding-skills

Clones a skill repository directly into the Kimchi harness directory. This is useful for installing skills from remote sources.

```bash
git clone https://github.com/user/my-skill.git ~/.config/kimchi/harness/skills/my-skill
```

--------------------------------

### Install Kimchi with Homebrew

Source: https://docs.kimchi.dev/docs/coding-getting-started

Install Kimchi on macOS using the Homebrew package manager.

```bash
brew install getkimchi/tap/kimchi
```

--------------------------------

### Run Claude Code Setup Wizard

Source: https://docs.kimchi.dev/docs/claude-code-otel

Run this command if you haven't already set up your API key. This is the initial step before configuring tool settings.

```bash
kimchi setup
```

--------------------------------

### Example Parallel Phase Structure

Source: https://docs.kimchi.dev/docs/coding-ferment

Illustrates how phases can be grouped to run in parallel. Phases within the same group activate and execute concurrently, with subsequent sequential phases only starting after all parallel groups are complete.

```plaintext
Phase 3: "Backend API"    (parallel group 1)
Phase 4: "Frontend UI"    (parallel group 1)
Phase 5: "Deploy"         (sequential — runs after both complete)
```

--------------------------------

### Start Claude Code

Source: https://docs.kimchi.dev/docs/claude-code

Navigate to your project directory and start the Claude Code interactive prompt.

```bash
cd ~/your-project
claude
```

--------------------------------

### Skill Body Example

Source: https://docs.kimchi.dev/docs/coding-skills

Provides instructions for the agent when a skill is activated. It should be written like a concise runbook, with important information first and specific steps.

```markdown
# Lint Fix

When triggered, run the project's linter with auto-fix enabled.

## Steps

1. Detect the project type (check for `package.json`, `Cargo.toml`, `pyproject.toml`).
2. Run the appropriate lint command with auto-fix:
   - Node.js: `npx eslint . --fix` or `npx biome check --write`
   - Rust: `cargo clippy --fix --allow-dirty`
   - Python: `ruff check --fix .`
3. Report what changed.

```

--------------------------------

### Launch Kimchi with a Session Name

Source: https://docs.kimchi.dev/docs/coding-getting-started

Start Kimchi and assign a specific name to the session for easier identification.

```bash
kimchi --name "my task"
```

--------------------------------

### Start Claude Code Session

Source: https://docs.kimchi.dev/docs/claude-code-otel

Begin a Claude Code session after completing the setup. No additional configuration is needed to start data collection.

```bash
claude
```

--------------------------------

### Install Cline CLI

Source: https://docs.kimchi.dev/docs/cline

Install the Cline CLI globally using npm. Ensure you have Node.js 20 or higher installed.

```bash
npm install -g cline
```

--------------------------------

### Install GSD Standalone TUI (2.0)

Source: https://docs.kimchi.dev/docs

Install the Get Shit Done (GSD) multi-agent system version 2.0, which provides a standalone Text User Interface (TUI).

```bash
gsd config

```

--------------------------------

### Launch Kimchi in Debug Mode

Source: https://docs.kimchi.dev/docs/coding-getting-started

Start Kimchi with debug mode enabled for detailed logging.

```bash
kimchi --debug
```

--------------------------------

### Install Kimchi

Source: https://docs.kimchi.dev/docs/claude-code-otel

Install Kimchi using the provided curl command. This is a prerequisite for setting up Claude Code usage metrics.

```bash
curl -fsSL https://github.com/getkimchi/kimchi/releases/latest/download/install.sh | bash
```

--------------------------------

### List Installed Pi Packages

Source: https://docs.kimchi.dev/docs/kimchi-cli

Lists all currently installed Pi packages managed by Kimchi.

```bash
kimchi list
```

--------------------------------

### Install Pi Package Extension

Source: https://docs.kimchi.dev/docs/kimchi-cli

Installs a Pi package from a specified npm package name. The installed package will appear as a plugin resource and requires a restart to take effect.

```bash
kimchi install npm:<package-name>
```

--------------------------------

### Install mitmproxy using Homebrew

Source: https://docs.kimchi.dev/docs/model-apis-dashboard-token-usage

Install the mitmproxy tool on macOS using the Homebrew package manager. This is a prerequisite for inspecting API traffic.

```bash
brew install mitmproxy
```

--------------------------------

### Install Claude Code

Source: https://docs.kimchi.dev/docs/claude-code

Install the Claude Code CLI tool globally using npm. Ensure Node.js 18 or higher is installed.

```bash
npm install -g @anthropic-ai/claude-code
```

--------------------------------

### Run Test Client Pod

Source: https://docs.kimchi.dev/docs/hosted-deploy-custom-model

Launches an Alpine Linux pod with curl installed to test the deployed model API.

```bash
kubectl run test-client --rm -i --tty --image=alpine/curl -- /bin/sh
```

--------------------------------

### Project Rule File Loading Order

Source: https://docs.kimchi.dev/docs/coding-skills

Illustrates the ancestor-first loading order of configuration files, starting from the root directory and moving towards the current working directory. Rules from root are applied first, and subdirectory rules can override them.

```text
/                         ← checked first
├── CLAUDE.md             ← loaded (root-level rules)
├── projects/
│   └── my-app/
│       ├── AGENTS.md     ← loaded (project-level rules)
│       ├── AGENTS.local.md  ← appended (local overrides)
│       └── src/
│           └── ...       ← cwd: rules from / and /projects/my-app/ both apply
```

--------------------------------

### Install Skill Manually

Source: https://docs.kimchi.dev/docs/coding-skills

Copies a local skill directory into a scanned skill path. This is useful for installing skills that are already present on the local filesystem.

```bash
cp -r my-skill ~/.config/kimchi/harness/skills/my-skill
```

--------------------------------

### Install GSD Standalone TUI

Source: https://docs.kimchi.dev/docs/model-apis-overview

Install the GSD 2.0 standalone TUI (Text-based User Interface) by running the config command.

```bash
gsd config
```

--------------------------------

### Custom Skill Directory Configuration

Source: https://docs.kimchi.dev/docs/coding-skills

Example JSON configuration for adding custom skill directories to Kimchi. This file specifies paths where Kimchi should look for skills.

```json
{
  "skillPaths": [
    ".config/kimchi/harness/skills",
    ".claude/skills",
    "/absolute/path/to/shared-team-skills"
  ]
}
```

--------------------------------

### Example GCS Model Layout

Source: https://docs.kimchi.dev/docs/hosted-deploy-custom-model

Shows the typical file structure for a fine-tuned model stored in Google Cloud Storage.

```text
gs://my-ml-bucket/models/llama3-support-bot-v1/
├── model.safetensors
├── tokenizer.json
├── config.json
└── metadata.json
```

--------------------------------

### Skill Frontmatter Example

Source: https://docs.kimchi.dev/docs/coding-skills

Defines metadata for a skill, including its name, description, triggers, category, state, and version. The name must follow specific validation rules.

```yaml
---
name: lint-fix
description: Run the project linter and auto-fix all fixable issues
triggers:
  - user types "/lint-fix"
  - user asks to fix lint errors
category: workflow
---

```

--------------------------------

### Start mitmweb for Traffic Inspection

Source: https://docs.kimchi.dev/docs/model-apis-dashboard-token-usage

Start the mitmweb interface to inspect HTTP/HTTPS traffic. This command will open a web UI at http://localhost:8081.

```bash
mitmweb --listen-port 8888
```

--------------------------------

### Move Kimchi CLI to PATH

Source: https://docs.kimchi.dev/docs/kimchi-cli

Installs the Kimchi CLI executable to a system-wide location, making it accessible from any terminal.

```shell
sudo mv kimchi /usr/local/bin/
```

--------------------------------

### Check Kimchi Version

Source: https://docs.kimchi.dev/docs/coding-acp

Verify the currently installed version of the Kimchi harness. This is useful for confirming successful updates or checking compatibility.

```bash
kimchi --version
```

--------------------------------

### Generate Fish Shell Completion for Kimchi

Source: https://docs.kimchi.dev/docs/kimchi-cli

Generates and installs fish shell completion scripts for Kimchi.

```fish
kimchi completion fish > ~/.config/fish/completions/kimchi.fish
```

--------------------------------

### Example Claude Code Prompt

Source: https://docs.kimchi.dev/docs/claude-code

Interact with Claude Code by asking a question in the prompt. If the response streams back, the connection to Kimchi is successful.

```bash
> Explain what this project does in one paragraph
```

--------------------------------

### Get Full Ferment Progress View

Source: https://docs.kimchi.dev/docs/coding-ferment-quickstart

Open a detailed, interactive view of the Ferment project's progress, including grades and available actions.

```bash
/ferment progress

```

--------------------------------

### Get Supported LLM Providers

Source: https://docs.kimchi.dev/docs/supported-providers

Use this endpoint to retrieve a list of all supported LLM providers and their models. This includes details on pricing, supported modalities, and deployment options.

```bash
curl --request GET \
     --url https://api.cast.ai/v1/llm/openai/supported-providers \
     --header 'X-API-Key: $CASTAI_API_KEY' \
     --header 'accept: application/json'
```

--------------------------------

### Check OTel Variables in Settings

Source: https://docs.kimchi.dev/docs/claude-code-otel

Use this command to inspect the OpenTelemetry variables within your Claude Code settings file. Ensure this command is run after `kimchi setup` and `kimchi setup-tools` have completed.

```bash
cat ~/.claude/settings.json | grep OTEL
```

--------------------------------

### Disable Automatic RTK Installation

Source: https://docs.kimchi.dev/docs/kimchi-cli

Prevent Kimchi from automatically installing RTK on session start by setting an environment variable before launching.

```bash
KIMCHI_RTK_AUTO_INSTALL=0 kimchi
```

--------------------------------

### Launch Kimchi Agent

Source: https://docs.kimchi.dev/docs/coding-getting-started

Run this command to launch the full Kimchi coding harness. It will prompt for authentication if no API key or provider is configured.

```bash
kimchi
```

--------------------------------

### Verify Claude Code Installation

Source: https://docs.kimchi.dev/docs/claude-code

Check the installed version of Claude Code to ensure the installation was successful.

```bash
claude --version
```

--------------------------------

### Create OpenCode Configuration File

Source: https://docs.kimchi.dev/docs/opencode

Creates an empty JSON configuration file for OpenCode.

```bash
touch ~/.config/opencode/opencode.json
```

--------------------------------

### Create OpenCode Configuration Directory

Source: https://docs.kimchi.dev/docs/opencode

Creates the necessary directory for OpenCode's configuration files if it does not already exist.

```bash
mkdir -p ~/.config/opencode
```

--------------------------------

### Create Skill Directory

Source: https://docs.kimchi.dev/docs/coding-skills

Use this command to create a new directory for your skill within the Kimchi harness skills path.

```bash
mkdir -p ~/.config/kimchi/harness/skills/my-skill
```

--------------------------------

### Create Per-Project Kimchi Configuration

Source: https://docs.kimchi.dev/docs/kimchi-cli

Creates a `.kimchi/config.json` file in the project root to override global Kimchi settings.

```shell
mkdir -p .kimchi
cat > .kimchi/config.json <<'EOF'
{
  "apiKey": "project-specific-key",
  "llmEndpoint": "https://custom-endpoint.example.com",
  "skillPaths": ["/project/skills"],
  "mcpSearch": {
    "strategy": "bm25"
  }
}
EOF
```

--------------------------------

### Enable Experimental Features in Kimchi

Source: https://docs.kimchi.dev/docs/coding-getting-started

Launch Kimchi with experimental features enabled.

```bash
kimchi --enable-experimental-features
```

--------------------------------

### Make Kimchi CLI Executable

Source: https://docs.kimchi.dev/docs/kimchi-cli

Sets execute permissions for the downloaded Kimchi CLI binary.

```shell
chmod +x kimchi
```

--------------------------------

### Add Supporting Files to Skill

Source: https://docs.kimchi.dev/docs/coding-skills

Use these commands to create subdirectories and copy supporting files, such as API specifications, into your skill's directory.

```bash
mkdir -p ~/.config/kimchi/harness/skills/my-skill/references
cp api-spec.md ~/.config/kimchi/harness/skills/my-skill/references/
```

--------------------------------

### Make First Request with cURL

Source: https://docs.kimchi.dev/docs/model-apis-overview

Verify your Kimchi connection by making a raw cURL call to the chat completions endpoint. This demonstrates the expected request format and headers.

```bash
curl https://llm.kimchi.dev/openai/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer $CASTAI_API_KEY' \
  -X POST -d '{
    "model": "kimi-k2.5",
    "messages": [
      {
        "role": "user",
        "content": "Explain what a Kubernetes DaemonSet does in one sentence."
      }
    ]
  }'
```

--------------------------------

### Launch Continue CLI with Custom Configuration (macOS/Linux)

Source: https://docs.kimchi.dev/docs/continue

Use this command to launch the Continue CLI with a specific configuration file. Ensure the path to your `config.yaml` is correct.

```bash
cn --config ~/.continue/config.yaml

```

--------------------------------

### Launch Kimchi in Plan Mode

Source: https://docs.kimchi.dev/docs/coding-getting-started

Launch Kimchi in read-only planning mode to explore codebases and generate structured plans without execution.

```bash
kimchi --plan
```

--------------------------------

### Node.js Lint Fix Command

Source: https://docs.kimchi.dev/docs/coding-skills

Example command to run ESLint with auto-fix for Node.js projects.

```bash
npx eslint . --fix
```

--------------------------------

### Open OpenCode Configuration File with Nano

Source: https://docs.kimchi.dev/docs/opencode

Opens the OpenCode JSON configuration file using the nano text editor for manual editing.

```bash
nano ~/.config/opencode/opencode.json
```

--------------------------------

### Generate Zsh Shell Completion for Kimchi

Source: https://docs.kimchi.dev/docs/kimchi-cli

Generates and installs zsh shell completion scripts for Kimchi.

```zsh
kimchi completion zsh > "${fpath[1]}/_kimchi"
```

--------------------------------

### OpenCode Configuration with Kimchi Models

Source: https://docs.kimchi.dev/docs/opencode

This JSON configuration sets up OpenCode to use Kimi K2.6 for planning, Kimi K2.5 for image analysis, and MiniMax M2.7 for code execution via Kimchi's serverless endpoints. Replace $KIMCHI_API_KEY with your actual API key.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "permission": {
    "*": "ask"
  },
  "compaction": {
    "auto": true,
    "prune": true
  },
  "model": "kimchi/minimax-m2.7",
  "mode": {
    "plan": {
      "model": "kimchi/kimi-k2.6"
    },
    "build": {
      "model": "kimchi/minimax-m2.7"
    }
  },
  "provider": {
    "kimchi": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Kimchi",
      "options": {
        "baseURL": "https://llm.kimchi.dev/openai/v1",
        "litellmProxy": true,
        "apiKey": "$KIMCHI_API_KEY"
      },
      "models": {
        "kimi-k2.6": {
          "id": "kimi-k2.6",
          "tool_call": true,
          "reasoning": false,
          "modalities": {
            "input": [
              "text",
              "image"
            ],
            "output": [
              "text"
            ]
          },
          "limit": {
            "context": 262144,
            "output": 32768
          }
        },
        "kimi-k2.5": {
          "id": "kimi-k2.5",
          "tool_call": true,
          "reasoning": false,
          "modalities": {
            "input": [
              "text",
              "image"
            ],
            "output": [
              "text"
            ]
          },
          "limit": {
            "context": 262144,
            "output": 32768
          }
        },
        "minimax-m2.7": {
          "name": "minimax-m2.7",
          "tool_call": true,
          "reasoning": false,
          "limit": {
            "context": 196608,
            "output": 32768
          }
        }
      }
    }
  }
}
```

--------------------------------

### Generate Bash Shell Completion for Kimchi

Source: https://docs.kimchi.dev/docs/kimchi-cli

Generates and installs bash shell completion scripts for Kimchi.

```bash
kimchi completion bash > /etc/bash_completion.d/kimchi
```

--------------------------------

### Create SKILL.md File

Source: https://docs.kimchi.dev/docs/coding-skills

This command creates a SKILL.md file with essential frontmatter and markdown content for a new skill.

```bash
cat > ~/.config/kimchi/harness/skills/my-skill/SKILL.md <<'EOF'
---
name: my-skill
description: Describe what this skill does and when to use it
---
# My Skill

Instructions for the agent go here.
EOF
```

--------------------------------

### Update WSL packages

Source: https://docs.kimchi.dev/docs/coding-getting-started

After installing WSL, update your system's packages within the WSL environment.

```bash
sudo apt-get update
```

--------------------------------

### Launch Kimchi in Single-Model Mode

Source: https://docs.kimchi.dev/docs/coding-getting-started

Specify a particular model to use for fast, direct code output.

```bash
kimchi --model <provider>/<id>
```

--------------------------------

### Log in from within Kimchi Harness

Source: https://docs.kimchi.dev/docs/kimchi-cli

Initiates the login process from within the Kimchi harness, presenting authentication options.

```bash
/login
```

--------------------------------

### Manage Kimchi Tips

Source: https://docs.kimchi.dev/docs/kimchi-cli

Control the display of contextual tips within the Kimchi editor. Preferences are saved to the global config file.

```bash
/tips              # show all available tips
/tips disable      # hide the tips widget
/tips enable       # show the tips widget again
```

--------------------------------

### Get Supported Providers

Source: https://docs.kimchi.dev/docs/supported-providers

Retrieves a list of all supported LLM providers, their available models, specifications, pricing, and deployment options.

```APIDOC
## GET /v1/llm/providers

### Description
Retrieves a comprehensive list of supported LLM providers, including their model catalogs, detailed specifications, pricing information, supported modalities, and deployment options.

### Method
GET

### Endpoint
/v1/llm/providers

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```bash
curl --request GET \
     --url https://api.cast.ai/v1/llm/providers \
     --header 'X-API-Key: $CASTAI_API_KEY' \
     --header 'accept: application/json'
```

### Response
#### Success Response (200)
- **supportedProviders** (array) - A list of supported LLM providers.
  - **provider** (string) - The identifier for the LLM provider.
  - **models** (array) - A list of models offered by the provider.
    - **name** (string) - The name of the model.
    - **maxInputTokens** (integer) - The maximum number of input tokens supported by the model.
    - **promptPricePerMilTokens** (string) - The price per million tokens for prompts.
    - **completionPricePerMilTokens** (string) - The price per million tokens for completions.
    - **modalities** (array) - The modalities supported by the model (e.g., "text", "image").
    - **type** (string) - The type of the model (e.g., "chat").
  - **pricingUrl** (string) - A URL to the provider's pricing page.
  - **websiteUrl** (string) - A URL to the provider's website.
  - **rateLimitsPerModel** (boolean) - Indicates if rate limits are applied per model.

#### Response Example
```json
{
  "supportedProviders": [
    {
      "provider": "openai",
      "models": [
        {
          "name": "gpt-4o-2024-05-13",
          "maxInputTokens": 128000,
          "promptPricePerMilTokens": "5",
          "completionPricePerMilTokens": "15",
          "modalities": ["text", "image"],
          "type": "chat"
        }
      ],
      "pricingUrl": "https://openai.com/pricing",
      "websiteUrl": "https://openai.com",
      "rateLimitsPerModel": true
    }
  ]
}
```
```

--------------------------------

### Update Kimchi Harness

Source: https://docs.kimchi.dev/docs/coding-acp

Ensure you have the latest version of the Kimchi harness installed. This command updates the harness to the latest available version.

```bash
kimchi update
```

--------------------------------

### Retry-After Header Example

Source: https://docs.kimchi.dev/docs/model-apis-rate-limits

The API response includes a 'Retry-After' header specifying the number of seconds to wait before making another request.

```text
Retry-After: 5
```

--------------------------------

### Basic Skill File Structure

Source: https://docs.kimchi.dev/docs/coding-skills

Illustrates the fundamental structure of a Kimchi skill file, including YAML frontmatter for metadata and a markdown body for instructions.

```markdown
---
name: my-skill
description: What this skill does and when to use it
---
# My Skill

Step-by-step instructions for the agent.
```

--------------------------------

### Stuck Loop Detection Message

Source: https://docs.kimchi.dev/docs/coding-ferment-reference

This message appears when a step is repeatedly started without completion, indicating a potential issue and prompting for recovery.

```text
⚠ Stuck loop detected: step 2 "Implement collision detection" has been started
  3 times without completing. Should we retry with a revised approach, skip
  this step, or pause the ferment?
```

--------------------------------

### Manage Kimchi Resources via CLI

Source: https://docs.kimchi.dev/docs/kimchi-cli

Control Kimchi resources like hooks, tools, and extensions using command-line arguments. Available actions include listing, enabling, disabling, and resetting resources.

```bash
kimchi resources list                        # show all resources and their status
kimchi resources enable <resource-id>        # enable a resource
kimchi resources disable <resource-id>       # disable a resource
kimchi resources reset <resource-id>         # reset to default
```

--------------------------------

### Launch Kimchi in YOLO Mode

Source: https://docs.kimchi.dev/docs/coding-getting-started

Use this mode with caution, as it grants all permissions to the harness.

```bash
kimchi --yolo
```

--------------------------------

### Get Deployed Model Pods

Source: https://docs.kimchi.dev/docs/hosted-model-deployments

Check the status of deployed model pods in the `castai-llms` namespace. This command helps monitor the deployment progress.

```shell
kubectl get pod -n castai-llms
```

--------------------------------

### Launch Continue CLI with Custom Configuration (Windows)

Source: https://docs.kimchi.dev/docs/continue

Use this command to launch the Continue CLI with a specific configuration file on Windows. Ensure the path to your `config.yaml` is correct.

```powershell
cn --config %USERPROFILE%\.continue\config.yaml

```

--------------------------------

### Continue Configuration for Kimchi LLMs

Source: https://docs.kimchi.dev/docs/continue

This YAML configuration file sets up Continue to use Kimchi's OpenAI-compatible API. Replace 'YOUR_KIMCHI_API_KEY' with your actual API key. The `model_defaults` anchor simplifies the configuration by avoiding repetition.

```yaml
name: Kimchi Config
version: 1.0.0
schema: v1
model_defaults: &model_defaults
  provider: "openai"
  apiBase: "https://llm.kimchi.dev/openai/v1"
  apiKey: "YOUR_KIMCHI_API_KEY"
models:
  - name: "kimi-k2.6"
    model: "kimi-k2.6"
    <<: *model_defaults
  - name: "kimi-k2.5"
    model: "kimi-k2.5"
    <<: *model_defaults
  - name: "minimax-m2.7"
    model: "minimax-m2.7"
    <<: *model_defaults

```

--------------------------------

### Manage Kimchi Resources

Source: https://docs.kimchi.dev/docs/coding-getting-started

List available resources such as hooks, tools, extensions, and plugins within Kimchi.

```bash
kimchi resources list
```

--------------------------------

### Verify OpenCode Configuration Directory

Source: https://docs.kimchi.dev/docs/opencode

Lists the contents of the OpenCode configuration directory to verify the configuration file exists.

```bash
ls ~/.config/opencode
```

--------------------------------

### Example Decisions

Source: https://docs.kimchi.dev/docs/coding-ferment

Architectural and design choices captured by the planner, providing context for future phases. Decisions include the technology used and key implementation strategies.

```plaintext
D001: Use Canvas API — better performance than DOM for grid rendering
D002: Single game loop at 60fps — simpler than event-driven approach
```

--------------------------------

### Start Cline Interactive Mode

Source: https://docs.kimchi.dev/docs/cline

Launch Cline in interactive mode to use its full terminal interface. Navigate tasks, review plans, and adjust settings within the session.

```bash
cline
```

--------------------------------

### CI/CD Workflow with Cline and Kimchi

Source: https://docs.kimchi.dev/docs/cline

Set up Cline in a CI pipeline by authenticating with Kimchi credentials and then using headless mode for automated code review on pull requests.

```bash
cline auth -p openai -k $KIMCHI_API_KEY -b https://llm.kimchi.dev/openai/v1 -m minimax-m2.7
git diff origin/main | cline -y "Review these changes for bugs or regressions"
```

--------------------------------

### Example Memories

Source: https://docs.kimchi.dev/docs/coding-ferment

Persistent knowledge including conventions, potential issues (gotchas), and common patterns. These are automatically injected into subsequent phases to maintain context and avoid repeating information.

```plaintext
M001 [gotcha]: requestAnimationFrame drops frames if loop takes >16ms
M002 [convention]: All piece coordinates are relative to their bounding box
M003 [pattern]: Use Uint8Array for grid — faster collision detection
```

--------------------------------

### Set Environment Variables for GUI Apps (macOS)

Source: https://docs.kimchi.dev/docs/claude-code

On macOS, use launchctl to set environment variables so they are visible to GUI applications like IDEs launched from the Dock or Start menu.

```bash
launchctl setenv ANTHROPIC_BASE_URL https://llm.kimchi.dev/anthropic
```