Kimi K2.7 Code 模型介绍、API 接口 & 代码示例

# TODO: 以下代码中的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net

curl --request POST 'https://wcode.net/api/gpt/v1/chat/completions' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer API_KEY' \
--data '{
    "model": "moonshotai/kimi-k2.7-code",
    "messages": [
        {
            "role": "user",
            "content": "你好"
        }
    ]
}'

import Foundation

let headers = [
  "Authorization": "Bearer API_KEY",     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
  "content-type": "application/json"
]
let parameters = [
  "model": "moonshotai/kimi-k2.7-code",
  "messages": [
    [
      "role": "user",
      "content": "你好"
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://wcode.net/api/gpt/v1/chat/completions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 60.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

var headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer API_KEY'     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
};
var request = http.Request('POST', Uri.parse('https://wcode.net/api/gpt/v1/chat/completions'));
request.body = json.encode({
  "model": "moonshotai/kimi-k2.7-code",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
});
request.headers.addAll(headers);

http.StreamedResponse response = await request.send();

if (response.statusCode == 200) {
  print(await response.stream.bytesToString());
}
else {
  print(response.reasonPhrase);
}

require 'uri'
require 'net/http'

url = URI("https://wcode.net/api/gpt/v1/chat/completions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer API_KEY'     # TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
request["content-type"] = 'application/json'
request.body = "{\"model\":\"moonshotai/kimi-k2.7-code\",\"messages\":[{\"role\":\"user\",\"content\":\"你好\"}]}"

response = http.request(request)
puts response.read_body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
  let url = "https://wcode.net/api/gpt/v1/chat/completions";

  let payload = json!({
    "model": "moonshotai/kimi-k2.7-code",
    "messages": (
      json!({
        "role": "user",
        "content": "你好"
      })
    )
  });

  let mut headers = reqwest::header::HeaderMap::new();
  headers.insert("Authorization", "Bearer API_KEY".parse().unwrap());     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
  headers.insert("content-type", "application/json".parse().unwrap());

  let client = reqwest::Client::new();
  let response = client.post(url)
    .headers(headers)
    .json(&payload)
    .send()
    .await;

  let results = response.unwrap()
    .json::<serde_json::Value>()
    .await
    .unwrap();

  dbg!(results);
}

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "https://wcode.net/api/gpt/v1/chat/completions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Authorization: Bearer API_KEY");    // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\"model\":\"moonshotai/kimi-k2.7-code\",\"messages\":[{\"role\":\"user\",\"content\":\"你好\"}]}");

CURLcode ret = curl_easy_perform(hnd);

package main

import (
  "fmt"
  "strings"
  "net/http"
  "io"
)

func main() {
  url := "https://wcode.net/api/gpt/v1/chat/completions"

  payload := strings.NewReader("{\"model\":\"moonshotai/kimi-k2.7-code\",\"messages\":[{\"role\":\"user\",\"content\":\"你好\"}]}")

  req, _ := http.NewRequest("POST", url, payload)

  req.Header.Add("Authorization", "Bearer API_KEY")     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
  req.Header.Add("content-type", "application/json")

  res, _ := http.DefaultClient.Do(req)

  defer res.Body.Close()
  body, _ := io.ReadAll(res.Body)

  fmt.Println(res)
  fmt.Println(string(body))
}

using System.Net.Http.Headers;


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "https://wcode.net/api/gpt/v1/chat/completions");

request.Headers.Add("Authorization", "Bearer API_KEY");     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net

request.Content = new StringContent("{\"model\":\"moonshotai/kimi-k2.7-code\",\"messages\":[{\"role\":\"user\",\"content\":\"你好\"}]}", null, "application/json");

var response = await client.SendAsync(request);

response.EnsureSuccessStatusCode();

Console.WriteLine(await response.Content.ReadAsStringAsync());

var client = new RestClient("https://wcode.net/api/gpt/v1/chat/completions");

var request = new RestRequest("", Method.Post);

request.AddHeader("Authorization", "Bearer API_KEY");     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net

request.AddHeader("content-type", "application/json");

