mcpcodeserver MCP Server

officiel

Au lieu d'appeler directement les outils MCP, le serveur mcpcodeserver transforme les appels d'outils MCP en programmes TypeScript, permettant une orchestration plus intelligente et à faible latence par les LLMs.

GitHub
13

Documentation

mcpcodeserver

NPM Version MIT licensed Install MCP Server Install in VS Code (npx)

Un serveur proxy Model Context Protocol (MCP) qui traduit les appels d'outils en génération de code TypeScript. Au lieu d'effectuer de multiples appels d'outils aller-retour, les LLM peuvent écrire du code TypeScript qui appelle plusieurs outils de manière naturelle, réduisant ainsi la surcharge de tokens et exploitant les capacités supérieures de génération de code des LLM.

❌ Sans mcpcodeserver

Les LLM effectuent de multiples appels d'outils séquentiels, consommant des tokens et peinant avec les flux de travail complexes :

  • ❌ Multiples allers-retours entre le LLM et les outils
  • ❌ Les séquences d'appels d'outils complexes sont sujettes aux erreurs
  • ❌ Les données ne peuvent pas facilement être transmises entre les outils
  • ❌ Gestion des erreurs et flux de contrôle limités

✅ Avec mcpcodeserver

Les LLM écrivent du code TypeScript qui appelle plusieurs outils naturellement :

  • ✅ Écrire du code pour appeler plusieurs outils en séquence
  • ✅ Utiliser naturellement des variables, boucles et conditions
  • ✅ Meilleure gestion des erreurs avec try/catch
  • ✅ Réduire l'utilisation de tokens en combinant les opérations
  • ✅ Exploiter les fortes capacités de génération de code des LLM

Démarrage rapide

  1. Installez mcpcodeserver dans votre client MCP (voir la section installation ci-dessous)
  2. Créez un fichier de configuration mcp.json avec vos serveurs MCP enfants
  3. Commencez à l'utiliser - votre LLM peut désormais générer et exécuter du code TypeScript qui appelle vos outils
// Instead of multiple tool calls, write code like this:
const files = await filesystem.list_directory({ path: "/tmp" });
const results = await Promise.all(
  files.map(file => filesystem.read_file({ path: file.path }))
);
return results.filter(content => content.includes("important"));

Aperçu

mcpcodeserver est un serveur MCP unique qui :

  • Agit comme un client MCP pour se connecter à un ou plusieurs serveurs MCP enfants
  • Découvre tous les outils des serveurs enfants
  • Expose trois outils puissants aux clients LLM parents :
    1. list_servers - Liste tous les sous-serveurs disponibles connectés à ce serveur MCP
    2. get_tool_definitions - Renvoie les définitions de types TypeScript pour les outils découverts (optionnellement filtrées par serveur)
    3. generate_and_execute_code - Génère et exécute du code TypeScript qui appelle ces outils dans un bac à sable

Cette architecture permet aux LLM d'orchestrer des flux de travail multi-outils complexes en écrivant du code au lieu d'effectuer des appels d'outils séquentiels, ce qui est souvent plus efficace et naturel pour les modèles de langage modernes.

Travaux connexes et recherche

Cette approche s'inspire de recherches récentes montrant que les LLM sont plus performants lorsqu'ils génèrent du code exécutable plutôt que d'effectuer des appels d'outils directs :

  • CodeAct: Your LLM Agent Acts Better when Generating Code (Apple, ICML 2024) - Démontre que les agents LLM atteignent des taux de réussite jusqu'à 20 % supérieurs en utilisant du code Python exécutable comme espace d'action unifié au lieu de formats d'appel d'outils prédéfinis.

  • Cloudflare Code Mode - Une implémentation similaire qui convertit les outils MCP en API TypeScript, montrant que « les LLM sont meilleurs pour écrire du code pour appeler MCP que pour appeler MCP directement ».

L'idée clé de cette recherche est que les LLM ont une formation approfondie sur le code du monde réel mais une exposition limitée aux formats synthétiques d'appel d'outils, faisant de la génération de code une approche plus naturelle et efficace pour les flux de travail d'agents complexes.

Pourquoi utiliser ceci ?

Problèmes traditionnels des appels d'outils

  • Les multiples allers-retours entre le LLM et les outils consomment des tokens
  • Les LLM peinent souvent avec les séquences d'appels d'outils complexes
  • Chaque appel d'outil nécessite la compréhension et le formatage du schéma JSON
  • Les données ne peuvent pas facilement être transmises entre les outils sans passer par le LLM

