🚀 MCP Server for Dynamic Tool Creation

Let Your AI
Build Its Own Tools

Skillz is a self-extending MCP server. Create WASM tools from Rust or register scripts in any language—Python, Node.js, Ruby, Bash—at runtime. Now with automatic dependency management.

Install Now → 📦 crates.io GitHub

⚡ Quick Install

Get started in seconds

🦀 Install with Cargo (Rust) 
# Install WASM target
rustup target add wasm32-wasip1

# Install Skillz
cargo install skillz

⚠️ Important: Make sure ~/.cargo/bin is in your PATH so your editor can find the executable.

Works with your favorite editor

🖱️ Cursor 🤖 Claude Desktop 💻 VS Code 🏄 Windsurf ⚡ Zed

🏗️ Architecture & Flows

Understanding how Skillz connects all the pieces

Skillz Architecture Diagram

📊 Key Flows Explained

🔨 1. Building & Registering Tools

WASM Tools: AI sends Rust code → Skillz compiles to WebAssembly → Tool registered in Tool Registry → Available immediately

Script Tools: AI sends Python/Node.js code → Skillz creates tool directory with dependencies → Registers in Tool Registry → Ready to execute

Pipelines: AI defines tool chain → Skillz creates pipeline tool → Automatically handles variable substitution → Executes tools in sequence

⚡ 2. Tool Execution Flow

Request: MCP Client calls tool → Skillz validates & prepares context → Runtime Engine executes

WASM: Loaded in WASI sandbox → Direct memory access → Fast execution → Returns result

Script: Process spawned → JSON-RPC over stdin/stdout → Can call back to server → Returns result

Response: Result formatted → Progress/logs included → Sent to MCP client

🔗 3. Script Tool Capabilities (Bidirectional)

Memory API: Script sends memory/set → Server stores in libSQL → Script sends memory/get → Server retrieves → TTL support

Resources API: Script sends resources/list → Server returns available resources → Script sends resources/read → Server returns content

Elicitation: Script needs user input → Sends elicitation/create → Server forwards to MCP client → User responds → Script receives answer

Sampling: Script needs LLM completion → Sends sampling/createMessage → Server forwards to MCP client → LLM responds → Script receives completion

Tool Calling: Script can call other Skillz tools → Sends tools/call → Server executes target tool → Returns result to caller

🔥 4. Hot Reload Flow (--hot-reload)

Watch: File watcher monitors tools directory → Detects changes to tool files

Reload: Tool removed from registry → Reloaded from disk → Re-registered

Notify: MCP notification sent to clients → tools/list_changed → resources/updated for subscribed tools

Zero Downtime: Other tools continue working → No server restart needed

📦 5. Versioning & Rollback Flow

Auto-Backup: Tool updated → Current version backed up to .versions/ → Timestamp added

List Versions: Use version tool with action: "list" → Returns all versions with timestamps

Rollback: Use version tool with action: "rollback" → Restores selected version → Current becomes backup

History: All versions preserved → Can rollback multiple times → Full version audit trail

🌐 6. HTTP/SSE Transport (--transport http)

HTTP Server: Skillz starts HTTP server → Accepts connections from web clients

SSE Stream: Client connects to /sse → Server sends events → Real-time notifications

Message Endpoint: Client posts JSON-RPC to /message → Server processes → Response sent via SSE

Multiple Clients: Each client gets own SSE connection → Isolated sessions → Concurrent execution

🐳 7. Docker Services & Pipelines

Service Definition: Use services tool to define containers (Postgres, Redis, etc.) → Skillz manages lifecycle

Auto-Injection: Connection strings automatically injected as env vars into Tools → Seamless integration

Pipelines: Chain multiple tools together → Tool A output becomes Tool B input → Complex workflows

Full Stack: Build complete applications: DB Service + Backend Tool + Frontend Tool → All managed by Skillz

🔧 Configuration

CLI options and environment variables

🔥

--hot-reload

Watch tools directory for changes and auto-reload.
skillz --hot-reload

🌍

--transport http

Run as HTTP server with SSE for web apps.
skillz --transport http --port 8080

📂

SKILLZ_ROOTS

Colon-separated list of allowed workspace roots.
/home/user/project:/data

🔒

SKILLZ_SANDBOX

Isolation mode for script tools (Linux only).
bubblewrap | firejail | nsjail

Powerful Features

Everything you need to build dynamic AI tools

🦀

WASM Tools (Rust)

