Serveur MCP TokenLab

Le serveur MCP TokenLab génère des outils MCP à partir du contrat OpenAPI public de TokenLab. Les agents compatibles MCP peuvent découvrir les modèles et les tarifs, appeler des endpoints LLM natifs et compatibles OpenAI, créer des médias multimodaux, télécharger des fichiers et gérer des tâches asynchrones. Utilisez-le lorsqu’un agent a besoin du contrat API TokenLab actuel au lieu d’une liste d’outils maintenue manuellement. Le profil core par défaut expose 29 outils d’endpoint générés ainsi que deux outils de découverte composites. Le profil full expose 78 outils d’endpoint générés ainsi que les deux mêmes outils composites. Cette page explique comment ajouter TokenLab comme serveur d’outils dans Claude Code, Cursor, VS Code, Codex, Claude Desktop, Cline, Windsurf ou un autre client MCP. Pour appeler TokenLab directement depuis le code d’une application, commencez par le démarrage rapide de l’API.

Les outils de catalogue public et de tarification ne nécessitent pas de clé API TokenLab. Définissez TOKENLAB_API_KEY pour les opérations d’inférence, de média, d’audio, de fichier, de tâche, d’embedding, de rerank et de traduction nécessitant une authentification. Ne placez jamais de clé API dans les arguments des outils.

Ce qu’il propose

Découverte de modèles en temps réel depuis https://api.tokenlab.sh/v1/models.
Recherche de détails sur les modèles depuis /v1/models/{model}.
Recherche de tarifs depuis /v1/models/{model}/pricing.
Aperçu de l’API lisible par les agents depuis https://api.tokenlab.sh/llms.txt.
Chat Completions et Responses compatibles OpenAI, Anthropic Messages et Gemini generateContent sans aplatir leurs structures de requête natives.
Génération et édition d’images via des URL JSON, des ID de fichiers TokenLab ou des fichiers multipart locaux.
Vidéo, musique, 3D, parole, transcription, traduction audio, embeddings, embeddings multimodaux, rerank et traduction de texte.
Résumés de tâches asynchrones normalisés pour les opérations de génération d’images, de vidéos, de musique, de 3D et de mondes.
Une synchronisation quotidienne du contrat qui récupère le document OpenAPI public, régénère les schémas d’outils, exécute des tests d’endpoint et de fichiers, et met à jour main uniquement lorsque chaque vérification réussit.

Démarrage rapide

Le moyen le plus simple et le plus sûr de commencer consiste à activer les six outils du catalogue public. Aucune clé API TokenLab n’est nécessaire et vous pourrez activer les outils authentifiés plus tard.

Installer dans Cursor

Ajouter le profil public catalog à Cursor en un clic

Installer dans VS Code

Ajouter le profil public catalog à la configuration utilisateur de VS Code

Vérifier les prérequis

Installez Node.js 18.17 ou une version plus récente et vérifiez que npx est disponible.

node --version
npx --version

Il n’est pas nécessaire d’installer le paquet MCP globalement ni de cloner son dépôt.

Choisir un niveau d'accès

Objectif	Clé API	Profil
Parcourir les modèles, leurs détails et leurs tarifs	Non requise	`catalog` (6 outils)
Utiliser les opérations courantes d’inférence, de média, de fichier et de tâche	Requise pour les appels payants	`core` (31 outils, par défaut)
Exposer toutes les opérations développeur autorisées	Requise pour les appels payants	`full` (80 outils)

Créez une clé dans Dashboard → API Keys uniquement pour effectuer des appels API authentifiés. Conservez-la dans l’environnement secret du client et ne la collez jamais dans un prompt ou un argument d’outil MCP.

Configurer votre client

Les exemples publics sélectionnent explicitement catalog afin que tous les outils exposés fonctionnent sans clé.

Ajoutez TokenLab au niveau utilisateur pour le rendre disponible dans tous les projets.

claude mcp add --env TOKENLAB_MCP_TOOL_PROFILE=catalog --scope user tokenlab-model-catalog -- npx -y @tokenlabai/mcp-server

Pour activer le profil core par défaut, ajoutez plutôt votre clé API.

claude mcp add --env TOKENLAB_API_KEY=your-tokenlab-api-key --scope user tokenlab-model-catalog -- npx -y @tokenlabai/mcp-server

