AI 助理
备案控制台
首页 大模型服务平台百炼（测试） 开发参考 对话 Kimi

Kimi

更新时间: 2025-08-14 20:04:50

本文介绍了在阿里云百炼平台通过API调用Kimi系列模型的方法。

模型列表和计费

Kimi 系列模型是由月之暗面公司（Moonshot AI）推出的大语言模型。

Kimi K2 是混合专家（MoE）语言模型，拥有1 万亿总参数和 320 亿激活参数 。Kimi K2 在前沿知识、推理和编码任务中表现出卓越性能，同时针对 Agent 能力进行了精心优化。

模型名称

上下文长度

输入成本

输出成本

免费额度

查看剩余额度

（Token数）

（每千Token）

Moonshot-Kimi-K2-Instruct

131,072

0.004元

0.016元

100万Token

有效期：百炼开通后180天内

模型不具备深度思考能力。
暂时不支持工具调用、结构化输出、前缀续写、上下文缓存。
关于模型限流，请参见限流。

快速开始

API 使用前提：已获取API Key并完成配置API Key到环境变量。如果通过SDK调用，需要安装 OpenAI 或 DashScope SDK。

OpenAI兼容

您可以通过 OpenAI SDK 或 OpenAI 兼容的HTTP方式快速体验 Kimi 模型。

Python

示例代码

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),  
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

completion = client.chat.completions.create(
    model="Moonshot-Kimi-K2-Instruct",
    messages=[
        {'role': 'user', 'content': '你是谁'}
    ]
)

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

返回结果

我是Kimi，你的智能伙伴和好朋友。我来自月之暗面科技有限公司，擅长中文和英文，会用有趣、准确、温暖的方式和你聊天。有什么我可以帮你的吗？

Node.js

示例代码

import OpenAI from "openai";

const openai = new OpenAI(
    {
        // 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
    }
);
const completion = await openai.chat.completions.create({
    model: "Moonshot-Kimi-K2-Instruct",
    messages: [
        { role: "user", content: "你是谁" }
    ],
});

console.log(completion.choices[0].message.content)

返回结果

我是Kimi，由月之暗面科技有限公司训练的大语言模型。

HTTP

示例代码

curl

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "Moonshot-Kimi-K2-Instruct",
    "messages": [
        {
            "role": "user", 
            "content": "你是谁"
        }
    ]
}'

返回结果

{
    "choices": [
        {
            "message": {
                "content": "我是Kimi，一个由月之暗面科技有限公司训练的大语言模型。我的知识截止到2025年4月，擅长用自然流畅的语言和你互动交流。很高兴认识你！",
                "role": "assistant"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 17,
        "completion_tokens": 36,
        "total_tokens": 53
    },
    "created": 1752659072,
    "system_fingerprint": null,
    "model": "Moonshot-Kimi-K2-Instruct",
    "id": "chatcmpl-4bfeb502-90ec-9a2b-8d51-66a676c5fb67"
}

DashScope

您可以通过 DashScope SDK 或 HTTP 方式快速体验 Kimi 模型。

Python

示例代码

import os
import dashscope

messages = [
    {'role': 'user', 'content': '你是谁？'}
]

response = dashscope.Generation.call(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="Moonshot-Kimi-K2-Instruct",
    messages=messages,
    # result_format参数不可以设置为"text"。
    result_format='message'
)

print(response.output.choices[0].message.content)

返回结果

我是Kimi，由月之暗面科技有限公司训练的大语言模型。我的知识截止到2025年4月，擅长用自然流畅的语言和你互动交流。有什么可以帮你的吗？

Java

示例代码

import java.util.Arrays;
import java.lang.System;
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.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;

public class Main {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        Generation gen = new Generation();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("你是谁？")
                .build();
        GenerationParam param = GenerationParam.builder()
                // 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("Moonshot-Kimi-K2-Instruct")
                .messages(Arrays.asList(userMsg))
                // 不可以设置为"text"
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            // 使用日志框架记录异常信息
            System.err.println("An error occurred while calling the generation service: " + e.getMessage());
        }
        System.exit(0);
    }
}

返回结果

我是Kimi，由月之暗面科技有限公司训练的大语言模型。我的知识截止于2025年4月，擅长用自然流畅的语言和你互动交流。有什么可以帮你的吗？

