ToolMesh: permite que los agentes de IA interactúen con sistemas reales. De forma segura.

La capa de control que faltaba entre los agentes de IA y los sistemas empresariales. ToolMesh convierte las llamadas a herramientas de IA no controladas en un proceso gobernado y auditable, y conecta cualquier API REST o servidor MCP en minutos, no en meses.

30 líneas de YAML. Sin servidores que construir.

En la práctica, los servidores MCP solo exponen una fracción de la API REST que envuelven, y pronto te encontrarás con limitaciones. ToolMesh te permite reemplazar la capa envoltorio con archivos .dadl, un formato YAML declarativo que describe cualquier API REST como herramientas MCP. No hay servidor envoltorio que construir, desplegar o mantener.

Current:    Claude → ToolMesh → MCP Server → REST API
With DADL:  Claude → ToolMesh → REST API (via .dadl file)

No escribes el YAML a mano. Se lo pides a un LLM. Claude, GPT, Gemini: cualquier modelo que conozca la especificación DADL genera un archivo .dadl funcional en segundos. Describe lo que necesitas, suelta el archivo en config/dadl/ y listo.

"Crea un DADL para la API de GitHub: listar repositorios, abrir incidencias y crear solicitudes de extracción (pull requests)."

10 segundos. Funciona con cualquier LLM que conozca el formato.

Y a diferencia de las puertas de enlace MCP que simplemente pasan las llamadas a las herramientas, ToolMesh añade lo que los despliegues en producción realmente necesitan:

• Seguridad de credenciales: secretos inyectados en el momento de la ejecución, nunca en prompts o configuraciones de clientes LLM.

• Autorización: control detallado de usuario → plan → herramienta (OpenFGA).

• Control de entrada y salida: las políticas JS bloquean datos confidenciales y filtran respuestas.

• Pista de auditoría: cada llamada a herramienta registrada con logs estructurados o SQLite consultable.

Related MCP server: MCPGate

Los seis pilares

Prueba la demo

¿Quieres probar ToolMesh antes de instalarlo? Conéctate a nuestra instancia de demostración pública: sin Docker, sin configuración, sin claves API:

demo.toolmesh.io: APIs de Hacker News a través de ToolMesh. Funciona con Claude Desktop, Claude Code y ChatGPT. Inicio de sesión: dadl / toolmesh.

Inicio rápido

# Clone
git clone https://github.com/DunkelCloud/ToolMesh.git
cd ToolMesh

# Configure
cp .env.example .env
# IMPORTANT: Set a password — without it, all requests are rejected:
#   TOOLMESH_AUTH_PASSWORD=my-secret-password
# Or set an API key for programmatic access:
#   TOOLMESH_API_KEY=my-api-key

# Optional: local overrides (build locally, enable OpenFGA, HTTPS proxy, ...)
# cp docker-compose.override.yml.example docker-compose.override.yml
# # then edit docker-compose.override.yml — picked up automatically by Docker Compose

# Start (runs in bypass mode by default — no authz required)
docker compose up -d

# Verify it's running (default port: 8123)
curl http://localhost:8123/health

# MCP endpoint: http://localhost:8123/mcp
# Note: Most MCP clients require HTTPS — see TLS section below

TLS (importante)

ToolMesh por sí mismo sirve HTTP plano. La mayoría de los clientes MCP, incluido Claude Desktop, requieren HTTPS y rechazarán las URLs http://. Necesitas un proxy inverso que termine TLS frente a ToolMesh:

Solo para desarrollo local, puedes omitir TLS editando claude_desktop_config.json manualmente (la interfaz gráfica impone https://).

Conectar a Claude Desktop

Añade esto a tu configuración MCP de Claude Desktop:

{
  "mcpServers": {
    "toolmesh": {
      "url": "https://toolmesh.example.com/mcp"
    }
  }
}

Para desarrollo local sin proxy TLS:

{
  "mcpServers": {
    "toolmesh": {
      "url": "http://localhost:8123/mcp"
    }
  }
}

Conectar a Claude.ai (Conector personalizado)

ToolMesh admite OAuth 2.1 con PKCE S256 para acceso remoto. Configura los usuarios en config/users.yaml y utiliza la URL HTTPS pública como punto de conexión MCP.

Autenticación

ToolMesh admite dos métodos de autenticación que pueden usarse de forma independiente o conjunta. Todo el estado de OAuth (tokens, códigos de autenticación, clientes) se persiste en Redis y sobrevive a los reinicios del servidor.

OAuth 2.1 (Inicio de sesión interactivo)

Define usuarios en config/users.yaml con contraseñas cifradas con bcrypt:

users:
  - username: admin
    password_hash: "$2a$10$..."
    company: dunkelcloud
    plan: pro
    roles: [admin]

Genera hashes de contraseña con cualquier utilidad compatible con bcrypt:

htpasswd -nbBC 10 "" "my-password" | cut -d: -f2

Para configuraciones de un solo usuario, TOOLMESH_AUTH_PASSWORD sigue funcionando como respaldo. Configura la identidad con TOOLMESH_AUTH_USER, TOOLMESH_AUTH_PLAN y TOOLMESH_AUTH_ROLES (valores predeterminados: owner, pro, admin).

Claves API (Acceso programático)

Define claves API en config/apikeys.yaml con claves cifradas con bcrypt:

keys:
  - key_hash: "$2a$10$..."
    user_id: claude-code-user
    company_id: dunkelcloud
    plan: pro
    roles: [tool-executor]

Cada clave se asigna a una identidad de usuario distinta con su propio plan y roles, que fluyen hacia la autorización de OpenFGA.

Para configuraciones de una sola clave, TOOLMESH_API_KEY sigue funcionando como respaldo. Las mismas variables TOOLMESH_AUTH_USER, TOOLMESH_AUTH_PLAN y TOOLMESH_AUTH_ROLES controlan la identidad.

Límite de tasa DCR

El registro dinámico de clientes (Dynamic Client Registration) tiene un límite de 5 registros por hora por IP para evitar abusos.

Modo de autorización

OPENFGA_MODE controla si se aplica la autorización de OpenFGA:

Comienza con bypass para empezar rápidamente, luego cambia a restrict después de configurar OpenFGA.

Configuración

Consulta docs/configuration.md para ver todas las variables de entorno.

Ajuste de tiempos de espera (timeouts)

Aumenta estos valores para backends que necesiten más tiempo (por ejemplo, buscadores web basados en navegador):

TOOLMESH_MCP_TIMEOUT=180
TOOLMESH_EXEC_TIMEOUT=180

Registro (Logging)

ToolMesh utiliza registro estructurado a través de slog. El nivel predeterminado es debug para una trazabilidad MCP completa desde el primer momento; establece LOG_LEVEL=info o superior para producción, ya que los registros de depuración incluyen cargas útiles completas de solicitud/respuesta. Los archivos de depuración por backend, los formatos de registro y todas las variables de registro están documentados en docs/configuration.md.

Arquitectura

Consulta docs/architecture.md para ver la documentación completa de la arquitectura.

                          ┌─────────────────────────────────┐
                          │          ToolMesh               │
                          │                                 │
                          │  Redis · OpenFGA · Audit        │
                          │  Credential Store · JS Gate     │
                          │                                 │
AI Agent ──MCP──────────▶ │   AuthZ ▸ Creds ▸ Gate ▸ Exec  │
                          │                                 │
                          └──┬──────┬───────┬───────┬───────┘
                             │      │       │       │
                          MCP Client  .dadl   .dadl   .dadl
                             │      │       │       │
                             ▼      ▼       ▼       ▼
                          MCP     Stripe  GitHub  Vikunja
                          Server   API     API     API

Añadir un servidor MCP externo

Crea o edita config/backends.yaml:

backends:
  - name: memorizer
    transport: http
    url: "https://memorizer.example.com/mcp"
    api_key_env: "MEMORIZER_API_KEY"

Establece la credencial como una variable de entorno:

CREDENTIAL_MEMORIZER_API_KEY=sk-mem-xxxxx

Las herramientas de cada backend se exponen con un prefijo (por ejemplo, memorizer_retrieve_knowledge). Las credenciales son inyectadas por el Ejecutor en tiempo de ejecución a través del CredentialStore: el LLM nunca ve las claves API.

Modo Proxy REST (DADL)

Cuando un servidor MCP no expone un punto de conexión que necesitas, descríbelo en un archivo .dadl y ToolMesh llamará a la API REST directamente; no se necesita servidor envoltorio. Ambos modos se ejecutan en paralelo.

Añade un backend REST a config/backends.yaml:

backends:
  - name: vikunja
    transport: rest
    dadl: /app/dadl/vikunja.dadl
    url: "https://vikunja.example.com/api/v1"

Para servicios internos con IPs privadas o certificados autofirmados:

backends:
  - name: internal-api
    transport: rest
    dadl: internal.dadl
    url: "https://192.168.1.50:8443/api"
    allow_private_url: true    # allow private/loopback addresses (default: true)
    tls_skip_verify: true      # accept self-signed certificates (default: false)

¿Quieres que Claude liste las incidencias de GitHub? Esto es todo lo que se necesita:

tools:
  list_issues:
    method: GET
    path: /repos/{owner}/{repo}/issues
    description: "List issues for a repository"
    params:
      owner: { type: string, in: path, required: true }
      repo:  { type: string, in: path, required: true }
      state: { type: string, in: query }

ToolMesh maneja la autenticación, paginación, reintentos y mapeo de errores. DADL admite tokens de portador (bearer tokens), OAuth2, autenticación de sesión, claves API, paginación automática, reintento con retroceso exponencial, transformación de respuestas, herramientas compuestas y más.

Para ver la especificación completa, ejemplos y el registro de la comunidad, visita dadl.ai. La forma más rápida de crear un archivo .dadl es preguntárselo a cualquier LLM que conozca el formato.

Modo Código

¿Conectar 15 servidores MCP a un solo agente de IA? Sin ToolMesh, eso simplemente no funciona: la ventana de contexto se llena, el cliente se bloquea. El Modo Código lo hace posible.

En lugar de exponer cientos de definiciones de herramientas individuales (más de 50,000 tokens), ToolMesh expone dos meta-herramientas: list_tools y execute_code. El LLM obtiene interfaces TypeScript compactas (~1,000 tokens) y escribe JavaScript sobre ellas:

const repos = await toolmesh.github_list_repos({ sort: "updated" });
const issues = await toolmesh.github_list_issues({
  owner: repos[0].owner.login,
  repo: repos[0].name,
  state: "open"
});

Múltiples llamadas a la API en un solo viaje de ida y vuelta. ToolMesh analiza el código, extrae las llamadas a las herramientas y las enruta a través de la tubería de ejecución completa.

Modelo de extensión

ToolMesh utiliza un modelo de extensión basado en registro inspirado en el patrón de controlador database/sql de Go. Tres tipos de componentes son extensibles mediante el registro init():

Las extensiones empresariales (InfisicalStore, VaultStore, Compliance-LLM, etc.) están planificadas y se incluirán mediante etiquetas de compilación de Go: go build -tags enterprise ./cmd/toolmesh.

Consulta docs/architecture.md para obtener más detalles.

Contribución

Consulta CONTRIBUTING.md.

Licencia

Apache 2.0: Copyright 2025–2026 Dunkel Cloud GmbH