mcpcodeserver MCP Server

oficial

En lugar de llamar directamente a las herramientas MCP, el servidor mcpcodeserver transforma las llamadas a herramientas MCP en programas TypeScript, permitiendo una orquestación más inteligente y de menor latencia por parte de los LLMs.

GitHub
13

Documentación

mcpcodeserver

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

Un servidor proxy del Protocolo de Contexto de Modelo (MCP) que traduce las llamadas a herramientas en generación de código TypeScript. En lugar de hacer múltiples llamadas a herramientas de ida y vuelta, los LLM pueden escribir código TypeScript que llama a múltiples herramientas de forma natural, reduciendo la sobrecarga de tokens y aprovechando las capacidades superiores de generación de código del LLM.

❌ Sin mcpcodeserver

Los LLM realizan múltiples llamadas secuenciales a herramientas, consumiendo tokens y teniendo dificultades con flujos de trabajo complejos:

  • ❌ Múltiples viajes de ida y vuelta entre el LLM y las herramientas
  • ❌ Las secuencias complejas de llamadas a herramientas son propensas a errores
  • ❌ Los datos no pueden pasarse fácilmente entre herramientas
  • ❌ Manejo de errores y flujo de control limitados

✅ Con mcpcodeserver

Los LLM escriben código TypeScript que llama a múltiples herramientas de forma natural:

  • ✅ Escribe código para llamar a múltiples herramientas en secuencia
  • ✅ Usa variables, bucles y condicionales de forma natural
  • ✅ Mejor manejo de errores con try/catch
  • ✅ Reduce el uso de tokens al combinar operaciones
  • ✅ Aprovecha las sólidas capacidades de generación de código del LLM

Inicio Rápido

  1. Instala mcpcodeserver en tu cliente MCP (consulta la sección de instalación más abajo)
  2. Crea un archivo de configuración mcp.json con tus servidores MCP secundarios
  3. Empieza a usarlo - tu LLM ahora puede generar y ejecutar código TypeScript que llama a tus herramientas
// 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"));

Descripción General

mcpcodeserver es un servidor MCP único que:

  • Actúa como un cliente MCP para conectarse a uno o más servidores MCP secundarios
  • Descubre todas las herramientas de los servidores secundarios
  • Expone tres potentes herramientas a los clientes LLM principales:
    1. list_servers - Lista todos los sub-servidores disponibles conectados a este servidor MCP
    2. get_tool_definitions - Devuelve definiciones de tipos TypeScript para las herramientas descubiertas (opcionalmente filtradas por servidor)
    3. generate_and_execute_code - Genera y ejecuta código TypeScript que llama a esas herramientas en un entorno aislado

Esta arquitectura permite a los LLM orquestar flujos de trabajo complejos con múltiples herramientas escribiendo código en lugar de hacer llamadas secuenciales a herramientas, lo que a menudo es más eficiente y natural para los modelos de lenguaje modernos.

Trabajo Relacionado e Investigación

Este enfoque está inspirado en investigaciones recientes que muestran que los LLM se desempeñan mejor cuando generan código ejecutable en lugar de hacer llamadas directas a herramientas:

  • CodeAct: Your LLM Agent Acts Better when Generating Code (Apple, ICML 2024) - Demuestra que los agentes LLM logran tasas de éxito hasta un 20% más altas cuando usan código Python ejecutable como un espacio de acción unificado en lugar de formatos predefinidos de llamada a herramientas.

  • Cloudflare Code Mode - Una implementación similar que convierte herramientas MCP en APIs TypeScript, mostrando que "los LLM son mejores escribiendo código para llamar a MCP, que llamando a MCP directamente."

La idea clave de esta investigación es que los LLM tienen un entrenamiento extenso en código del mundo real pero una exposición limitada a formatos sintéticos de llamada a herramientas, lo que hace que la generación de código sea un enfoque más natural y efectivo para flujos de trabajo de agentes complejos.

