Serveur MCP Dodo Payments

Overview

Le Model Context Protocol (MCP) est un standard ouvert qui permet aux applications d’IA de se connecter à des sources de données et à des API externes. Le serveur MCP Dodo Payments permet aux assistants IA tels que Claude, Cursor et d’autres clients compatibles avec MCP d’accéder à votre infrastructure de paiement. Le serveur MCP Dodo Payments utilise une architecture Code Mode. Au lieu d’exposer des centaines d’outils individuels pour chaque endpoint d’API, Code Mode permet aux agents IA d’écrire et d’exécuter du code TypeScript avec le SDK Dodo Payments dans un sandbox isolé.

Fonctionnalités principales

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 changements d’offre et les annulations
Administration des clients — Gérer les données client et l’accès au portail
Catalogue de produits — Créer et mettre à jour les produits, les tarifs et les remises
Gestion des licences — Activer, valider et gérer les licences logicielles
Facturation à l’usage — Suivre et facturer l’utilisation mesurée

How Code Mode Works

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

Outil de recherche dans la documentation — Interroge la documentation de l’API et du SDK Dodo Payments afin de comprendre les opérations et paramètres disponibles.
Outil d’exécution de code — Écrit du code TypeScript avec le SDK, exécuté dans un sandbox sécurisé.

Cette architecture permet aux agents d’effectuer des opérations complexes en plusieurs étapes lors d’une seule invocation. Par exemple, un agent peut répertorier tous les abonnements actifs, les filtrer selon certains critères et appliquer une remise à chacun, le tout dans un seul script.

Les agents peuvent enchaîner plusieurs appels d’API, gérer une logique conditionnelle et effectuer des calculs sans effectuer d’aller-retour vers le LLM.

Quick Setup

Connect to the Dodo Payments MCP Server in your AI client:

Agent Plugin (recommended)
Cursor
Claude Desktop
Windsurf
Claude Code

Le Dodo Agent Plugin installe les serveurs MCP ainsi que les dix-sept skills en une seule étape pour Claude Code, Codex CLI, Cursor, VS Code / GitHub Copilot, Kiro et OpenCode (OpenCode nécessite un paramètre skills.paths supplémentaire). Gemini CLI ne reçoit que les deux serveurs MCP, car il ne dispose pas de primitive d’agent-skill. Consultez le guide des agents de programmation IA pour connaître les commandes d’installation propres à chaque agent.If your agent isn’t in that list, use the tabs below to configure the MCP server directly.

Add to ~/.cursor/mcp.json:

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

Add to your Claude Desktop configuration:

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

Configuration file locations:

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

Add to ~/.codeium/windsurf/mcp_config.json:

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

Run in your terminal:

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

Nécessite Node.js 18 ou version ultérieure. Le serveur distant utilise OAuth pour l’authentification. Lors de la première connexion, vous serez invité à saisir votre clé API et à sélectionner votre environnement.

Dodo Knowledge MCP

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

Built with ContextMCP.ai: Dodo Knowledge MCP is powered by ContextMCP, enabling fast semantic search across our documentation using vector embeddings.

What is Dodo Knowledge MCP?

Dodo Knowledge MCP est un serveur MCP distant qui fournit une recherche sémantique dans la documentation. Trouvez la documentation pertinente à l’aide de requêtes en langage naturel, obtenez des informations précises et à jour sur Dodo Payments et connectez-vous sans clé API ni installation locale.

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 à la configuration de 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

Nécessite Node.js 18 ou version ultérieure. 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, utilisez les deux serveurs MCP :

Serveur	Fonction	Cas d’utilisation
Dodo Knowledge MCP	Recherche dans la documentation	”Comment gérer les webhooks ?”, “Quels moyens de paiement sont pris en charge ?”
Dodo Payments MCP	Opérations d’API	Créer des paiements, gérer les abonnements et 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/mcp"]
    }
  }
}

Avec les deux serveurs configurés, votre agent peut rechercher dans la documentation pour comprendre une fonctionnalité, puis exécuter les appels d’API nécessaires pour l’implémenter, le tout au cours d’une seule conversation.

Dépannage de Knowledge MCP

Si vous rencontrez des problèmes de connexion, videz le cache d’authentification MCP avec rm -rf ~/.mcp-auth, redémarrez votre application cliente, consultez les journaux du client pour trouver les messages d’erreur et vérifiez la version de Node.js (18 ou version ultérieure requise).

Knowledge MCP Server

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

Installation

Choisissez la méthode d’installation qui correspond à votre workflow.

Serveur MCP distant (recommandé)

Accédez au serveur MCP hébergé sans configuration ni installation locale.

Access the remote server

Ouvrez 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-la à vos paramètres MCP :

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

Authenticate and configure

Le flux OAuth vous invitera à :

Saisir votre clé API Dodo Payments
Sélectionner votre environnement (test ou live)
Choisir le type de votre client MCP

