Tutoriel pour connecter Codex à Rhino MCP : réaliser une modélisation automatique par IA en 3 étapes

Note de l’auteur : déployez Rhino MCP Server depuis zéro, configurez l’interface APIYI dans Codex et exécutez votre première commande de modélisation en langage naturel en 3 étapes. Comparez ensuite les performances de modélisation de GPT Codex et des modèles Claude.

Piloter Rhino pour créer automatiquement un modèle 3D à partir d’une seule phrase : c’est un besoin fréquent chez les concepteurs 3D et les ingénieurs en modélisation paramétrique. La difficulté ne vient pas de Rhino, mais de la façon de relier le Grand modèle de langage, le protocole MCP et le client. Cet article présente la procédure complète pour connecter Codex + Rhino MCP + l’interface APIYI et vous montre concrètement comment intégrer Rhino MCP à Codex.

Cet article ne se contente pas d’expliquer des concepts : c’est un guide pratique qui suit les étapes « déployer MCP Server → configurer l’interface de Codex → exécuter la première commande ». D’après notre expérience auprès des utilisateurs, trois questions reviennent souvent : comment préparer l’environnement depuis zéro, comment connecter Codex à une API tierce et quel modèle produit les meilleurs résultats en modélisation. Nous y répondons une par une.

Ce que vous allez apprendre : à la fin de cet article, vous pourrez piloter Rhino en langage naturel sur votre ordinateur pour créer des objets géométriques et comparer de manière rigoureuse les performances de différents modèles en modélisation.

Points clés pour connecter Codex à Rhino MCP

Avant de commencer, prenez le temps de comprendre les différents éléments de la chaîne et le rôle de chacun. Beaucoup d’échecs de connexion viennent d’un diagnostic qui confond les problèmes d’API du modèle et ceux du serveur MCP.

Fonctionnement détaillé de Rhino MCP

MCP (Model Context Protocol) est un protocole qui permet aux clients IA d’appeler des outils externes de manière unifiée. Le serveur MCP Rhino enregistre différentes capacités sous forme d’outils, comme « créer un cube », « récupérer les objets du document actuel » ou « exécuter un script Python ». Au démarrage de Codex, celui-ci récupère le nom, la description et la structure des paramètres de ces outils, puis les transmet au Grand modèle de langage.

Lorsque vous saisissez « dessine un cube de 100 × 50 × 20 à l’origine », le modèle ne manipule pas directement Rhino : il renvoie une demande structurée d’appel d’outil. Codex transmet cette demande au serveur MCP, qui la relaie ensuite au plugin Rhino par une connexion locale. Le résultat est renvoyé au modèle en suivant le même chemin. Ainsi, la qualité de la modélisation dépend essentiellement de la capacité du modèle à appeler les outils et à planifier des tâches en plusieurs étapes. C’est donc le critère à prendre le plus en compte lors du choix d’un modèle.

Préparer l’environnement Rhino MCP pour Codex

Avant de commencer, vérifiez que votre machine répond aux conditions suivantes. Rhino MCP est un projet open source communautaire ; les modalités d’installation peuvent légèrement varier d’une version à l’autre. Consultez le README du projet pour connaître les instructions à jour.

Si votre réseau ne permet pas d’accéder de façon fiable aux interfaces officielles à l’étranger, commencez par vérifier l’accès à l’API du modèle. Le serveur MCP et Rhino fonctionnent sur votre machine : seule l’inférence du modèle nécessite une connexion Internet.

Bien démarrer avec Codex et Rhino MCP : créez automatiquement un modèle en 3 étapes

Étape 1 : déployer Rhino MCP Server

Prenons l’exemple du projet open source communautaire rhinomcp. Le déploiement se compose de deux parties : le plug-in côté Rhino et le serveur MCP.

