Tovanix
Tovanix

Accès MCP

Connectez votre compte Tovanix à tout client IA compatible MCP. Le point d’accès https://tovanix.com/api/mcp/rpc utilise Streamable HTTP sans état et accepte uniquement POST.

  • Authentification : Authorization: Bearer <credential>, ou l’en-tête X-MCP-Key ; les identifiants commencent par mcp_live_ et ne sont affichés qu’une fois
  • Permissions : chaque capacité est désactivée initialement ; tools/list ne renvoie que les capacités activées, nommées avec tovanix_ suivi du nom de la capacité
  • Les outils de dépenses et actions irréversibles exigent un code unique totp_code et respectent les plafonds par appel et par jour
  • Listes d’IP source autorisées, dates d’expiration et limite par défaut de 120 appels par minute (jusqu’à 600)
  • Trois ressources (catalogue des capacités, aperçu du compte, guide de plateforme) et trois invites (bilan du compte, rapport de dépenses, vérification des échéances)
  • Erreurs : 401 identifiants invalides, 403 source ou état du compte interdit, 405 méthode autre que POST, 413 requête trop volumineuse
  • La création exige de lire et accepter l’accord d’accès MCP. Vous êtes responsable des contenus et actions envoyés en votre nom
  • Outre dépenses et actions irréversibles, les réglages sensibles comme URL de notification, publications et accès public aux compartiments exigent un code unique. Publications IA, messages d’assistance, courriels et lectures Telegram en direct ont des limites par compte. Les publications et messages répétés sont rejetés ; l’assistance porte la mention « Envoyé via un assistant IA »

POST /api/mcp/rpc

Trois types d’accès, chacun avec son rôle

MCP (Model Context Protocol) permet aux clients d’IA tels que Claude d’appeler les capacités de votre compte Tovanix sous forme d’« outils ». Dans la console, vous créez un jeton d’accès MCP pour chaque client et activez une par une les capacités autorisées ; le client se connecte au point de terminaison avec ce jeton, puis peut consulter des données et effectuer des actions dans une conversation.

