Kimi

import dashscope

client = dashscope.Client(workspace="{WorkspaceId}", region="us-east-1")

import com.alibaba.dashscope.protocol.Protocol;
Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.us-east-1.maas.aliyuncs.com/api/v1");

import com.alibaba.dashscope.utils.Constants;
Constants.baseHttpApiUrl="https://{WorkspaceId}.us-east-1.maas.aliyuncs.com/api/v1";

import dashscope

client = dashscope.Client(workspace="{WorkspaceId}", region="eu-central-1")

import com.alibaba.dashscope.protocol.Protocol;
Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.eu-central-1.maas.aliyuncs.com/api/v1");

import com.alibaba.dashscope.utils.Constants;
Constants.baseHttpApiUrl="https://{WorkspaceId}.eu-central-1.maas.aliyuncs.com/api/v1";

# La siguiente configuración corresponde a la región de Singapur. Sustituya {WorkspaceId} por el ID real de su espacio de trabajo. El valor de region varía según la región.
import dashscope

client = dashscope.Client(workspace="{WorkspaceId}", region="ap-southeast-1")

import com.alibaba.dashscope.protocol.Protocol;
// Singapore region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");

import com.alibaba.dashscope.utils.Constants;
// Singapore region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
Constants.baseHttpApiUrl="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1";

import dashscope

client = dashscope.Client(workspace="{WorkspaceId}", region="ap-northeast-1")

import com.alibaba.dashscope.protocol.Protocol;
Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-northeast-1.maas.aliyuncs.com/api/v1");

import com.alibaba.dashscope.utils.Constants;
Constants.baseHttpApiUrl="https://{WorkspaceId}.ap-northeast-1.maas.aliyuncs.com/api/v1";

import dashscope

client = dashscope.Client(workspace="{WorkspaceId}", region="cn-hongkong")

import com.alibaba.dashscope.protocol.Protocol;
Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.cn-hongkong.maas.aliyuncs.com/api/v1");

import com.alibaba.dashscope.utils.Constants;
Constants.baseHttpApiUrl="https://{WorkspaceId}.cn-hongkong.maas.aliyuncs.com/api/v1";

# La siguiente configuración corresponde a la región de China (Pekín). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo. El valor de region varía según la región.
import dashscope

client = dashscope.Client(workspace="{WorkspaceId}", region="cn-beijing")

import com.alibaba.dashscope.protocol.Protocol;
// China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1");

import com.alibaba.dashscope.utils.Constants;
// China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
Constants.baseHttpApiUrl="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1";

​

Primeros pasos

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Who are you?"}],
    stream=True,
    extra_body={"enable_thinking": True},  # Enable thinking mode to get reasoning_content
)

reasoning_content = ""  # Complete thinking process
answer_content = ""     # Complete response
is_answering = False    # Tracks if the main response has started.

print("\n" + "=" * 20 + "Thinking Process" + "=" * 20 + "\n")

for chunk in completion:
    if chunk.choices:
        delta = chunk.choices[0].delta
        # Store content from the thinking process.
        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
        # Start printing the main response once its content arrives.
        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

====================Thinking Process====================

The user asks "Who are you?", which is a direct question about my identity. I need to answer truthfully based on my actual identity.

I am Kimi, an AI assistant developed by Moonshot AI. I should introduce myself clearly and concisely, including:
1. My identity: AI assistant
2. My developer: Moonshot AI
3. My name: Kimi
4. My core capabilities: long-text processing, intelligent conversation, file processing, search, etc.

I should maintain a friendly and professional tone, avoiding overly technical terms for clarity. I should also emphasize that I am an AI without personal consciousness, emotions, or experiences to prevent misunderstandings.

Response structure:
- Directly state my identity
- Mention my developer
- Briefly introduce core capabilities
- Keep it clear and concise
====================Complete Response====================

I am Kimi, an AI assistant developed by Moonshot AI. I am based on a Mixture-of-Experts (MoE) architecture and have capabilities such as ultra-long context understanding, intelligent conversation, file processing, code generation, and complex task reasoning. How can I help you?

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

