Kimi

​

Quick start

import os
from openai import OpenAI

client = OpenAI(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
  model="kimi-k2.7-code",
  messages=[{"role": "user", "content": "Who are you?"}],
  stream=True,
)

reasoning_content = ""
answer_content = ""
is_answering = False
print("\n" + "=" * 20 + "Thinking Process" + "=" * 20 + "\n")

for chunk in completion:
  if chunk.choices:
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
      if not is_answering:
        print(delta.reasoning_content, end="", flush=True)
      reasoning_content += delta.reasoning_content
    if hasattr(delta, "content") and delta.content:
      if not is_answering:
        print("\n" + "=" * 20 + "Complete Response" + "=" * 20 + "\n")
        is_answering = True
      print(delta.content, end="", flush=True)
      answer_content += delta.content

import OpenAI from "openai";
import process from "process";

const openai = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
});

const stream = await openai.chat.completions.create({
  model: "kimi-k2.7-code",
  messages: [{role: "user", content: "Who are you?"}],
  stream: true,
});

let reasoningContent = "";
let answerContent = "";
let isAnswering = false;

for await (const chunk of stream) {
  if (chunk.choices && chunk.choices.length > 0) {
    const delta = chunk.choices[0].delta;
    if (delta.reasoning_content) {
      if (!isAnswering) {
        process.stdout.write(delta.reasoning_content);
      }
      reasoningContent += delta.reasoning_content;
    }
    if (delta.content) {
      if (!isAnswering) {
        console.log("\n" + "=".repeat(20) + "Complete Response" + "=".repeat(20) + "\n");
        isAnswering = true;
      }
      process.stdout.write(delta.content);
      answerContent += delta.content;
    }
  }
}

curl -X POST https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "kimi-k2.7-code",
  "messages": [
    {"role": "user", "content": "Who are you?"}
  ],
  "stream": true
}'

import os
import dashscope

dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"

response = dashscope.Generation.call(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  model="kimi-k2.7-code",
  messages=[{"role": "user", "content": "Who are you?"}],
  result_format="message",
  stream=True,
  incremental_output=True,
)

reasoning_content = ""
answer_content = ""
is_answering = False
print("\n" + "=" * 20 + "Thinking Process" + "=" * 20 + "\n")

for chunk in response:
  if chunk.status_code == 200:
    message = chunk.output.choices[0].message
    if hasattr(message, "reasoning_content") and message.reasoning_content:
      if not is_answering:
        print(message.reasoning_content, end="", flush=True)
      reasoning_content += message.reasoning_content
    if message.content:
      if not is_answering:
        print("\n" + "=" * 20 + "Complete Response" + "=" * 20 + "\n")
        is_answering = True
      print(message.content, end="", flush=True)
      answer_content += message.content

import java.util.Arrays;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.protocol.Protocol;
import io.reactivex.Flowable;

public class Main {
  public static void main(String[] args) {
    Generation gen = new Generation(Protocol.HTTP.getValue(), "https://dashscope-intl.aliyuncs.com/api/v1");
    Message userMsg = Message.builder()
        .role(Role.USER.getValue())
        .content("Who are you?")
        .build();
    GenerationParam param = GenerationParam.builder()
        .model("kimi-k2.7-code")
        .messages(Arrays.asList(userMsg))
        .resultFormat(GenerationParam.ResultFormat.MESSAGE)
        .incrementalOutput(true)
        .build();
    Flowable<GenerationResult> result = gen.streamCall(param);
    StringBuilder reasoningContent = new StringBuilder();
    StringBuilder answerContent = new StringBuilder();
    result.blockingForEach(chunk -> {
      String reasoning = chunk.getOutput().getChoices().get(0).getMessage().getReasoningContent();
      String content = chunk.getOutput().getChoices().get(0).getMessage().getContent();
      if (reasoning != null && !reasoning.isEmpty()) {
        reasoningContent.append(reasoning);
        System.out.print(reasoning);
      }
      if (content != null && !content.isEmpty()) {
        answerContent.append(content);
        System.out.print(content);
      }
    });
  }
}

curl -X POST https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/text-generation/generation \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-DashScope-SSE: enable" \
  -d '{
  "model": "kimi-k2.7-code",
  "input": {
    "messages": [
      {"role": "user", "content": "Who are you?"}
    ]
  },
  "parameters": {
    "result_format": "message",
    "incremental_output": true
  }
}'

import anthropic
import os

client = anthropic.Anthropic(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://dashscope-intl.aliyuncs.com/apps/anthropic",
)

