Serveur MCP

Aperçu

Le Protocole de Contexte de Modèle (MCP) est une norme ouverte qui permet aux applications IA de se connecter de manière sécurisée à des sources de données et des API externes. Le Serveur MCP Dodo Payments fournit aux assistants IA comme Claude, Cursor et d’autres clients compatibles MCP un accès structuré à votre infrastructure de paiement. Le serveur MCP de Dodo Payments utilise l’architecture Code Mode. Plutôt que d’exposer des centaines d’outils individuels pour chaque point de terminaison d’API, le Code Mode permet aux agents IA d’écrire et d’exécuter du code TypeScript avec le SDK Dodo Payments dans un environnement isolé de bac à sable.

Capacités clés

Opérations de paiement : Créer, récupérer et gérer les paiements et les remboursements
Gestion des abonnements : Gérer la facturation récurrente, les mises à niveau et les annulations
Administration des clients : Gérer les données des clients et l’accès au portail
Catalogue de produits : Créer et mettre à jour des produits, des prix et des remises
Gestion des licences : Activer, valider et gérer les licences logicielles
Facturation basée sur l’utilisation : Suivre et facturer l’utilisation mesurée

Comment fonctionne le Code Mode

Le serveur MCP de Dodo Payments fournit exactement deux outils à votre agent IA :

Outil de recherche dans la documentation : interroge la documentation sur l’API et le SDK Dodo Payments pour comprendre les opérations et paramètres disponibles.
Outil d’exécution de code : écrit du code TypeScript contre le SDK qui s’exécute dans un environnement sécurisé de bac à sable.

Cette architecture permet aux agents d’effectuer des opérations complexes en plusieurs étapes dans un seul appel. Par exemple, un agent peut lister tous les abonnements actifs, les filtrer selon des critères spécifiques et appliquer une remise à chacun — tout cela dans un seul script.

Grâce au Code Mode, les agents peuvent chaîner plusieurs appels API, gérer des logiques conditionnelles et effectuer des calculs sans avoir besoin de multiples allers-retours vers la LLM.

Configuration rapide

Connectez-vous au serveur MCP de Dodo Payments depuis votre client IA :

Cursor
Claude Desktop
Windsurf
Claude Code

Ajoutez à ~/.cursor/mcp.json :

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}

Ajoutez à votre configuration Claude Desktop :

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}

Emplacements des fichiers de configuration :

macOS : ~/Library/Application Support/Claude/claude_desktop_config.json
Windows : %APPDATA%\Claude\claude_desktop_config.json
Linux : ~/.config/Claude/claude_desktop_config.json

Ajoutez à ~/.codeium/windsurf/mcp_config.json :

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}

Exécutez dans votre terminal :

claude mcp add dodopayments -- npx -y mcp-remote@latest https://mcp.dodopayments.com/sse

Requiert Node.js 18 ou supérieur. Le serveur distant utilise OAuth pour l’authentification — vous serez invité à entrer votre clé API et à sélectionner votre environnement lors de la première connexion.

Dodo Knowledge MCP

En plus du serveur MCP Dodo Payments (pour exécuter des opérations API), nous proposons Dodo Knowledge MCP — un serveur de recherche sémantique qui donne aux assistants IA un accès instantané à la documentation et à la base de connaissances de Dodo Payments.

Construit avec ContextMCP.ai : Dodo Knowledge MCP est propulsé par ContextMCP, permettant des recherches sémantiques rapides dans notre documentation via des embeddings vectoriels.

Qu’est-ce que Dodo Knowledge MCP ?

Dodo Knowledge MCP est un serveur MCP distant qui fournit :

Recherche sémantique de la documentation : trouvez la documentation pertinente avec des requêtes en langage naturel.
Réponses contextuelles : les assistants IA obtiennent des informations précises et à jour sur Dodo Payments.
Zéro configuration : aucune clé API ni installation locale requise — il suffit de se connecter et de commencer à interroger.