Conservez votre clé API en lieu sûr. Utilisez les clés du 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.

Le serveur local exécute votre code dans un sandbox Deno. Installez Deno 2.8 ou une version antérieure et assurez-vous que deno figure dans votre PATH ; le sandbox ne démarre pas avec Deno 2.9 ou une version ultérieure. L’exécution de code locale fonctionne uniquement sur macOS et Linux. Sous Windows, utilisez le serveur distant ou exécutez le serveur local dans WSL2.

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="test_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": "test_mode"
      }
    }
  }
}

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

Docker

Exécutez le serveur MCP dans un conteneur.

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

# Run the container (-i keeps stdin open for the stdio transport)
docker run -i -e DODO_PAYMENTS_API_KEY="dodo_test_..." \
  -e DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key" \
  -e DODO_PAYMENTS_ENVIRONMENT="test_mode" \
  ghcr.io/dodopayments/mcp:latest

Les images Docker sont disponibles sur GitHub Container Registry.

Configuration du client

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

Configurez le serveur MCP Dodo Payments dans Cursor pour accéder à vos données de paiement par conversation.Installation en un clicUtilisez le bouton ci-dessous pour installer directement le serveur MCP dans Cursor :[ Ajouter à Cursor

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

Open Cursor settings

Accédez à Cursor Settings > Tools & MCP ou appuyez sur Cmd/Ctrl + Shift + P, puis recherchez « MCP Settings ».

Edit configuration

Cliquez sur New MCP Server pour ouvrir le fichier mcp.json.

Add Dodo Payments configuration

Choisissez l’une des configurations suivantes :Remote Server (Recommended)

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

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 d’IA des informations sur vos données Dodo Payments.

Configurez le serveur MCP Dodo Payments dans Claude Desktop pour accéder à vos données de paiement par conversation.

Locate configuration file

Recherchez 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 :Remote Server (Recommended)

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

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 puis rouvrez Claude Desktop pour appliquer les modifications.

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 enregistrée dans le fichier .claude.json du répertoire personnel de l’utilisateur.

Claude Code récupère automatiquement les variables d’environnement depuis votre shell. Vous pouvez donc également les exporter avant d’exécuter la commande.

Configurez le serveur MCP Dodo Payments dans VS Code.Installation en un clicOuvrir VS CodeAprès avoir cliqué, définissez vos variables d’environnement dans le fichier 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 accéder à vos données de paiement par conversation.

Open Cline settings

Recherchez 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 de VS Code (Cmd/Ctrl + Shift + P > « Reload Window ») pour activer la connexion au serveur MCP.

Configurez le serveur MCP Dodo Payments dans Zed pour accéder à vos données de paiement par conversation.

Open Zed settings

Accédez à 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 d’IA de Zed.

Configurez le serveur MCP Dodo Payments dans d’autres clients compatibles avec MCP.Remote Server (Recommended)

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

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"
      }
    }
  }
}

Consultez modelcontextprotocol.io/clients pour obtenir la liste complète des clients compatibles avec MCP et de leurs méthodes de configuration.

Variables d’environnement

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

Variable	Description	Required
`DODO_PAYMENTS_API_KEY`	Votre clé API Dodo Payments	Yes
`DODO_PAYMENTS_WEBHOOK_KEY`	Votre clé de signature de webhook	No
`DODO_PAYMENTS_ENVIRONMENT`	`live_mode` ou `test_mode` ; la valeur par défaut est `live_mode`	No

Exécution à distance

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 le serveur déployé, les clients peuvent se connecter à l’aide de 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 :

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

Bonnes pratiques de sécurité

Code Mode offre une sécurité intrinsèque en exécutant le code dans un environnement sandboxé et en injectant les clés API côté serveur. Suivez ces bonnes pratiques pour protéger vos identifiants.

API Key Management

Ne validez jamais d’identifiants dans le contrôle de version. Stockez les clés API dans des variables d’environnement ou des systèmes sécurisés de gestion des secrets :

# 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 régulièrement tourner les clés en générant périodiquement de nouvelles clés API et en révoquant les anciennes depuis votre tableau de bord Dodo Payments. Utilisez toujours des clés API en mode test pendant le développement afin d’éviter d’affecter les données de production.

Access Control

Lors d’un déploiement distant, exigez toujours une authentification via l’en-tête Authorization ou l’en-tête x-dodo-payments-api-key.

Network Security

Déployez toujours les serveurs MCP distants derrière des points de terminaison HTTPS. Protégez-vous contre les abus en implémentant des limites de débit au niveau du serveur MCP et de l’API. Configurez des règles de pare-feu pour limiter les clients pouvant se connecter à votre serveur MCP.

Résolution des problèmes

Connection issues

Vérifiez 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 que vous pouvez atteindre les points de terminaison de l’API Dodo Payments. Activez la journalisation détaillée dans votre client MCP pour diagnostiquer les problèmes de connexion.