1. Dans Rhino, ouvrez le gestionnaire de packages, recherchez rhinomcp et installez le plug-in. Redémarrez Rhino une fois l’installation terminée.
2. Dans la ligne de commande de Rhino, saisissez la commande de démarrage fournie par le plug-in — mcpstart dans ce projet — afin qu’il commence à écouter les connexions locales.
3. Dans un terminal, exécutez uvx rhinomcp et vérifiez que le serveur MCP démarre correctement, sans afficher d’erreur.

À partir de l’étape 2, Codex démarre automatiquement le serveur MCP. Le démarrage manuel sert donc uniquement à vérifier que l’environnement est correctement configuré. Si uvx est introuvable, c’est généralement parce que uv n’a pas été ajouté au PATH du système. Rouvrez le terminal ou suivez les instructions officielles de uv pour le configurer.

Étape 2 : configurer l’interface APIYI dans Codex

Le fichier de configuration de Codex se trouve dans le répertoire utilisateur, à l’emplacement ~/.codex/config.toml. Il faut y effectuer deux opérations : déclarer un fournisseur de modèles personnalisé et enregistrer Rhino MCP Server.

# ~/.codex/config.toml
model = "gpt-5-codex"          # Utilisez le nom du modèle réellement disponible dans la console APIYI
model_provider = "apiyi"

[model_providers.apiyi]
name = "APIYI"
base_url = "https://api.apiyi.com/v1"   # Interface compatible avec OpenAI d’APIYI
env_key = "APIYI_API_KEY"               # Récupère la clé depuis une variable d’environnement
wire_api = "responses"                  # Pour utiliser le protocole Chat Completions, remplacez par "chat"

[mcp_servers.rhino]
command = "uvx"
args = ["rhinomcp"]

Définissez ensuite la variable d’environnement dans un terminal. Sous Windows, vous pouvez l’ajouter dans les variables d’environnement système :

export APIYI_API_KEY="sk-votre-clé"

La valeur de wire_api doit correspondre au protocole pris en charge par le modèle choisi. Si une erreur liée au protocole apparaît après la configuration, essayez l’autre valeur. Pour plus de détails, consultez la documentation APIYI sur l’utilisation de Codex.

Étape 3 : lancer votre première instruction de modélisation en langage naturel

Laissez Rhino ouvert et le plug-in en mode écoute, puis saisissez codex dans le terminal pour lancer le client. Vous pouvez commencer par demander : « Quels outils Rhino sont disponibles ? » Si le modèle vous présente des outils de modélisation, cela signifie que MCP a bien été chargé.

Commencez par des instructions simples, puis augmentez progressivement la complexité des tâches. En cas de problème, vous pourrez ainsi en trouver plus facilement la cause :

Pour les tâches complexes, le modèle choisit généralement un outil du type « Exécuter un script Python » et génère en une seule fois le code RhinoScript nécessaire à la modélisation. La réussite dépend alors directement de ses capacités à générer du code.

Exemple minimal : vérifier avec Python la capacité d’un modèle à appeler des outils

Avant d’intégrer Codex, vous pouvez aussi exécuter un petit script pour vérifier que le modèle renvoie les bons paramètres d’appel pour les outils de modélisation. Cette étape permet d’écarter rapidement un problème d’indisponibilité de l’API du modèle :

import openai, json

client = openai.OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")

tools = [{"type": "function", "function": {
    "name": "create_box",
    "description": "在 Rhino 中创建立方体",
    "parameters": {"type": "object", "properties": {
        "origin": {"type": "array", "items": {"type": "number"}},
        "size": {"type": "array", "items": {"type": "number"}}},
        "required": ["origin", "size"]}}}]

resp = client.chat.completions.create(
    model="gpt-5-codex",  # 以控制台实际模型名为准
    messages=[{"role": "user", "content": "在原点画一个 100x50x20 的立方体"}],
    tools=tools)
call = resp.choices[0].message.tool_calls[0]
print(call.function.name, json.loads(call.function.arguments))

import openai
import json
from typing import List, Dict

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # 同一个 Key 可调用 GPT 与 Claude 系列
)

