Skills Wiki — Local AI Skills Manager

An open-source, fully local AI skills manager. Connect 120+ community-built skill packs to Claude, ChatGPT, or Gemini — all running on your own machine, no accounts, subscriptions, or cloud services required.

Browse skills, enable what you need, copy your local connection URL, and start working smarter in minutes.

Table of Contents

1. How It Works

2. Tech Stack & Project Structure

3. Getting Started

4. Dashboard Walkthrough

5. Connecting Your AI Assistant

6. Using the Active Skills Panel

7. Adding New Skills

8. Per-Skill Configuration

9. Connecting External Services

10. Environment Variables

11. Skill Library

12. License

Related MCP server: skill-curator-mcp

1. How It Works

Skills Wiki runs two processes on your machine:

Your AI Assistant (Claude / ChatGPT / Gemini)
             │
             │  MCP protocol or OpenAPI
             ▼
  Python MCP Server — http://localhost:8000
  (FastMCP, mounts all enabled skills)
             │
             │  reads config
             ▼
  data/local_config.json
  (enabled skills, connections, per-skill settings)
             ▲
             │  manages via UI
  Next.js Dashboard — http://localhost:3000

• The Python server (main.py) loads every skill in skills_library/ at startup and exposes them over the MCP protocol at localhost:8000/mcp and as an OpenAPI schema at localhost:8000/openapi.json.

• The dashboard (dashboard/) is a Next.js app for browsing skills, toggling what's active, copying connection URLs, running skill tools, and managing connected services.

• data/local_config.json is the single source of truth — no database, no cloud.

Everything runs locally. Your data never leaves your machine.

2. Tech Stack & Project Structure

Tech Stack

Frontend Dashboard (Next.js)

• Next.js 15 — React 19, App Router, server components

• TypeScript 5 — strict mode enabled

• Tailwind CSS 3 — utility-first styling with custom v4 design tokens

• shadcn/ui — accessible UI components

• JetBrains Mono — monospace font for the terminal-style UI

Backend MCP Server (Python)

• FastMCP — Model Context Protocol SDK; each skill is a mounted namespace

• Python 3.10+ — async throughout

• python-dotenv — environment variable management

Storage

• data/local_config.json — all state in one JSON file: enabled skills, connections, per-skill configs, and auto-generated credentials

Project Structure

skills_wiki_opensource/
├── main.py                        # FastMCP server entry point
├── requirements.txt               # Python dependencies
├── .env.example                   # Environment variable template
├── package.json                   # Root scripts (setup, dev, etc.)
│
├── data/
│   └── local_config.json          # All runtime state (auto-created on first run)
│
├── core/                          # Python server utilities
│   ├── config.py                  # Reads enabled_skills from local_config.json
│   ├── db.py                      # JSON read/write helpers
│   ├── skill_config.py            # Per-skill presentation hints
│   ├── skill_runtime.py           # Skill execution helpers
│   └── credentials.py             # Service credential resolution
│
├── skills_library/                # 120+ MCP skill packs
│   ├── marketing_skills/          # Example skill
│   │   ├── main.py                #   FastMCP tool definitions
│   │   ├── skill_meta.json        #   Metadata: displayName, description, theme
│   │   ├── skill_files/           #   Cached reference docs, indexed via _index.json
│   │   └── __init__.py
│   └── ... (120+ skill folders)
│
├── scripts/
│   └── add_skill.py               # Install a skill from a GitHub repo
│
└── dashboard/                     # Next.js frontend
    ├── app/
    │   ├── dashboard/             # Main control center
    │   ├── marketplace/           # Browse & enable skills
    │   ├── connections/           # Manage third-party service credentials
    │   ├── config/                # Per-skill customization
    │   ├── setup/                 # Platform connection guides
    │   └── api/                   # Next.js API routes
    │       ├── skills/            # PATCH — update enabled skills
    │       ├── skill-tools/       # GET  — list tools for a skill
    │       ├── tool-run/          # POST — run a skill tool
    │       ├── connections/       # GET/POST/DELETE — manage services
    │       └── config/            # GET/POST/DELETE — per-skill settings
    ├── components/
    │   ├── DashboardClient.tsx    # Active skills panel + credentials panel
    │   ├── CredentialsPopup.tsx   # Copyable CLIENT_ID, API_KEY, URLs
    │   └── ...
    └── lib/
        ├── skills.ts              # Skill registry (500+ skills, 40+ themes)
        ├── local-db.ts            # JSON config read/write
        └── utils.ts               # URL helpers, key masking