request.AddParameter("application/json", "{\"model\":\"moonshotai/kimi-k2.7-code\",\"messages\":[{\"role\":\"user\",\"content\":\"你好\"}]}", ParameterType.RequestBody);

var response = client.Execute(request);

const axios = require('axios');

let data = JSON.stringify({
  "model": "moonshotai/kimi-k2.7-code",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
});

let config = {
  method: 'post',
  maxBodyLength: Infinity,
  url: 'https://wcode.net/api/gpt/v1/chat/completions',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer API_KEY'     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
  },
  data : data
};

axios.request(config).then((response) => {
  console.log(JSON.stringify(response.data));
}).catch((error) => {
  console.log(error);
});

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");

RequestBody body = RequestBody.create(mediaType, "{\"model\":\"moonshotai/kimi-k2.7-code\",\"messages\":[{\"role\":\"user\",\"content\":\"你好\"}]}");

Request request = new Request.Builder()
  .url("https://wcode.net/api/gpt/v1/chat/completions")
  .post(body)
  .addHeader("Authorization", "Bearer API_KEY")             // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

$client = new \GuzzleHttp\Client();

$headers = [
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer API_KEY',     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
];

$body = '{
  "model": "moonshotai/kimi-k2.7-code",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
}';

$request = new \GuzzleHttp\Psr7\Request('POST', 'https://wcode.net/api/gpt/v1/chat/completions', $headers, $body);

$response = $client->sendAsync($request)->wait();

echo $response->getBody();

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://wcode.net/api/gpt/v1/chat/completions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 5,
  CURLOPT_TIMEOUT => 300,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'model' => 'moonshotai/kimi-k2.7-code',
    'messages' => [
      [
        'role' => 'user',
        'content' => '你好'
      ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer API_KEY",     // TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
    "content-type: application/json",
  ],
]);

$response = curl_exec($curl);
$error = curl_error($curl);

curl_close($curl);

if ($error) {
  echo "cURL Error #:" . $error;
} else {
  echo $response;
}

import requests
import json

url = "https://wcode.net/api/gpt/v1/chat/completions"

payload = {
  "model": "moonshotai/kimi-k2.7-code",
  "messages": [
    {
      "role": "user",
      "content": "你好"
    }
  ]
}