Utilisez --scope local uniquement pour le projet actuel, ou --scope project pour créer un fichier .mcp.json partagé. Ne validez jamais une vraie clé dans une configuration de projet.

Utilisez l’installation en un clic ci-dessus, ou enregistrez la configuration dans ~/.cursor/mcp.json pour tous les projets ou .cursor/mcp.json pour un seul projet.

{
  "mcpServers": {
    "tokenlab-model-catalog": {
      "command": "npx",
      "args": ["-y", "@tokenlabai/mcp-server"],
      "env": { "TOKENLAB_MCP_TOOL_PROFILE": "catalog" }
    }
  }
}

Utilisez l’installation en un clic, exécutez MCP: Add Server ou enregistrez ce fichier sous .vscode/mcp.json.

{
  "servers": {
    "tokenlab-model-catalog": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@tokenlabai/mcp-server"],
      "env": { "TOKENLAB_MCP_TOOL_PROFILE": "catalog" }
    }
  }
}

Pour une configuration globale à l’utilisateur, exécutez MCP: Open User Configuration et ajoutez-y le même objet serveur.

# Catalogue public
codex mcp add --env TOKENLAB_MCP_TOOL_PROFILE=catalog tokenlab-model-catalog -- npx -y @tokenlabai/mcp-server

# Profil core par défaut avec clé API
codex mcp add --env TOKENLAB_API_KEY=your-tokenlab-api-key tokenlab-model-catalog -- npx -y @tokenlabai/mcp-server

Dans claude_desktop_config.json, ajoutez à l’objet standard mcpServers la commande npx et les arguments -y et @tokenlabai/mcp-server. Pour les seuls outils publics, définissez TOKENLAB_MCP_TOOL_PROFILE=catalog.

Cline CLI peut installer directement le serveur stdio publié.

cline mcp add tokenlab --yes -- npx -y @tokenlabai/mcp-server

Pour Windsurf, enregistrez la configuration standard mcpServers dans ~/.codeium/windsurf/mcp_config.json. Les autres clients stdio utilisent la même commande et les mêmes arguments, sans répertoire de travail.

Redémarrer et vérifier

Redémarrez ou rechargez le client MCP, approuvez le serveur local si nécessaire, puis vérifiez que tokenlab-model-catalog est connecté.

claude mcp list
codex mcp list

Demandez ensuite à l’agent d’appeler list_models. Une liste de modèles non vide confirme le démarrage du serveur, la découverte MCP et l’accès au catalogue public TokenLab. Cette vérification ne nécessite aucune clé API.

Référence de configuration

Pour tout client stdio local, utilisez le nom tokenlab-model-catalog, la commande npx, les arguments séparés -y et @tokenlabai/mcp-server, et aucun répertoire de travail. Utilisez @tokenlabai/mcp-server@0.6.17 pour figer la version actuellement vérifiée. Configuration standard des outils authentifiés :

{
  "mcpServers": {
    "tokenlab-model-catalog": {
      "command": "npx",
      "args": ["-y", "@tokenlabai/mcp-server"],
      "env": {
        "TOKENLAB_API_KEY": "<TOKENLAB_API_KEY>",
        "TOKENLAB_MCP_TOOL_PROFILE": "core"
      }
    }
  }
}

VS Code utilise un objet servers à la racine. Si le client attend un seul objet serveur, copiez uniquement l’objet interne contenant command, args et env.

Variable d’environnement	Valeur par défaut	Rôle
`TOKENLAB_API_BASE`	`https://api.tokenlab.sh`	Remplacer l’URL de base de l’API, sans barre oblique finale.
`TOKENLAB_API_KEY`	Non définie	Requise pour les appels authentifiés d’inférence, de média, de fichier, de tâche, d’embedding, de rerank et de traduction.
`TOKENLAB_MCP_TOOL_PROFILE`	`core`	Choisir `catalog`, `core` ou `full`.
`TOKENLAB_MCP_SCHEMA_MODE`	Valeur du profil	Choisir `portable`, `exact` ou `strict` ; conserver normalement `portable`.
`TOKENLAB_REQUEST_TIMEOUT_MS`	`120000`	Délai maximal des requêtes API en millisecondes.
`TOKENLAB_MCP_MAX_FILE_BYTES`	`104857600`	Taille maximale en octets de chaque fichier local envoyé.
`TOKENLAB_MCP_INLINE_BYTES`	`2097152`	Taille maximale d’un résultat binaire ou JSON renvoyé en ligne.
`TOKENLAB_ARTIFACT_DIR`	Répertoire temporaire du système	Emplacement d’écriture des artefacts de réponse volumineux.