# 待测试的模型，请替换为控制台中实际可用的模型名
MODELS = ["gpt-5-codex", "claude-sonnet-4-5"]

TOOLS = [
    {"type": "function", "function": {
        "name": "create_box",
        "description": "创建立方体，origin 为角点坐标，size 为长宽高",
        "parameters": {"type": "object", "properties": {
            "origin": {"type": "array", "items": {"type": "number"}},
            "size": {"type": "array", "items": {"type": "number"}}},
            "required": ["origin", "size"]}}},
    {"type": "function", "function": {
        "name": "create_cylinder",
        "description": "创建圆柱，base 为底面圆心，radius 为半径，height 为高度",
        "parameters": {"type": "object", "properties": {
            "base": {"type": "array", "items": {"type": "number"}},
            "radius": {"type": "number"},
            "height": {"type": "number"}},
            "required": ["base", "radius", "height"]}}},
]

PROMPT = "画一张 1200x600x30 的桌面，桌面底部在 z=720，四角各加一条直径 40、高 720 的桌腿"


def run_test(model: str) -> List[Dict]:
    """返回模型规划出的全部工具调用"""
    try:
        resp = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": "你是 Rhino 建模助手，请一次性规划所有工具调用。"},
                {"role": "user", "content": PROMPT},
            ],
            tools=TOOLS,
        )
        calls = resp.choices[0].message.tool_calls or []
        return [{"name": c.function.name,
                 "args": json.loads(c.function.arguments)} for c in calls]
    except Exception as e:
        return [{"error": str(e)}]


if __name__ == "__main__":
    for m in MODELS:
        result = run_test(m)
        print(f"\n===== {m}：共 {len(result)} 个调用 =====")
        for item in result:
            print(item)
        # 期望：1 个 create_box + 4 个 create_cylinder，且桌腿位于四个角

🚀 Pour commencer rapidement : nous vous conseillons de récupérer d’abord les crédits gratuits de test réservés aux nouveaux utilisateurs sur APIYI, apiyi.com. Exécutez le script ci-dessus pour vérifier que les appels d’outils fonctionnent, puis intégrez Codex et Rhino. En cas de problème, vous pourrez ainsi déterminer s’il vient de l’API du modèle ou de l’environnement MCP local.

Comment choisir un modèle pour connecter Codex à Rhino MCP

La modélisation automatisée par l’IA repose sur trois capacités essentielles : la génération de code, les appels d’outils et la planification de tâches complexes. D’après notre expérience, nous vous recommandons de tester en priorité les séries GPT Codex et Claude Sonnet/Opus. Le tableau ci-dessous propose une comparaison qualitative ; les résultats peuvent varier selon vos tâches de modélisation. Le mieux est donc de faire vos propres essais.

Comparaison avec GPT Codex : la série GPT Codex s’intègre de façon particulièrement naturelle au client Codex. Sa configuration est simple et son style reste stable lors de la génération de scripts RhinoScript Python. En revanche, pour les tâches de modification qui nécessitent de consulter la scène à plusieurs reprises avant de prendre une décision, les résultats peuvent varier selon la formulation de l’invite. Pour la modélisation paramétrique principalement basée sur la génération de scripts, c’est un choix de départ fiable.

Comparaison avec la série Claude : Claude Sonnet/Opus est réputé pour la précision des paramètres lors des appels d’outils et sa capacité à planifier des séquences d’actions complexes. Si vous préférez Claude, vous pouvez aussi utiliser Claude Code avec le même serveur Rhino MCP, comme client de remplacement. Cela dit, appeler Claude dans Codex via une interface compatible avec OpenAI facilite la comparaison des modèles dans un même environnement.

💡 Conseil : les performances d’un modèle dépendent fortement du type de modélisation ; il n’existe pas de meilleur choix dans l’absolu. Nous vous conseillons de tester GPT Codex et Claude avec la même clé via APIYI apiyi.com. Utilisez le script de comparaison présenté plus haut avec les mêmes instructions, puis faites votre choix en fonction du taux de réussite et du coût.

