Xcode prend désormais en charge Kimi K3 : le guide complet pas à pas pour débutants

Dès la sortie de Kimi K3, beaucoup de développeurs de l'écosystème Apple ont eu la même première réaction : "est-ce que je peux l'utiliser directement dans Xcode ?" La réponse est oui — et il existe même plusieurs façons de le faire. Ce guide est purement pratique, étape par étape, sans détour théorique : trois méthodes réelles de connexion, dans l'ordre — le fournisseur de modèle personnalisé natif de Xcode (aucun outil tiers, la plus simple), OpenCode (authentification Moonshot AI intégrée officiellement, avec en plus le pont MCP de Xcode 27 qui permet à l'agent d'agir réellement sur votre projet), et l'outil tiers open source CC Switch (routeur local + convertisseur de protocole, idéal si vous jonglez avec plusieurs CLI et plusieurs modèles). Chaque méthode est accompagnée d'étapes à suivre directement, des noms de champs réels, et des pièges connus. Une section est aussi dédiée aux lecteurs de Chine continentale : si la connexion directe au nœud international officiel de Moonshot n'est pas pratique, les trois méthodes peuvent être redirigées sans problème vers le point de terminaison d'un relais d'API IA.

1. Pourquoi ça vaut le coup de connecter Kimi K3 à Xcode

Moonshot AI a lancé Kimi K3 le 16 juillet 2026 — 2,8 billions de paramètres, présenté par l'entreprise comme "le premier modèle de pointe à poids ouverts de classe 3T au monde", avec une fenêtre de contexte de 1 048 576 tokens (environ 1M), l'une des plus longues actuellement accessibles aux développeurs de l'écosystème Apple. La demande a été multipliée par six en moins de 48 heures après le lancement, forçant Moonshot à suspendre temporairement les nouvelles inscriptions pour préserver la qualité de service des utilisateurs existants — un signe assez fort que sa capacité de codage tient réellement la charge réelle, pas seulement les benchmarks.

Pour qui écrit du Swift/SwiftUI/UIKit, plusieurs points de Kimi K3 méritent l'attention : sa fenêtre de contexte de 1M tokens permet de lui confier un module entier, voire plusieurs fichiers d'un coup, sans avoir à découper le contenu comme on le ferait avec un modèle à contexte plus court ; son "mode de réflexion" toujours actif (ajustable via reasoning_effort sur trois niveaux low/high/max) tend à être plus stable qu'un modèle "en un seul passage" sur des refactorings complexes ou pour démêler des dépendances entre plusieurs fichiers ; et il s'agit d'une API déjà lancée officiellement — pas d'une préversion — donc le tarif, les benchmarks et la stabilité sont tous vérifiables, sans avoir à parier sur un produit encore en bêta.

Xcode ne reconnaît pas Kimi K3 par défaut, cependant : il sort d'usine relié à Apple Intelligence et à une courte liste de modèles de grands fournisseurs "officiellement reconnus". Pour utiliser Kimi K3, il faut passer par l'une des trois méthodes ci-dessous afin de le "brancher" sur la fonctionnalité Coding Intelligence de Xcode. Aucune des trois n'est strictement meilleure que les autres — elles répondent à des besoins différents. La section suivante donne la version courte, puis chaque méthode est détaillée pas à pas.