HTTP

示例代码

curl

curl -X POST "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "Moonshot-Kimi-K2-Instruct",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

返回结果

{
    "output": {
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "role": "assistant",
                    "content": "我是Kimi，一个由月之暗面科技有限公司训练的大语言模型，知识截止于2025年4月。很高兴认识你！"
                }
            }
        ]
    },
    "usage": {
        "total_tokens": 46,
        "output_tokens": 28,
        "input_tokens": 18
    },
    "request_id": "9c8156f8-3e5b-9b84-8776-d88a8c615bdf"
}

多轮对话

阿里云百炼提供的 Kimi API 默认不会记录您的历史对话信息。多轮对话功能可以让大模型“拥有记忆”，满足如追问、信息采集等需要连续交流的场景。

OpenAI兼容

您可以通过 OpenAI SDK 或 OpenAI 兼容的 HTTP 方式使用多轮对话功能。

Python

示例代码

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),  
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 通过 messages 数组实现上下文管理
messages = [{"role": "user", "content": "你好"}]
completion = client.chat.completions.create(
    model="Moonshot-Kimi-K2-Instruct", 
    messages=messages
)

print("=" * 20 + "第一轮对话" + "=" * 20)
print(completion.choices[0].message.content)

messages.append({"role": "assistant", "content": completion.choices[0].message.content})
messages.append({"role": "user", "content": "你是谁"})
print("=" * 20 + "第二轮对话" + "=" * 20)
completion = client.chat.completions.create(
    model="Moonshot-Kimi-K2-Instruct", 
    messages=messages
)
print(completion.choices[0].message.content)

返回结果

====================第一轮对话====================
你好！很高兴见到你，有什么可以帮到你的吗？
====================第二轮对话====================
我是 Kimi，一个由月之暗面科技有限公司训练的大语言模型，很高兴认识你哦～

Node.js

示例代码

import OpenAI from "openai";
import * as readline from 'readline';

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

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let messages = [];

async function chat() {
    while (true) {
        const userInput = await new Promise(resolve => {
            rl.question('用户：', resolve);
        });

        if (userInput.toLowerCase() === '退出') {
            break;
        }

        messages.push({ role: "user", content: userInput });

        try {
            const completion = await openai.chat.completions.create({
                model: "Moonshot-Kimi-K2-Instruct",
                messages: messages
            });

            // 使用纯文本符号分隔不同区域
            console.log('\n===== 用户输入 =====');
            console.log(userInput);
            
            console.log('\n===== 助手回复 =====');
            const aiResponse = completion.choices[0].message.content;
            console.log(aiResponse);
            
            console.log('\n====================\n');
            
            messages.push({ role: "assistant", content: aiResponse });
        } catch (error) {
            console.error('发生错误：', error);
            break;
        }
    }
    rl.close();
}

console.log('请输入内容（输入"退出"结束对话）');
chat();

HTTP

示例代码

curl

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "Moonshot-Kimi-K2-Instruct",
    "messages": [
        {
            "role": "user", 
            "content": "你好"
        },
        {
            "role": "assistant",
            "content": "你好！很高兴见到你，有什么我可以帮忙的吗？"
        },
        {
            "role": "user",
            "content": "你是谁？"
        }
    ]
}'

返回结果

