Providers

Moonshot AI

Moonshot fornisce l'API Kimi con endpoint compatibili OpenAI. Configura il provider e imposta il modello predefinito su moonshot/kimi-k2.6, oppure usa Kimi Coding con kimi/kimi-code.

Catalogo modelli integrato

Ref modello Nome Reasoning Input Contesto Output max
moonshot/kimi-k2.6 Kimi K2.6 No text, image 262,144 262,144
moonshot/kimi-k2.5 Kimi K2.5 No text, image 262,144 262,144
moonshot/kimi-k2-thinking Kimi K2 Thinking text 262,144 262,144
moonshot/kimi-k2-thinking-turbo Kimi K2 Thinking Turbo text 262,144 262,144
moonshot/kimi-k2-turbo Kimi K2 Turbo No text 256,000 16,384

Le stime di costo incluse per gli attuali modelli K2 ospitati da Moonshot usano le tariffe pay-as-you-go pubblicate da Moonshot: Kimi K2.6 costa $0.16/MTok cache hit, $0.95/MTok input e $4.00/MTok output; Kimi K2.5 costa $0.10/MTok cache hit, $0.60/MTok input e $3.00/MTok output. Le altre voci legacy del catalogo mantengono placeholder a costo zero a meno che tu non le sovrascriva nella configurazione.

Per iniziare

Scegli il tuo provider e segui i passaggi di configurazione.

API Moonshot