Un peu de contexte sur pourquoi ça vaut ces quelques minutes : plusieurs médias économiques rapportent un chiffre d'affaires annualisé (ARR) de Moonshot d'environ 300 millions de dollars en juin, une valorisation ayant brièvement dépassé les 20 milliards de dollars, une levée de fonds en cours, et une introduction en bourse à Hong Kong en préparation. Ces chiffres ne disent rien sur la qualité du code produit, mais ils suggèrent que ce n'est pas un modèle "lancé puis oublié" — les mises à jour et les intégrations dans l'écosystème (Xcode, OpenCode, divers plugins d'IDE) devraient continuer à suivre, ce qui rend l'investissement de ces quelques minutes de configuration plutôt rentable sur la durée.

2. En bref : comment choisir entre les trois méthodes

Les trois méthodes ne répondent pas au même besoin — voici d'abord un tableau des différences, avant de détailler chacune pas à pas :

Si vous voulez simplement discuter avec Kimi K3 dans Xcode le plus vite possible, allez directement à la Méthode 1 : cinq minutes suffisent. Si vous privilégiez l'autonomie de l'agent (modifier des fichiers, lancer des builds, lire les diagnostics à votre place), regardez la Méthode 2. Si Xcode n'est pas votre seul outil et que vous devez aussi gérer Claude Code, Codex et d'autres CLI, regardez la Méthode 3.

3. Préparation : obtenir une clé API Kimi K3

Les trois méthodes utilisent la même clé — une clé API de la plateforme ouverte officielle de Moonshot AI. Commencez par cette étape :

1. Rendez-vous sur platform.kimi.ai (Kimi Open Platform) et inscrivez-vous / connectez-vous
2. Le compte doit d'abord être rechargé d'au moins 1 $ pour que la clé fonctionne réellement (les appels échouent une fois le quota gratuit épuisé ou le solde à zéro)
3. Créez une nouvelle clé API dans la console et sauvegardez-la bien — elle ne s'affiche en entier qu'une seule fois

Notez au passage deux informations que vous réutiliserez pour chaque méthode :

• URL de base de l'API : https://api.moonshot.ai/v1 (un point de terminaison compatible OpenAI, protocole Chat Completions)
• Identifiant du modèle : kimi-k3 (exactement ces caractères, pas kimi-k3-chat — une faute ici renvoie directement une erreur 404)

4. Méthode 1 : le fournisseur de modèle personnalisé natif de Xcode (la plus simple, aucun outil tiers)

La fonctionnalité Coding Intelligence de Xcode 26/27 permet d'ajouter n'importe quel fournisseur de modèle personnalisé compatible avec le format OpenAI (ou le format Claude), sans logiciel supplémentaire. C'est le chemin le plus direct des trois.

Étape 1 : ouvrir les réglages Intelligence

Ouvrez Xcode, appuyez sur ⌘, pour accéder aux Réglages (Settings), puis passez à l'onglet Intelligence. Le libellé exact peut légèrement varier selon la version de Xcode (certaines l'appellent "Intelligence", d'autres "Intelligence Mode"), mais l'option se trouve toujours dans les réglages.

Étape 2 : ajouter un Model Provider

Cliquez sur "Add a Model Provider…" (sur certaines versions récentes, ce bouton s'intitule "Add a Chat Provider" — le libellé change au fil des versions de Xcode, mais l'emplacement reste le même). Dans le sélecteur de type qui apparaît, choisissez "Internet Hosted" (à distinguer de "Locally Hosted", réservé aux modèles exécutés localement comme Ollama).

Étape 3 : renseigner les informations de connexion

Quelques champs apparaissent ensuite — voici exactement quoi y mettre :

Étape 4 : choisir le modèle

Une fois le fournisseur enregistré, Xcode tente de récupérer la liste des modèles disponibles pour ce provider. Si Kimi K3 n'apparaît pas automatiquement, saisissez le nom du modèle manuellement — il doit être exactement kimi-k3. L'erreur courante est de taper kimi-k3-chat, un nom qui n'existe pas et renvoie une erreur 404.

Étape 5 : vérifier la connexion

Ouvrez n'importe quel projet, passez en mode Agent de Xcode (ou dans le panneau de discussion Coding Intelligence), sélectionnez Kimi K3 comme modèle actif, posez d'abord une question simple ("présente-toi en une phrase") pour vérifier que la connexion fonctionne, puis testez un cas réel — par exemple, sélectionnez un fichier de View existant et demandez-lui "d'expliquer le flux de données de ce code SwiftUI et de signaler les risques potentiels de retain cycle", et vérifiez si la réponse comprend bien le contexte du projet et propose des conseils concrets et applicables. Si tout fonctionne, la configuration est réussie. En cas d'erreur, passez directement à la section 8 pour le dépannage.

Concrètement, voici ce qui se passe : Xcode envoie directement vos requêtes de discussion, au format OpenAI Chat Completions, vers le point de terminaison officiel de Moonshot, sans aucune couche de proxy ou de conversion intermédiaire — le chemin le plus court, la latence la plus faible, et la méthode la moins susceptible de poser problème parmi les trois. La contrepartie, c'est qu'elle ne fait que de la conversation : Xcode envoie le contenu du fichier actuellement ouvert comme contexte, mais ne permet pas au modèle de créer ou modifier lui-même plusieurs fichiers, ni de lancer un build pour vérifier les diagnostics, contrairement à la Méthode 2 couplée au pont MCP. Pour écrire du code au quotidien, poser des questions ou obtenir des extraits, cette méthode est déjà largement suffisante.

5. Méthode 2 : se connecter via OpenCode (authentification Moonshot AI intégrée + pont MCP Xcode 27)

OpenCode est un agent de codage open source qui tourne dans le terminal, avec une prise en charge officielle et intégrée de l'authentification Moonshot AI — pas besoin de saisir une URL de base manuellement. Plus loin encore, la documentation officielle de Kimi confirme un usage plus agentique : connecter OpenCode (avec Kimi K3 comme modèle) directement au projet Xcode via le support MCP (Model Context Protocol) de Xcode 27, lui donnant la capacité de lire/écrire des fichiers, récupérer les diagnostics de compilation en temps réel, exécuter le REPL Swift et piloter les aperçus SwiftUI — pas seulement discuter.

Étape 1 : installer OpenCode

Sur macOS, Homebrew est la solution la plus simple :

brew install opencode-ai/tap/opencode

Ou via npm (multiplateforme, nécessite Node.js 18+) :

npm install -g @opencode-ai/opencode

Étape 2 : s'authentifier auprès de Moonshot AI

Une fois installé, exécutez la commande d'authentification dans le terminal :

opencode auth login

Dans la liste des fournisseurs qui apparaît, choisissez "Moonshot AI", collez la clé API obtenue à la section 3, et validez. Aucune URL de base à saisir manuellement — OpenCode intègre déjà la configuration de Moonshot.

Étape 3 : sélectionner le modèle Kimi K3

Une fois OpenCode lancé, utilisez la commande intégrée pour changer de modèle :

/models

Choisissez Kimi K3 dans la liste. Toutes les conversations, générations de code et actions d'agent dans OpenCode seront désormais pilotées par Kimi K3.

Étape 4 (avancé) : relier OpenCode au pont MCP de Xcode 27

Si vous vouliez juste une conversation autonome avec OpenCode, l'étape 3 suffit déjà. Mais l'usage explicitement mentionné dans la documentation officielle de Kimi consiste à laisser OpenCode agir directement sur le projet ouvert dans Xcode — ce qui nécessite le support MCP (Model Context Protocol) ajouté par Xcode 27 :

1. Ouvrez les Réglages de Xcode (⌘,) → Intelligence, repérez l'option liée au Model Context Protocol et activez-la (sur certaines versions le libellé est "Enable Model Context Protocol")
2. Les outils en ligne de commande de Xcode incluent un binaire nommé mcpbridge, chargé de traduire les requêtes du protocole MCP standard en appels XPC internes à Xcode — le même mécanisme qu'Apple utilise pour donner à des agents externes comme Claude Code ou Codex un accès au projet
3. Enregistrez OpenCode comme client capable de se connecter à ce pont MCP. La commande officielle d'enregistrement pour Claude Code est claude mcp add --transport stdio xcode -- xcrun mcpbridge ; OpenCode utilise un champ de configuration standard mcp — ajoutez un bloc similaire à celui ci-dessous à la racine du projet (ou dans ~/.opencode.json) pour enregistrer xcrun mcpbridge comme serveur MCP local
4. Xcode doit rester ouvert avec un projet chargé — mcpbridge se connecte via XPC à un processus Xcode "vivant", donc les environnements en ligne de commande pure (comme la CI) ne peuvent pas emprunter ce chemin

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "xcode": {
      "type": "local",
      "command": ["xcrun", "mcpbridge"],
      "enabled": true
    }
  }
}