// Initialize the OpenAI client
const openai = new OpenAI({
    // If not using an environment variable, replace `process.env.DASHSCOPE_API_KEY` with your API key string (e.g., "sk-xxx").
    apiKey: process.env.DASHSCOPE_API_KEY,
    // China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    baseURL: 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1'
});

let reasoningContent = ''; // Complete thinking process
let answerContent = ''; // Complete response
let isAnswering = false; // Tracks if the main response has started.

async function main() {
    const messages = [{ role: 'user', content: 'Who are you?' }];

    const stream = await openai.chat.completions.create({
        model: 'kimi-k3',
        messages,
        stream: true,
        enable_thinking: true,  // Enable thinking mode to get reasoning_content
    });

    console.log('\n' + '='.repeat(20) + 'Thinking Process' + '='.repeat(20) + '\n');

    for await (const chunk of stream) {
        if (chunk.choices?.length) {
            const delta = chunk.choices[0].delta;
            // Store content from the thinking process.
            if (delta.reasoning_content !== undefined && delta.reasoning_content !== null) {
                if (!isAnswering) {
                    process.stdout.write(delta.reasoning_content);
                }
                reasoningContent += delta.reasoning_content;
            }

            // Start printing the main response once its content arrives.
            if (delta.content !== undefined && delta.content) {
                if (!isAnswering) {
                    console.log('\n' + '='.repeat(20) + 'Complete Response' + '='.repeat(20) + '\n');
                    isAnswering = true;
                }
                process.stdout.write(delta.content);
                answerContent += delta.content;
            }
        }
    }
}

main();

====================Thinking Process====================

The user asks "Who are you?", which is a direct question about my identity. I need to answer truthfully based on my actual identity.

I am Kimi, an AI assistant developed by Moonshot AI. I should introduce myself clearly and concisely, including:
1. My identity: AI assistant
2. My developer: Moonshot AI
3. My name: Kimi
4. My core capabilities: long-text processing, intelligent conversation, file processing, search, etc.

I should maintain a friendly and professional tone and avoid overly technical terms for clarity. I should also emphasize that I am an AI without personal consciousness, emotions, or experiences to prevent misunderstandings.

Response structure:
- Directly state my identity
- Mention my developer
- Briefly introduce core capabilities
- Keep it clear and concise
====================Complete Response====================

I am Kimi, an AI assistant developed by Moonshot AI.

I am skilled in:
- Long-text understanding and generation
- Intelligent conversation and question answering
- File processing and analysis
- Information retrieval and integration

As an AI assistant, I do not have personal consciousness, emotions, or experiences, but I am designed to provide accurate and helpful assistance. How can I help you?

# China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "kimi-k3",
    "messages": [
        {
            "role": "user",
            "content": "Who are you?"
        }
    ],
    "enable_thinking": true
}'