headers = {
  "Authorization": "Bearer API_KEY",     # TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
  "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(json.dumps(response.json(), indent=4, ensure_ascii=False))

from openai import OpenAI

client = OpenAI(
  base_url="https://wcode.net/api/gpt/v1",
  api_key="API_KEY"                             # TODO: 这里的 API_KEY 需要替换，获取 API Key 入口：https://platform.wcode.net
)

completion = client.chat.completions.create(
  model="moonshotai/kimi-k2.7-code",
  messages=[
    {
      "role": "user",
      "content": "你好"
    }
  ]
)

print(completion.choices[0].message.content)

配置 Hermes Agent 使用 Kimi K2.7 Code 模型：

注意事项：以下配置中的 <API_KEY> 需要替换为从 https://platform.wcode.net 获取（创建）的 API Key

方式一：交互式配置

在命令行输入 hermes model，然后选择 Custom endpoint 选项，根据交互式命令引导，分别配置以下信息：

• API base URL：https://wcode.net/api/gpt/v1
• API Key：<API_KEY>
• Model：moonshotai/kimi-k2.7-code

方式二：手动配置

修改 config.yaml（通常位于~/.hermes/config.yaml）

model:
  default: "moonshotai/kimi-k2.7-code"
  provider: custom
  base_url: "https://wcode.net/api/gpt/v1"
  api_key: "<API_KEY>"
  context_length: 256000

配置完成后，就可以开始使用 Hermes Agent ~

配置 Roo Code 使用 Kimi K2.7 Code 模型：

注意事项：以下配置中的 <API_KEY> 需要替换为从 https://platform.wcode.net 获取（创建）的 API Key

• API Provider：OpenAI Compatible
• Base URL：https://wcode.net/api/gpt/v1
• API Key：<API_KEY>
• Model：moonshotai/kimi-k2.7-code

配置完成后，就可以开始使用 Roo Code ~

配置 Kilo Code 使用 Kimi K2.7 Code 模型：

注意事项：以下配置中的 <API_KEY> 需要替换为从 https://platform.wcode.net 获取（创建）的 API Key

选择 Use your own API key，然后配置以下信息：

• API Provider：OpenAI Compatible
• Base URL：https://wcode.net/api/gpt/v1
• API Key：<API_KEY>
• Model：moonshotai/kimi-k2.7-code

配置完成后，就可以开始使用 Kilo Code ~

配置 Cline 使用 Kimi K2.7 Code 模型：

注意事项：以下配置中的 <API_KEY> 需要替换为从 https://platform.wcode.net 获取（创建）的 API Key

• API Provider：OpenAI Compatible
• Base URL：https://wcode.net/api/gpt/v1
• API Key：<API_KEY>
• Model ID：moonshotai/kimi-k2.7-code

配置完成后，就可以开始使用 Cline ~

注：以下安装和配置过程以 Ubuntu Server 24.04 (root 用户) + Node 22 安装 OpenClaw 🦞 2026.3.8 为例

安装 🦞 OpenClaw（龙虾），步骤如下：

1. 命令行执行 npm install -g openclaw@latest
2. 命令行执行 openclaw onboard --install-daemon
3. I understand this is personal-by-default and shared/multi-user use requires lock-down. Continue? 选择 yes
4. Onboarding mode 选择 QuickStart
5. Model/auth provider 选择 Skip for now
6. Default model 选择 Keep current (default: ...)
7. Select channel (QuickStart) 选择 Skip for now
8. Web search 选择 Skip for now
9. Configure skills now? (recommended) 选择 No
10. Enable hooks? （这是一个多选，按空格键可选中选项）按空格键选中 📝 command-logger 和 💾 session-memory 这两个选项，然后按回车键进入下一步
11. (如有) How do you want to hatch your bot? 选择 Hatch in TUI (recommended)

配置 🦞 OpenClaw（龙虾）使用 Kimi K2.7 Code 模型：

注意事项：以下配置中的 <API_KEY> 需要替换为从 https://platform.wcode.net 获取（创建）的 API Key

推荐方式：修改 openclaw.json（通常位于~/.openclaw/openclaw.json）

找到openclaw.json的第一层级的models和agents属性（如果没有则在第一层级添加models和agents属性），改为如下配置：

{
  ...其他配置,

  "models": {
      "mode": "merge",
      "providers": {
          "wcode": {
              "baseUrl": "https://wcode.net/api/gpt/v1",
              "apiKey": "<API_KEY>",
              "api": "openai-completions",
              "models": [
                  {
                      "id": "moonshotai/kimi-k2.7-code",
                      "name": "Kimi K2.7 Code",
                      "reasoning": false,
                      "input": ["text"],
                      "contextWindow": 256000,
                      "maxTokens": 8192
                  }
              ]
          }
      }
  },
  "agents": {
      "defaults": {
         "model": {
             "primary": "wcode/moonshotai/kimi-k2.7-code"
         }
      }
  },

  ...其他配置
}

完成以上配置后，

1. 执行以下命令，即可通过命令行的方式开始对话：

openclaw tui

2. 执行以下命令，即可通过 Web 界面的方式开始对话：

openclaw dashboard

配置 OpenCode 使用 Kimi K2.7 Code 模型：

推荐方式：修改 opencode.json（通常位于~/.config/opencode/opencode.json）

注意事项：以下配置中的 <API_KEY> 需要替换为从 https://platform.wcode.net 获取的 API Key

配置如下：

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "wcode",
      "options": {
        "baseURL": "https://wcode.net/api/gpt/v1",
        "apiKey": "<API_KEY>"
      },
      "models": {
        "moonshotai/kimi-k2.7-code": {
          "name": "Kimi K2.7 Code"
        }
      }
    }
  }
}

完成以上配置后，执行以下命令，即可启动 OpenCode：

opencode

输入 /models，选择配置的 moonshotai/kimi-k2.7-code 模型并在 OpenCode 中使用。