Ne publiez jamais de capture d’écran, journal, historique de shell ou fichier de configuration contenant une vraie clé API. Préférez les entrées secrètes ou les variables d’environnement du client, utilisez des espaces réservés dans les exemples partagés et renouvelez toute clé exposée.

Installation depuis les sources

Utilisez une copie des sources uniquement pour auditer ou développer le serveur MCP. La configuration normale d’un client doit utiliser le paquet npm publié ci-dessus.

git clone https://github.com/hedging8563/tokenlab-mcp-server.git
cd tokenlab-mcp-server
npm install
npm test
npm start

Les profils core et full publient par défaut des schémas portable limités en taille et en profondeur, tandis que le serveur valide chaque appel avec la définition OpenAPI complète. Utilisez exact pour les schémas imbriqués complets, ou strict lorsque le fournisseur du modèle exige des objets fermés et chaque propriété dans required.

Profils d’outils générés

Profil	Outils exposés	Couverture
`catalog`	6	Quatre outils publics générés de catalogue et de tarification, plus `compare_models` et `get_api_overview`. Aucune clé API requise.
`core` (par défaut)	31	29 outils d’endpoint générés plus `compare_models` et `get_api_overview`. Couvre le catalogue, la tarification, les endpoints LLM natifs, les images, la vidéo, la musique, la 3D, l’audio, les tâches, les fichiers, les embeddings, le rerank et la traduction.
`full`	80	78 outils d’endpoint générés plus les deux outils de découverte composites. Ajoute le cycle de vie des réponses, les lots, les mondes, la découverte de modèles natifs et d’autres opérations développeur autorisées.

Les noms des outils, les descriptions, les schémas d’entrée, les méthodes HTTP, les chemins, les types de contenu, les exigences d’authentification et le comportement des tâches sont générés à partir de l’instantané OpenAPI intégré. Une surcouche spécifique à MCP fournit des alias d’outils stables, l’appartenance aux profils, la sémantique des tâches asynchrones, des variantes multipart, l’omission des secrets et des contraintes de non-streaming. La version 0.6.0 renvoie également le JSON via structuredContent de MCP, publie trois ressources de contrat et fournit deux modèles de prompts pour la sélection de modèles et la construction de requêtes natives. Les outils générés et composites incluent des annotations de risque standard afin que les clients compatibles puissent appliquer des politiques d’approbation plus sûres. Les outils core courants incluent :

Famille	Outils représentatifs
Catalogue et tarification	`list_models`, `get_model`, `get_model_pricing`, `get_pricing`, `compare_models`
Endpoints LLM natifs	`create_chat_completion`, `create_response`, `create_anthropic_message`, `create_gemini_content`
Images	`create_image`, `create_image_file`, `edit_image`, `edit_image_file`
Vidéo, musique et 3D	`create_video`, `create_music`, `create_3d_model`
Audio	`create_speech`, `transcribe_audio`, `translate_audio`
Embeddings et texte	`create_embedding`, `create_multimodal_embedding`, `rerank_documents`, `translate_text`
Fichiers et tâches	`upload_file`, `list_files`, `retrieve_file`, `retrieve_file_content`, `delete_file`, `get_task_status`, `cancel_task`

Les appels d’outils MCP renvoient un résultat final. Les opérations de streaming uniquement et en temps réel sont exclues ; le serveur fixe en interne les arguments stream pris en charge à false sans exposer de constante booléenne aux adaptateurs du provider. Les petites réponses d’image et d’audio renvoient du contenu MCP natif ; les réponses binaires plus volumineuses sont écrites dans TOKENLAB_ARTIFACT_DIR et renvoyées avec leur chemin local, leur type MIME et leur nombre d’octets.

Résultats de médias asynchrones

La création de vidéos, de musique et de modèles 3D renvoie des résumés de tâches asynchrones. La génération et l’édition d’images peuvent renvoyer soit un résultat terminé, soit une tâche asynchrone, selon le modèle et la requête sélectionnés. Lorsque delivery.mode est async, appelez get_task_status avec { "id": delivery.task_id } jusqu’à ce que delivery.terminal soit true. Déterminez l’achèvement à partir de status ; progress est optionnel et ne doit pas être utilisé comme condition terminale.

