Jilebi

Un runtime MCP seguro y extensible con plugins JS.

Documentación

Jilebi Logo

                              $$$$$\ $$\ $$\           $$\       $$\ 
                              __$$ |__|$$ |          $$ |      __|
                                 $$ |$$\ $$ | $$$$$$\  $$$$$$$\  $$\ 
                                 $$ |$$ |$$ |$$  __$$\ $$  __$$\ $$ |
                           $$\   $$ |$$ |$$ |$$$$$$$$ |$$ |  $$ |$$ |
                           $$ |  $$ |$$ |$$ |$$   ____|$$ |  $$ |$$ |
                           \$$$$$$  |$$ |$$ |\$$$$$$$\ $$$$$$$  |$$ |
                            ______/ __|__| _______|_______/ __|

https://jilebi.ai

Un potente servidor MCP (Model Context Protocol) basado en plugins que extiende los asistentes de IA con herramientas, recursos y prompts personalizados.

Tabla de Contenidos

Descripción General
Descarga
Instalación
- Windows
- Linux
- macOS
Configuración del Host
Sistema de Plugins
Creación de Plugins
Registro y Depuración
Enlaces

Descripción General

Jilebi es una implementación de servidor MCP que permite a los asistentes de IA interactuar con sistemas externos mediante una arquitectura modular de plugins. Proporciona una forma estandarizada de exponer herramientas, recursos y prompts a los modelos de lenguaje, manteniendo la seguridad a través de un sistema granular de permisos.

Características Clave:

Soporte multiplataforma (Windows, Linux, macOS)
Extensibilidad basada en plugins
Modelo de permisos seguro para acceso al sistema de archivos y red
Gestión de estado persistente para plugins
Compatible con los principales entornos de desarrollo de IA

Instalación Rápida

La forma más rápida de instalar Jilebi es usando nuestros scripts de instalación:

Linux y macOS

Usando curl:

curl -fsSL https://mcp.jilebi.ai/install.sh | bash

Usando wget:

wget -qO- https://mcp.jilebi.ai/install.sh | bash

Windows (PowerShell)

irm https://mcp.jilebi.ai/install.ps1 | iex

O con el comando completo:

Invoke-RestMethod https://mcp.jilebi.ai/install.ps1 | Invoke-Expression

Qué hace el instalador

Detecta tu plataforma y arquitectura automáticamente
Descarga el binario apropiado
Instala en ~/.jilebi/bin (Unix) o %LOCALAPPDATA%\jilebi\bin (Windows)
Añade Jilebi a tu PATH
Opcionalmente instala plugins recomendados (memoria, pensamiento secuencial)

Desinstalación

Para eliminar completamente Jilebi de tu sistema:

Linux y macOS

Usando curl:

curl -fsSL https://mcp.jilebi.ai/uninstall.sh | bash

Usando wget:

wget -qO- https://mcp.jilebi.ai/uninstall.sh | bash

Windows (PowerShell)

irm https://mcp.jilebi.ai/uninstall.ps1 | iex

O con opciones:

# Skip confirmation prompts
irm https://mcp.jilebi.ai/uninstall.ps1 -OutFile uninstall.ps1; .\uninstall.ps1 -Force

# Keep plugins and data
irm https://mcp.jilebi.ai/uninstall.ps1 -OutFile uninstall.ps1; .\uninstall.ps1 -KeepData

Qué elimina el desinstalador

El binario de Jilebi y el directorio de instalación
La entrada del PATH en el perfil del shell (Unix) o en el entorno del usuario (Windows)
Opcionalmente: plugins, datos y archivos de configuración

Descarga Manual

Plataforma	Arquitectura	Descarga
Windows 10/11	x86_64	Descargar
Linux	x86_64	Descargar
macOS	Apple Silicon	Descargar
macOS	Intel	Descargar

Instalación Manual

Windows

# 1. Unzip the downloaded file to your desired location

# 2. Install recommended plugins
.\jilebi.exe plugins add memory
.\jilebi.exe plugins add sequential-thinking

# 3. Start the MCP server
.\jilebi.exe stdio

Linux

# 1. Unzip the downloaded file to your desired location

# 2. Grant execution access
chmod +x jilebi

# 3. Install recommended plugins
./jilebi plugins add memory
./jilebi plugins add sequential-thinking

# 4. Start the MCP server
./jilebi stdio

macOS

# 1. Unzip the downloaded file to your desired location

# 2. Grant execution access
chmod +x jilebi

# 3. Remove quarantine attribute (required for unverified developers)
xattr -d com.apple.quarantine /path/to/jilebi

# 4. Install xz dependency
brew install xz

# 5. Install recommended plugins
./jilebi plugins add memory
./jilebi plugins add sequential-thinking

# 6. Start the MCP server
./jilebi stdio

Encuentra más plugins en github.com/datron/jilebi-plugins

Configuración del Host

Jilebi se integra con varios entornos de desarrollo de IA. A continuación se muestran ejemplos de configuración para los hosts compatibles.

Claude Desktop

Ubicación de Configuración:

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