¿Por Qué Usar Esto?

Problemas Tradicionales de Llamada a Herramientas

  • Múltiples viajes de ida y vuelta entre el LLM y las herramientas consumen tokens
  • Los LLM a menudo tienen dificultades con secuencias complejas de llamadas a herramientas
  • Cada llamada a herramienta requiere comprensión y formateo de esquema JSON
  • Los datos no pueden pasarse fácilmente entre herramientas sin pasar por el LLM

Solución de Generación de Código

  • Escribe código TypeScript para llamar a múltiples herramientas en secuencia
  • Usa variables, bucles y condicionales de forma natural
  • Mejor manejo de errores con try/catch
  • Reduce el uso de tokens al combinar operaciones
  • Aprovecha las sólidas capacidades de generación de código del LLM

Descubrimiento Dinámico de Herramientas

mcpcodeserver monitorea automáticamente los servidores MCP secundarios en busca de cambios en las herramientas y notifica a los clientes principales cuando se agregan, eliminan o modifican herramientas:

  • Actualización Automática: Verifica cambios en las herramientas cada 30 segundos
  • Notificaciones en Tiempo Real: Envía notifications/tools/list_changed a los clientes principales
  • Actualizaciones Dinámicas: Las definiciones de herramientas y los resúmenes se actualizan automáticamente
  • Sin Actualización Manual: Los LLM principales reciben notificaciones para actualizar su conocimiento de herramientas

Esto asegura que los LLM principales siempre tengan las definiciones de herramientas más actuales sin requerir intervención manual.

Filtrado de Servidores

Para reducir el uso de la ventana de contexto y mejorar el enfoque, mcpcodeserver soporta el filtrado de definiciones de herramientas por servidores específicos:

  • Listar Servidores Disponibles: Usa list_servers para ver todos los sub-servidores conectados
  • Definiciones de Herramientas Filtradas: Usa get_tool_definitions con el parámetro server_names para obtener herramientas solo de servidores específicos
  • Verbosidad Reducida: Obtén definiciones TypeScript enfocadas sin abrumar la ventana de contexto del LLM
  • Espaciado de Nombres de Métodos: Todas las funciones generadas tienen prefijo con nombres de servidor (ej., pizzashop_create_pizza, filesystem_read_file)

Ejemplo de uso:

// 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"]
});

Características Avanzadas de MCP

mcpcodeserver soporta el paso transparente de características avanzadas del protocolo MCP cuando tanto los servidores principales como los secundarios las soportan:

  • Elicitación: Los servidores secundarios pueden solicitar entrada del usuario durante la ejecución de herramientas, lo cual se transmite a los clientes principales
  • Raíces: Lista y agrega raíces de todos los servidores secundarios, proporcionando una vista unificada de los recursos disponibles
  • Muestreo: Permite que las solicitudes de muestreo del LLM se transmitan a los servidores secundarios para capacidades avanzadas de IA

Estas características se anuncian automáticamente a los clientes principales y funcionan sin problemas cuando son soportadas por los servidores MCP secundarios subyacentes.

Inicio Rápido

Pruébalo inmediatamente con npx (no requiere instalación):

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

# Or when published to npm
npx mcpcodeserver --help

🛠️ Instalación

Requisitos

  • Node.js >= v18.0.0
  • Cursor, Claude Code, VSCode, Windsurf u otro Cliente MCP

Instalación vía Smithery

Para instalar mcpcodeserver para cualquier cliente automáticamente vía Smithery:

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

Instalar en Cursor

Ve a: Settings -> Cursor Settings -> MCP -> Add new global MCP server

Pegar la siguiente configuración en tu archivo ~/.cursor/mcp.json de Cursor es el enfoque recomendado. También puedes instalar en un proyecto específico creando .cursor/mcp.json en la carpeta de tu proyecto.

Instalación en Un Clic para Cursor

Install MCP Server