message = client.messages.create(
  model="kimi-k3",
  max_tokens=1024,
  messages=[
    {"role": "user", "content": "Who are you?"}
  ],
  stream=True,
)

for event in message:
  if event.type == "content_block_delta":
    if hasattr(event.delta, "thinking"):
      print(event.delta.thinking, end="", flush=True)
    if hasattr(event.delta, "text"):
      print(event.delta.text, end="", flush=True)

curl -X POST https://dashscope-intl.aliyuncs.com/apps/anthropic/v1/messages \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "anthropic-version: 2023-06-01" \
-d '{
    "model": "kimi-k3",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": "Who are you?"
        }
    ]
}'

​

Dynamically loaded tools

​

Inject tool declarations in messages

• A system message carrying tools has the same status as an ordinary message: the tools become visible to the model starting from the position where that message appears in the messages list.
• Dynamically loaded tools coexist with the global tools declared in the request's top-level tools field; the model can see both kinds of tools at the same time.
• A dynamically injected tool declaration must be a complete tool definition; you cannot pass only a tool name or reference a globally declared tool.
• A system message carrying tools must not also carry a content field, or the request fails with a 400 error. When using the OpenAI SDK, you can pass the tools field through directly in messages.

import os
from openai import OpenAI

client = OpenAI(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
  model="kimi-k3",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Please calculate 23 * 47 for me."},
    # Dynamically load a tool: insert a system message carrying a tools field into the conversation
    {
      "role": "system",
      "tools": [
        {
          "type": "function",
          "function": {
            "name": "Calculator",
            "description": "Calculator; evaluates a single arithmetic expression only",
            "parameters": {
              "type": "object",
              "properties": {
                "expr": {
                  "type": "string",
                  "description": "Arithmetic expression supporting basic operations, exponentiation, logarithms, and trigonometric functions, in JavaScript syntax",
                }
              },
              "required": ["expr"],
            },
          },
        }
      ],
    },
  ],
)
print(completion.choices[0].message.tool_calls)

curl -X POST https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -d '{
  "model": "kimi-k3",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Please calculate 23 * 47 for me."},
    {
      "role": "system",
      "tools": [
        {
          "type": "function",
          "function": {
            "name": "Calculator",
            "description": "Calculator; evaluates a single arithmetic expression only",
            "parameters": {
              "type": "object",
              "properties": {
                "expr": {
                  "type": "string",
                  "description": "Arithmetic expression supporting basic operations, exponentiation, logarithms, and trigonometric functions, in JavaScript syntax"
                }
              },
              "required": ["expr"]
            }
          }
        }
      ]
    }
  ]
}'

​

On-demand loading combined with a search tool

1. At the start of the session, declare in the top-level tools only a search_tools tool implemented by your application backend (it returns matching tool names and summaries by keyword), plus a few core tools that may be used every turn.
2. Declare the searchable keywords (such as a tool catalog or domain tags) in the system prompt to guide the model to call search_tools first when it needs a tool. You can set tool_choice: "required" on the first request to force the model to search before answering, then restore tool_choice to "auto" after the search. Changing tool_choice does not break the prefix cache.
3. Based on the results returned by search_tools, the application dynamically inserts the complete declarations of the corresponding tools into messages through a system message carrying tools.
4. The model can then call these newly loaded tools directly in subsequent generation.

​

Notes

• Dynamic tool declarations take effect per request and are not remembered by the server. Whether to keep carrying them in the next request is up to the integrator: keep carrying them and the tools remain available (which also helps hit the prefix cache); stop carrying them and the declaration expires — if the tool is not declared elsewhere, the model cannot call it, and the prefix cache after the change point may miss.
• Appending a dynamic tool declaration at the end of messages does not affect the cache of the existing prefix; deleting or modifying earlier tool declarations may affect cache hits after the change point. Declaring global tools in the request's top-level tools field also does not affect cache hits.
• A system message carrying tools also consumes context length, so inject only the tools truly needed by the current conversation.
• Dynamic tool declarations use exactly the same format as global tools declarations, so integrators do not need to maintain two schemas.

​

Supported features

​

Parameter defaults

​

Models and billing

• kimi-k3: Kimi's most capable flagship model to date. It always reasons and uses preserved thinking (thinking-only mode). Supports text and image input (video input is not supported), conversation and agent tasks, and dynamic tool loading.
• kimi-k2.7-code: The most capable Kimi model for coding. It follows long-context instructions more reliably and achieves higher success rates on programming tasks. Supports text, image, and video input, thinking mode, conversation, and agent tasks.

​

Error codes