{
    "choices": [
        {
            "message": {
                "content": "I am Kimi, an AI assistant developed by Moonshot AI. I am skilled in long-text processing, intelligent conversation, file analysis, programming assistance, and complex task reasoning. I can help you answer questions, create content, and analyze documents. How can I assist you?",
                "reasoning_content": "The user asks \"Who are you?\", which is a direct question about my identity. I must answer truthfully based on my actual identity.\n\nI am Kimi, an AI assistant developed by Moonshot AI. I should introduce myself clearly and concisely, including:\n1. My identity: AI assistant\n2. My developer: Moonshot AI\n3. My name: Kimi\n4. My core capabilities: long-text processing, intelligent conversation, file processing, search, etc.\n\nI should maintain a friendly and professional tone while providing useful information. No need to overcomplicate; a direct answer is sufficient.",
                "role": "assistant"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 8,
        "completion_tokens": 183,
        "total_tokens": 191
    },
    "created": 1762753998,
    "system_fingerprint": null,
    "model": "kimi-k3",
    "id": "chatcmpl-485ab490-90ec-48c3-85fa-1c732b683db2"
}

import os
import dashscope
# La siguiente configuración corresponde a la región de China (Pekín). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo al realizar la llamada. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustitúyala por su API Key de Model Studio: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    workspace="{WorkspaceId}",
    region="cn-beijing",
)

# Inicialice los parámetros de la solicitud
messages = [{"role": "user", "content": "Who are you?"}]

completion = client.multimodal.chat.create(
    model="kimi-k3",
    messages=messages,
    stream=True,              # Habilite la salida en streaming
    enable_thinking=True,     # Habilite el modo de pensamiento
)

reasoning_content = ""  # Proceso de pensamiento completo
answer_content = ""     # Respuesta completa
is_answering = False    # Indica si se ha entrado en la fase de respuesta

print("\n" + "=" * 20 + "Proceso de pensamiento" + "=" * 20 + "\n")

for chunk in completion:
    message = chunk.choices[0].delta

    # Recoja solo el contenido del pensamiento
    reasoning_chunk = message.reasoning_content
    if reasoning_chunk:
        if not is_answering:
            print(reasoning_chunk, end="", flush=True)
        reasoning_content += reasoning_chunk

    # Al recibir content, comienza la respuesta
    if message.content:
        if not is_answering:
            print("\n" + "=" * 20 + "Respuesta completa" + "=" * 20 + "\n")
            is_answering = True
        print(message.content, end="", flush=True)
        answer_content += message.content

====================Thinking Process====================

The user asks "Who are you?", which is a direct question about my identity. I need to answer truthfully based on my actual identity.

I am Kimi, an AI assistant developed by Moonshot AI. I should state this clearly and concisely.

Key information to include:
1. My name: Kimi
2. My developer: Moonshot AI
3. My nature: AI assistant
4. What I can do: answer questions, assist with content creation, etc.

I should maintain a friendly and helpful tone while accurately stating my identity. I should not pretend to be human or have a personal identity.

A suitable response would be:
"I am Kimi, an AI assistant developed by Moonshot AI. I can help you with a variety of tasks such as answering questions, creating content, and analyzing documents. How can I help you?"

This response is direct, accurate, and encourages further interaction.
====================Complete Response====================

I am Kimi, an AI assistant developed by Moonshot AI. I can help you with a variety of tasks such as answering questions, creating content, and analyzing documents. How can I help you?

// DashScope SDK version >= 2.19.4
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversation;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversationParam;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversationResult;
import com.alibaba.dashscope.common.MultiModalMessage;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.exception.UploadFileException;
import com.alibaba.dashscope.utils.Constants;
import java.util.Arrays;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        // China (Beijing) region configuration. Replace {WorkspaceId} with your actual workspace ID. For other regions, use the corresponding base URL.
        Constants.baseHttpApiUrl = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1";
        try {
            MultiModalConversation conv = new MultiModalConversation();

            MultiModalMessage userMsg = MultiModalMessage.builder()
                    .role(Role.USER.getValue())
                    .content(Arrays.asList(Collections.singletonMap("text", "Who are you?")))
                    .build();

            MultiModalConversationParam param = MultiModalConversationParam.builder()
                    // If not using an environment variable, replace the following line with your API key, e.g., .apiKey("sk-xxx")
                    .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                    .model("kimi-k3")
                    .messages(Arrays.asList(userMsg))
                    .build();

            MultiModalConversationResult result = conv.call(param);

            String content = (String) result.getOutput().getChoices().get(0).getMessage().getContent().get(0).get("text");
            System.out.println("Response: " + content);
        } catch (ApiException | NoApiKeyException | UploadFileException e) {
            System.err.println("An exception occurred: " + e.getMessage());
        }
        System.exit(0);
    }
}

Response: I am Kimi, an AI assistant developed by Moonshot AI. My skills include long-text processing, intelligent conversation, question answering, content creation, and file analysis and processing. How can I assist you?

# China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
curl -X POST "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "kimi-k3",
    "input":{
        "messages":[
            {
                "role": "user",
                "content": "Who are you?"
            }
        ]
    },
    "parameters": {
        "result_format": "message",
        "enable_thinking": true
    }
}'

