Kimi

Chame o Kimi K3 e Kimi Modelos de código K2.7 através da API compatível com OpenAI ou DashScope SDK ligado QwenCloud.

-Começo rápido.

kimi-k3 É KimiÉ o modelo mais capaz até agora. Sempre raciocina e usa o pensamento preservado (modo de pensar somente). Suporta texto e entrada de imagem (input de vídeo não é suportado), tarefas de conversação e agente, e carregamento dinâmico de ferramentas.

kimi-k2.7-code é o mais capaz Kimi Modelo para codificação. Segue instruções de longo contexto mais confiáveis e alcança taxas de sucesso mais altas em tarefas de programação. Suporta texto, imagem e entrada de vídeo, modo de pensar, conversa e tarefas de agente.

kimi-k3 e kimi-k2.7-code são modelos só de pensamento: modo de pensar é sempre habilitado (enable_thinking predefinições para true e não pode ser desactivada), e preserve_thinking predefinições para true.

kimi-k3 Não suporta o thinking_budget Parâmetro, e ainda não suporta a API de Respostas Compatíveis com OpenAI. Use a API de completações de chat compatível com OpenAI.

Os exemplos abaixo usam kimi-k2.7-code. Para chamar kimi-k3, substituir o nome do modelo com kimi-k3.

Antes de começar, pegue uma chave API (/api-reference/preparation/api-key) e defini-lo como uma variável de ambiente. Se você chamar o modelo através de um SDK, [instalar o OpenAI ou DashScope SDK] (/api-reference/preparation/install-sdk).

OpenAI compatible

  O `enable_thinking` O parâmetro não faz parte da API padrão OpenAI. No OpenAI Python SDK, passe-o através `extra_body`. No SDK de Node.js, passe-o como um parâmetro de nível superior.

Python

    ```python
    import os
    from openai import OpenAI

    client = OpenAI(
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      base_url="https://maas.qwencloudapi.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
    ```

Node.js

    ```javascript
    import OpenAI from "openai";
    import process from "process";

    const openai = new OpenAI({
      apiKey: process.env.DASHSCOPE_API_KEY,
      baseURL: "https://maas.qwencloudapi.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

    ```bash
    curl -X POST https://maas.qwencloudapi.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
    }'
    ```

DashScope

Python

    ```python
    import os
    import dashscope

    dashscope.base_http_api_url = "https://maas.qwencloudapi.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
    ```

Java

    ```java
    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://maas.qwencloudapi.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

    ```bash
    curl -X POST https://maas.qwencloudapi.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
      }
    }'
    ```

Anthropic compatible

A API compatível com Antrópicos suporta apenas o ponto final das Mensagens (`/v1/messages`). Para limites de protocolo e uso, veja [Mensagens Antrópicas Compatíveis] (/api-reference/chat/anthropic).

Python

    ```python
    import anthropic
    import os

    client = anthropic.Anthropic(
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      base_url="https://maas.qwencloudapi.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

    ```bash
    curl -X POST https://maas.qwencloudapi.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?"
            }
        ]
    }'
    ```

Ferramentas carregadas dinamicamente

Quando uma aplicação precisa montar um grande número de ferramentas, colocando cada declaração de ferramenta no nível superior do pedido tools O campo de uma vez leva à inchação de definição de ferramenta: cada pedido deve carregar a descrição e esquema de parâmetros de todas as ferramentas, aumentando o consumo de tokens, e quanto mais ferramentas candidatas existem, mais provável é o modelo escolher a ferramenta errada e construir argumentos de chamadas incorretas.

Ferramentas carregadas dinamicamente permitem injetar ferramentas sob demanda durante uma conversação: montar apenas algumas ferramentas principais primeiro, e quando a conversa chegar a um ponto onde uma ferramenta específica é necessária, insira dinamicamente em messages, reduzindo o consumo de fichas e melhorando a precisão de seleção de ferramentas.

Ferramentas carregadas dinamicamente são suportadas apenas por kimi-k3. Pedindo-os em outros modelos retorna um tokenization failed Erro.

Injete declarações de ferramentas em mensagens

Insira uma mensagem com role - Pronto para... system em messagesE declarar as ferramentas para carregar através dessa mensagem tools Campo. O formato é idêntico ao pedido de nível superior. tools E você deve fornecer a informação completa da ferramenta.name, description, parameters).

• A system mensagem carregando tools tem o mesmo status que uma mensagem comum: as ferramentas se tornam visíveis para o modelo a partir da posição onde essa mensagem aparece na messages Lista.
• Ferramentas carregadas dinamicamente coexistem com as ferramentas globais declaradas no nível superior da solicitação. tools O modelo pode ver os dois tipos de ferramentas ao mesmo tempo.
• Uma declaração de ferramenta injetada dinamicamente deve ser uma definição completa de ferramenta; não se pode passar apenas um nome de ferramenta ou referência uma ferramenta declarada globalmente.
• A system mensagem carregando tools Não pode também carregar um content campo, ou o pedido falha com um erro de 400. Ao usar o OpenAI SDK, você pode passar o tools campo através diretamente em messages.

Python

```python
import os
from openai import OpenAI