Conexión a Servidor Local de Cursor

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

Conexión a Servidor Remoto de Cursor (si configuraste transporte HTTP)

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

Instalar en Claude Code

Ejecuta este comando. Consulta la documentación de Claude Code MCP para más información.

Conexión a Servidor Local de Claude Code

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

Conexión a Servidor Remoto de Claude Code

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

Instalar en VSCode

Instalación en Un Clic para VSCode

Install in VS Code (npx)

Configuración Manual de VSCode

Agrega a tu configuración de MCP de VSCode:

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

Instalar en Windsurf

Instalación en Un Clic para Windsurf

Install in Windsurf

Instalar en Asistentes de Codificación IA

Para Continue, Cline, y RooCode, agrega a tu configuración:

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

Instalar en Amp

Ejecuta este comando en tu terminal. Consulta la documentación de Amp MCP para más información.

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

Instalar en Editores de Texto

Para Aider, Codium, Zed, Nova, y Sublime Text, agrega a tu configuración:

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

Instalar en Neovim

Agrega a tu configuración de MCP de Neovim:

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

Instalar en Emacs

Agrega a tu configuración de MCP de Emacs:

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

Instalar en IDEs de JetBrains

Para IntelliJ IDEA, WebStorm, PyCharm, y Android Studio, agrega a tu configuración de MCP:

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

Instalar en Herramientas de IA

Para Codeium, Tabnine, GitHub Copilot, y Amazon CodeWhisperer, agrega a tu configuración de MCP:

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

Instalar en IDEs en la Nube

Para Replit, CodeSandbox, StackBlitz, GitPod, GitHub Codespaces, GitLab Web IDE, y Bitbucket Cloud, agrega a tu configuración de MCP:

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

Instalar en Otras Herramientas

Para Xcode, Fleet, Sourcegraph, y JetBrains Gateway, agrega a tu configuración de MCP:

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

Instalar en Desarrollo Remoto

Para entornos de desarrollo remoto, también puedes usar transporte HTTP:

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

Archivo de Configuración

Crea un archivo de configuración mcp.json para definir tus servidores MCP secundarios:

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

Instalación para Desarrollo

# 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

Nota: Este proyecto usa Bun para mejor rendimiento, pero npm/node también funcionan bien.

🚨 Solución de Problemas

Errores de Módulo No Encontrado

Si encuentras ERR_MODULE_NOT_FOUND, intenta usar bunx en lugar de npx:

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

Problemas de Resolución ESM

Para errores como Error: Cannot find module, prueba la bandera --experimental-vm-modules:

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

Problemas de TLS/Certificado

Usa la bandera --experimental-fetch para evitar problemas relacionados con TLS:

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

Errores Generales del Cliente MCP

  1. Intenta agregar @latest al nombre del paquete
  2. Usa bunx como alternativa a npx
  3. Considera usar deno como otra alternativa
  4. Asegúrate de estar usando Node.js v18 o superior para soporte nativo de fetch

Problemas de Configuración

  • Asegúrate de que tu archivo mcp.json sea JSON válido
  • Verifica que todos los comandos del servidor secundario estén disponibles en tu PATH
  • Verifica que los servidores secundarios puedan iniciarse independientemente
  • Comprueba los permisos de archivo para la ruta del archivo de configuración

Pruebas con MCP Inspector

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

💻 Desarrollo

Argumentos de CLI

mcpcodeserver acepta las siguientes banderas de CLI:

  • --config <path> – Ruta al archivo de configuración MCP (por defecto: ./mcp.json)
  • --transport <stdio|http> – Transporte a usar (stdio por defecto). Ten en cuenta que el transporte HTTP proporciona automáticamente tanto endpoints HTTP como SSE
  • --port <number> – Puerto en el que escuchar cuando se usa transporte http (por defecto 3000)
  • --help – Mostrar mensaje de ayuda

Ejemplo con transporte HTTP y puerto 8080:

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