Compile Rust code to WebAssembly at runtime. Tools run in a secure sandbox with memory isolation and near-native performance.

📜

Script Tools (Any Language)

Register tools in Python, Node.js, Ruby, Bash, Perl, PHP, or any language. Scripts communicate via JSON-RPC 2.0 protocol.

📦

Dependency Management

Automatic pip/npm dependency installation. Each tool gets its own isolated virtual environment that persists across restarts.

⛓️

Pipeline Tools

Chain tools together declaratively with variable resolution ($input, $prev, $step_name).

📡

Full MCP Protocol

Resources, roots, logging, progress updates, elicitation, and sampling support. Complete MCP compatibility.

💾

Persistent Tools

Tools, dependencies, and environments persist across restarts. Build your AI's toolbox over time.

🔒

Secure Sandbox

WASM tools run in isolated WebAssembly environment. Optional bubblewrap/firejail isolation for scripts.

🏷️

Tool Annotations

Mark tools with hints: readOnlyHint, destructiveHint, idempotentHint. Helps AI understand tool behavior.

⚡

Code Execution Mode

Compose multiple tools via Python/JS code. Reduces token usage by 98% (150k → 2k tokens)!

💬

Elicitation & Memory

Scripts can request user input via MCP elicitation and use persistent storage for state.

📖

Dynamic Guide

Built-in skillz://guide resource that automatically updates when new tools are added.

🌐

Tool Import

Import tools from GitHub repos or Gists. Share your tools with the community!

🔌

MCP Integration

Import external stdio MCP servers. Tools exposed under namespaces, work in pipelines!

💡

Built-in Prompts

6 native prompts to help create tools: create_wasm_tool, create_python_tool, create_pipeline, and more!

🔥

Hot Reload

Watch tools directory for changes. Auto-reload modified tools without server restart!

🐳

Docker Services

Define Docker services (databases, caches) that tools depend on. Auto-inject connection env vars!

🛠️ Available Tools

Built-in tools for creating and managing your AI toolkit

Tool Description Type
build_tool Compile Rust code → WASM tool with crate dependencies. Core
register_script Register script tool (Python, Node.js, etc.) with dependencies. Core
call_tool Execute any registered tool (WASM, Script, Pipeline, or MCP). Core
list_tools List all available tools grouped by type. Core
delete_tool Delete a tool and clean up its files. Core
import_tool Import tools from Git repos or GitHub Gists. Core
import_mcp Register external stdio MCP servers under a namespace. New
execute_code Run Python/JS code that composes multiple tools. 98% token savings! Core
pipeline Create, list, delete pipeline tools (action: create|list|delete). New
memory Persistent storage for tools (action: store|get|list|delete|stats). New
services Define & manage Docker services for tools (action: define|start|stop|list|status). New

Simple to Use

Create tools with just a few lines of code

🦀 Rust WASM Tool 
// Build a Fibonacci generator
build_tool(
  name: "fibonacci",
  code: "fn main() {
    let mut a = 0u64;
    let mut b = 1;
    for _ in 0..20 {
        print!(\"{} \", a);
        let t = a + b;
        a = b;
        b = t;
    }
}",
  description: "Generates Fibonacci numbers"
)

Architecture

Clean, modular design

Skillz Architecture Diagram

📊 How Skillz Works

Visual overview of the tool creation and execution flow

Tool Types & Execution Flow

MCP Server Skillz Runtime 🦀 WASM Tools Rust + Dependencies WebAssembly ✓ Sandboxed 📜 Script Tools Python, Node.js, etc. JSON-RPC 2.0 ✓ Isolated Env AI Editor / Client compile register execute

Tool Creation Lifecycle

1. Design Define inputs, outputs, schema 📋 2. Implement Write Rust or Script code 💻 3. Test Validate & compile check 🧪 4. Finalize Register & persist tool ✅

How It Works

From code to execution in seconds

1

Write Code

AI writes Rust code for WASM tools or scripts in any language (Python, Node.js, etc.). Specify dependencies if needed.

2

Compile & Register

WASM tools are compiled using cargo. Scripts are saved with appropriate interpreter. Dependencies are installed in isolated environments.

3

Execute

WASM runs in Wasmtime sandbox. Scripts execute via subprocess with JSON-RPC 2.0 protocol using their virtual environment.

4

Persist

Tools, dependencies, and environments are stored on disk. Available across server restarts. Build your AI's toolbox over time.

☕ Support Skillz Development

Help keep this project growing! Your support enables new features and improvements.

Buy Me a Coffee