Solution de génération de code

  • Écrire du code TypeScript pour appeler plusieurs outils en séquence
  • Utiliser naturellement des variables, boucles et conditions
  • Meilleure gestion des erreurs avec try/catch
  • Réduire l'utilisation de tokens en combinant les opérations
  • Exploiter les fortes capacités de génération de code des LLM

Découverte dynamique d'outils

mcpcodeserver surveille automatiquement les serveurs MCP enfants pour détecter les changements d'outils et notifie les clients parents lorsque des outils sont ajoutés, supprimés ou modifiés :

  • Actualisation automatique : Vérifie les changements d'outils toutes les 30 secondes
  • Notifications en temps réel : Envoie notifications/tools/list_changed aux clients parents
  • Mises à jour dynamiques : Les définitions d'outils et les résumés se mettent à jour automatiquement
  • Pas d'actualisation manuelle : Les LLM parents reçoivent des notifications pour actualiser leur connaissance des outils

Cela garantit que les LLM parents disposent toujours des définitions d'outils les plus récentes sans nécessiter d'intervention manuelle.

Filtrage par serveur

Pour réduire l'utilisation de la fenêtre de contexte et améliorer la concentration, mcpcodeserver prend en charge le filtrage des définitions d'outils par serveurs spécifiques :

  • Lister les serveurs disponibles : Utilisez list_servers pour voir tous les sous-serveurs connectés
  • Définitions d'outils filtrées : Utilisez get_tool_definitions avec le paramètre server_names pour obtenir uniquement les outils de serveurs spécifiques
  • Verbose réduite : Obtenez des définitions TypeScript ciblées sans submerger la fenêtre de contexte du LLM
  • Espacement des noms de méthodes : Toutes les fonctions générées sont préfixées par les noms de serveur (par exemple, pizzashop_create_pizza, filesystem_read_file)

Exemple d'utilisation :

// List available servers
const servers = await list_servers({});
// Returns: ["pizzashop", "filesystem", "memory"]

// Get all tool definitions
const allTools = await get_tool_definitions({});

// Get only pizzashop tools
const pizzashopTools = await get_tool_definitions({
  server_names: ["pizzashop"]
});

Fonctionnalités MCP avancées

mcpcodeserver prend en charge le transfert transparent des fonctionnalités avancées du protocole MCP lorsque les serveurs parents et enfants les prennent en charge :

  • Élicitation : Les serveurs enfants peuvent demander une saisie utilisateur pendant l'exécution de l'outil, qui est transmise aux clients parents
  • Racines : Liste et agrège les racines de tous les serveurs enfants, fournissant une vue unifiée des ressources disponibles
  • Échantillonnage : Permet aux demandes d'échantillonnage LLM d'être transmises aux serveurs enfants pour des capacités d'IA avancées

Ces fonctionnalités sont automatiquement annoncées aux clients parents et fonctionnent de manière transparente lorsqu'elles sont prises en charge par les serveurs MCP enfants sous-jacents.

Démarrage rapide

Essayez-le immédiatement avec npx (aucune installation requise) :

# From GitHub
npx github:zbowling/mcpcodeserver --help

# Or when published to npm
npx mcpcodeserver --help

🛠️ Installation

Prérequis

  • Node.js >= v18.0.0
  • Cursor, Claude Code, VSCode, Windsurf ou un autre client MCP

Installation via Smithery

Pour installer mcpcodeserver pour n'importe quel client automatiquement via Smithery :

npx -y @smithery/cli@latest install mcpcodeserver --client <client-name> --key <smithery-key>

Installer dans Cursor

Allez dans : Settings -> Cursor Settings -> MCP -> Add new global MCP server

Coller la configuration suivante dans votre fichier ~/.cursor/mcp.json Cursor est l'approche recommandée. Vous pouvez également installer dans un projet spécifique en créant .cursor/mcp.json dans votre dossier de projet.

Installation en un clic pour Cursor

Install MCP Server

Connexion au serveur local Cursor

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Connexion au serveur distant Cursor (si vous configurez le transport HTTP)

{
  "mcpServers": {
    "mcpcodeserver": {
      "url": "http://localhost:3000/mcp"
    }
  }
}

Installer dans Claude Code

Exécutez cette commande. Consultez la documentation Claude Code MCP pour plus d'informations.

Connexion au serveur local Claude Code

claude mcp add mcpcodeserver -- npx -y mcpcodeserver --config /path/to/your/mcp.json