Dépannage des erreurs fréquentes lors de la connexion de Codex à Rhino MCP

La plupart des erreurs rencontrées lors de la connexion peuvent être diagnostiquées étape par étape, dans cet ordre : « interface du modèle → configuration de Codex → serveur MCP → plug-in Rhino ».

FAQ

Points clés pour connecter Codex à Rhino MCP

• Composants de la chaîne : le plug-in Rhino, le serveur MCP, le client Codex et l’API du modèle sont tous indispensables.
• Déploiement local : le serveur Rhino MCP et Codex fonctionnent sur votre ordinateur ; seule l’inférence du modèle nécessite une connexion Internet.
• Configuration essentielle : déclarez à la fois le fournisseur du modèle et mcp_servers dans config.toml.
• Progression par étapes : commencez par créer un seul cube, puis passez progressivement à des tâches de planification en plusieurs étapes et de génération de scripts.
• Choix du modèle : testez en priorité les modèles de la gamme GPT Codex et les modèles Claude Sonnet/Opus.
• Pour démarrer : une seule clé API APIYI suffit pour comparer plusieurs modèles dans le même environnement.

En résumé

Pour connecter Codex à Rhino MCP, suivez ces étapes :

1. Étape 1 : déployer le serveur MCP : installez le plug-in Rhino et lancez l’écoute, puis vérifiez le service avec uvx rhinomcp.
2. Étape 2 : configurer l’interface du modèle : définissez un fournisseur personnalisé dans le fichier de configuration de Codex et ajoutez Rhino MCP.
3. Étape 3 : tester les commandes de modélisation : commencez par des instructions simples, puis vérifiez progressivement la capacité du modèle à appeler des outils et à planifier.

Une fois toute la chaîne opérationnelle, le choix du modèle et la formulation des instructions déterminent vraiment la qualité de la modélisation. Nous vous conseillons d’utiliser le script de comparaison de cet article pour tester vos propres tâches de modélisation courantes.

Pour vérifier rapidement les résultats, nous vous recommandons APIYI, sur apiyi.com. La plateforme propose une interface compatible avec OpenAI, un crédit d’essai gratuit et un accès unifié à plusieurs modèles, ce qui permet de passer facilement des modèles GPT à ceux de Claude dans Codex.

📚 Références

1. Projet open source rhinomcp : implémentation du plugin Rhino MCP et du serveur
2. Lien : github.com/jingcheng-chen/rhinomcp

3. Présentation : comprend les étapes d’installation, la liste des outils disponibles et les informations de compatibilité des versions

4. Dépôt du projet OpenAI Codex : instructions d’installation et de configuration de Codex CLI

5. Lien : github.com/openai/codex

6. Présentation : documentation de référence sur les fournisseurs de modèles et les paramètres de configuration du serveur MCP dans config.toml

7. Documentation officielle du Model Context Protocol : spécification du protocole MCP

8. Lien : modelcontextprotocol.io
9. Présentation : ressources de base pour comprendre l’enregistrement, l’appel et le retour des outils

Auteur : équipe technique d’APIYI
Échanges techniques : n’hésitez pas à nous contacter depuis la page d’accueil du site officiel d’APIYI. Pour les instructions de configuration de Codex, Claude Code et d’autres cas d’utilisation, consultez le centre de documentation à l’adresse docs.apiyi.com

Articles connexes

• Tutoriel pas à pas : une seule clé pour connecter tous les agents et unifier l’accès aux API avec la passerelle API open source magpie (exemples avec Claude Code, Codex, Pi et Hermes): Un tutoriel à suivre étape par étape : en environ 30 minutes, faites en sorte que tous les agents de programmation de votre machine (Claude Code, Codex, Pi et Hermes, par exemple) utilisent la même clé API et la même adresse de passerelle ; il comprend des captures d’écran de l’interface magpie, les étapes de configuration, une comparaison des configurations natives et un tableau de dépannage.