Configuration rapide

Connectez-vous à Dodo Knowledge MCP depuis votre client IA :

Cursor
Claude Desktop
Windsurf
Claude Code

Ajoutez à ~/.cursor/mcp.json :

{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    }
  }
}

Ajoutez à votre configuration Claude Desktop :

{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    }
  }
}

Emplacements des fichiers de configuration :

macOS : ~/Library/Application Support/Claude/claude_desktop_config.json
Windows : %APPDATA%\Claude\claude_desktop_config.json
Linux : ~/.config/Claude/claude_desktop_config.json

Ajoutez à ~/.codeium/windsurf/mcp_config.json :

{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    }
  }
}

Exécutez dans votre terminal :

claude mcp add dodo-knowledge -- npx -y mcp-remote@latest https://knowledge.dodopayments.com/mcp

Requiert Node.js 18 ou supérieur. Le package mcp-remote gère la connexion au serveur MCP distant.

Utiliser les deux serveurs MCP ensemble

Pour une expérience de développement assistée par IA optimale, nous recommandons d’utiliser les deux serveurs MCP :

Serveur	Objectif	Cas d’utilisation
Dodo Knowledge MCP	Recherche documentaire	« Comment gérer les webhooks ? », « Quels moyens de paiement sont pris en charge ? »
Dodo Payments MCP	Opérations API	Créer des paiements, gérer les abonnements, traiter les remboursements

{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    },
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}

Avec les deux serveurs configurés, votre assistant IA peut d’abord rechercher la documentation pour comprendre comment implémenter une fonctionnalité, puis exécuter les appels API réels — le tout dans une seule conversation.

Dépannage de Knowledge MCP

Si vous rencontrez des problèmes de connexion :

Effacez le cache d’authentification MCP : rm -rf ~/.mcp-auth
Redémarrez votre application cliente
Vérifiez les journaux du client pour les messages d’erreur
Vérifiez la version de Node.js : nécessite Node.js 18+

Knowledge MCP Server

Accédez à la page de configuration de Dodo Knowledge MCP

Installation

Choisissez la méthode d’installation qui correspond le mieux à votre flux de travail.

Serveur MCP distant (recommandé)

Accédez au serveur MCP hébergé sans aucune configuration ni installation locale. C’est la façon la plus rapide de démarrer.

Access the remote server

Rendez-vous sur https://mcp.dodopayments.com dans votre navigateur.

Configure your MCP client

Copiez la configuration JSON fournie pour votre client spécifique. Pour Cursor ou Claude Desktop, ajoutez ceci à vos paramètres MCP :

{
  "mcpServers": {
    "dodopayments_api": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}

Authenticate and configure

Le flux OAuth vous invitera à :

Entrer votre clé API Dodo Payments
Sélectionner votre environnement (test ou production)
Choisir votre type de client MCP

Gardez votre clé API sécurisée. Utilisez des clés en mode test pendant le développement.

Complete setup

Cliquez sur Login and Approve pour autoriser la connexion.

Une fois connecté, votre assistant IA peut interagir avec l’API Dodo Payments en votre nom.

Package NPM

Installez et exécutez le serveur MCP localement avec NPM.

NPX (No Installation)
MCP Client Configuration

# Set your environment variables
export DODO_PAYMENTS_API_KEY="dodo_test_..."
export DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key"
export DODO_PAYMENTS_ENVIRONMENT="live_mode"

# Run the latest version
npx -y dodopayments-mcp@latest

{
  "mcpServers": {
    "dodopayments_api": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key",
        "DODO_PAYMENTS_ENVIRONMENT": "live_mode"
      }
    }
  }
}

Utilisez @latest pour toujours récupérer la version la plus récente, ou fixez une version spécifique comme @1.0.0 pour plus de stabilité.

Docker

Exécutez le serveur MCP dans un environnement conteneurisé pour un déploiement homogène.