client = OpenAI(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://maas.qwencloudapi.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

```bash
curl -X POST https://maas.qwencloudapi.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"]
            }
          }
        }
      ]
    }
  ]
}'
```

Carregamento sob demanda combinado com uma ferramenta de busca

Não há API de pesquisa de ferramentas dedicada. Quando há muitas ferramentas, você pode combinar uma ferramenta de busca personalizada com ferramentas carregadas dinamicamente para carregar ferramentas sob demanda:

1. No início da sessão, declare no nível superior tools Apenas um search_tools ferramenta implementada pela sua infraestrutura de aplicação (ele retorna nomes de ferramentas correspondentes e resumos por palavra-chave), além de algumas ferramentas principais que podem ser usadas a cada turno.
2. Declare as palavras-chave pesquisáveis (como um catálogo de ferramentas ou tags de domínio) no prompt do sistema para guiar o modelo para chamar search_tools Primeiro quando precisa de uma ferramenta. Você pode definir tool_choice: "required" no primeiro pedido para forçar o modelo a procurar antes de responder, em seguida, restaurar tool_choice para "auto" Depois da busca. Mudando. tool_choice Não quebra o prefixo de cache.
3. Baseado nos resultados devolvidos por search_tools, a aplicação dinamicamente insere as declarações completas das ferramentas correspondentes em messages através de uma system mensagem carregando tools.
4. O modelo pode então chamar essas ferramentas recém carregadas diretamente na geração subsequente.

Assim, não importa o tamanho do número total de ferramentas, apenas algumas declarações de ferramentas estão realmente presentes em cada pedido, mantendo a janela de contexto e a pressão de seleção do modelo sob controle.

Notas

• Declarações dinâmicas de ferramentas fazem efeito por pedido e não são lembradas pelo servidor. Se continuar carregando-os no próximo pedido é com o integrador: continue carregando-os e as ferramentas permanecem disponíveis (o que também ajuda a atingir o prefixo cache); pare de carregá-los e a declaração expira – se a ferramenta não for declarada em outro lugar, o modelo não pode chamá-lo, e o prefixo cache após o ponto de mudança pode falhar.
• Com uma declaração dinâmica de ferramentas no final do messages Não afeta o cache do prefixo existente; excluir ou modificar declarações anteriores de ferramentas pode afetar os hits do cache após o ponto de mudança. Declarando ferramentas globais no nível superior do pedido tools O campo também não afeta os golpes do cache.
• A system mensagem carregando tools Também consome o comprimento do contexto, então injete apenas as ferramentas realmente necessárias pela conversa atual.
• Declarações dinâmicas de ferramentas usam exatamente o mesmo formato que o global tools Declarações, então integradores não precisam manter dois esquemas.

Recursos apoiados

Ver a tabela estruturada nos quadros de referência desta página ↓

Parâmetro padrão

• Parameter * kimi-k3* | kimi-k2.7-code | | ----------------- | ------------------------- | ------------------------- | Ative o pensamento verdadeiro Temperatura 1.0 1.0 Topo 0,95, 0.95

Presença # # Penalidade

Modelos e faturamento

O Kimi Séries são grandes modelos de linguagem da Moonshot IA.

• kimi-k3: KimiÉ o modelo mais capaz até agora. Sempre raciocina e usa o pensamento preservado (modo de pensar somente). Suporta texto e entrada de imagem (input de vídeo não é suportado), tarefas de conversação e agente, e carregamento dinâmico de ferramentas.
• **kimi-k2.7-codeO mais capaz Kimi Modelo para codificação. Segue instruções de longo contexto mais confiáveis e alcança taxas de sucesso mais altas em tarefas de programação. Suporta texto, imagem e entrada de vídeo, modo de pensar, conversa e tarefas de agente.

Para detalhes de preços e janelas de contexto, veja o [Modelo Marketplace] (https://www.qwencloud.com/models).

A faturação é baseada na contagem de entrada e saída.

No modo de pensar, a cadeia de pensamento conta como fichas de saída.

Códigos de erro.

Se uma chamada de modelo falhar e retornar uma mensagem de erro, veja [Códigos de erro] (/api-reference/preparation/error-messages).