Ejemplo con transporte stdio:

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

Variables de Entorno

Puedes usar variables de entorno para la configuración:

  • MCP_CONFIG_PATH – Ruta al archivo de configuración MCP (alternativa a --config)
  • MCP_TRANSPORT – Tipo de transporte (alternativa a --transport)
  • MCP_PORT – Número de puerto para transporte HTTP (alternativa a --port)

Ejemplo con variables de entorno:

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

Ejemplo de configuración MCP usando variables de entorno:

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

Nota: Las banderas de CLI tienen prioridad sobre las variables de entorno cuando se proporcionan ambas.

Configuración de Desarrollo Local

Para desarrollo local, puedes ejecutar el código fuente TypeScript directamente:

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

Modos de Ejecución

Modo Stdio (Predeterminado)

El servidor se ejecuta en modo stdio por defecto, lo cual es perfecto para la integración con clientes MCP como Claude Desktop:

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

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

Modo HTTP

Para depuración, pruebas o integración con clientes MCP basados en web, puedes ejecutar el servidor en modo 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

Cuando se ejecuta en modo HTTP, el servidor estará disponible en:

  • URL del Servidor: http://localhost:3000/mcp (o tu host:puerto personalizado)
  • MCP Inspector: Usa npx @modelcontextprotocol/inspector http://localhost:3000/mcp para depurar y probar

Integración con MCP Inspector

MCP Inspector es una herramienta poderosa para depurar y probar servidores MCP. Cuando se ejecuta en modo HTTP, puedes usarlo para:

  • Inspeccionar herramientas disponibles y sus esquemas
  • Probar llamadas a herramientas de forma interactiva
  • Depurar acceso a recursos y prompts
  • Monitorear notificaciones en tiempo real
# 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

El inspector se abrirá en tu navegador y proporcionará una interfaz completa para explorar y probar tu servidor MCP.

Nota: El comando npm run inspector usa mcp-test.json que incluye 8 servidores MCP (67 herramientas en total) de los ejemplos oficiales, incluyendo servidores basados tanto en TypeScript (npx) como en Python (uvx).

Configuración

Cree un archivo mcp.json que defina a qué servidores MCP secundarios conectarse. Esto sigue el formato estándar de configuración del cliente 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"
    }
  }
}

Opciones de configuración

Cada entrada de servidor admite:

Para transporte stdio:

  • command (requerido) - El comando a ejecutar (p. ej., "node", "python", "npx")
  • args (opcional) - Arreglo de argumentos para pasar al comando
  • env (opcional) - Variables de entorno para el proceso hijo

Para transporte HTTP/SSE:

  • url (requerido) - La URL del endpoint HTTP
  • transport - Establecer como "sse" para Server-Sent Events

Uso

Iniciar el servidor

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

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

# Show help
mcpcodeserver --help

Usar como un servidor MCP

Configure mcpcodeserver en su cliente MCP (como Claude Desktop, Claude Code, Cline, etc.):

Con npx (recomendado - no necesita instalación):

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

Desde GitHub (funciona inmediatamente):

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

Con otros gestores de paquetes:

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

Consulte examples/ para más ejemplos de configuración y configuraciones específicas de clientes MCP.

Herramienta 1: get_tool_definitions

Esta herramienta devuelve definiciones de tipo TypeScript para todas las herramientas descubiertas de los servidores secundarios.

Entrada:

  • include_examples (booleano opcional) - Si se deben incluir ejemplos de uso

Ejemplo:

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

Salida: Devuelve código TypeScript con interfaces y declaraciones de funciones:

/**
 * 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

Herramienta 2: generate_and_execute_code

Esta herramienta ejecuta código TypeScript en un entorno aislado con acceso a todas las funciones de herramientas descubiertas.

Entrada:

  • code (cadena requerida) - Código TypeScript/JavaScript a ejecutar
  • timeout (número opcional) - Tiempo máximo de ejecución en milisegundos (predeterminado: 30000, máximo: 300000)

Ejemplo:

// 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
    };
  `
})

Salida:

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

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

Entorno aislado

El entorno aislado de ejecución de TypeScript proporciona:

Disponible:

  • Todas las funciones de herramientas descubiertas (como funciones asíncronas)
  • Métodos de consola: console.log(), console.error(), console.warn(), console.info()
  • Globales básicos de JavaScript: Math, JSON, Date, Array, Object, String, Number, Boolean
  • Soporte para Promise y async/await
  • Manejo de errores con try/catch
  • Temporizadores: setTimeout, setInterval, clearTimeout, clearInterval

No disponible:

  • Módulos de Node.js (fs, http, child_process, etc.)
  • Acceso al sistema de archivos (excepto mediante herramientas MCP)
  • Acceso a la red (excepto mediante herramientas MCP)
  • Información del proceso

Nota de seguridad: Este no es un entorno aislado completamente seguro. El contexto de la VM proporciona aislamiento pero no es infalible. Ejecute solo código de confianza.

Manejo de errores

Los errores en el entorno aislado se capturan y se devuelven con trazas de pila:

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
    }
  `
})

Pruebas con Claude Code

¿Quiere probar mcpcodeserver con Claude Code? Use la configuración de un solo comando:

./setup-claude-code-test.sh

Esto construirá el proyecto, instalará las dependencias de prueba y le mostrará exactamente qué agregar a su configuración de Claude Code. Consulte TESTING_WITH_CLAUDE.md para instrucciones detalladas.

Desarrollo

# 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

Estructura del proyecto

Consulte AGENTS.md para obtener documentación detallada de la estructura del proyecto y los componentes.

Casos de uso

Operaciones multiarchivo

En lugar de realizar múltiples llamadas a herramientas a través del LLM, escriba código:

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);

Transformación de datos

Procese datos entre llamadas a herramientas sin intervención del 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;

Lógica condicional

Tome decisiones basadas en los resultados de las herramientas:

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) };
}

Recuperación de errores

Maneje errores con gracia sin abortar todo el flujo de trabajo:

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;

Integración con servidores MCP upstream

mcpcodeserver puede integrarse con servidores MCP upstream oficiales del repositorio de servidores del Protocolo de Contexto de Modelo. Esto le permite usar servidores MCP reales y listos para producción junto con sus herramientas personalizadas.

Servidores upstream soportados

  • filesystem: Operaciones del sistema de archivos (leer, escribir, listar directorios)
  • memory: Almacenamiento clave-valor en memoria
  • sqlite: Operaciones de base de datos SQLite
  • github: Integración con la API de GitHub
  • brave-search: Capacidades de búsqueda web
  • fetch: Capacidades de solicitudes HTTP

Ejemplo de configuración

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

Pruebas de integración upstream

El proyecto incluye pruebas exhaustivas para la integración de servidores upstream:

# 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

Flujos de trabajo entre servidores

Con los servidores upstream, puede crear potentes flujos de trabajo entre servidores:

// 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}`
});

Limitaciones

  • Tiempo de espera de ejecución: Máximo 5 minutos (configurable, predeterminado 30 segundos)
  • Memoria: Limitada por el contexto de la VM de Node.js
  • Sin estado persistente entre ejecuciones
  • No se puede requerir/importar módulos externos
  • No es un entorno aislado de seguridad - no ejecute código no confiable

Contribuciones

¡Las contribuciones son bienvenidas! Este proyecto está construido con:

  • TypeScript 5.7+
  • Node.js 18+
  • MCP TypeScript SDK 1.20+
  • Zod para validación

Consulte CONTRIBUTING.md para obtener pautas detalladas de contribución.

Soporte

Si encuentra útil este proyecto, ¡considere invitarme un café!

Buy Me A Coffee

Licencia

MIT

Recursos