Enregistrez ce fichier .opencode.json (ou le fichier global ~/.opencode.json) puis redémarrez OpenCode — il lancera automatiquement xcrun mcpbridge comme processus local et établira la connexion. Vérifiez les noms exacts des champs dans la documentation MCP actuelle d'OpenCode, mais la structure globale — un champ de premier niveau mcp, type: "local", et un tableau command — correspond au schéma standard qu'OpenCode utilise pour configurer un serveur MCP local.

Astuce : ajuster reasoning_effort selon la tâche

Le mode de réflexion de Kimi K3 ne peut pas être complètement désactivé, mais son intensité peut être réglée via reasoning_effort sur trois niveaux : low / high / max. Pour les petites modifications du quotidien, les commentaires, ou compléter des tests unitaires, le niveau low suffit largement et reste rapide ; pour démêler des dépendances entre plusieurs fichiers, un refactoring au niveau architecture, ou traquer un bug tenace — des tâches qui demandent de "bien réfléchir avant d'agir" — passez sur high ou max : le temps d'attente augmente, mais la qualité du résultat est généralement plus fiable. Dans OpenCode, ce réglage peut être ajusté par session sans toucher au fichier de configuration.

6. Méthode 3 : CC Switch (routeur local tiers, pour les configurations multi-outils)