# Pull the latest image
docker pull ghcr.io/dodopayments/mcp:latest

# Run the container
docker run -e DODO_PAYMENTS_API_KEY="dodo_test_..." \
  -e DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key" \
  -e DODO_PAYMENTS_ENVIRONMENT="live_mode" \
  ghcr.io/dodopayments/mcp:latest

Les images Docker sont disponibles sur GitHub Container Registry.

Configuration client

Configurez le serveur MCP Dodo Payments dans votre client IA préféré.

Configurez le serveur MCP Dodo Payments dans Cursor pour activer l’accès conversationnel à vos données de paiement.Installation en un clicUtilisez le bouton ci-dessous pour installer le serveur MCP directement dans Cursor :[ Add to Cursor

](https://cursor.com/en-US/install-mcp?name=dodopayments-mcp&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImRvZG9wYXltZW50cy1tY3AiXSwiZW52Ijp7IkRPRE9fUEFZTUVOVFNfQVBJX0tFWSI6IlNldCB5b3VyIERPRE9fUEFZTUVOVFNfQVBJX0tFWSBoZXJlLiIsIkRPRE9fUEFZTUVOVFNfV0VCSE9PS19LRVkiOiJTZXQgeW91ciBET0RPX1BBWU1FTlRTX1dFQkhPT0tfS0VZIGhlcmUuIn19)Après avoir cliqué, définissez vos variables d’environnement dans mcp.json de Cursor via Cursor Settings > Tools & MCP > New MCP Server.Configuration manuelle

Open Cursor settings

Rendez-vous dans Cursor Settings > Features > Model Context Protocol ou appuyez sur Cmd/Ctrl + Shift + P et recherchez « MCP Settings ».

Edit configuration

Cliquez sur Edit Config pour ouvrir le fichier mcp_config.json.

Add Dodo Payments configuration

Choisissez l’une des configurations suivantes :Serveur distant (recommandé)

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}

Local NPX

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Save and restart

Enregistrez le fichier de configuration et redémarrez Cursor.

Vérifiez la connexion en demandant à l’assistant IA des informations sur vos données Dodo Payments.

Configurez le serveur MCP Dodo Payments dans Claude Desktop pour activer l’accès conversationnel à vos données de paiement.

Locate configuration file

Trouvez le fichier de configuration de Claude Desktop :

macOS : ~/Library/Application Support/Claude/claude_desktop_config.json
Windows : %APPDATA%\Claude\claude_desktop_config.json
Linux : ~/.config/Claude/claude_desktop_config.json

Edit configuration

Ouvrez le fichier dans un éditeur de texte et ajoutez la configuration Dodo Payments :Serveur distant (recommandé)

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}

Local NPX

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Restart Claude Desktop

Fermez et rouvrez Claude Desktop pour que les modifications prennent effet.

Recherchez l’icône 🔌 dans Claude Desktop pour confirmer que le serveur MCP est connecté.

Configurez le serveur MCP Dodo Payments dans Claude Code CLI.Exécutez la commande suivante dans votre terminal :

claude mcp add --transport stdio dodopayments_api \
  --env DODO_PAYMENTS_API_KEY="dodo_test_..." \
  DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key" \
  -- npx -y dodopayments-mcp

La configuration sera stockée dans le fichier .claude.json de votre répertoire personnel.

Claude Code récupère automatiquement les variables d’environnement de votre shell, vous pouvez donc aussi les exporter avant d’exécuter la commande.

Configurez le serveur MCP Dodo Payments dans VS Code.Installation en un clicOpen VS CodeAprès avoir cliqué, définissez vos variables d’environnement dans mcp.json de VS Code via Command Palette > MCP: Open User Configuration.Configuration manuelle

Open MCP configuration

Ouvrez la palette de commandes (Cmd/Ctrl + Shift + P) et recherchez « MCP: Open User Configuration ».