3. Getting Started

Prerequisites

• Python 3.10 or higher

• Node.js 18 or higher

• A Gemini API key (optional — only needed to install new skills from GitHub)

Install & Run

# 1. Clone the repo
git clone https://github.com/appleaa123/skills-wiki.git
cd skills-wiki

# 2. Copy the environment file (add your Gemini key if you plan to add skills)
cp .env.example .env

# 3. Install all dependencies (Python + Node)
npm run setup

# 4. Start both servers
npm run dev

Open http://localhost:3000 in your browser.

The MCP server starts at http://localhost:8000. Your credentials and connection URLs are generated automatically on first launch and shown on the dashboard.

What npm run dev starts

Both processes run concurrently. Stop them with Ctrl+C.

4. Dashboard Walkthrough

Navigate to http://localhost:3000/dashboard after starting the app.

Command Line Strip

At the top of the page, a status bar shows:

$ skills-wiki status --verbose          ● gateway: live    ● plan: local

Plan Strip

plan = "local"   // running fully local — no cloud required

Two-Column Grid

The main section splits into two panels side by side:

Left — active_skills[]

Lists all your currently enabled skills. Each skill shows as a card with its name and function count.

• Click a card → expands to show all tools/functions inside that skill with checkboxes

• Check tools → select the ones you want to run

• ▶ run → executes selected tools and displays the output as formatted markdown

• copy → copies the markdown output to clipboard so you can paste it into any AI chat

This is the core workflow: expand a skill, select a function, run it, copy the result, paste it into Claude or ChatGPT to give the AI detailed context for that topic.

• --edit button → switches to edit mode with toggle switches; enable or disable individual skills

• --save → persists changes to data/local_config.json

• + install more from ./marketplace → opens the marketplace to add more skills

Right — gateway_credentials

Shows all the information you need to connect your AI assistant:

Every field has a copy button. Click cat ./setup_guide → for step-by-step platform instructions.

Danger Zone

The rm -rf ./connection button clears all active skills and connections from your local config. This is irreversible.

5. Connecting Your AI Assistant

Navigate to http://localhost:3000/setup for per-platform guides. A summary:

Claude Desktop

Open ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) and add:

{
  "mcpServers": {
    "skills-wiki": {
      "type": "http",
      "url": "http://localhost:8000/mcp"
    }
  }
}

Restart Claude Desktop. Your enabled skills appear as tools.

Note: Claude Desktop must be able to reach localhost:8000. Ensure the Python server is running before opening Claude Desktop.

Claude.ai (Remote MCP)

Claude.ai requires a publicly accessible MCP URL. For local use, expose your server with a tunnel tool:

# Example using ngrok
ngrok http 8000

Then use the HTTPS URL ngrok provides in Claude.ai → Settings → Connectors → Add Custom Connector.

ChatGPT Custom GPT

1. Go to chatgpt.com → Explore GPTs → Create → Configure → Actions → Add action

2. Import from URL: http://localhost:8000/openapi.json (or your ngrok URL for remote access)

3. Set Authentication → API Key → paste the API_KEY value from the dashboard

4. Save the Custom GPT

Gemini

Gemini supports MCP via the same URL as Claude: http://localhost:8000/mcp.

6. Using the Active Skills Panel

This panel is the primary way to interact with skills before connecting them to an AI assistant. It lets you preview what a skill does, get its guidance text, and copy it to paste directly into any AI chat — no formal MCP connection needed.

Step-by-step flow

1. Go to the dashboard → http://localhost:3000/dashboard

2. Expand a skill card — click the ▶ arrow next to any skill name