Connexion au serveur distant Claude Code

claude mcp add --transport http mcpcodeserver http://localhost:3000/mcp

Installer dans VSCode

Installation en un clic pour VSCode

Install in VS Code (npx)

Configuration manuelle pour VSCode

Ajoutez à vos paramètres MCP VSCode :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Installer dans Windsurf

Installation en un clic pour Windsurf

Install in Windsurf

Installer dans les assistants de codage IA

Pour Continue, Cline et RooCode, ajoutez à votre configuration :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Installer dans Amp

Exécutez cette commande dans votre terminal. Consultez la documentation Amp MCP pour plus d'informations.

amp mcp add mcpcodeserver -- npx -y mcpcodeserver --config /path/to/your/mcp.json

Installer dans les éditeurs de texte

Pour Aider, Codium, Zed, Nova et Sublime Text, ajoutez à votre configuration :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Installer dans Neovim

Ajoutez à votre configuration MCP Neovim :

{
  mcpServers = {
    mcpcodeserver = {
      command = "npx",
      args = {"-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"}
    }
  }
}

Installer dans Emacs

Ajoutez à votre configuration MCP Emacs :

(setq mcp-servers
      '((mcpcodeserver
         :command "npx"
         :args ("-y" "mcpcodeserver" "--config" "/path/to/your/mcp.json"))))

Installer dans les IDE JetBrains

Pour IntelliJ IDEA, WebStorm, PyCharm et Android Studio, ajoutez à vos paramètres MCP :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Installer dans les outils d'IA

Pour Codeium, Tabnine, GitHub Copilot et Amazon CodeWhisperer, ajoutez à vos paramètres MCP :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Installer dans les IDE Cloud

Pour Replit, CodeSandbox, StackBlitz, GitPod, GitHub Codespaces, GitLab Web IDE et Bitbucket Cloud, ajoutez à vos paramètres MCP :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Installer dans d'autres outils

Pour Xcode, Fleet, Sourcegraph et JetBrains Gateway, ajoutez à votre configuration MCP :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Installer pour le développement à distance

Pour les environnements de développement à distance, vous pouvez également utiliser le transport HTTP :

{
  "mcpServers": {
    "mcpcodeserver": {
      "url": "http://your-server:3000/mcp"
    }
  }
}

Fichier de configuration

Créez un fichier de configuration mcp.json pour définir vos serveurs MCP enfants :

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "env": { "DEBUG": "false" }
    },
    "memory": {
      "command": "npx", 
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": { "BRAVE_API_KEY": "your-api-key" }
    }
  }
}

Installation pour le développement

# Install dependencies (using Bun for faster performance)
bun install

# Or with npm
npm install

# Build the project
bun run build

# Test the built server
bun dist/index.js --help

Remarque : Ce projet utilise Bun pour de meilleures performances, mais npm/node fonctionnent également très bien.

🚨 Dépannage

Erreurs de module introuvable

Si vous rencontrez ERR_MODULE_NOT_FOUND, essayez d'utiliser bunx au lieu de npx :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "bunx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Problèmes de résolution ESM

Pour les erreurs comme Error: Cannot find module, essayez le drapeau --experimental-vm-modules :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "--node-options=--experimental-vm-modules", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Problèmes TLS/Certificat

Utilisez le drapeau --experimental-fetch pour contourner les problèmes liés à TLS :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "--node-options=--experimental-fetch", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Erreurs générales du client MCP

  1. Essayez d'ajouter @latest au nom du paquet
  2. Utilisez bunx comme alternative à npx
  3. Envisagez d'utiliser deno comme autre alternative
  4. Assurez-vous d'utiliser Node.js v18 ou supérieur pour la prise en charge native de fetch

Problèmes de configuration

  • Assurez-vous que votre fichier mcp.json est un JSON valide
  • Vérifiez que toutes les commandes du serveur enfant sont disponibles dans votre PATH
  • Vérifiez que les serveurs enfants peuvent démarrer indépendamment
  • Vérifiez les permissions du fichier pour le chemin du fichier de configuration

Test avec MCP Inspector

npx -y @modelcontextprotocol/inspector npx mcpcodeserver --config /path/to/your/mcp.json

💻 Développement

Arguments CLI

mcpcodeserver accepte les drapeaux CLI suivants :

  • --config <path> – Chemin vers le fichier de configuration MCP (par défaut : ./mcp.json)
  • --transport <stdio|http> – Transport à utiliser (stdio par défaut). Notez que le transport HTTP fournit automatiquement à la fois des points de terminaison HTTP et SSE
  • --port <number> – Port d'écoute lors de l'utilisation du transport http (par défaut 3000)
  • --help – Afficher le message d'aide