Ideale per: modelli Kimi K2 tramite Moonshot Open Platform.

  • Scegli la tua regione endpoint

    Scelta auth Endpoint Regione
    moonshot-api-key https://api.moonshot.ai/v1 Internazionale
    moonshot-api-key-cn https://api.moonshot.cn/v1 Cina
  • Esegui l'onboarding

    openclaw onboard --auth-choice moonshot-api-key
    

    Oppure per l'endpoint Cina:

    openclaw onboard --auth-choice moonshot-api-key-cn
    
  • Imposta un modello predefinito

    {
      agents: {
        defaults: {
          model: { primary: "moonshot/kimi-k2.6" },
        },
      },
    }
    
  • Verifica che i modelli siano disponibili

    openclaw models list --provider moonshot
    
  • Esegui uno smoke test live

    Usa una directory di stato isolata quando vuoi verificare accesso al modello e tracciamento dei costi senza toccare le tue normali sessioni:

    OPENCLAW_CONFIG_PATH=/tmp/openclaw-kimi/openclaw.json \
    OPENCLAW_STATE_DIR=/tmp/openclaw-kimi \
    openclaw agent --local \
      --session-id live-kimi-cost \
      --message 'Reply exactly: KIMI_LIVE_OK' \
      --thinking off \
      --json
    

    La risposta JSON dovrebbe riportare provider: "moonshot" e model: "kimi-k2.6". La voce transcript dell'assistente memorizza l'uso normalizzato dei token più il costo stimato sotto usage.cost quando Moonshot restituisce metadati di utilizzo.

  • Esempio di configurazione

    {
      env: { MOONSHOT_API_KEY: "sk-..." },
      agents: {
        defaults: {
          model: { primary: "moonshot/kimi-k2.6" },
          models: {
            // moonshot-kimi-k2-aliases:start
            "moonshot/kimi-k2.6": { alias: "Kimi K2.6" },
            "moonshot/kimi-k2.5": { alias: "Kimi K2.5" },
            "moonshot/kimi-k2-thinking": { alias: "Kimi K2 Thinking" },
            "moonshot/kimi-k2-thinking-turbo": { alias: "Kimi K2 Thinking Turbo" },
            "moonshot/kimi-k2-turbo": { alias: "Kimi K2 Turbo" },
            // moonshot-kimi-k2-aliases:end
          },
        },
      },
      models: {
        mode: "merge",
        providers: {
          moonshot: {
            baseUrl: "https://api.moonshot.ai/v1",
            apiKey: "${MOONSHOT_API_KEY}",
            api: "openai-completions",
            models: [
              // moonshot-kimi-k2-models:start
              {
                id: "kimi-k2.6",
                name: "Kimi K2.6",
                reasoning: false,
                input: ["text", "image"],
                cost: { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0 },
                contextWindow: 262144,
                maxTokens: 262144,
              },
              {
                id: "kimi-k2.5",
                name: "Kimi K2.5",
                reasoning: false,
                input: ["text", "image"],
                cost: { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0 },
                contextWindow: 262144,
                maxTokens: 262144,
              },
              {
                id: "kimi-k2-thinking",
                name: "Kimi K2 Thinking",
                reasoning: true,
                input: ["text"],
                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
                contextWindow: 262144,
                maxTokens: 262144,
              },
              {
                id: "kimi-k2-thinking-turbo",
                name: "Kimi K2 Thinking Turbo",
                reasoning: true,
                input: ["text"],
                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
                contextWindow: 262144,
                maxTokens: 262144,
              },
              {
                id: "kimi-k2-turbo",
                name: "Kimi K2 Turbo",
                reasoning: false,
                input: ["text"],
                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
                contextWindow: 256000,
                maxTokens: 16384,
              },
              // moonshot-kimi-k2-models:end
            ],
          },
        },
      },
    }
    

    Kimi Coding

    Ideale per: attività focalizzate sul codice tramite l'endpoint Kimi Coding.

  • Esegui l'onboarding

    openclaw onboard --auth-choice kimi-code-api-key
    
  • Imposta un modello predefinito

    {
      agents: {
        defaults: {
          model: { primary: "kimi/kimi-code" },
        },
      },
    }
    
  • Verifica che il modello sia disponibile

    openclaw models list --provider kimi
    
  • Esempio di configurazione

    {
      env: { KIMI_API_KEY: "sk-..." },
      agents: {
        defaults: {
          model: { primary: "kimi/kimi-code" },
          models: {
            "kimi/kimi-code": { alias: "Kimi" },
          },
        },
      },
    }
    

    Ricerca web Kimi

    OpenClaw include anche Kimi come provider web_search, supportato dalla ricerca web Moonshot.

  • Esegui il setup interattivo della ricerca web

    openclaw configure --section web
    

    Scegli Kimi nella sezione web-search per salvare plugins.entries.moonshot.config.webSearch.*.

  • Configura la regione e il modello della ricerca web

    Il setup interattivo richiede:

    Impostazione Opzioni
    Regione API https://api.moonshot.ai/v1 (internazionale) o https://api.moonshot.cn/v1 (Cina)
    Modello ricerca web Predefinito kimi-k2.6
  • La configurazione si trova sotto plugins.entries.moonshot.config.webSearch:

    {
      plugins: {
        entries: {
          moonshot: {
            config: {
              webSearch: {
                apiKey: "sk-...", // oppure usa KIMI_API_KEY / MOONSHOT_API_KEY
                baseUrl: "https://api.moonshot.ai/v1",
                model: "kimi-k2.6",
              },
            },
          },
        },
      },
      tools: {
        web: {
          search: {
            provider: "kimi",
          },
        },
      },
    }
    

    Configurazione avanzata

    Modalità thinking nativa

    Moonshot Kimi supporta thinking nativo binario:

    • thinking: { type: "enabled" }
    • thinking: { type: "disabled" }

    Configuralo per modello tramite agents.defaults.models.<provider/model>.params:

    {
      agents: {
        defaults: {
          models: {
            "moonshot/kimi-k2.6": {
              params: {
                thinking: { type: "disabled" },
              },
            },
          },
        },
      },
    }
    

    OpenClaw mappa anche i livelli runtime /think per Moonshot:

    Livello /think Comportamento Moonshot
    /think off thinking.type=disabled
    Qualsiasi livello non-off thinking.type=enabled

    Kimi K2.6 accetta anche un campo facoltativo thinking.keep che controlla la conservazione multi-turn di reasoning_content. Impostalo su "all" per mantenere il reasoning completo tra i turni; omettilo (o lascialo null) per usare la strategia predefinita del server. OpenClaw inoltra thinking.keep solo per moonshot/kimi-k2.6 e lo rimuove dagli altri modelli.

    {
      agents: {
        defaults: {
          models: {
            "moonshot/kimi-k2.6": {
              params: {
                thinking: { type: "enabled", keep: "all" },
              },
            },
          },
        },
      },
    }
    
    Sanitizzazione dell'id di chiamata degli strumenti

    Moonshot Kimi serve id tool_call con forma functions.<name>:<index>. OpenClaw li preserva invariati così le chiamate agli strumenti multi-turn continuano a funzionare.

    Per forzare la sanitizzazione rigida su un provider personalizzato compatibile OpenAI, imposta sanitizeToolCallIds: true:

    {
      models: {
        providers: {
          "my-kimi-proxy": {
            api: "openai-completions",
            sanitizeToolCallIds: true,
          },
        },
      },
    }
    
    Compatibilità dell'utilizzo in streaming

    Gli endpoint Moonshot nativi (https://api.moonshot.ai/v1 e https://api.moonshot.cn/v1) pubblicizzano compatibilità dell'utilizzo in streaming sul trasporto condiviso openai-completions. OpenClaw la ricava dalle capacità degli endpoint, quindi id provider personalizzati compatibili che puntano agli stessi host Moonshot nativi ereditano lo stesso comportamento di streaming-usage.

    Con i prezzi K2.6 inclusi, l'uso in streaming che include token di input, output e cache-read viene anche convertito nel costo USD locale stimato per /status, /usage full, /usage cost e la contabilità delle sessioni supportata dal transcript.

    Riferimento per endpoint e ref modello
    Provider Prefisso ref modello Endpoint Variabile env auth
    Moonshot moonshot/ https://api.moonshot.ai/v1 MOONSHOT_API_KEY
    Moonshot CN moonshot/ https://api.moonshot.cn/v1 MOONSHOT_API_KEY
    Kimi Coding kimi/ Endpoint Kimi Coding KIMI_API_KEY
    Ricerca web N/A Uguale alla regione API Moonshot KIMI_API_KEY o MOONSHOT_API_KEY
    • La ricerca web Kimi usa KIMI_API_KEY o MOONSHOT_API_KEY e usa come predefiniti https://api.moonshot.ai/v1 con il modello kimi-k2.6.
    • Sovrascrivi i metadati di prezzo e contesto in models.providers se necessario.
    • Se Moonshot pubblica limiti di contesto diversi per un modello, regola contextWindow di conseguenza.

    Correlati