{
    "choices": [
        {
            "message": {
                "content": "你好！我是 **Kimi**，一个由 **月之暗面科技有限公司（Moonshot AI）** 训练的大语言模型。我的知识截止时间是 **2025年4月**，可以帮你解答各种问题、写作、翻译、总结信息，或者陪你聊聊天。有什么我可以为你做的吗？",
                "role": "assistant"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 38,
        "completion_tokens": 60,
        "total_tokens": 98
    },
    "created": 1752659632,
    "system_fingerprint": null,
    "model": "Moonshot-Kimi-K2-Instruct",
    "id": "chatcmpl-ac60a15a-15b6-93b3-b5d0-f25c7e22d0d3"
}

DashScope

您可以通过 DashScope SDK 或 HTTP 方式使用多轮对话功能。

Python

示例代码

import os
import dashscope

# 通过 messages 数组实现上下文管理
messages = [
    {'role': 'user', 'content': '你好'}
]

response = dashscope.Generation.call(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="Moonshot-Kimi-K2-Instruct",
    messages=messages,
    result_format='message'
)

print("=" * 20 + "第一轮对话" + "=" * 20)
print(response.output.choices[0].message.content)

messages.append({'role': 'assistant', 'content': response.output.choices[0].message.content})
messages.append({'role': 'user', 'content': '你是谁'})

print("=" * 20 + "第二轮对话" + "=" * 20)
response = dashscope.Generation.call(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="Moonshot-Kimi-K2-Instruct",
    messages=messages,
    # result_format参数不可以设置为"text"。
    result_format='message'
)
print(response.output.choices[0].message.content)

返回结果

====================第一轮对话====================
你好！很高兴见到你。有什么我可以帮你的吗？
====================第二轮对话====================
你好！我是 Kimi，一个由月之暗面科技有限公司（Moonshot AI）训练的大语言模型。我的知识截止于 2025 年 4 月，擅长用自然流畅的语言和你互动交流。很高兴为你提供帮助！

Java

示例代码

// dashscope SDK的版本 >= 2.18.2
import java.util.Arrays;
import java.lang.System;
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.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.JsonUtils;

public class Main {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        Generation gen = new Generation();
        Message userMsg1 = Message.builder()
                .role(Role.USER.getValue())
                .content("你好")
                .build();
        Message AssistantMsg = Message.builder()
                .role(Role.ASSISTANT.getValue())
                .content("你好！很高兴见到你，有什么我可以帮忙的吗？")
                .build();
        Message UserMsg2 = Message.builder()
                .role(Role.USER.getValue())
                .content("你是谁")
                .build();
        GenerationParam param = GenerationParam.builder()
                // 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("Moonshot-Kimi-K2-Instruct")
                .messages(Arrays.asList(userMsg1,AssistantMsg,UserMsg2))
                // 不可以设置为"text"
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println("回复内容：");
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            // 使用日志框架记录异常信息
            System.err.println("An error occurred while calling the generation service: " + e.getMessage());
        }
        System.exit(0);
    }
}

返回结果

回复内容：
我是 Kimi，由月之暗面科技有限公司训练的大语言模型。很高兴为你服务！

HTTP

示例代码

curl

curl -X POST "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "Moonshot-Kimi-K2-Instruct",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "你好"
            },
            {
                "role": "assistant",
                "content": "你好！很高兴见到你，有什么我可以帮忙的吗？"
            },
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

返回结果

{
    "output": {
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "role": "assistant",
                    "content": "我是 Kimi，由月之暗面科技有限公司训练的大语言模型。很高兴认识你！"
                }
            }
        ]
    },
    "usage": {
        "total_tokens": 56,
        "output_tokens": 18,
        "input_tokens": 38
    },
    "request_id": "4ab5af3b-d5c0-98df-a0a7-ddd695dce0cb"
}

流式输出

用流式输出的方式调用 Kimi API，能够实时返回中间结果，减少用户的阅读等待时间，并降低请求的超时风险。

OpenAI兼容

Python

示例代码

from openai import OpenAI
import os

# 初始化OpenAI客户端
client = OpenAI(
    # 如果没有配置环境变量，请用阿里云百炼API Key替换：api_key="sk-xxx"
    api_key = os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

answer_content = ""     # 定义完整回复

# 创建聊天完成请求
completion = client.chat.completions.create(
    model="Moonshot-Kimi-K2-Instruct",
    messages=[
        {"role": "user", "content": "9.9和9.11谁大"}
    ],
    stream=True,
    # 解除以下注释会在最后一个chunk返回Token使用量
    # stream_options={
    #     "include_usage": True
    # }
)

for chunk in completion:
    # 如果chunk.choices为空，则打印usage
    if not chunk.choices:
        print("\nUsage:")
        print(chunk.usage)
    else:
        delta = chunk.choices[0].delta
        # 打印回复过程
        print(delta.content, end='', flush=True)
        answer_content += delta.content

# print("=" * 20 + "完整回复" + "=" * 20 + "\n")
# print(answer_content)

返回结果

### 第一步：理解题目

首先，我需要明确题目在问什么。题目给出了两个数字：9.9和9.11，问哪一个更大。看起来是在比较两个小数的大小。

### 第二步：小数的结构

...

### 第六步：可能的误区

有时候，人们可能会忽略小数点后的数字位数，误以为 9.11 比 9.9 大，因为 11 看起来比 9 大。但这是错误的，因为 0.11 < 0.9。

### 第七步：总结

通过以上步骤，可以确认：

**9.9 比 9.11 大。**

Node.js

示例代码

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

// 初始化 openai 客户端
const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY, // 从环境变量读取
    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1'
});