Exemple avec le transport HTTP et le port 8080 :

npx mcpcodeserver --config /path/to/mcp.json --transport http --port 8080

Exemple avec le transport stdio :

npx mcpcodeserver --config /path/to/mcp.json --transport stdio

Variables d'environnement

Vous pouvez utiliser des variables d'environnement pour la configuration :

  • MCP_CONFIG_PATH – Chemin vers le fichier de configuration MCP (alternative à --config)
  • MCP_TRANSPORT – Type de transport (alternative à --transport)
  • MCP_PORT – Numéro de port pour le transport HTTP (alternative à --port)

Exemple avec des variables d'environnement :

# .env
MCP_CONFIG_PATH=/path/to/your/mcp.json
MCP_TRANSPORT=stdio

Exemple de configuration MCP utilisant des variables d'environnement :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver"],
      "env": {
        "MCP_CONFIG_PATH": "/path/to/your/mcp.json"
      }
    }
  }
}

Remarque : Les drapeaux CLI prennent le pas sur les variables d'environnement lorsque les deux sont fournis.

Configuration de développement local

Pour le développement local, vous pouvez exécuter la source TypeScript directement :

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcpcodeserver/src/index.ts", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Modes d'exécution

Mode Stdio (par défaut)

Le serveur s'exécute en mode stdio par défaut, ce qui est parfait pour l'intégration avec les clients MCP comme Claude Desktop :

# Run in stdio mode
npx mcpcodeserver --config mcp.json

# Or with custom config path
npx mcpcodeserver --config /path/to/your/mcp.json

Mode HTTP

Pour le débogage, les tests ou l'intégration avec des clients MCP basés sur le Web, vous pouvez exécuter le serveur en mode HTTP :

# Run in HTTP mode on default port 3000
npx mcpcodeserver --http --config mcp.json

# Run on custom port and host
npx mcpcodeserver --http --port 8080 --host 0.0.0.0 --config mcp.json

Lors de l'exécution en mode HTTP, le serveur sera disponible à :

  • URL du serveur : http://localhost:3000/mcp (ou votre hôte:port personnalisé)
  • MCP Inspector : Utilisez npx @modelcontextprotocol/inspector http://localhost:3000/mcp pour déboguer et tester

Intégration de MCP Inspector

MCP Inspector est un outil puissant pour déboguer et tester les serveurs MCP. Lors de l'exécution en mode HTTP, vous pouvez l'utiliser pour :

  • Inspecter les outils disponibles et leurs schémas
  • Tester les appels d'outils de manière interactive
  • Déboguer l'accès aux ressources et les invites
  • Surveiller les notifications en temps réel
# Start the server in HTTP mode
npx mcpcodeserver --http --config mcp.json

# In another terminal, start the MCP Inspector
npx @modelcontextprotocol/inspector http://localhost:3000/mcp

# Or use the shorthand script (includes all example servers)
npm run inspector

L'inspecteur s'ouvrira dans votre navigateur et fournira une interface complète pour explorer et tester votre serveur MCP.

Remarque : La commande npm run inspector utilise mcp-test.json qui inclut 8 serveurs MCP (67 outils au total) des exemples officiels, y compris des serveurs basés sur TypeScript (npx) et Python (uvx).

Configuration

Créez un fichier mcp.json qui définit les serveurs MCP enfants auxquels se connecter. Cela suit le format standard de configuration du client MCP :

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "env": {
        "DEBUG": "false"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    },
    "weather": {
      "url": "http://localhost:3000/mcp",
      "transport": "sse"
    }
  }
}

Options de configuration

Chaque entrée de serveur prend en charge :

Pour le transport stdio :

  • command (obligatoire) - La commande à exécuter (par exemple, "node", "python", "npx")
  • args (facultatif) - Tableau d'arguments à passer à la commande
  • env (facultatif) - Variables d'environnement pour le processus enfant

Pour le transport HTTP/SSE :

  • url (obligatoire) - L'URL du point de terminaison HTTP
  • transport - Définir sur "sse" pour les événements envoyés par le serveur

Utilisation

Démarrage du serveur

# Use default config (./mcp.json)
mcpcodeserver

# Use custom config location
mcpcodeserver --config /path/to/custom-mcp.json

# Show help
mcpcodeserver --help