Add server configuration

Ajoutez le serveur MCP Dodo Payments :

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Reload window

Rechargez VS Code (Cmd/Ctrl + Shift + P > « Reload Window ») pour activer le serveur MCP.

Configurez le serveur MCP Dodo Payments dans Cline (VS Code) pour permettre un accès conversationnel à vos données de paiement.

Open Cline settings

Localisez le fichier de configuration de Cline :

macOS : ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Windows : %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
Linux : ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Configure MCP server

Ajoutez la configuration du serveur MCP Dodo Payments :

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Reload VS Code

Rechargez la fenêtre VS Code (Cmd/Ctrl + Shift + P > « Reload Window ») pour activer la connexion au serveur MCP.

Configurez le serveur MCP Dodo Payments dans Zed pour permettre un accès conversationnel à vos données de paiement.

Open Zed settings

Rendez-vous dans Settings > Assistant > Model Context Protocol.

Add server configuration

Ajoutez la configuration suivante :

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Save and verify

Enregistrez la configuration. Le serveur MCP devrait maintenant être disponible dans l’assistant IA de Zed.

Configurez le serveur MCP Dodo Payments dans d’autres clients compatibles MCP.Serveur distant (recommandé)

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}

Local NPX

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Visitez modelcontextprotocol.io/clients pour une liste complète des clients compatibles MCP et de leurs méthodes de configuration.

Variables d’environnement

Configurez le comportement du serveur MCP à l’aide des variables d’environnement.

Variable	Description	Obligatoire
`DODO_PAYMENTS_API_KEY`	Votre clé API Dodo Payments	Oui
`DODO_PAYMENTS_WEBHOOK_KEY`	Votre clé de signature de webhook	Non
`DODO_PAYMENTS_ENVIRONMENT`	Définir sur `live_mode` pour la production	Non

Exécution distante

Déployez le serveur MCP en tant que serveur HTTP distant pour les clients web ou les workflows agentiques.

# Start as remote server
npx -y dodopayments-mcp --transport=http

# Specify a custom port
npx -y dodopayments-mcp --transport=http --port=3000

Configuration du serveur distant

Une fois déployé, les clients peuvent se connecter en utilisant l’URL du serveur :

{
  "mcpServers": {
    "dodopayments_api": {
      "url": "http://localhost:3000",
      "headers": {
        "Authorization": "Bearer your_api_key"
      }
    }
  }
}

En-têtes d’autorisation

Le serveur distant accepte l’authentification via les en-têtes suivants :

En-tête	Description
`Authorization`	Authentification par jeton Bearer
`x-dodo-payments-api-key`	En-tête de clé API directe

Bonnes pratiques de sécurité

Le Code Mode apporte une sécurité inhérente en exécutant du code dans un environnement isolé et en injectant les clés API côté serveur. Suivez ces bonnes pratiques supplémentaires pour protéger vos identifiants.

API Key Management

Ne commitez jamais de clés dans le contrôle de versionStockez les clés API dans des variables d’environnement ou des systèmes de gestion secrète sécurisés.

# Use environment variables
export DODO_PAYMENTS_API_KEY="dodo_test_..."

# Use a .env file (add to .gitignore)
echo "DODO_PAYMENTS_API_KEY=dodo_test_..." > .env

Faites pivoter les clés régulièrementGénérez de nouvelles clés API périodiquement et révoquez les anciennes via votre tableau de bord Dodo Payments.Utilisez des clés de test pendant le développementUtilisez toujours des clés API en mode test pendant le développement pour éviter d’impacter les données de production.

Access Control

Mettez en place une authentification pour les serveurs distantsLors du déploiement distant, exigez toujours l’authentification via l’en-tête Authorization ou x-dodo-payments-api-key.Surveillez l’utilisation de l’APISuivez l’activité du serveur MCP depuis votre tableau de bord Dodo Payments et configurez des alertes pour les comportements inhabituels.