Flux de travail recommandé pour l’agent

Appelez list_models lorsque l’utilisateur n’a pas nommé de modèle.
Utilisez recommended_for pour les tâches autres que le chat, telles que l’image, la vidéo, la musique, la 3D, le TTS, le STT, les embeddings, le rerank ou la traduction.
Appelez get_model avant de construire une requête hors chat, de réessayer une requête échouée ou de changer de famille d’endpoints.
Appelez get_model_pricing lorsque le coût du modèle affecte le choix de l’utilisateur.
Utilisez compare_models lorsque le choix dépend de plusieurs candidats.
Appelez l’outil généré qui correspond au contrat API requis, ou utilisez get_api_overview pour une carte compacte des familles d’API TokenLab.

Conseils sur les endpoints natifs

TokenLab prend en charge les routes compatibles OpenAI et les familles d’endpoints natives. Le serveur MCP aide un agent à choisir la bonne route avant d’écrire du code :

Famille	Route courante
Chat compatible OpenAI	`/v1/chat/completions`
Réponses	`/v1/responses`
Anthropic Messages	`/v1/messages`
Gemini natif	`/v1beta/models/{model}:generateContent`
Images	`/v1/images/generations`, `/v1/images/edits`
Vidéo	`/v1/videos/generations`
Musique	`/v1/music/generations`
3D	`/v1/3d/generations`
Audio	`/v1/audio/speech`, `/v1/audio/transcriptions`, `/v1/audio/translations`
Embeddings et rerank	`/v1/embeddings`, `/v1/rerank`
Traduction de texte	`/v1/translations`

Explorateur de modèles hébergé

Les clients qui prennent en charge le HTTP Streamable peuvent se connecter à :

https://tokenlab-model-explorer.vercel.app/mcp

L’explorateur hébergé est public et expose open_tokenlab_model_explorer, compare_tokenlab_models et generate_tokenlab_endpoint_example. Utilisez le serveur npm local ci-dessus lorsque vous avez besoin des profils core/full générés, des téléchargements de fichiers locaux ou des opérations API authentifiées.

Utilisation avec les compétences TokenLab

Le serveur MCP est utile au moment de l’exécution, tandis que le dépôt de compétences TokenLab apprend aux agents de codage comment générer et réparer le code d’intégration. Utilisez les deux lorsque cela est possible :

Serveur MCP : découvrez les modèles actuels, les tarifs et les détails des endpoints.
Compétence tokenlab-api-integration : générez des exemples d’API exécutables et gérez les erreurs structurées de TokenLab.
Compétence tokenlab-model-picker : choisissez des modèles performants pour la tâche de l’utilisateur.
Compétence tokenlab-native-endpoints : décidez quand utiliser les routes Responses, Anthropic Messages, Gemini, médias, audio, embedding, rerank ou traduction.

Dépannage

Le client ne peut pas démarrer le serveur

Vérifiez que Node.js est au moins en version 18.17 et que le client trouve npx. Exécutez npx -y @tokenlabai/mcp-server dans un terminal pour afficher les erreurs npm ou réseau. Un démarrage stdio réussi attend silencieusement les messages MCP ; quittez avec Ctrl+C après la vérification.

Le serveur est configuré mais aucun outil n'apparaît

Redémarrez le client et approuvez le serveur local. Dans Claude Code, consultez claude mcp list ou /mcp ; dans VS Code, MCP: List Servers puis Show Output ; dans Cursor, Settings → Tools & MCP.

Claude Code affiche Pending approval

Les serveurs .mcp.json d’un projet nécessitent la confiance du workspace et une approbation explicite. Lancez Claude Code de façon interactive dans le projet, acceptez la confiance, puis approuvez tokenlab-model-catalog dans /mcp. Utilisez --scope user pour une configuration privée disponible dans tous vos projets.

La liste des modèles est vide

Vérifiez que la machine peut atteindre https://api.tokenlab.sh/v1/models. Si vous remplacez TOKENLAB_API_BASE, assurez-vous qu’il n’inclut pas de barre oblique finale.

L'agent choisit toujours des ID de modèles obsolètes

Demandez à l’agent d’appeler list_models ou get_model avant de coder en dur un nom de modèle. Associer le serveur MCP à tokenlab-model-picker donne de meilleurs résultats.