3. Wait for tools to load — the panel fetches all available functions from main.py (shows // loading tools… briefly)

4. Check one or more tools — each checkbox represents a skill function (e.g., cold-email, product-marketing-context)

5. Click ▶ run (N selected) — the panel runs the selected tools and displays formatted markdown output

6. Click copy — the button changes to ✓ tools are copied

7. Paste into your AI chat — open Claude, ChatGPT, or Gemini and paste. The AI now has the full skill context to follow

What does "run" actually do?

When you run a tool:

1. The dashboard calls POST /api/tool-run with the skill name and selected tool

2. It first tries to call the Python MCP server at localhost:8000/mcp using JSON-RPC

3. If the server isn't reachable, it falls back to reading the guidance text directly from skills_library/{skill}/main.py

4. The result — typically detailed markdown with instructions, frameworks, or structured guidance — appears in the panel

This means the run feature works even when the Python server isn't running, as long as the skill has guidance text embedded in its main.py.

7. Adding New Skills

From the UI

Go to http://localhost:3000/config, then Link a Skill from GitHub. Paste any public GitHub repo URL that contains FastMCP skill definitions. The skill is installed to skills_library/ and activated immediately.

Requires GEMINI_API_KEY in your .env for AI-assisted skill generation.

From the command line

# Add a skill from a public GitHub repo
python3 scripts/add_skill.py --url https://github.com/org/repo --name my_skill

# Force the entire repo to be treated as one skill (no auto-split)
python3 scripts/add_skill.py --url https://github.com/org/repo --name my_skill --no-split

# Add only a specific subdirectory
python3 scripts/add_skill.py \
  --url https://github.com/org/repo \
  --name my_skill \
  --subdir "skills/marketing"

# Add from a local file or folder
python3 scripts/add_skill.py --file ~/path/to/tools.py --name my_skill
python3 scripts/add_skill.py --file ~/path/to/skill-folder/ --name my_skill

After adding a skill, enable it from the dashboard marketplace. Then restart the Python server so it picks up the new skill:

# Stop the running server (Ctrl+C), then restart
npm run dev

Skill format

Each skill in skills_library/ is a folder with at minimum:

• main.py — defines a FastMCP instance named mcp with tool functions

• skill_meta.json — metadata: display_name, description, theme, source_repo

• __init__.py — empty file (required for Python module loading)

Example skill_meta.json:

{
  "display_name": "Marketing Skills",
  "description": "Conversion, content, SEO, and growth skills.",
  "source_repo": "https://github.com/coreyhaines31/marketingskills",
  "theme": "marketing"
}

Example main.py structure:

from fastmcp import FastMCP

mcp = FastMCP("my-skill")

_SKILLS = {
  "my-tool": {
    "description": "Does something useful.",
    "guidance": """# My Tool\n\nDetailed instructions here...""",
  }
}

@mcp.tool()
def get_my_skill(skill_name: str) -> str:
    """Returns guidance for the requested skill."""
    skill = _SKILLS.get(skill_name)
    if not skill:
        return f"Unknown skill: {skill_name}"
    return skill["guidance"]

8. Per-Skill Configuration

Go to http://localhost:3000/config to customize how each skill behaves.

For each installed skill you can set:

Settings are stored in data/local_config.json under skill_configs.

9. Connecting External Services

Go to http://localhost:3000/connections to add credentials for third-party services your skills need (GitHub tokens, Notion API keys, custom HTTP endpoints, etc.).

Credentials are stored in plaintext in data/local_config.json. Treat this file like a .env file — do not commit it to version control.

Skills that need external services read credentials from this store at runtime via core/credentials.py.

10. Environment Variables

Copy .env.example to .env and fill in what you need:

cp .env.example .env

The dashboard reads NEXT_PUBLIC_GATEWAY_BASE_URL to construct the CLAUDE_URL, CHATGPT_URL, and GEMINI_URL values shown in the credentials panel. Set this if you expose your server over a tunnel or run the server on a non-default port.

11. Skill Library

Every folder in skills_library/ is one skill pack, included out of the box. The table below covers most of them; run ls skills_library for the full, current list.

12. License

apache license 2.0