{
    "output": {
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "content": "I am Kimi, an AI assistant developed by Moonshot AI. I can help you answer questions, create content, analyze documents, and write code. How can I help you?",
                    "reasoning_content": "The user asks \"Who are you?\", which is a direct question about my identity. I need to answer truthfully based on my actual identity.\n\nI am Kimi, an AI assistant developed by Moonshot AI. I should state this clearly and concisely.\n\nKey information to include:\n1. My name: Kimi\n2. My developer: Moonshot AI\n3. My nature: AI assistant\n4. What I can do: answer questions, assist with content creation, etc.\n\nThe response should be friendly, direct, and easy to understand.",
                    "role": "assistant"
                }
            }
        ]
    },
    "usage": {
        "input_tokens": 9,
        "output_tokens": 156,
        "total_tokens": 165
    },
    "request_id": "709a0697-ed1f-4298-82c9-a4b878da1849"
}

import anthropic
import os

client = anthropic.Anthropic(
    # If the environment variable is not configured, replace the value with your Model Studio API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # When you make a call, replace {WorkspaceId} with your actual Workspace ID.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.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)

# Singapore region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.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?"
        }
    ]
}'

​

Llamadas multimodales

​

Habilitar o deshabilitar el modo de pensamiento

• true: Habilitar el modo de pensamiento
• false (predeterminado): Deshabilita el modo de pensamiento

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

# Single-image input example (thinking mode enabled)
completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What scene is depicted in the image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"
                    }
                }
            ]
        }
    ],
    extra_body={"enable_thinking":True}  # Enable thinking mode
)

# Print the thinking process
if hasattr(completion.choices[0].message, 'reasoning_content') and completion.choices[0].message.reasoning_content:
    print("\n" + "=" * 20 + "Thinking Process" + "=" * 20 + "\n")
    print(completion.choices[0].message.reasoning_content)

# Print the complete response
print("\n" + "=" * 20 + "Complete Response" + "=" * 20 + "\n")
print(completion.choices[0].message.content)

# Multi-image input example (thinking mode enabled, uncomment to use)
# completion = client.chat.completions.create(
#     model="kimi-k2.6",
#     messages=[
#         {
#             "role": "user",
#             "content": [
#                 {"type": "text", "text": "What do these images depict?"},
#                 {
#                     "type": "image_url",
#                     "image_url": {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"}
#                 },
#                 {
#                     "type": "image_url",
#                     "image_url": {"url": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/tiger.png"}
#                 }
#             ]
#         }
#     ],
#     extra_body={"enable_thinking":True}
# )
#
# # Print the thinking process and complete response
# if hasattr(completion.choices[0].message, 'reasoning_content') and completion.choices[0].message.reasoning_content:
#     print("\nThinking Process:\n" + completion.choices[0].message.reasoning_content)
# print("\nComplete Response:\n" + completion.choices[0].message.content)

import os
import dashscope
# La siguiente configuración corresponde a la región de China (Pekín). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo al realizar la llamada. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustitúyala por su API Key de Model Studio: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    workspace="{WorkspaceId}",
    region="cn-beijing",
)

# Ejemplo de entrada de una sola imagen (modo de pensamiento habilitado)
response = client.multimodal.chat.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"text": "What scene is depicted in the image?"},
                {"image": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"}
            ]
        }
    ],
    enable_thinking=True  # Habilite el modo de pensamiento
)

# Muestre el proceso de pensamiento
if response.choices[0].message.reasoning_content:
    print("\n" + "=" * 20 + "Proceso de pensamiento" + "=" * 20 + "\n")
    print(response.choices[0].message.reasoning_content)

# Muestre la respuesta completa
print("\n" + "=" * 20 + "Respuesta completa" + "=" * 20 + "\n")
print(response.output_text)