Ce serveur peut-il appeler des API d'inférence TokenLab payantes ?

Oui. Définissez TOKENLAB_API_KEY, puis utilisez les outils générés pour LLM, média, audio, tâche, fichier, embedding, rerank ou traduction. Les outils de catalogue et de tarification restent disponibles sans clé.

Un outil authentifié renvoie une erreur d'authentification

Définissez TOKENLAB_API_KEY dans l’environnement du serveur MCP, jamais dans les arguments de l’outil ou le prompt, puis redémarrez le client. Renouvelez toute clé exposée dans un fichier partagé, une image, un journal ou l’historique du shell.

Le client refuse les schémas ou charge trop d'outils

Utilisez TOKENLAB_MCP_TOOL_PROFILE=catalog pour 6 outils de découverte ou le profil core par défaut pour 31 outils. Conservez normalement portable ; utilisez exact pour l’imbrication complète et strict pour les objets fermés avec toutes les propriétés dans required.

Comment figer ou mettre à jour la version du paquet ?

Utilisez @tokenlabai/mcp-server@0.6.17 pour figer la version actuellement vérifiée. Pour changer de version, modifiez l’argument du paquet, redémarrez le serveur et consultez le dépôt public avant d’adopter une version plus récente.

Ressources

TokenLab MCP

Vue d’ensemble du produit et options de connexion pour les ensembles Core 31 et Full 80

Dépôt GitHub

Code source et instructions de configuration locale

Compétences TokenLab

Compétences d’agent maintenues pour les intégrations TokenLab

API du catalogue de modèles

Endpoint de découverte de modèles publics

llms.txt

Aperçu de l’API TokenLab lisible par les agents

Serveur MCP Glama

Voir la liste vérifiée du serveur MCP TokenLab

Explorateur de modèles Glama

Explorez les modèles, les tarifs et des exemples d’endpoints natifs

Liste MCP.so

Découvrez TokenLab dans le répertoire AI & Agents

Explorateur de modèles hébergé

Ouvrez l’explorateur de modèles public et l’endpoint MCP distant

Guide MCP de Claude Code

Portées, approbations, vérifications d’état et configuration MCP

Guide MCP de Cursor

Emplacements de configuration, contrôle des outils et sécurité

Guide MCP de VS Code

Configuration utilisateur et workspace, confiance, journaux et gestion des serveurs

Matrice de compatibilité

Outils de code

SDK natifs

Frameworks et plateformes

Apps de chat

Serveur MCP TokenLab

Ce qu’il propose

Démarrage rapide

Installer dans Cursor

Installer dans VS Code

Référence de configuration

Installation depuis les sources

Profils d’outils générés

Résultats de médias asynchrones

Flux de travail recommandé pour l’agent

Conseils sur les endpoints natifs

Explorateur de modèles hébergé

Utilisation avec les compétences TokenLab

Dépannage

Ressources

TokenLab MCP

Dépôt GitHub

Compétences TokenLab

API du catalogue de modèles

llms.txt

Serveur MCP Glama

Explorateur de modèles Glama

Liste MCP.so

Explorateur de modèles hébergé

Guide MCP de Claude Code

Guide MCP de Cursor

Guide MCP de VS Code

​Ce qu’il propose

​Démarrage rapide

Installer dans Cursor

Installer dans VS Code

​Référence de configuration

​Installation depuis les sources

​Profils d’outils générés

​Résultats de médias asynchrones

​Flux de travail recommandé pour l’agent

​Conseils sur les endpoints natifs

​Explorateur de modèles hébergé

​Utilisation avec les compétences TokenLab

​Dépannage

​Ressources

TokenLab MCP

Dépôt GitHub

Compétences TokenLab

API du catalogue de modèles

llms.txt

Serveur MCP Glama

Explorateur de modèles Glama

Liste MCP.so

Explorateur de modèles hébergé

Guide MCP de Claude Code

Guide MCP de Cursor

Guide MCP de VS Code

Ce qu’il propose

Démarrage rapide

Référence de configuration

Installation depuis les sources

Profils d’outils générés

Résultats de médias asynchrones

Flux de travail recommandé pour l’agent

Conseils sur les endpoints natifs

Explorateur de modèles hébergé

Utilisation avec les compétences TokenLab

Dépannage

Ressources