Network Security

Utilisez HTTPS pour les serveurs distantsDéployez toujours les serveurs MCP distants derrière des points de terminaison HTTPS.Mettez en place des limites de débitProtégez-vous contre les abus en implémentant des limites de débit au niveau du serveur MCP et de l’API.Restreignez l’accès réseauConfigurez les règles de pare-feu pour limiter les clients pouvant se connecter à votre serveur MCP.

Dépannage

Connection issues

Vérifiez votre clé APIAssurez-vous que votre clé API est correctement définie et dispose des autorisations nécessaires.

# Test your API key
curl -H "Authorization: Bearer dodo_test_..." \
  https://test.dodopayments.com/payments

Vérifiez votre connexion réseauAssurez-vous de pouvoir atteindre les points de terminaison de l’API Dodo Payments.Consultez les journaux du clientActivez la journalisation détaillée dans votre client MCP pour diagnostiquer les problèmes de connexion.

Authentication errors

Confirmez l’environnement de la clé APIAssurez-vous d’utiliser des clés de test avec les points de terminaison de test et des clés live avec les points de terminaison de production.Vérifiez la variable d’environnementAssurez-vous que DODO_PAYMENTS_ENVIRONMENT est correctement définie (live_mode pour la production).Régénérez les identifiantsSi les problèmes persistent, générez une nouvelle clé API depuis votre tableau de bord.

Tool execution failures

Validez les paramètres d’entréeAssurez-vous que l’assistant IA fournit des paramètres correctement formatés pour chaque outil.Examinez les messages d’erreurConsultez la réponse d’erreur de l’API pour obtenir des indications spécifiques sur l’origine du problème.Testez directement avec l’APIVérifiez que l’opération fonctionne en appelant directement l’API Dodo Payments via curl ou Postman.

Pourquoi Code Mode

Les implémentations MCP traditionnelles souffrent souvent de « prolifération d’outils », chaque point de terminaison API étant exposé comme un outil distinct. Le Code Mode est une approche supérieure pour plusieurs raisons :

Les LLM sont meilleurs pour écrire du code que pour appeler des outils

Les LLM ont été entraînés sur des millions de lignes de code réel, ce qui les rend naturellement compétents pour écrire des scripts. En revanche, l’appel d’outils repose souvent sur des exemples synthétiques.

« Faire exécuter des tâches à un LLM via l’appel d’outils, c’est comme mettre Shakespeare dans un cours intensif de mandarin pendant un mois, puis lui demander d’écrire une pièce dans cette langue. » — Cloudflare

Élimine le gonflement de la fenêtre de contexte

Avec une approche traditionnelle, chaque définition d’outil consomme des jetons avant même que la conversation ne commence. Exposer plus de 50 outils peut facilement consommer 55K–100K+ jetons. Anthropic a constaté que les définitions d’outils peuvent consommer jusqu’à 134K jetons avant optimisation. Avec le Code Mode, seules 2 définitions d’outils sont chargées (~1K jetons). L’agent recherche la documentation nécessaire à la demande. L’outil Tool Search d’Anthropic a préservé 95 % de la fenêtre de contexte, réduisant les frais généraux de 77K à 8,7K jetons.

Réduit la latence via l’orchestration programmatique

L’appel d’outils traditionnel nécessite un aller-retour complet du modèle pour chaque opération. Si une tâche requiert 20 appels API, cela équivaut à 20 aller-retours. En Code Mode, l’agent écrit un seul script qui exécute tous les appels et ne renvoie que le résultat final. Anthropic a observé une réduction de 37 % des jetons et une meilleure précision (la récupération des connaissances est passée de 25,6 % à 28,5 %) en utilisant cette approche programmatique.

Plus sûr par conception

Le Code Mode apporte des avantages de sécurité inhérents :