# Ejemplo de entrada de varias imágenes (modo de pensamiento habilitado, quite los comentarios para usarlo)
# response = client.multimodal.chat.create(
#     model="kimi-k2.6",
#     messages=[
#         {
#             "role": "user",
#             "content": [
#                 {"text": "What do these images depict?"},
#                 {"image": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"},
#                 {"image": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/tiger.png"}
#             ]
#         }
#     ],
#     enable_thinking=True
# )
#
# # Muestre el proceso de pensamiento y la respuesta
# if response.choices[0].message.reasoning_content:
#     print("\nProceso de pensamiento:\n" + response.choices[0].message.reasoning_content)
# print("\nRespuesta completa:\n" + response.output_text)

​

Comprensión de video

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                # When passing a video file directly, set the "type" parameter to "video_url".
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241115/cqqkru/1.mp4"
                    },
                    "fps": 2
                },
                {
                    "type": "text",
                    "text": "What is the content of this video?"
                }
            ]
        }
    ]
)

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

import dashscope
import os

# La siguiente configuración corresponde a la región de China (Pekín). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo al realizar la llamada. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustitúyala por su API Key de Model Studio: api_key="sk-xxx"
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    workspace="{WorkspaceId}",
    region="cn-beijing",
)

messages = [
    {"role": "user",
        "content": [
            # El parámetro fps controla la frecuencia de extracción de fotogramas del video; se extrae un fotograma cada 1/fps segundos
            {"video": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241115/cqqkru/1.mp4","fps":2},
            {"text": "What is the content of this video?"}
        ]
    }
]

response = client.multimodal.chat.create(
    model='kimi-k2.6',
    messages=messages
)

print(response.output_text)

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user","content": [
        # When passing an image list, set the "type" parameter in the user message to "video".
         {"type": "video","video": [
         "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/xzsgiz/football1.jpg",
         "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/tdescd/football2.jpg",
         "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/zefdja/football3.jpg",
         "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/aedbqh/football4.jpg"],
         "fps":2},
         {"type": "text","text": "Describe the action in this video."},
    ]}]
)

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

import os
import dashscope

# La siguiente configuración corresponde a la región de China (Pekín). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo al realizar la llamada. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustitúyala por su API Key de Model Studio: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    workspace="{WorkspaceId}",
    region="cn-beijing",
)

messages = [{"role": "user",
             "content": [
                 {"video":["https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/xzsgiz/football1.jpg",
                           "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/tdescd/football2.jpg",
                           "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/zefdja/football3.jpg",
                           "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/aedbqh/football4.jpg"],
                   "fps":2},
                 {"text": "Describe the action in this video."}]}]
response = client.multimodal.chat.create(
    model='kimi-k2.6',
    messages=messages
)
print(response.output_text)

​

Pasar un archivo local

from openai import OpenAI
import os
import base64

# Encoding function: Converts a local file to a Base64-encoded string.
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Replace "xxx/eagle.png" with the absolute path to your local image.
base64_image = encode_image("xxx/eagle.png")

client = OpenAI(
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{base64_image}"},
                },
                {"type": "text", "text": "What scene is depicted in the image?"},
            ],
        }
    ],
)
print(completion.choices[0].message.content)

# The following examples show how to pass a local video file and a local image list.

# [Local video file] Encode the local video as a Data URL and pass it to the video_url parameter:
#   def encode_video_to_data_url(video_path):
#       with open(video_path, "rb") as f:
#           return "data:video/mp4;base64," + base64.b64encode(f.read()).decode("utf-8")

#   video_data_url = encode_video_to_data_url("xxx/local.mp4")
#   content = [{"type": "video_url", "video_url": {"url": video_data_url}, "fps": 2}, {"type": "text", "text": "What is the content of this video?"}]

# [Local image list] Encode multiple local images with Base64 and pass them as a list to the video parameter:
#   image_data_urls = [f"data:image/jpeg;base64,{encode_image(p)}" for p in ["xxx/f1.jpg", "xxx/f2.jpg", "xxx/f3.jpg", "xxx/f4.jpg"]]
#   content = [{"type": "video", "video": image_data_urls, "fps": 2}, {"type": "text", "text": "Describe the sequence of events in this video."}]

import base64
import os
import dashscope