Utilisation en tant que serveur MCP

Configurez mcpcodeserver dans votre client MCP (comme Claude Desktop, Claude Code, Cline, etc.) :

Avec npx (recommandé - aucune installation nécessaire) :

{
  "mcpServers": {
    "codeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/mcp.json"]
    }
  }
}

Depuis GitHub (fonctionne immédiatement) :

{
  "mcpServers": {
    "codeserver": {
      "command": "npx",
      "args": ["-y", "github:zbowling/mcpcodeserver", "--config", "/path/to/mcp.json"]
    }
  }
}

Avec d'autres gestionnaires de paquets :

// yarn
{ "command": "yarn", "args": ["dlx", "mcpcodeserver", "--config", "/path/to/mcp.json"] }

// pnpm
{ "command": "pnpm", "args": ["dlx", "mcpcodeserver", "--config", "/path/to/mcp.json"] }

// bun
{ "command": "bunx", "args": ["mcpcodeserver", "--config", "/path/to/mcp.json"] }

Consultez examples/ pour plus d'exemples de configuration et des configurations spécifiques aux clients MCP.

Outil 1 : get_tool_definitions

Cet outil renvoie les définitions de type TypeScript pour tous les outils découverts des serveurs enfants.

Entrée :

  • include_examples (booléen facultatif) - Inclure ou non des exemples d'utilisation

Exemple :

// Call the tool (in your MCP client)
get_tool_definitions({ include_examples: true })

Sortie : Renvoie du code TypeScript avec des interfaces et des déclarations de fonctions :

/**
 * Auto-generated TypeScript definitions for MCP tools
 */

interface ToolResult {
  content: Array<{
    type: string;
    text?: string;
    // ...
  }>;
  isError?: boolean;
}

/**
 * Read contents of a file
 * Server: filesystem
 * Tool: read_file
 */
interface ReadFileParams {
  path: string;
}

declare function filesystem_read_file(params: ReadFileParams): Promise<ToolResult>;

// ... more tool definitions

Outil 2 : generate_and_execute_code

Cet outil exécute du code TypeScript dans un bac à sable avec accès à toutes les fonctions d'outils découvertes.

Entrée :

  • code (chaîne obligatoire) - Code TypeScript/JavaScript à exécuter
  • timeout (nombre facultatif) - Temps d'exécution maximal en millisecondes (par défaut : 30000, max : 300000)

Exemple :

// Call the tool with TypeScript code
generate_and_execute_code({
  code: `
    // Read multiple files and combine them
    const file1 = await filesystem_read_file({ path: "/tmp/file1.txt" });
    const file2 = await filesystem_read_file({ path: "/tmp/file2.txt" });

    const text1 = file1.content[0].text;
    const text2 = file2.content[0].text;

    console.log("File 1 length:", text1.length);
    console.log("File 2 length:", text2.length);

    return {
      combined: text1 + text2,
      totalLength: text1.length + text2.length
    };
  `
})

Sortie :

=== Console Output ===
File 1 length: 42
File 2 length: 38

=== Result ===
{
  "combined": "...",
  "totalLength": 80
}

Environnement du bac à sable

Le bac à sable d'exécution TypeScript fournit :

Disponible :

  • Toutes les fonctions d'outils découvertes (en tant que fonctions asynchrones)
  • Méthodes de console : console.log(), console.error(), console.warn(), console.info()
  • Objets globaux JavaScript de base : Math, JSON, Date, Array, Object, String, Number, Boolean
  • Prise en charge de Promise et async/await
  • Gestion des erreurs avec try/catch
  • Temporisateurs : setTimeout, setInterval, clearTimeout, clearInterval

Non disponible :

  • Modules Node.js (fs, http, child_process, etc.)
  • Accès au système de fichiers (sauf via les outils MCP)
  • Accès réseau (sauf via les outils MCP)
  • Informations sur le processus

Note de sécurité : Ce n'est pas un bac à sable entièrement sécurisé. Le contexte VM fournit une isolation mais n'est pas infaillible. N'exécutez que du code de confiance.

Gestion des erreurs

Les erreurs dans le bac à sable sont interceptées et renvoyées avec les traces de pile :

generate_and_execute_code({
  code: `
    try {
      const result = await filesystem_read_file({ path: "/nonexistent" });
      return result;
    } catch (error) {
      console.error("Failed to read file:", error.message);
      throw error; // Re-throw to surface to parent
    }
  `
})

Test avec Claude Code