let answerContent = '';

async function main() {
    try {
        const stream = await openai.chat.completions.create({
            model: 'Moonshot-Kimi-K2-Instruct',
            messages: [{ role: 'user', content: '9.9和9.11谁大' }],
            stream: true
        });

        for await (const chunk of stream) {
            if (!chunk.choices?.length) {
                console.log('\nUsage:');
                console.log(chunk.usage);
                continue;
            }
            const delta = chunk.choices[0].delta;
            // 处理正式回复
            if (delta.content) {
                process.stdout.write(delta.content);
                answerContent += delta.content;
            }
        }
    } catch (error) {
        console.error('Error:', error);
    }
}
main();

返回结果

### 第一步：理解题目

首先，我需要明确题目在问什么。题目给出了两个数字：9.9和9.11，问哪一个更大。看起来是在比较两个小数的大小。

### 第二步：小数的结构

...

### 第六步：可能的误区

有时候，人们可能会忽略小数点后的数字位数，误以为 9.11 比 9.9 大，因为 11 看起来比 9 大。但这是错误的，因为 0.11 < 0.9。

### 第七步：总结

通过以上步骤，可以确认：

**9.9 比 9.11 大。**

HTTP

示例代码

curl

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "Moonshot-Kimi-K2-Instruct",
    "messages": [
        {
            "role": "user", 
            "content": "你是谁"
        }
    ],
    "stream": true,
    "stream_options": {
        "include_usage": true
    }
}'

返回结果

data: {"choices":[{"delta":{"content":"","role":"assistant"},"index":0,"logprobs":null,"finish_reason":null}],"object":"chat.completion.chunk","usage":null,"created":1752660243,"system_fingerprint":null,"model":"Moonshot-Kimi-K2-Instruct","id":"chatcmpl-2be85972-eeab-9909-8bbb-1a4479c6af4a"}

data: {"choices":[{"finish_reason":null,"logprobs":null,"delta":{"content":"我是"},"index":0}],"object":"chat.completion.chunk","usage":null,"created":1752660243,"system_fingerprint":null,"model":"Moonshot-Kimi-K2-Instruct","id":"chatcmpl-2be85972-eeab-9909-8bbb-1a4479c6af4a"}