# La siguiente configuración corresponde a la región de China (Pekín). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo al realizar la llamada. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustitúyala por su API Key de Model Studio: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    workspace="{WorkspaceId}",
    region="cn-beijing",
)

#  Función de codificación: convierte un archivo local en una cadena codificada en Base64
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Sustituya "xxx/eagle.png" por la ruta absoluta de su imagen local
base64_image = encode_image("xxx/eagle.png")

messages = [
    {
        "role": "user",
        "content": [
            {"image": f"data:image/png;base64,{base64_image}"},
            {"text": "What scene is depicted in the image?"},
        ],
    },
]
response = client.multimodal.chat.create(
    model="kimi-k2.6",
    messages=messages,
)
print(response.output_text)

# Los siguientes ejemplos muestran cómo pasar un archivo de video local y una lista de imágenes locales

# [Archivo de video local]
#   video_data_url = "data:video/mp4;base64," + base64.b64encode(open("xxx/local.mp4","rb").read()).decode("utf-8")
#   content: [{"video": video_data_url, "fps": 2}, {"text": "What is the content of this video?"}]

# [Lista de imágenes locales]
#   image_data_urls = [f"data:image/jpeg;base64,{encode_image(p)}" for p in ["xxx/f1.jpg","xxx/f2.jpg","xxx/f3.jpg","xxx/f4.jpg"]]
#   content: [{"video": image_data_urls, "fps": 2}, {"text": "Describe the sequence of events in this video."}]

import os
import dashscope

# La siguiente configuración corresponde a la región de China (Pekín). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo al realizar la llamada. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustitúyala por su API Key de Model Studio: api_key="sk-xxx"
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    workspace="{WorkspaceId}",
    region="cn-beijing",
)

# Sustituya "xxx/eagle.png" por la ruta absoluta de su imagen local
local_path = "xxx/eagle.png"
image_path = f"file://{local_path}"
messages = [
                {'role':'user',
                'content': [{'image': image_path},
                            {'text': 'What scene is depicted in the image?'}]}]
response = client.multimodal.chat.create(
    model='kimi-k2.6',
    messages=messages)
print(response.output_text)

#   Los siguientes ejemplos muestran cómo pasar un video local y una lista de imágenes locales mediante rutas de archivos
# [Archivo de video local]
#  video_path = "file:///path/to/local.mp4"
#  content: [{"video": video_path, "fps": 2}, {"text": "What is the content of this video?"}]

# [Lista de imágenes locales]
# image_paths = ["file:///path/f1.jpg", "file:///path/f2.jpg", "file:///path/f3.jpg", "file:///path/f4.jpg"]
# content: [{"video": image_paths, "fps": 2}, {"text": "Describe the sequence of events in this video."}]

​

Limitaciones de archivos

​

Otras funciones

​

Herramientas cargadas dinámicamente

​

Inyectar declaraciones de herramientas en mensajes

• Un mensaje system que lleva tools tiene el mismo estado que un mensaje ordinario: las herramientas se vuelven visibles para el modelo a partir de la posición donde aparece ese mensaje en la lista messages.
• Las herramientas cargadas dinámicamente coexisten con las herramientas globales declaradas en el campo tools de nivel superior de la solicitud; el modelo puede ver ambos tipos de herramientas al mismo tiempo.
• Una declaración de herramienta inyectada dinámicamente debe ser una definición completa de herramienta; no puede pasar solo un nombre de herramienta ni hacer referencia a una herramienta declarada globalmente.
• Un mensaje system que lleva tools no debe llevar también un campo content, de lo contrario la solicitud fallará con un error 400. Al usar el SDK de OpenAI, puede pasar el campo tools directamente en messages.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The following is the URL for the China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID; URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.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)

​

Carga bajo demanda combinada con una herramienta de búsqueda