Vous voulez essayer mcpcodeserver avec Claude Code ? Utilisez la configuration en une seule commande :

./setup-claude-code-test.sh

Cela construira le projet, installera les dépendances de test et vous montrera exactement ce qu'il faut ajouter à votre configuration Claude Code. Consultez TESTING_WITH_CLAUDE.md pour des instructions détaillées.

Développement

# Install dependencies
bun install

# Build the project
bun run build

# Watch mode for development
bun run dev

# Run the server
bun start

# Run tests
bun test                # All tests
bun run test:unit       # Unit tests only
bun run test:integration # Integration tests (requires Python)

# Code quality
bun run lint            # Check linting
bun run format          # Format code
bun run typecheck       # Type checking

Structure du projet

Consultez AGENTS.md pour la structure détaillée du projet et la documentation des composants.

Cas d'utilisation

Opérations multi-fichiers

Au lieu d'effectuer plusieurs appels d'outils via le LLM, écrivez du code :

const files = ["/tmp/a.txt", "/tmp/b.txt", "/tmp/c.txt"];
const contents = await Promise.all(
  files.map(path => filesystem_read_file({ path }))
);
return contents.map(r => r.content[0].text);

Transformation de données

Traitez les données entre les appels d'outils sans intervention du LLM :

const data = await api_fetch({ url: "https://api.example.com/data" });
const json = JSON.parse(data.content[0].text);
const filtered = json.items.filter(item => item.active);
return filtered.length;

Logique conditionnelle

Prenez des décisions basées sur les résultats des outils :

const exists = await filesystem_read_file({ path: "/tmp/config.json" });
if (exists.isError) {
  console.log("Config doesn't exist, using defaults");
  return { source: "defaults" };
} else {
  return { source: "file", config: JSON.parse(exists.content[0].text) };
}

Récupération d'erreur

Gérez les erreurs avec élégance sans interrompre l'ensemble du flux de travail :

const results = [];
for (const path of ["/tmp/a.txt", "/tmp/b.txt", "/tmp/c.txt"]) {
  try {
    const content = await filesystem_read_file({ path });
    results.push({ path, success: true, data: content });
  } catch (error) {
    results.push({ path, success: false, error: error.message });
  }
}
return results;

Intégration des serveurs MCP en amont

mcpcodeserver peut s'intégrer aux serveurs MCP officiels en amont du dépôt des serveurs Model Context Protocol. Cela vous permet d'utiliser de vrais serveurs MCP prêts pour la production aux côtés de vos outils personnalisés.

Serveurs en amont pris en charge

  • filesystem : Opérations sur le système de fichiers (lecture, écriture, liste des répertoires)
  • memory : Stockage clé-valeur en mémoire
  • sqlite : Opérations de base de données SQLite
  • github : Intégration de l'API GitHub
  • brave-search : Capacités de recherche Web
  • fetch : Capacités de requête HTTP

Exemple de configuration

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "/tmp/test.db"]
    }
  }
}

Test de l'intégration en amont

Le projet comprend des tests complets pour l'intégration des serveurs en amont :

# Run upstream servers integration tests
bun tests/integration/run-upstream-tests.ts

# Or manually test with upstream config
npx mcpcodeserver --config tests/integration/upstream-test-config.json

Flux de travail inter-serveurs

Avec les serveurs en amont, vous pouvez créer de puissants flux de travail inter-serveurs :

// Store database query results in memory and write to file
const queryResult = await sqlite_execute_sql({
  sql: "SELECT COUNT(*) as count FROM users"
});
const count = queryResult.content[0].text;

await memory_create({
  key: "user-count",
  value: count
});

await filesystem_write_file({
  path: "/tmp/user-count.txt",
  content: `Total users: ${count}`
});

Limitations

  • Délai d'exécution : Maximum 5 minutes (configurable, par défaut 30 secondes)
  • Mémoire : Limitée par le contexte VM Node.js
  • Pas d'état persistant entre les exécutions
  • Impossible de require/importer des modules externes
  • Pas un bac à sable de sécurité - n'exécutez pas de code non fiable

Contribution

Les contributions sont les bienvenues ! Ce projet est construit avec :

  • TypeScript 5.7+
  • Node.js 18+
  • MCP TypeScript SDK 1.20+
  • Zod pour la validation

Consultez CONTRIBUTING.md pour des directives de contribution détaillées.

Soutien

Si vous trouvez ce projet utile, pensez à m'offrir un café !

Buy Me A Coffee

Licence

MIT

Ressources