data: {"choices":[{"delta":{"content":"K"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1752660243,"system_fingerprint":null,"model":"Moonshot-Kimi-K2-Instruct","id":"chatcmpl-2be85972-eeab-9909-8bbb-1a4479c6af4a"}

...

data: {"choices":[{"delta":{"content":"认识你"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1752660243,"system_fingerprint":null,"model":"Moonshot-Kimi-K2-Instruct","id":"chatcmpl-2be85972-eeab-9909-8bbb-1a4479c6af4a"}

data: {"choices":[{"delta":{"content":"哦"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1752660243,"system_fingerprint":null,"model":"Moonshot-Kimi-K2-Instruct","id":"chatcmpl-2be85972-eeab-9909-8bbb-1a4479c6af4a"}

data: {"choices":[{"delta":{"content":"～"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1752660243,"system_fingerprint":null,"model":"Moonshot-Kimi-K2-Instruct","id":"chatcmpl-2be85972-eeab-9909-8bbb-1a4479c6af4a"}

data: {"choices":[{"finish_reason":"stop","delta":{"content":""},"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1752660243,"system_fingerprint":null,"model":"Moonshot-Kimi-K2-Instruct","id":"chatcmpl-2be85972-eeab-9909-8bbb-1a4479c6af4a"}

data: {"choices":[],"object":"chat.completion.chunk","usage":{"prompt_tokens":17,"completion_tokens":19,"total_tokens":36},"created":1752660243,"system_fingerprint":null,"model":"Moonshot-Kimi-K2-Instruct","id":"chatcmpl-2be85972-eeab-9909-8bbb-1a4479c6af4a"}

data: [DONE]

DashScope

您可以通过 DashScope SDK 或 HTTP 方式使用流式输出功能。

Python

示例代码

import os
import dashscope

messages = [
    {'role': 'user', 'content': '你是谁？'}
]

response = dashscope.Generation.call(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="Moonshot-Kimi-K2-Instruct",
    messages=messages,
    # result_format参数不可以设置为"text"。
    result_format='message',
    stream=True,
    incremental_output=True
)

answer_content = ""

for chunk in response:
    print(chunk.output.choices[0].message.content, end="",flush=True)
    answer_content += chunk.output.choices[0].message.content

# print("=" * 20 + "完整回复" + "=" * 20 + "\n")
# print(f"{answer_content}")

返回结果

我是Kimi，一个由月之暗面科技有限公司（Moonshot AI）训练的大语言模型，知识截止于2025年4月。我擅长用自然流畅的语言和你互动交流，很高兴为你提供帮助！

Java

示例代码

package org.example;
// dashscope SDK的版本 >= 2.18.2
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import io.reactivex.Flowable;
import java.lang.System;

public class Main {
    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    private static StringBuilder finalContent = new StringBuilder();

    private static void handleGenerationResult(GenerationResult message) {
        String content = message.getOutput().getChoices().get(0).getMessage().getContent();
        if (!content.isEmpty()) {
            finalContent.append(content);
            System.out.print(content);
        }
    }
    private static GenerationParam buildGenerationParam(Message userMsg) {
        return GenerationParam.builder()
                // 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("Moonshot-Kimi-K2-Instruct")
                .messages(Arrays.asList(userMsg))
                // 不可以设置为"text"
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .incrementalOutput(true)
                .build();
    }
    public static void streamCallWithMessage(Generation gen, Message userMsg)
            throws NoApiKeyException, ApiException, InputRequiredException {
        GenerationParam param = buildGenerationParam(userMsg);
        Flowable<GenerationResult> result = gen.streamCall(param);
        result.blockingForEach(message -> handleGenerationResult(message));
    }

    public static void main(String[] args) {
        try {
            Generation gen = new Generation();
            Message userMsg = Message.builder().role(Role.USER.getValue()).content("你是谁？").build();
            streamCallWithMessage(gen, userMsg);
//             打印最终结果
//            if (reasoningContent.length() > 0) {
//                System.out.println("\n====================完整回复====================");
//                System.out.println(finalContent.toString());
//            }
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            logger.error("An exception occurred: {}", e.getMessage());
        }
        System.exit(0);
    }
}

返回结果

我是 **Kimi**，由 **月之暗面科技有限公司**（Moonshot AI）训练的大语言模型。我的知识截止于2025年4月，擅长用自然流畅的语言和你互动交流。有什么我可以帮你的吗？

HTTP

示例代码

curl

curl -X POST "https://dashscope.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": "Moonshot-Kimi-K2-Instruct",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    },
    "parameters": {
        "result_format": "message",
        "incremental_output": true
    }
}'

返回结果

id:1
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"我是","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":19,"input_tokens":18,"output_tokens":1},"request_id":"1e3ba1e2-931a-9e87-9ee2-d7c532b98038"}

id:2
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"K","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":20,"input_tokens":18,"output_tokens":2},"request_id":"1e3ba1e2-931a-9e87-9ee2-d7c532b98038"}

id:3
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"imi","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":21,"input_tokens":18,"output_tokens":3},"request_id":"1e3ba1e2-931a-9e87-9ee2-d7c532b98038"}

...

id:23
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"月","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":41,"input_tokens":18,"output_tokens":23},"request_id":"1e3ba1e2-931a-9e87-9ee2-d7c532b98038"}

id:24
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"。","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":42,"input_tokens":18,"output_tokens":24},"request_id":"1e3ba1e2-931a-9e87-9ee2-d7c532b98038"}

id:25
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","role":"assistant"},"finish_reason":"stop"}]},"usage":{"total_tokens":42,"input_tokens":18,"output_tokens":24},"request_id":"1e3ba1e2-931a-9e87-9ee2-d7c532b98038"}

联网搜索

由于训练数据的时效性，大模型无法准确回答如股票价格、今日资讯等时效性问题。您可以通过设置enable_search参数为true以启用联网检索功能，使大模型可以基于实时检索数据进行回复。

开启enable_search后，模型会先判断是否需要使用联网搜索能力来回答您的问题：

  • 需要联网搜索

    当问题被模型判断需要使用联网搜索能力，模型会根据联网搜索的结果进行回复。

    联网搜索功能当前免费，但搜索到的信息会增加 Token 消耗。

  • 不需要联网搜索

    模型本身已经可以回答如“你是谁”、“一年有多少天”等简单或常识性的问题。此时模型不会去联网搜索，而是直接进行回答。

    如果您希望强制开启联网搜索功能，请参见下文的forced_search参数。

在设置enable_search参数为true后，您可以通过search_options参数来配置联网搜索策略，包括以下方面：

是否强制联网搜索

通过forced_search配置，可选值：

  • true

    强制开启。

  • false（默认值）

    不强制开启。

搜索数量

通过search_strategy配置。可选值：

  • "standard"（默认值）

    模型会联网搜索5条信息。

  • "pro"

    模型会联网搜索10条信息。

是否返回搜索来源

该策略仅支持 DashScope 方式。通过enable_source配置，可选值：

  • true

    返回数据中包含搜索来源的信息。搜索来源信息通过search_info参数返回。

  • false（默认值）

    返回数据中不包含搜索来源的信息。

开启角标标注

该策略仅支持 DashScope 方式。

就像在写论文时在右上角用[i] 来标注引用的文献，角标标注可以在大模型的回复内容中标注引用来源。如果返回数据包含搜索来源的信息（enable_source为true），您可以通过enable_citation来配置是否开启角标标注功能。可选值：

  • true

    开启角标标注。

    角标标注的样式可以通过下方的citation_format参数设置。

  • false（默认值）

    不开启角标标注。

在开启角标标注功能后，您可以通过citation_format配置角标样式。可选值：

  • "[<number>]"（默认值）

    角标形式为[i]。

  • "[ref_<number>]"

    角标形式为[ref_i]。

DashScope

示例代码

import os
import dashscope
 
messages = [
    {'role': 'user', 'content': '杭州的天气'}
]
 
response = dashscope.Generation.call(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx"
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="Moonshot-Kimi-K2-Instruct",  
    messages=messages,
    enable_search = True, # 开启联网搜索的参数
    search_options = {
        "forced_search": True, # 强制开启联网搜索
        "enable_source": True, # 使返回结果包含搜索来源的信息，OpenAI 兼容方式暂不支持返回
        "enable_citation": True, # 开启角标标注功能
        "citation_format": "[ref_<number>]", # 角标形式为[ref_i]
        "search_strategy": "pro" # 模型将搜索10条互联网信息
    },
    result_format="message",
)
 
# 定义完整回复
answer_content = ""
 
print("=" * 20 + "搜索信息" + "=" * 20)
search_results = response.output.search_info["search_results"]
for web in search_results:
    print(f"[{web['index']}]: [{web['title']}]({web['url']})")
 
print("\n" + "=" * 20 + "完整回复" + "=" * 20)
print(response.output.choices[0].message.content)
import java.util.Arrays;
import java.lang.System;
import com.alibaba.dashscope.aigc.generation.SearchOptions;
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.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
 
public class Main {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        Generation gen = new Generation();
        SearchOptions searchOptions = SearchOptions.builder()
                // 使返回结果中包含搜索信息的来源
                .enableSource(true)
                // 强制开启互联网搜索
                .forcedSearch(true)
                // 开启角标标注
                .enableCitation(true)
                // 设置角标标注样式为[ref_i]
                .citationFormat("[ref_<number>]")
                // 联网搜索10条信息
                .searchStrategy("pro")
                .build();
        Message systemMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .content("You are a helpful assistant.")
                .build();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("明天杭州什么天气？")
                .build();
        GenerationParam param = GenerationParam.builder()
                // 若没有配置环境变量，请用百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("Moonshot-Kimi-K2-Instruct")
                .messages(Arrays.asList(systemMsg, userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .enableSearch(true)
                .searchOptions(searchOptions)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println(result.getOutput().getSearchInfo().getSearchResults());
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            // 使用日志框架记录异常信息
            System.err.println("An error occurred while calling the generation service: " + e.getMessage());
        }
        System.exit(0);
    }
}
curl -X POST "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "Moonshot-Kimi-K2-Instruct",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "明天杭州的天气"
            }
        ]
    },
    "parameters":{
        "result_format": "message",
        "enable_search": true,
        "search_options": {
            "forced_search": true,
            "enable_source": true,
            "enable_citation": true,
            "citation_format": "[ref_<number>]",
            "search_strategy": "pro"
        }
    }
}'