{
  "mcpServers": {
    "jilebi": {
      "command": "jilebi",
      "args": ["stdio"],
      "env": {}
    }
  }
}

Claude Code

Añade a .claude.json:

{
  "mcpServers": {
    "jilebi": {
      "command": "jilebi",
      "args": ["stdio"],
      "env": {}
    }
  }
}

Cursor

Edita ~/.cursor/mcp.json:

{
  "mcpServers": {
    "jilebi": {
      "command": "jilebi",
      "args": ["stdio"],
      "env": {}
    }
  }
}

VS Code

Añade a tu mcp.json:

{
  "servers": {
    "jilebi": {
      "type": "stdio",
      "command": "jilebi",
      "args": ["stdio"]
    }
  }
}

Zed

Edita ~/.config/zed/settings.json:

{
  "context_servers": {
    "jilebi": {
      "command": "jilebi",
      "args": ["stdio"],
      "enabled": true,
      "source": "custom",
      "env": {}
    }
  }
}

Codex CLI

Añade a ~/.codex/config.toml:

[mcp_servers.jilebi]
command = "jilebi"
args = ["stdio"]

Opencode

Edita ~/.config/opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "jilebi": {
      "type": "local",
      "command": ["jilebi", "stdio"],
      "enabled": true,
      "environment": {}
    }
  }
}

Sistema de Plugins

Los plugins extienden Jilebi con funcionalidad personalizada a través de tres componentes principales:

Componente	Descripción
Herramientas	Funciones que los modelos pueden invocar para interactuar con sistemas externos
Recursos	Fuentes de datos de solo lectura para contexto (archivos, esquemas, documentación)
Prompts	Plantillas de conversación predefinidas con interpolación de argumentos

Gestión de Plugins

# Install a plugin
jilebi plugins add <plugin-name>

# Create a new plugin
jilebi plugins create

# Setup/reconfigure a plugin
jilebi plugins setup <plugin-name>

# View plugin logs
jilebi plugins log <plugin-id>

Creación de Plugins

Inicio Rápido

jilebi plugins create

Sigue las indicaciones para iniciar un nuevo proyecto de plugin.

Manifiesto del Plugin

Los plugins se definen usando un archivo de manifiesto TOML. Aquí hay una estructura de ejemplo:

# Metadata
name = "my-plugin"
version = "1.0.0"
homepage = "github.com/user/my-plugin"
creator = "Your Name"
contact = "you@example.com"

# Environment Variables
[env]
API_URL = { schema = { type = "string" }, default = "https://api.example.com" }

# Secrets (no defaults allowed)
[secrets]
API_KEY = { schema = { type = "string" } }

# Tools
[tools.my-tool]
name = "my-tool"
description = "Description of what this tool does"
input_schema = { type = "object", properties = { param = { type = "string" } }, required = ["param"] }
function = "my_tool_function"

[tools.my-tool.permissions]
hosts = ["https://api.example.com"]

# Resources
[resources.my-resource]
name = "my-resource"
description = "Description of this resource"
mime_type = "application/json"
function = "get_resource"

# Prompts
[prompts.my-prompt]
name = "my-prompt"
description = "A helpful prompt template"
arguments = [
  { name = "topic", description = "The topic to discuss", required = true }
]
messages = [
  { role = "user", content = { type = "text", content = "Tell me about {{topic}}" } }
]

Tipos de Permisos

Los plugins pueden solicitar los siguientes permisos:

Permiso	Descripción
`hosts`	Dominios de host permitidos para solicitudes de red
`urls`	URLs específicas permitidas
`read_files`	Rutas de archivos que el plugin puede leer
`write_files`	Rutas de archivos que el plugin puede escribir
`read_dirs`	Directorios desde los que el plugin puede leer
`write_dirs`	Directorios en los que el plugin puede escribir

Usa "user_defined" para solicitar al usuario un valor personalizado durante la configuración.

Funciones Integradas

Los plugins tienen acceso a:

Gestión de Estado:

setState(env, key, value) - Persistir datos entre sesiones
getState(env, key) - Recuperar datos persistidos
deleteState(env, key) - Eliminar datos persistidos

Sistema de Archivos (API de Deno):

Operaciones de directorio: mkdir, readDir
Operaciones de archivo: readFile, writeFile, readTextFile, writeTextFile
Manipulación de archivos: stat, copyFile, rename, remove
Archivos temporales: makeTempDir, makeTempFile
Y más...

Registro y Depuración

Ubicaciones de Registro

Plataforma	Ruta
Windows	`C:\Users\<user>\AppData\Roaming\jilebi\jilebi-server\data\logs`
Linux	`~/.local/share/jilebi-server/logs/`
macOS	`~/Library/Application Support/ai.jilebi.jilebi-server/logs`

Visualización de Registros

# View Jilebi server logs
jilebi log

# View plugin-specific logs
jilebi plugins log <plugin-id>

Escritura de Registros en Plugins

console.log("Info message");
console.warn("Warning message");
console.error("Error message");
console.debug("Debug message");

Enlaces

_{Construido con la especificación del Model Context Protocol (MCP) versión 2025-03-26}