CC Switch (GitHub : farion1231/cc-switch) est une application de bureau open source et multiplateforme, conçue à l'origine pour unifier la configuration des fournisseurs à travers Claude Code, Codex, Gemini CLI, OpenCode et d'autres CLI de codage IA. Son mécanisme central consiste à démarrer un proxy HTTP local (à l'écoute par défaut sur 127.0.0.1:15721) qui expose vers l'extérieur une interface Chat Completions compatible OpenAI unifiée, tout en gérant en interne la véritable conversion de protocole et le routage.

Étape 1 : installer CC Switch

Sur macOS, Homebrew est recommandé (avec mises à jour automatiques) :

brew tap farion1231/ccswitch
brew install --cask cc-switch

Les utilisateurs Windows peuvent télécharger l'installeur .msi depuis GitHub Releases ; les utilisateurs Linux choisissent selon leur distribution : .deb/.rpm/AUR/.AppImage. Vous pouvez aussi vous rendre directement sur ccswitch.io ou le dépôt GitHub pour récupérer le bon paquet.

Étape 2 : ajouter un fournisseur Kimi K3

1. Ouvrez CC Switch et cliquez sur le "+" en haut à droite pour ajouter un nouveau fournisseur
2. Si un préréglage comme "Kimi For Coding" existe dans la liste, sélectionnez-le directement ; sinon, choisissez "Fournisseur personnalisé" et saisissez manuellement https://api.moonshot.ai/v1 comme URL de base et kimi-k3 comme nom de modèle
3. Collez votre clé API Moonshot
4. Dans les "Réglages avancés", vérifiez ces points : Upstream format réglé sur Chat Completions (routing required) ; Context window réglé sur 1048576 ; activez Supports thinking mode et Supports reasoning effort (correspondant au mode de réflexion toujours actif de Kimi K3 et à son paramètre reasoning_effort)

Ce paramètre "routing required" est essentiel : des outils comme Codex CLI utilisent le protocole OpenAI Responses API, tandis que Kimi Open Platform expose une API Chat Completions standard compatible OpenAI — deux protocoles différents. La fonction Local Routing de CC Switch se charge de convertir en temps réel les requêtes et les réponses en streaming entre les deux, ce qui explique pourquoi cette troisième méthode nécessite son propre processus de routage local dédié, contrairement à la Méthode 1 qui se connecte directement.

Étape 3 : activer le Local Routing

1. Allez dans les Réglages de CC Switch et activez l'interrupteur principal de Routing pour démarrer le service local (adresse par défaut 127.0.0.1:15721)
2. Dans la liste Routing Enabled, cochez l'outil cible que vous voulez router (par exemple Codex)
3. Cliquez sur "Health Check" (vérification de santé) sur l'entrée Kimi K3 que vous venez de configurer — CC Switch envoie une requête de test pour confirmer que la clé et le point de terminaison fonctionnent bien, évitant ainsi de déboguer une configuration cassée plus tard depuis Xcode

CC Switch existe fondamentalement pour transformer "N CLI, chacune avec son propre fichier de configuration, chacune pointant vers un fournisseur différent" en "un seul écran qui gère tout". Si Xcode est votre seul outil, la Méthode 1 suffit déjà et installer toute une application de bureau juste pour ce cas serait excessif ; mais si vous utilisez aussi Claude Code ou Codex sur d'autres projets, CC Switch permet de garder les clés de Kimi K3, DeepSeek, GLM et de tous les relais au même endroit, rendant les changements et le dépannage bien plus simples — c'est la principale raison pour laquelle il est régulièrement recommandé dans les communautés de développeurs.

Étape 4 : faire passer Xcode par le routeur local de CC Switch (optionnel)

CC Switch cible avant tout des outils en ligne de commande comme Codex CLI ou Claude Code — il n'intègre pas nativement une option "Xcode Provider" dédiée. Mais comme ce qu'il expose vers l'extérieur reste un point de terminaison Chat Completions standard compatible OpenAI, vous pouvez tout à fait reprendre la configuration du fournisseur personnalisé de Xcode vue en Méthode 1 et remplacer l'URL de l'adresse officielle de Moonshot par l'adresse locale de CC Switch :

URL : http://127.0.0.1:15721
API Key Header : Authorization
API Key : (selon ce que demande cette entrée de fournisseur dans CC Switch — souvent n'importe quelle chaîne de caractères de remplacement fonctionne, car la véritable authentification a déjà eu lieu dans CC Switch)

Ainsi, les requêtes de Xcode arrivent en réalité sur la passerelle locale de CC Switch sur votre machine, qui les transmet ensuite à Kimi K3 — l'avantage étant de pouvoir gérer depuis CC Switch le changement de fournisseur, la bascule automatique et les préréglages de relais, sans devoir modifier la configuration de Xcode dans un sens puis dans l'autre.

7. Note pour la Chine continentale : utiliser un relais à la place du point de terminaison officiel

Si la connexion directe au nœud international officiel de Moonshot n'est pas toujours fluide depuis la Chine continentale, les trois méthodes ci-dessus n'ont fondamentalement besoin que d'"une URL de base compatible OpenAI plus une clé API" — les remplacer est simple :

• Méthode 1 (fournisseur natif de Xcode) : remplacez l'URL par l'adresse de votre relais d'API IA (en veillant toujours à ne pas ajouter /v1 en trop, selon la documentation de ce relais), remplacez la clé API par celle fournie par le relais, et utilisez l'alias de modèle indiqué par sa documentation si celui-ci mappe Kimi K3 sous un autre nom
• Méthode 2 (OpenCode) : si le relais n'est pas reconnu comme fournisseur natif dans OpenCode, utilisez la configuration générique de fournisseur personnalisé compatible OpenAI d'OpenCode — renseignez l'URL de base et la clé du relais, Kimi K3 reste sélectionnable
• Méthode 3 (CC Switch) : CC Switch intègre plus de 50 préréglages pour les principaux relais chinois — il suffit de sélectionner le préréglage du relais lors de l'ajout d'un fournisseur et de coller la clé correspondante, plus simple que de saisir l'adresse à la main

Lors du choix d'un relais, vérifiez qu'il proxifie bien Kimi K3 spécifiquement (et pas seulement une ancienne version de Kimi), et comparez sa facturation à celle du lien direct officiel — voir notre comparatif des relais d'API IA pour une vue d'ensemble.

8. Checklist de dépannage

9. Conclusion : laquelle choisir