返回结果

====================搜索信息====================
[1]: [杭州的天气](http://tianqi.so.com/weather/101210101)
[2]: [【杭州天气】杭州天气预报,蓝天,蓝天预报,雾霾,雾霾消散,天气预报...](https://www.weather.com.cn/html/weather/101210101.shtml)
[3]: [杭州天气_杭州本周天气实况](https://tianqi.cncn.com/hangzhou)
[4]: [杭州-天气预报](http://www.nmc.cn/publish/forecast/AZJ/hangzhou.html)
[5]: [杭州天气预报,杭州7天天气预报,杭州15天天气预报,杭州天气查询](https://www.weather.com.cn/weather/101210101.shtml)
[6]: [杭州天气预报_杭州一周天气_杭州实时天气](http://weather.zuzuche.com/c252.html)
[7]: [杭州1月份天气_2025杭州1月份天气](http://www.hangzhoutianqi114.com/1yuefen.html)
[8]: [杭州天气预报30天_杭州天气预报30天查询](https://www.tianqi.com/hangzhou/30/)
[9]: [杭州天气预报,历史气温,旅游指数,杭州一周天气预报【携程攻略】](https://you.ctrip.com/weather/hangzhou14.html)
 
====================完整回复====================
杭州今天（2025-07-17）的天气实况：  
- **天气**：多云，下午转阴  
- **当前气温**：36℃  
- **风向/风力**：东北风5-6级  
- **降水**：局部短时小雨  
 
**未来3天预报**（参考权威渠道）：  
- **7月18日（周五）**：小雨，33℃/25℃，东南风[ref_1]  
- **7月19日（周六）**：小雨转阴，33℃/26℃，东风  
- **7月20日（周日）**：多云，33℃/26℃，东南风  
 
近期湿度较大，体感闷热，建议携带雨具并注意防暑降温。

OpenAI 兼容

示例代码

from openai import OpenAI
import os
 
# 初始化OpenAI客户端
client = OpenAI(
    # 如果没有配置环境变量，请用阿里云百炼API Key替换：api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
 
# 创建聊天完成请求
completion = client.chat.completions.create(
    model="Moonshot-Kimi-K2-Instruct",
    messages=[{"role": "user", "content": "明天杭州的天气"}],
    extra_body={
        "enable_search": True,  # 开启联网搜索的参数
        "search_options": {
            "forced_search": True,  # 强制联网搜索的参数
            "search_strategy": "pro",  # 模型将搜索10条互联网信息
        },
    },
)
 
print(completion.choices[0].message.content)
import OpenAI from "openai";
import process from 'process';
 
// 初始化 openai 客户端
const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY, // 从环境变量读取
    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1'
});
 
async function main() {
    try {
        const completion = await openai.chat.completions.create({
            model: 'Moonshot-Kimi-K2-Instruct',
            messages: [{ role: 'user', content: '明天杭州的天气' }],
            enable_search: true, // 开启联网搜索的参数
            search_options: {
                forced_search: true // 强制联网搜索的参数
            },
        });
        console.log(completion.choices[0].message.content);
    } catch (error) {
        console.error('Error:', error);
    }
}
main();
curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "Moonshot-Kimi-K2-Instruct",
    "messages": [
        {
            "role": "user", 
            "content": "明天杭州的天气"
        }
    ],
    "enable_search": true,
    "search_options": {
        "forced_search": true
    }
}'

返回结果

明天（7月18日，星期五）杭州天气为**小雨**，气温**25℃～33℃**，东南风。建议外出携带雨具，注意防滑。

默认值

  • temperature：0.6

  • top_p： 1.0

  • presence_penalty： 0

错误码

如果模型调用失败并返回报错信息，请参见错误信息进行解决。

常见问题

Q：如何部署 Kimi-K2-Instruct 模型？

A：我们推荐您通过本文介绍的阿里云百炼 API 方式调用。如有私有化部署需求，请参见阿里云 Kimi K2 解决方案，涵盖了通过 PAI、GPU 云服务器等部署模型的方式。

上一篇: DeepSeek