> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokenlab.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Serveur MCP TokenLab

> Connectez les clients MCP à la découverte de modèles, aux tarifs, au chat compatible OpenAI et aux endpoints d'inférence natifs de TokenLab.

Le [serveur MCP TokenLab](https://github.com/hedging8563/tokenlab-mcp-server) offre aux agents compatibles MCP la découverte de modèles en direct, les tarifs, Chat Completions compatible OpenAI et des outils d'inférence natifs.

Utilisez-le lorsqu'un agent doit comparer des modèles, inspecter les formats de requête, consulter les tarifs ou appeler TokenLab via OpenAI Chat Completions, Responses, Anthropic Messages ou Gemini generateContent.

<Note>
  Les outils du catalogue public ne nécessitent pas de clé API TokenLab. Définissez `TOKENLAB_API_KEY` pour utiliser les quatre outils d'inférence payants.
</Note>

## Ce qu'il propose

* Découverte de modèles en temps réel depuis `https://api.tokenlab.sh/v1/models`.
* Consultation des détails d'un modèle depuis `/v1/models/{model}`.
* Consultation de la tarification depuis `/v1/models/{model}/pricing`.
* Aperçu de l'API lisible par les agents depuis `https://api.tokenlab.sh/llms.txt`.
* Conseils sur les familles d'endpoints pour le chat compatible OpenAI, Responses, Anthropic Messages, Gemini, les médias, l'audio, les embeddings, le rerank et la traduction.
* Inférence facultative via Chat Completions compatible OpenAI, Responses, Anthropic Messages et Gemini generateContent.

## Installation depuis GitHub

Clonez le dépôt public et installez les dépendances :

```bash theme={null}
git clone https://github.com/hedging8563/tokenlab-mcp-server.git
cd tokenlab-mcp-server
npm install
npm test
```

Démarrez le serveur via stdio :

```bash theme={null}
npm start
```

La variable d'environnement optionnelle `TOKENLAB_API_BASE` a pour valeur par défaut `https://api.tokenlab.sh`.

## Installer dans Codex

Ajoutez le serveur de catalogue public à votre configuration Codex :

```bash theme={null}
codex mcp add tokenlab-model-catalog -- npx -y @tokenlabai/mcp-server
```

Démarrez une nouvelle session Codex après l'ajout du serveur. Les outils de catalogue public ne nécessitent pas `TOKENLAB_API_KEY`.

Pour activer les outils d'inférence, ajoutez votre clé API TokenLab lors de l'ajout du serveur :

```bash theme={null}
codex mcp add --env TOKENLAB_API_KEY=your-tokenlab-api-key tokenlab-model-catalog -- npx -y @tokenlabai/mcp-server
```

## Installer dans Cline

Installez le serveur stdio publié avec la CLI Cline :

```bash theme={null}
cline mcp add tokenlab --yes -- npx -y @tokenlabai/mcp-server
```

La commande a été vérifiée avec la CLI Cline et s’exécute sans avertissement de configuration. Les outils publics du catalogue fonctionnent immédiatement ; définissez `TOKENLAB_API_KEY` dans l’environnement Cline pour les outils d’inférence.

## Configuration de Claude Desktop

Ajoutez le package npm publié à la configuration de votre client MCP :

```json theme={null}
{
  "mcpServers": {
    "tokenlab-model-catalog": {
      "command": "npx",
      "args": ["-y", "@tokenlabai/mcp-server"]
    }
  }
}
```

Redémarrez le client MCP après avoir enregistré la configuration.

## Cursor, Windsurf et autres clients MCP

Utilisez la même commande et les mêmes arguments dans tout client prenant en charge les serveurs MCP via stdio :

```json theme={null}
{
  "command": "npx",
  "args": ["-y", "@tokenlabai/mcp-server"],
  "env": {
    "TOKENLAB_API_BASE": "https://api.tokenlab.sh"
  }
}
```

Si votre client stocke des serveurs nommés, utilisez `tokenlab-model-catalog` comme nom de serveur.

## Outils

| Outil                      | Objectif                                                                                                                                              |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `list_models`              | Lister les modèles publics TokenLab. Filtrer optionnellement avec `recommended_for` tel que `image`, `video`, `embedding`, `rerank` ou `translation`. |
| `get_model`                | Récupérer les détails publics et le format de requête pris en charge pour un modèle.                                                                  |
| `get_model_pricing`        | Récupérer les détails de tarification publique d'un modèle.                                                                                           |
| `compare_models`           | Comparer les détails et les tarifs de plusieurs ID de modèles.                                                                                        |
| `create_chat_completion`   | Appeler l'endpoint compatible OpenAI `/v1/chat/completions`, avec messages multimodaux et appels d'outils. Nécessite `TOKENLAB_API_KEY`.              |
| `create_response`          | Appeler l'endpoint `/v1/responses`. Nécessite `TOKENLAB_API_KEY`.                                                                                     |
| `create_anthropic_message` | Appeler l'endpoint Anthropic Messages `/v1/messages`. Nécessite `TOKENLAB_API_KEY`.                                                                   |
| `create_gemini_content`    | Appeler l'endpoint natif Gemini `generateContent`. Nécessite `TOKENLAB_API_KEY`.                                                                      |
| `get_api_overview`         | Récupérer l'aperçu `llms.txt` de TokenLab pour des conseils sur les endpoints lisibles par les agents.                                                |

Les outils d'inférence renvoient des résultats JSON normaux. Le streaming est volontairement désactivé pour les appels d'outils MCP.

## Flux de travail recommandé pour l'agent

1. Appelez `list_models` lorsque l'utilisateur n'a pas nommé de modèle.
2. Utilisez `recommended_for` pour les tâches autres que le chat, telles que l'image, la vidéo, la musique, la 3D, TTS, STT, les embeddings, le rerank ou la traduction.
3. Appelez `get_model` avant de construire une requête autre que le chat, de réessayer une requête échouée ou de changer de famille d'endpoints.
4. Appelez `get_model_pricing` lorsque le coût du modèle influence le choix de l'utilisateur.
5. Utilisez `compare_models` lorsque le choix dépend de plusieurs candidats.
6. Appelez l'outil d'inférence correspondant 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 natifs. Le serveur MCP aide un agent à choisir la bonne route avant d'écrire du code :

| Famille                | Route courante                                                           |
| ---------------------- | ------------------------------------------------------------------------ |
| Chat compatible OpenAI | `/v1/chat/completions`                                                   |
| Responses              | `/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 compatibles avec Streamable HTTP peuvent se connecter à :

```text theme={null}
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 pour les neuf outils ou l’inférence authentifiée.

## 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](https://github.com/hedging8563/tokenlab-skills) apprend aux agents de codage comment générer et réparer le code d'intégration.

Utilisez les deux lorsqu'ils sont disponibles :

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

## Dépannage

<AccordionGroup>
  <Accordion title="Le client ne parvient pas à démarrer le serveur">
    Vérifiez que Node.js est en version 18.17 ou ultérieure, puis exécutez une fois `npx -y @tokenlabai/mcp-server` dans un terminal pour afficher les erreurs npm ou réseau.
  </Accordion>

  <Accordion title="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 ne contient pas de barre oblique finale.
  </Accordion>

  <Accordion title="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 avec `tokenlab-model-picker` donne de meilleurs résultats.
  </Accordion>

  <Accordion title="Ce serveur peut-il appeler les API d'inférence payantes de TokenLab ?">
    Oui. Définissez `TOKENLAB_API_KEY`, puis utilisez `create_chat_completion`, `create_response`, `create_anthropic_message` ou `create_gemini_content`. Les outils de catalogue et de tarification restent disponibles sans clé.
  </Accordion>
</AccordionGroup>

## Ressources

<CardGroup cols={2}>
  <Card title="Dépôt GitHub" icon="github" href="https://github.com/hedging8563/tokenlab-mcp-server">
    Code source et instructions de configuration locale
  </Card>

  <Card title="Compétences TokenLab" icon="sparkles" href="https://github.com/hedging8563/tokenlab-skills">
    Compétences d'agent maintenues pour les intégrations TokenLab
  </Card>

  <Card title="API du catalogue de modèles" icon="list" href="https://api.tokenlab.sh/v1/models">
    Endpoint de découverte des modèles publics
  </Card>

  <Card title="llms.txt" icon="file-lines" href="https://api.tokenlab.sh/llms.txt">
    Aperçu de l'API TokenLab lisible par les agents
  </Card>

  <Card title="Glama MCP Server" icon="globe" href="https://glama.ai/mcp/servers/hedging8563/tokenlab-mcp-server">
    Consultez la fiche vérifiée de TokenLab MCP Server
  </Card>

  <Card title="Explorateur de modèles Glama" icon="search" href="https://glama.ai/mcp/servers/hedging8563/tokenlab-openai-apps-model-explorer">
    Explorez les modèles, les tarifs et des exemples d'endpoints natifs
  </Card>

  <Card title="Fiche MCP.so" icon="compass" href="https://mcp.so/servers/tokenlab-mcp-server">
    Découvrez TokenLab dans le répertoire AI & Agents
  </Card>

  <Card title="Explorateur de modèles hébergé" icon="rocket" href="https://tokenlab-model-explorer.vercel.app">
    Ouvrez l’explorateur public et l’endpoint MCP distant
  </Card>
</CardGroup>