1. Al inicio de la sesión, declare en el nivel superior de tools solo una herramienta search_tools implementada por el backend de su aplicación (devuelve nombres de herramientas coincidentes y resúmenes por palabra clave), además de algunas herramientas principales que pueden usarse en cada turno.
2. Declare las palabras clave buscables (como un catálogo de herramientas o etiquetas de dominio) en el prompt del sistema para guiar al modelo a llamar primero a search_tools cuando necesite una herramienta. Establecer tool_choice: "required" en la primera solicitud garantiza al menos una llamada a herramienta, pero no garantiza que se llame primero a search_tools. Si es obligatorio buscar primero, establezca explícitamente tool_choice: {"type": "function", "function": {"name": "search_tools"}} y luego restaure tool_choice a "auto" después de la búsqueda. Cambiar tool_choice no rompe la caché de prefijos.
3. Basándose en los resultados devueltos por search_tools, la aplicación inserta dinámicamente las declaraciones completas de las herramientas correspondientes en messages mediante un mensaje system que lleva tools.
4. El modelo puede entonces llamar a estas herramientas recién cargadas directamente en la generación subsiguiente.

​

Notas

• Las declaraciones de herramientas dinámicas surten efecto por solicitud y no son recordadas por el servidor. Si se siguen incluyendo en la siguiente solicitud depende del integrador: si se siguen incluyendo, las herramientas permanecen disponibles (lo que también ayuda a acertar en la caché de prefijos); si se deja de incluirlas, la declaración caduca; si la herramienta no se declara en otro lugar, el modelo no puede llamarla y la caché de prefijos después del punto de cambio podría fallar.
• Agregar una declaración de herramienta dinámica al final de messages no afecta la caché del prefijo existente; eliminar o modificar declaraciones de herramientas anteriores puede afectar los aciertos de caché después del punto de cambio. Declarar herramientas globales en el campo tools de nivel superior de la solicitud tampoco afecta los aciertos de caché.
• Un mensaje system que lleva tools también consume longitud de contexto, así que inyecte solo las herramientas realmente necesarias para la conversación actual.
• Las declaraciones de herramientas dinámicas usan exactamente el mismo formato que las declaraciones globales de tools, por lo que los integradores no necesitan mantener dos esquemas.

​

Parámetros predeterminados

• max (predeterminado): razonamiento profundo
• high: razonamiento mejorado
• medium: razonamiento moderado
• low: razonamiento ligero

• OpenAI Chat Completions: use el campo reasoning_effort de nivel superior. Con el SDK de OpenAI para Python, pase reasoning_effort="max" directamente.
• DashScope: use el parámetro reasoning_effort del SDK o parameters.reasoning_effort en las solicitudes HTTP.
• OpenAI Responses: use reasoning.effort.
• Anthropic Messages: use output_config.effort.

​

Modelos y facturación

• kimi-k3.1-pro: Admite entrada de texto e imagen, salida de texto y carga dinámica de herramientas. No admite entrada de video, Batch ni ajuste fino.
• kimi-k3: Un modelo insignia de Kimi. Razona y usa pensamiento preservado de forma predeterminada. Admite entrada de texto e imagen (no se admite entrada de video), tareas de conversación y de agente, y carga dinámica de herramientas.
• kimi-k2.7-code: Un modelo Kimi para programación. Sigue instrucciones de contexto largo de manera más confiable y logra mayores tasas de éxito en tareas de programación. Admite entrada de texto, imagen y video, modo de pensamiento, conversación y tareas de agente.
• kimi-k2.6: Un modelo de la serie Kimi con rendimiento mejorado en programación de largo alcance, seguimiento de instrucciones y autocorrección. Admite entrada de texto, imagen y video, modos de pensamiento y sin pensamiento, conversación y tareas de agente.
• kimi-k2.5: Logra un rendimiento de vanguardia (SOTA) en benchmarks de código abierto para tareas de agente, generación de código, comprensión visual y otras tareas de inteligencia general. Admite entrada de imagen, video y texto, modos de pensamiento y sin pensamiento, conversación y tareas de agente.

Para precios, consulte facturación de invocación de modelos.

En el modo de pensamiento, la cadena de pensamiento cuenta como tokens de salida.

​

Códigos de error