Authentication errors

Vérifiez que vous utilisez 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 que DODO_PAYMENTS_ENVIRONMENT est correctement défini (live_mode pour la production). Si le problème persiste, générez une nouvelle clé API depuis votre tableau de bord.

Tool execution failures

Vérifiez que l’assistant d’IA fournit des paramètres correctement formatés pour chaque outil. Consultez la réponse d’erreur de l’API pour obtenir des indications précises sur l’origine du problème. Vérifiez que l’opération fonctionne lorsque vous appelez directement l’API Dodo Payments via curl ou Postman.

Pourquoi utiliser Code Mode

Les implémentations MCP traditionnelles souffrent de la « prolifération des outils », où chaque point de terminaison d’API est exposé comme un outil distinct. Code Mode est préférable pour plusieurs raisons :

Les LLM écrivent mieux du code qu’ils n’appellent des outils

Les LLM sont entraînés sur des millions de lignes de code réel et écrivent donc naturellement de bons scripts. L’appel d’outils repose souvent sur des exemples synthétiques.

« Faire exécuter des tâches à un LLM avec l’appel d’outils, c’est comme inscrire Shakespeare à un cours de mandarin d’un mois, puis lui demander d’y écrire une pièce. » — Cloudflare

Élimine la surcharge de la fenêtre de contexte

Dans les approches traditionnelles, chaque définition d’outil consomme des tokens avant le début de la conversation. Exposer plus de 50 outils peut consommer de 55K à plus de 100K tokens. Anthropic a constaté que les définitions d’outils pouvaient consommer jusqu’à 134K tokens avant optimisation. Code Mode ne charge que 2 définitions d’outils (environ 1K tokens). L’agent recherche la documentation à la demande. Le Tool Search Tool d’Anthropic a préservé 95 % de la fenêtre de contexte, réduisant la surcharge de 77K à 8,7K tokens.

Réduit la latence grâce à l’orchestration programmatique

L’appel d’outils traditionnel nécessite un aller-retour complet d’inférence du modèle pour chaque opération. Si une tâche nécessite 20 appels d’API, cela représente 20 aller-retours. Avec 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 % du nombre de tokens et une amélioration de la précision (la récupération des connaissances est passée de 25,6 % à 28,5 %) avec cette approche.

Plus sécurisé par conception

Code Mode offre des avantages de sécurité intrinsèques :

Aucune clé 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 des outils envoyés au LLM.
Sandbox 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 disponibles pour l’agent.

S’adapte à toute taille d’API

À mesure qu’une API se développe, les performances du MCP traditionnel se dégradent, car davantage d’outils doivent être chargés. Code Mode reste constant avec 2 outils, quelle que soit l’étendue de l’API. Cloudflare a regroupé plus de 2 500 points de terminaison d’API en 2 outils et environ 1 000 tokens de contexte.

Pour plus de détails, consultez les blogs d’ingénierie d’Anthropic et de 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

En savoir plus sur la norme 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

Overview

Fonctionnalités principales

How Code Mode Works

Quick Setup

Dodo Knowledge MCP

What is 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 du client

Variables d’environnement

Exécution à distance

Configuration du serveur distant

En-têtes d’autorisation

Bonnes pratiques de sécurité

Résolution des problèmes

Pourquoi utiliser Code Mode

Les LLM écrivent mieux du code qu’ils n’appellent des outils

Élimine la surcharge de la fenêtre de contexte

Réduit la latence grâce à l’orchestration programmatique

Plus sécurisé par conception

S’adapte à toute taille d’API

Ressources

API Reference

MCP Protocol

GitHub Repository

NPM Package

​Overview

​Fonctionnalités principales

​How Code Mode Works

​Quick Setup

​Dodo Knowledge MCP

​What is 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 du client

​Variables d’environnement

​Exécution à distance

​Configuration du serveur distant

​En-têtes d’autorisation

​Bonnes pratiques de sécurité

​Résolution des problèmes

​Pourquoi utiliser Code Mode

​Les LLM écrivent mieux du code qu’ils n’appellent des outils

​Élimine la surcharge de la fenêtre de contexte

​Réduit la latence grâce à l’orchestration programmatique

​Plus sécurisé par conception

​S’adapte à toute taille d’API

​Ressources

API Reference

MCP Protocol

GitHub Repository

NPM Package

Overview

Fonctionnalités principales

How Code Mode Works

Quick Setup

Dodo Knowledge MCP

What is 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 du client

Variables d’environnement

Exécution à distance

Configuration du serveur distant

En-têtes d’autorisation

Bonnes pratiques de sécurité

Résolution des problèmes

Pourquoi utiliser Code Mode

Les LLM écrivent mieux du code qu’ils n’appellent des outils

Élimine la surcharge de la fenêtre de contexte

Réduit la latence grâce à l’orchestration programmatique

Plus sécurisé par conception

S’adapte à toute taille d’API

Ressources