Pas de clés API dans les paramètres : les clés API sont injectées côté serveur et ne sont jamais exposées dans les paramètres envoyés au LLM.
Bac à sable isolé : le code s’exécute dans un environnement sécurisé sans accès au réseau ni au système de fichiers hôte.
SDK contrôlé : seules les méthodes SDK autorisées sont accessibles à l’agent.

S’adapte à n’importe quelle taille d’API

À mesure qu’une API se développe, les performances MCP traditionnelles se détériorent car davantage d’outils doivent être chargés dans le contexte. Le Code Mode reste constant avec 2 outils, indépendamment de la surface de l’API. Cloudflare a réussi à condenser plus de 2 500 points de terminaison API en seulement 2 outils et environ 1 000 jetons de contexte.

Pour plus de détails sur les avantages de cette architecture, consultez les articles techniques de Anthropic et Cloudflare, ainsi que la documentation Programmatic Tool Calling de Claude.

Ressources

API Reference

Explorez la documentation complète de l’API Dodo Payments

MCP Protocol

Découvrez le standard Model Context Protocol

GitHub Repository

Consultez le code source du serveur MCP et contribuez

NPM Package

Installez le serveur MCP depuis NPM

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

Aperçu

Capacités clés

Comment fonctionne le Code Mode

Configuration rapide

Dodo Knowledge MCP

Qu’est-ce que Dodo Knowledge MCP ?

Configuration rapide

Utiliser les deux serveurs MCP ensemble

Dépannage de Knowledge MCP

Knowledge MCP Server

Installation

Serveur MCP distant (recommandé)

Package NPM

Docker

Configuration client

Variables d’environnement

Exécution distante

Configuration du serveur distant

En-têtes d’autorisation

Bonnes pratiques de sécurité

Dépannage

Pourquoi Code Mode

Les LLM sont meilleurs pour écrire du code que pour appeler des outils

Élimine le gonflement de la fenêtre de contexte

Réduit la latence via l’orchestration programmatique

Plus sûr par conception

S’adapte à n’importe quelle taille d’API

Ressources

API Reference

MCP Protocol

GitHub Repository

NPM Package

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

​Aperçu

​Capacités clés

​Comment fonctionne le Code Mode

​Configuration rapide

​Dodo Knowledge MCP

​Qu’est-ce que Dodo Knowledge MCP ?

​Configuration rapide

​Utiliser les deux serveurs MCP ensemble

​Dépannage de Knowledge MCP

Knowledge MCP Server

​Installation

​Serveur MCP distant (recommandé)

​Package NPM

​Docker

​Configuration client

​Variables d’environnement

​Exécution distante

​Configuration du serveur distant

​En-têtes d’autorisation

​Bonnes pratiques de sécurité

​Dépannage

​Pourquoi Code Mode

​Les LLM sont meilleurs pour écrire du code que pour appeler des outils

​Élimine le gonflement de la fenêtre de contexte

​Réduit la latence via l’orchestration programmatique

​Plus sûr par conception

​S’adapte à n’importe quelle taille d’API

​Ressources

API Reference

MCP Protocol

GitHub Repository

NPM Package

Aperçu

Capacités clés

Comment fonctionne le Code Mode

Configuration rapide

Dodo Knowledge MCP

Qu’est-ce que Dodo Knowledge MCP ?

Configuration rapide

Utiliser les deux serveurs MCP ensemble

Dépannage de Knowledge MCP

Installation

Serveur MCP distant (recommandé)

Package NPM

Docker

Configuration client

Variables d’environnement

Exécution distante

Configuration du serveur distant

En-têtes d’autorisation

Bonnes pratiques de sécurité

Dépannage

Pourquoi Code Mode

Les LLM sont meilleurs pour écrire du code que pour appeler des outils

Élimine le gonflement de la fenêtre de contexte

Réduit la latence via l’orchestration programmatique

Plus sûr par conception

S’adapte à n’importe quelle taille d’API

Ressources