MCP dispose de son propre point de terminaison et de ses propres jetons d’accès, indépendants de l’API ouverte et de la connexion à la console : supprimer un jeton MCP n’affecte jamais vos intégrations API existantes, et inversement.

  • API ouverte /api/v1/* — Clé API (X-API-Key / signature) — Programmes que vous écrivez — Selon la configuration de la clé
  • MCP /api/mcp/rpc — Jeton d’accès MCP (Bearer) — Clients d’IA — Aucune — activation une par une
  • Console — Session de connexion — Vous — Tout dans votre compte

Démarrage rapide

Tout client MCP compatible avec Streamable HTTP et permettant de définir les en-têtes de requête peut se connecter. Choisissez votre outil ci-dessous et copiez la commande ou la configuration correspondante.

Vous pouvez aussi vérifier un jeton d’accès en appelant tools/list avec curl : le serveur est sans état, aucun appel initialize préalable n’est donc nécessaire.

Seule une empreinte du jeton d’accès est conservée ; il ne peut donc pas être récupéré. En cas de perte, supprimez-le et créez-en un nouveau. Conservez-le dans la configuration du client, jamais dans un dépôt public, une capture d’écran ou une discussion.

Point de terminaison et authentification

La page « Accès MCP » de la console affiche le point de terminaison de votre compte, prêt à copier.

  • Point de terminaison — Toutes les requêtes sont envoyées à cette URL unique.
  • Transport — Streamable HTTP, sans état : chaque requête est authentifiée indépendamment, seul POST est accepté et aucun Mcp-Session-Id n’est délivré ; GET et DELETE renvoient 405.
  • Authentification — Authorization: Bearer <credential>. Si votre client permet seulement d’ajouter des en-têtes personnalisés sans modifier Authorization, utilisez X-MCP-Key: <credential> à la place.
  • Versions du protocole — 2025-06-18 (la plus récente), 2025-03-26 et 2024-11-05, négociées à partir de la version envoyée par le client dans initialize ; les versions non prises en charge reviennent à la plus récente.
  • Messages — JSON-RPC 2.0, avec une limite de 1 Mo par corps de requête. Les requêtes groupées des anciens clients peuvent contenir au maximum 32 éléments.
  • Requêtes du navigateur — Les requêtes contenant un en-tête Origin provenant d’autres sites que ceux de la plateforme sont rejetées (protection contre le DNS rebinding). Les clients de bureau et en ligne de commande n’envoient pas Origin et ne sont pas affectés.

Jetons d’accès et autorisations

Les jetons d’accès commencent par mcp_live_ et comportent 73 caractères. Chacun possède les paramètres ci-dessous, modifiables à tout moment dans la console ; un jeton expiré ou désactivé cesse de fonctionner immédiatement.

Avant de créer un jeton d’accès, vous devez lire et accepter l’accord d’accès MCP. Il précise les risques liés à l’utilisation de votre compte par une IA et leur responsabilité : les opérations et pertes via MCP relèvent de votre responsabilité. Aucun jeton ne peut être créé sans accord publié ; après une mise à jour, les nouveaux jetons exigent une nouvelle acceptation, tandis que les jetons existants continuent de fonctionner.

Lorsqu’un compte est restreint, MCP n’autorise que les capacités de lecture ; les écritures, dépenses et actions irréversibles sont refusées avec un message renvoyant à la console. Si le compte est gelé, chaque requête renvoie 403.

Outils et nomenclature

Nom de l’outil = tovanix_ + nom de la capacité, les points étant remplacés par des traits de soulignement. Par exemple, account.balance.get devient l’outil tovanix_account_balance_get.

tools/list renvoie uniquement les capacités activées pour ce jeton d’accès. La description de chaque outil explique quand l’utiliser, le sens de ses paramètres et les précautions à prendre ; les clients d’IA s’en servent pour choisir leurs outils.

Lecture : accès en lecture seule. Écriture : modifications réversibles, comme modifier une note. Dépense : prélève de l’argent sur votre solde. Irréversible : impossible à annuler, comme supprimer une clé ou résilier une carte. Les outils de dépense et irréversibles exigent un code à usage unique (voir la section suivante). Certaines modifications réversibles nécessitant tout de même votre approbation immédiate — changer une URL de rappel, publier un message, rendre un bucket public — exigent aussi ce code ; elles portent la mention « Code requis » dans la console.

Codes à usage unique

Les outils de dépense et irréversibles prennent un paramètre supplémentaire totp_code, qui doit contenir le code actuel à 6 chiffres de votre application d’authentification. L’IA ne peut pas obtenir ce code et vous le demandera au besoin. Il en va de même pour les outils marqués « Code requis ».

  • Chaque code ne fonctionne qu’une seule fois. Un code qui vient d’être utilisé dans la console ne peut pas non plus être réutilisé via MCP.
  • Si l’authentification à deux facteurs n’est pas activée sur le compte, ces outils sont toujours refusés, avec une invitation à l’activer dans la console.
  • Le code est vérifié avant toute autre étape ; un code incorrect ne consomme donc jamais l’allocation quotidienne de dépenses.

Plafonds de dépenses

Chaque appel entraînant une dépense passe par ces quatre étapes dans l’ordre ; si l’une échoue, aucun argent n’est prélevé.

confirmed_total_usd

La plupart des outils de dépense exigent confirmed_total_usd : le total annoncé par l’IA et que vous avez accepté. Si le prix réel à l’exécution est supérieur, rien n’est exécuté et l’IA vous indique le nouveau prix.

Sort de l’allocation en cas d’échec

Si un appel échoue et qu’il est certain qu’aucun montant n’a été facturé, l’allocation réservée est restituée. Si la facturation ne peut pas être confirmée, elle reste réservée pour qu’une dépense potentielle ne soit jamais exclue du décompte. Vos factures indiquent les montants réellement facturés.

Limites de débit et contenus envoyés pour vous

En plus de la limite propre à chaque jeton d’accès, les outils qui écrivent du contenu pour vous ou effectuent des requêtes Telegram réelles ont des limites par compte : elles sont partagées par tous les jetons du compte et réinitialisées chaque jour à 00:00 UTC+8. Les appels dépassant la limite sont refusés et l’IA est invitée à s’arrêter ; les publications communautaires et messages d’assistance au contenu strictement identique répétés sous 10 minutes sont aussi refusés. Les e-mails sont dédupliqués par leur clé d’idempotence, pas par leur contenu. Ces outils portent la mention « Débit limité » dans la console.

Contenus envoyés en votre nom

Une fois les outils correspondants activés, l’IA peut publier et répondre dans la communauté, contacter l’assistance en direct et envoyer des e-mails depuis votre compte SMTP en votre nom. Ces contenus vous représentent et vous en êtes responsable :

Ressources et prompts

Outre les outils, le serveur fournit trois ressources en lecture seule et trois prompts utilisables directement par les clients.

  • tovanix://catalog — Catalogue des capacités : tous les domaines et capacités, ainsi que ceux activés pour ce jeton d’accès. L’IA le lit lorsqu’elle rencontre « non autorisé » ou qu’on lui demande ce qu’elle peut faire.
  • tovanix://account/overview — Aperçu du compte : état du compte, services utilisés, autorisations de ce jeton d’accès et utilisation de son allocation quotidienne. Le solde n’est affiché que si « Consulter le solde du compte » est activé.
  • tovanix://guide — Guide de la plateforme : représentation des montants et devises, états des commandes et points à confirmer avant de passer une commande.
  • account_health — — — Bilan du compte : solde, abonnements et échéances des services, commandes inhabituelles et liste des points à traiter.
  • spend_report — days, 30 par défaut — Rapport de dépenses : factures récentes et dépenses regroupées par service.
  • renewal_check — within_days, 14 par défaut — Vérification des échéances : services proches de l’expiration et coût de renouvellement ; aucun renouvellement automatique.

Erreurs et dépannage

Les problèmes de connexion et d’authentification sont renvoyés sous forme de codes d’état HTTP. Les échecs métier sont des résultats d’outil (isError: true) dont le texte indique à l’IA la prochaine action, par exemple « demander un code à usage unique » ou « solde insuffisant : demander de recharger d’abord ».

Connecter Tovanix MCP depuis chaque outil IA

Remplacez <YOUR_MCP_CREDENTIAL> par les identifiants MCP créés dans la console.

  • Claude Code — Exécuter dans un terminal
    claude mcp add --scope user --transport http tovanix https://tovanix.com/api/mcp/rpc --header "Authorization: Bearer <YOUR_MCP_CREDENTIAL>"
  • Codex — Fichier de configuration: ~/.codex/config.toml
    [mcp_servers.tovanix]
    url = "https://tovanix.com/api/mcp/rpc"
    bearer_token_env_var = "TOVANIX_MCP_CREDENTIAL"
  • Cursor — Fichier de configuration: ~/.cursor/mcp.json
    {
      "mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • GitHub Copilot (VS Code) — Fichier de configuration: .vscode/mcp.json
    {
      "servers": {
        "tovanix": {
          "type": "http",
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer ${input:tovanix-credential}"
          }
        }
      },
      "inputs": [
        {
          "type": "promptString",
          "id": "tovanix-credential",
          "description": "Tovanix MCP credential",
          "password": true
        }
      ]
    }
  • Gemini CLI — Fichier de configuration: ~/.gemini/settings.json
    {
      "mcpServers": {
        "tovanix": {
          "httpUrl": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • OpenCode — Fichier de configuration: ~/.config/opencode/opencode.json
    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "tovanix": {
          "type": "remote",
          "url": "https://tovanix.com/api/mcp/rpc",
          "enabled": true,
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Qwen Code — Exécuter dans un terminal
    qwen mcp add --scope user --transport http tovanix https://tovanix.com/api/mcp/rpc --header "Authorization: Bearer <YOUR_MCP_CREDENTIAL>"
  • Kimi Code CLI — Fichier de configuration: ~/.kimi-code/mcp.json
    {
      "mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • CodeBuddy Code — Exécuter dans un terminal
    codebuddy mcp add --scope user --transport http --header "Authorization: Bearer <YOUR_MCP_CREDENTIAL>" tovanix https://tovanix.com/api/mcp/rpc
  • Qoder CLI — Fichier de configuration: ~/.qoder/settings.json
    {
      "mcpServers": {
        "tovanix": {
          "type": "streamable-http",
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Kiro — Fichier de configuration: ~/.kiro/settings/mcp.json
    {
      "mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Trae — Fichier de configuration: .trae/mcp.json
    {
      "mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Trae CN — Fichier de configuration: .trae/mcp.json
    {
      "mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Trae CLI — Fichier de configuration: trae_cli.yaml
    mcp_servers:
      - name: "tovanix"
        url: "https://tovanix.com/api/mcp/rpc"
        type: "http"
        headers:
          Authorization: "Bearer <YOUR_MCP_CREDENTIAL>"
  • GitHub Copilot CLI — Fichier de configuration: ~/.copilot/mcp-config.json
    {
      "mcpServers": {
        "tovanix": {
          "type": "http",
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          },
          "tools": [
            "*"
          ]
        }
      }
    }
  • Cline — Fichier de configuration: cline_mcp_settings.json
    {
      "mcpServers": {
        "tovanix": {
          "type": "streamableHttp",
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Kilo Code — Fichier de configuration: ~/.config/kilo/kilo.jsonc
    {
      "mcp": {
        "tovanix": {
          "type": "remote",
          "url": "https://tovanix.com/api/mcp/rpc",
          "enabled": true,
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Continue — Fichier de configuration: ~/.continue/config.yaml
    mcpServers:
      - name: tovanix
        type: streamable-http
        url: https://tovanix.com/api/mcp/rpc
        requestOptions:
          headers:
            Authorization: Bearer <YOUR_MCP_CREDENTIAL>
  • Zed — Fichier de configuration: ~/.config/zed/settings.json
    {
      "context_servers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Junie — Fichier de configuration: ~/.junie/mcp/mcp.json
    {
      "mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Amp — Fichier de configuration: ~/.config/amp/settings.json
    {
      "amp.mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Goose — Fichier de configuration: ~/.config/goose/config.yaml
    extensions:
      tovanix:
        enabled: true
        type: streamable_http
        name: tovanix
        uri: https://tovanix.com/api/mcp/rpc
        headers:
          Authorization: "Bearer <YOUR_MCP_CREDENTIAL>"
        timeout: 300
  • Augment (Auggie) — Exécuter dans un terminal
    auggie mcp add tovanix --transport http --url https://tovanix.com/api/mcp/rpc --header "Authorization:Bearer <YOUR_MCP_CREDENTIAL>"
  • Factory Droid — Exécuter dans un terminal
    droid mcp add tovanix https://tovanix.com/api/mcp/rpc --type http --header "Authorization: Bearer <YOUR_MCP_CREDENTIAL>" --no-oauth
  • Crush — Fichier de configuration: ~/.config/crush/crushrc
    mcp add tovanix --type http --url https://tovanix.com/api/mcp/rpc --header Authorization "Bearer <YOUR_MCP_CREDENTIAL>"
  • Warp — Coller dans les paramètres de l’application
    {
      "tovanix": {
        "url": "https://tovanix.com/api/mcp/rpc",
        "headers": {
          "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
        }
      }
    }
  • Windsurf — Fichier de configuration: ~/.codeium/windsurf/mcp_config.json
    {
      "mcpServers": {
        "tovanix": {
          "serverUrl": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Claude (web / bureau) — Saisissez l’adresse dans l’application et ajoutez l’en-tête Authorization (Bearer + identifiants)
    https://tovanix.com/api/mcp/rpc
  • LM Studio — Fichier de configuration: mcp.json
    {
      "mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }
  • Dify — Saisissez l’adresse dans l’application et ajoutez l’en-tête Authorization (Bearer + identifiants)
    https://tovanix.com/api/mcp/rpc
  • Coze — Saisissez l’adresse dans l’application et ajoutez l’en-tête Authorization (Bearer + identifiants)
    https://tovanix.com/api/mcp/rpc
  • n8n — Saisissez l’adresse dans l’application et ajoutez l’en-tête Authorization (Bearer + identifiants)
    https://tovanix.com/api/mcp/rpc
  • Autres clients MCP — Coller dans les paramètres de l’application
    {
      "mcpServers": {
        "tovanix": {
          "url": "https://tovanix.com/api/mcp/rpc",
          "headers": {
            "Authorization": "Bearer <YOUR_MCP_CREDENTIAL>"
          }
        }
      }
    }

Questions fréquentes

Pourquoi tools/list renvoie-t-il une liste vide ?

Aucune capacité n’est encore activée pour ces identifiants. Activez celles nécessaires dans « Accès MCP » dans la console, puis reconnectez-vous.

Pourquoi les outils de dépenses sont-ils toujours refusés ?

Vérifiez trois points : les plafonds sont-ils encore à la valeur par défaut 0, l’authentification à deux facteurs est-elle activée et le plafond quotidien est-il épuisé ?

Pages connexes: Confiez la gestion de votre compte Tovanix à votre assistant IA · Documentation API · Intégration développeur

Chargement…