Skill Seeker

https://github.com/zeeeepa/skill_seekers
Admin
Automatically convert documentation websites, GitHub repositories, and PDFs into Claude AI skills in...
Tokens:137,860
Snippets:845
Trust Score:6.7
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Complete Example Workflow

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

A recommended workflow combining installation, scraping with local enhancement, and packaging. It also shows an alternative for enhancing after scraping.

```bash
# 1. Install (once)
pip3 install requests beautifulsoup4

# 2. Scrape React docs with LOCAL enhancement
skill-seekers scrape --config configs/react.json --enhance-local
# Wait 15-30 minutes (scraping) + 60 seconds (enhancement)

# 3. Package
skill-seekers package output/react/

# 4. Use react.zip in Claude!

```

```bash
# Alternative: Enhancement after scraping
# 2a. Scrape only (no enhancement)
skill-seekers scrape --config configs/react.json

# 2b. Enhance later
skill-seekers enhance output/react/

# 3. Package
skill-seekers package output/react/

```

--------------------------------

### Install Skill Seekers Dependencies

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Installs the necessary Python packages for Skill Seekers. This includes `requests` for fetching web content and `beautifulsoup4` for parsing HTML.

```bash
pip3 install requests beautifulsoup4
```

--------------------------------

### Quick Start Installation and Scraping with Skill Seekers

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/USAGE.md

This bash script outlines the quick start process for using Skill Seekers. It includes installing necessary Python packages, performing a scrape with local enhancement, packaging the output, and instructions for uploading the artifact. This is a streamlined workflow for beginners.

```bash
pip3 install requests beautifulsoup4
python3 cli/doc_scraper.py --config configs/react.json --enhance-local
python3 cli/package_skill.py output/react/
# Upload output/react.zip to Claude!
```

--------------------------------

### Run Skill Seekers Tool - Interactive Mode

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Launches the Skill Seekers tool in interactive mode, prompting the user for input to guide the skill creation process. This is suitable for users who prefer guided setup.

```bash
skill-seekers scrape --interactive
```

--------------------------------

### Generate Skill from Scratch (Svelte Example)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This example demonstrates the process of generating a Svelte skill. It involves creating a configuration file, estimating pages, scraping documentation, and packaging the skill.

```text
User: Generate config for Svelte docs at https://svelte.dev/docs

Claude: ✅ Config created: configs/svelte.json

User: Estimate pages for configs/svelte.json

Claude: 📊 Estimated pages: 150
        Recommended max_pages: 180

User: Scrape docs using configs/svelte.json

Claude: ✅ Skill created at output/svelte/
        Run: python3 cli/package_skill.py output/svelte/

User: Package skill at output/svelte/

Claude: ✅ Created: output/svelte.zip
        Ready to upload to Claude!
```

--------------------------------

### Quick Setup Script (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/src/skill_seekers/mcp/README.md

Executes the automated setup script for the MCP server. This script handles dependency installation, server testing, configuration generation, and guides through Claude Code setup.

```bash
# Run the setup script
./setup_mcp.sh
```

--------------------------------

### Install Skill Seekers via Pip

Source: https://github.com/zeeeepa/skill_seekers/blob/development/README.md

Installs the Skill Seekers package from the Python Package Index (PyPI), providing the easiest and recommended method for getting started. No cloning or setup is required.

```bash
pip install skill-seekers
```

--------------------------------

### Use Existing Config (React Example)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This example shows how to utilize an existing configuration file, such as 'react.json', to scrape and package a skill with a specified maximum number of pages.

```text
User: List all available configs

Claude: [Shows 7 configs]

User: Scrape docs using configs/react.json with max 50 pages

Claude: ✅ Skill created at output/react/

User: Package skill at output/react/

Claude: ✅ Created: output/react.zip
```

--------------------------------

### Project Installation and Configuration Script (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This bash script guides through the installation of Skill Seekers, including cloning the repository, installing Python dependencies, and setting up the MCP configuration file. It assumes a Linux/macOS environment.

```bash
# 1. Install
cd ~/
# Assuming Projects directory exists, if not create it: mkdir -p ~/Projects
cd ~/Projects
git clone https://github.com/yusufkaraaslan/Skill_Seekers.git
cd Skill_Seekers
pip3 install -r skill_seeker_mcp/requirements.txt
pip3 install requests beautifulsoup4

# 2. Configure
mkdir -p ~/.config/claude-code
cat > ~/.config/claude-code/mcp.json << 'EOF'
{
  "mcpServers": {
    "skill-seeker": {
      "command": "python3",
      "args": [
        "/Users/username/Projects/Skill_Seekers/skill_seeker_mcp/server.py"
      ],
      "cwd": "/Users/username/Projects/Skill_Seekers"
    }
  }
}
EOF
# (Replace paths with your actual paths!)

# 3. Restart Claude Code

# 4. Test in Claude Code:
```

**In Claude Code:**
```
User: List all available configs
User: Scrape docs using configs/react.json with max 50 pages
User: Package skill at output/react/
```

**Result:** `output/react.zip` ready to upload!
```

--------------------------------

### Run Skill Seekers Tool - Presets

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Executes the Skill Seekers tool using a predefined configuration file. Presets simplify the process by providing ready-to-use settings for popular frameworks.

```bash
skill-seekers scrape --config configs/godot.json
```

```bash
skill-seekers scrape --config configs/react.json
```

```bash
skill-seekers scrape --config configs/vue.json
```

```bash
skill-seekers scrape --config configs/django.json
```

```bash
skill-seekers scrape --config configs/fastapi.json
```

--------------------------------

### Validate Config Before Scraping (Godot Example)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This example illustrates the validation process for a configuration file, 'godot.json', before initiating the scraping of documentation. It checks configuration validity, estimates page count, and confirms sufficiency of max_pages.

```text
User: Validate configs/godot.json

Claude: ✅ Config is valid
        - Base URL: https://docs.godotengine.org/en/stable/
        - Max pages: 500
        - Rate limit: 0.5s
        - Categories: 3

User: Estimate pages for configs/godot.json

Claude: 📊 Estimated pages: 450
        Current max_pages (500) is sufficient

User: Scrape docs using configs/godot.json

Claude: [Scraping starts...]
```

--------------------------------

### Create and Use Custom Configuration

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Enables the creation of custom configuration files by copying and modifying existing presets. This allows users to tailor the scraping process to their specific needs.

```bash
# Copy a preset
cp configs/react.json configs/myframework.json

# Edit it
nano configs/myframework.json

# Use it
skill-seekers scrape --config configs/myframework.json
```

--------------------------------

### Quick Reference Card for Skill Seekers

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

A concise summary of essential commands and steps for setting up, verifying, generating skills, and troubleshooting within the Skill Seekers project.

```text
SETUP:
1. Install dependencies: pip3 install -r skill_seeker_mcp/requirements.txt
2. Configure: ~/.config/claude-code/mcp.json
3. Restart Claude Code

VERIFY:
- "List all available configs"
- "Validate configs/react.json"

GENERATE SKILL:
1. "Generate config for [name] at [url]"
2. "Estimate pages for configs/[name].json"
3. "Scrape docs using configs/[name].json"
4. "Package skill at output/[name]/"

TROUBLESHOOTING:
- Check: cat ~/.config/claude-code/mcp.json
- Test: python3 skill_seeker_mcp/server.py
- Logs: ~/Library/Logs/Claude Code/
```

--------------------------------

### Package the Skill

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Packages the generated skill into a zip archive, making it ready for distribution or use in platforms like Claude. The output file is named after the skill, e.g., `godot.zip`.

```bash
skill-seekers package output/godot/
```

--------------------------------

### React Configuration Example

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/USAGE.md

A JSON configuration file defining parameters for scraping the React documentation site. It includes base URL, start URLs, selectors for content extraction, URL patterns for inclusion/exclusion, and category mappings.

```json
{
  "name": "react",
  "base_url": "https://react.dev/",
  "description": "React - JavaScript library for building UIs",
  "start_urls": [
    "https://react.dev/learn",
    "https://react.dev/reference/react",
    "https://react.dev/reference/react-dom"
  ],
  "selectors": {
    "main_content": "article",
    "title": "h1",
    "code_blocks": "pre code"
  },
  "url_patterns": {
    "include": ["/learn/", "/reference/"],
    "exclude": ["/blog/", "/community/"]
  },
  "categories": {
    "getting_started": ["learn", "tutorial", "intro"],
    "api": ["reference", "api", "hooks"],
    "guides": ["guide"]
  },
  "rate_limit": 0.5,
  "max_pages": 300
}
```

--------------------------------

### Configure Max Pages for Testing

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Allows testing with a limited number of pages by modifying the configuration file. This is useful for quick iteration and debugging before a full scrape.

```json
{
  "max_pages": 20  // Test with just 20 pages
}
```

--------------------------------

### MCP Tool Examples

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/CLAUDE.md

Demonstrates how to use the MCP tools available through Claude Code after the setup script has been executed. These commands allow for managing configurations, generating skills, and more.

```bash
"List all available configs"
"Generate config for Tailwind at https://tailwindcss.com/docs"
"Split configs/godot.json using router strategy"
"Generate router for configs/godot-*.json"
"Package skill at output/react/"
```

--------------------------------

### Use Existing Data for Faster Scrapes

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Leverages previously scraped data to significantly speed up subsequent scrape operations. The tool prompts the user to confirm the use of existing data.

```bash
skill-seekers scrape --config configs/godot.json --skip-scrape
```

--------------------------------

### Verify MCP Server Startup (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

Tests if the Skill Seeker MCP server can start. It uses the 'timeout' command to prevent the server from running indefinitely, expecting it to exit cleanly or timeout, which indicates successful startup.

```bash
# Test MCP server can start
timeout 3 python3 skill_seeker_mcp/server.py || echo "Server OK (timeout expected)"

# Should exit cleanly or timeout (both are normal)
```

--------------------------------

### Start Interactive Documentation Scraper (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/USAGE.md

Initiates the interactive mode of the documentation scraper, guiding the user through a series of prompts to create a configuration and perform the scraping process.

```bash
# 1. Start interactive wizard
python3 cli/doc_scraper.py --interactive

# 2. Answer prompts:
#    - Name: my-framework
#    - URL: https://framework.dev/
#    - Description: My favorite framework
#    - Selectors: (uses defaults)
#    - Rate limit: 0.5
#    - Max pages: 100

# 3. Enhance
python3 cli/enhance_skill_local.py output/my-framework/

# 4. Package
python3 cli/package_skill.py output/my-framework/
```

--------------------------------

### Troubleshoot Output Directories (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/TESTING.md

Commands to clean up test artifacts, such as output directories, that might be created by test runs. It also advises checking `setUp` methods for `dry_run` configurations.

```bash
# Clean up test artifacts
rm -rf output/test-*

# Make sure tests use dry_run=True
# Check test setUp methods
```

--------------------------------

### Troubleshooting: Test CLI Tools Directly

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This command tests individual CLI tools by displaying their help information, useful for diagnosing issues with tool execution.

```bash
python3 cli/doc_scraper.py --help
```

--------------------------------

### Troubleshooting: Install Missing Modules

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This command installs all necessary Python dependencies listed in the requirements file, resolving 'ModuleNotFoundError' issues.

```bash
pip3 install -r skill_seeker_mcp/requirements.txt
```

--------------------------------

### Run Skill Seekers Tool - Quick Command

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Executes the Skill Seekers tool with specific parameters for name and URL, allowing for quick scraping of a single source without a full configuration file.

```bash
skill-seekers scrape --name react --url https://react.dev/
```

--------------------------------

### First-Time User Workflow

Source: https://github.com/zeeeepa/skill_seekers/blob/development/CLAUDE.md

A recommended workflow for new users, starting with installing from PyPI, estimating page count to gauge effort, scraping with local enhancement, and finally packaging the skill for upload. This workflow is designed for ease of use and efficient skill creation.

```bash
# 1. Install from PyPI (one-time, easiest!)
pip install skill-seekers

# 2. Estimate page count BEFORE scraping (fast, no data download)
skill-seekers estimate configs/godot.json

# 3. Scrape with local enhancement (uses Claude Code Max, no API key)
skill-seekers scrape --config configs/godot.json --enhance-local

# 4. Package the skill
skill-seekers package output/godot/
```

--------------------------------

### Check Python Version (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

Verifies the installed Python version. Ensures that Python 3.10 or higher is available, which is a prerequisite for the Skill Seeker MCP setup.

```bash
python3 --version
# Should show: Python 3.10.x or higher
```

--------------------------------

### Clone Repository and Setup (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/README.md

This bash script demonstrates the initial steps for setting up Skill Seeker. It includes cloning the repository from GitHub and executing a setup script named 'setup_mcp.sh', which is part of the one-time setup process for using the MCP server.

```bash
# Clone repository
git clone https://github.com/yusufkaraaslan/Skill_Seekers.git
cd Skill_Seekers

# One-time setup (5 minutes)
./setup_mcp.sh
```

--------------------------------

### Run Skill Seekers Tool - Unified Multi-Source

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Utilizes the unified multi-source feature to combine documentation and GitHub code into a single skill, automatically detecting and resolving conflicts. Requires a specific configuration file.

```bash
skill-seekers unified --config configs/react_unified.json
```

```bash
skill-seekers unified --config configs/django_unified.json
```

```bash
skill-seekers unified --config configs/fastapi_unified.json
```

```bash
skill-seekers unified --config configs/godot_unified.json
```

--------------------------------

### Install Python Dependencies (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

Installs the required Python packages for the Skill Seeker MCP server and the CLI scraping tool. It uses pip3 to install from a requirements file and specific packages like requests and beautifulsoup4.

```bash
# Navigate to repository root
cd /path/to/Skill_Seekers

# Install MCP server dependencies
pip3 install -r skill_seeker_mcp/requirements.txt

# Install CLI tool dependencies (for scraping)
pip3 install requests beautifulsoup4
```

--------------------------------

### Test CLI Tool Directly (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/TROUBLESHOOTING.md

Executes a command-line interface tool directly to test its functionality. This is useful for verifying that tools are installed and configured correctly, especially after MCP setup issues.

```bash
skill-seekers scrape --help
```

--------------------------------

### Run Typical Skill Seekers Workflow (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/BULLETPROOF_QUICKSTART.md

This snippet demonstrates the typical command-line workflow for using Skill Seekers. It includes commands for scraping a website with a specific configuration and page limit, packaging the scraped data, and a note about uploading the package.

```bash
# Your typical workflow:

# 1. Create/use a config
skill-seekers scrape --config configs/react.json --max-pages 50

# 2. Package it
skill-seekers package output/react/

# 3. Upload output/react.zip to Claude

# Done! 🎉
```

--------------------------------

### Get Current Working Directory (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

Retrieves the absolute path of the current working directory. This path is crucial for configuring the Skill Seeker MCP server in Claude Code.

```bash
# Get absolute path
pwd

# Example output: /Users/username/Projects/Skill_Seekers
# or: /home/username/Skill_Seekers
```

--------------------------------

### Advanced Configuration: Multiple Python Versions

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This JSON configuration shows how to specify a particular Python executable, such as 'python3.11', for the Skill Seeker MCP server when multiple Python versions are installed.

```json
{
  "mcpServers": {
    "skill-seeker": {
      "command": "/usr/local/bin/python3.11",
      "args": ["/path/to/Skill_Seekers/skill_seeker_mcp/server.py"],
      "cwd": "/path/to/Skill_Seekers"
    }
  }
}
```

--------------------------------

### Using Presets for Scraping

Source: https://github.com/zeeeepa/skill_seekers/blob/development/README.md

Demonstrates how to use predefined configuration presets for various frameworks and technologies. Each preset targets a specific framework, allowing for quick setup of scraping tasks.

```bash
# Godot
skill-seekers scrape --config configs/godot.json

# React
skill-seekers scrape --config configs/react.json

# Vue
skill-seekers scrape --config configs/vue.json

# Django
skill-seekers scrape --config configs/django.json

# FastAPI
skill-seekers scrape --config configs/fastapi.json

# Ansible
skill-seekers scrape --config configs/ansible-core.json
```

--------------------------------

### Run MCP Server Tests (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

Installs pytest and runs the unit tests for the MCP server. This step verifies the functionality and stability of the MCP server components, expecting all tests to pass.

```bash
# Install test dependencies
pip3 install pytest

# Run MCP server tests (25 tests)
python3 -m pytest tests/test_mcp_server.py -v

# Expected: 25 passed in ~0.3s
```

--------------------------------

### Enhance SKILL.md Locally

Source: https://github.com/zeeeepa/skill_seekers/blob/development/QUICKSTART.md

Enhances the `SKILL.md` file using locally available resources (no API key required), leveraging Claude Code Max for improved quality. This process typically takes about 60 seconds.

```bash
skill-seekers enhance output/godot/
```

--------------------------------

### Troubleshooting: Test MCP Server Manually

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This command manually starts the Skill Seeker MCP server, allowing for direct testing and error diagnosis without relying on the Claude Code IDE.

```bash
cd /path/to/Skill_Seekers
python3 skill_seeker_mcp/server.py
```

--------------------------------

### Check pip Installation (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/TROUBLESHOOTING.md

Verifies that the pip package installer is installed and accessible. Helps in troubleshooting module installation problems.

```bash
pip3 --version
```

--------------------------------

### Test Skill Seekers Installation

Source: https://github.com/zeeeepa/skill_seekers/blob/development/BULLETPROOF_QUICKSTART.md

Verifies that the main script can be executed by running the '--help' command. Success is indicated by the usage information of the 'doc_scraper.py' script.

```bash
# Test the main script can run
skill-seekers scrape --help
```

--------------------------------

### Troubleshoot Installation: Directory and Files

Source: https://github.com/zeeeepa/skill_seekers/blob/development/BULLETPROOF_QUICKSTART.md

Provides commands to check the current directory and list files within the 'cli/' directory if the 'skill-seekers' command is not found or scripts are missing. This helps diagnose 'No such file or directory' errors.

```bash
# Check you're in the right directory
pwd
# Should show path ending in /Skill_Seekers

# List files
ls cli/
# Should show: doc_scraper.py, estimate_pages.py, etc.
```

--------------------------------

### API-Based SKILL.md Enhancement with Anthropic

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/ENHANCEMENT.md

This script enhances SKILL.md files using the Anthropic API. It requires installation of the `anthropic` package and setup of the `ANTHROPIC_API_KEY`. The script analyzes reference files to generate practical code examples, quick references, and guidance, then saves the enhanced SKILL.md, backing up the original.

```bash
# Install package:
pip3 install anthropic

# Set API key (environment variable recommended):
export ANTHROPIC_API_KEY=sk-ant-...

# Usage examples:
python3 cli/enhance_skill.py output/steam-inventory/
python3 cli/doc_scraper.py --config configs/steam-inventory.json --enhance
python3 cli/enhance_skill.py output/react/ --dry-run
```

--------------------------------

### Run Skill Seekers CLI Commands (Pip Install)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/README.md

Demonstrates common commands for the Skill Seekers unified CLI after installation via pip. These commands cover scraping, GitHub repository processing, enhancement, and packaging.

```bash
# Use the unified CLI
skill-seekers scrape --config configs/react.json
skill-seekers github --repo facebook/react
skill-seekers enhance output/react/
skill-seekers package output/react/
```

--------------------------------

### Add Skill Seeker MCP Server to Claude Code Config (JSON)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

An example JSON configuration for Claude Code's MCP settings, demonstrating how to add the Skill Seeker MCP server. It specifies the command, arguments, working directory, and environment variables for the server.

```json
{
  "mcpServers": {
    "skill-seeker": {
      "command": "python3",
      "args": [
        "/Users/username/Projects/Skill_Seekers/skill_seeker_mcp/server.py"
      ],
      "cwd": "/Users/username/Projects/Skill_Seekers",
      "env": {}
    }
  }
}
```

--------------------------------

### Example Custom Configuration Structure

Source: https://github.com/zeeeepa/skill_seekers/blob/development/README.md

Illustrates the structure of a custom configuration file (JSON format). It includes parameters for naming, description, base URL, content selectors, URL patterns, categorization, and rate limiting.

```json
{
  "name": "myframework",
  "description": "When to use this skill",
  "base_url": "https://docs.myframework.com/",
  "selectors": {
    "main_content": "article",
    "title": "h1",
    "code_blocks": "pre code"
  },
  "url_patterns": {
    "include": ["/docs", "/guide"],
    "exclude": ["/blog", "/about"]
  },
  "categories": {
    "getting_started": ["intro", "quickstart"],
    "api": ["api", "reference"]
  },
  "rate_limit": 0.5,
  "max_pages": 500
}
```

--------------------------------

### Install Python Dependencies with User Flag (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/TROUBLESHOOTING.md

Installs Python packages specifically for the current user, bypassing system-wide permission issues. Useful when encountering 'Permission denied' errors during pip installations.

```bash
pip3 install --user requests beautifulsoup4
```

--------------------------------

### Check Python Installation and Version (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/TROUBLESHOOTING.md

Verify if Python 3 is installed and accessible on your system. This involves checking the command path and displaying the version. Useful for diagnosing 'Python Not Found' errors during installation.

```bash
which python3
python --version
```

--------------------------------

### Install Python 3 (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/TROUBLESHOOTING.md

Provides commands to install Python 3 on macOS, Linux, and Windows. Essential for setting up the environment when Python is not found.

```bash
# macOS:
brew install python3

# Linux:
sudo apt install python3 python3-pip

# Windows:
# Download from python.org, check "Add to PATH"
```

--------------------------------

### Create a Small Test Skill Configuration

Source: https://github.com/zeeeepa/skill_seekers/blob/development/BULLETPROOF_QUICKSTART.md

Creates a JSON configuration file for a small test skill, specifying the name, description, base URL, maximum pages to scrape, and rate limit. This is used to create a basic skill for initial testing.

```bash
# Create a config for a small site first
cat > configs/test.json << 'EOF'
{
  "name": "test-skill",
  "description": "Test skill creation",
  "base_url": "https://tailwindcss.com/docs/installation",
  "max_pages": 5,
  "rate_limit": 0.5
}
EOF
```

--------------------------------

### Interactive Scraping Mode

Source: https://github.com/zeeeepa/skill_seekers/blob/development/CLAUDE.md

Initiates the scraping process in interactive mode, guiding the user through a step-by-step configuration wizard. This is useful for users who prefer a guided setup or are unsure about specific configuration options.

```bash
# Step-by-step configuration wizard
skill-seekers scrape --interactive
```

--------------------------------

### Skill Seeker PDF Scraper and Packaging Workflow

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/PDF_SCRAPER.md

Demonstrates the command-line interface commands for creating a PDF configuration, running the PDF scraper, and packaging the resulting skill for distribution or upload.

```bash
# 1. Create PDF config
cat > configs/api_manual.json <<EOF
{
  "name": "api_manual",
  "pdf_path": "docs/api.pdf",
  "extract_options": {
    "min_quality": 7.0,
    "extract_images": true
  }
}
EOF

# 2. Run PDF scraper
python3 cli/pdf_scraper.py --config configs/api_manual.json

# 3. Package skill
python3 cli/package_skill.py output/api_manual/

# 4. Upload to Claude (if ANTHROPIC_API_KEY set)
python3 cli/package_skill.py output/api_manual/ --upload

# Result: api_manual.zip ready for Claude!
```

--------------------------------

### API Enhanced MCP Server Configuration (JSON)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/MCP_SETUP.md

This configuration enhances the minimal setup by including environment variables, such as the ANTHROPIC_API_KEY, for API-dependent features.

```json
{
  "mcpServers": {
    "skill-seeker": {
      "command": "python3",
      "args": [
        "/Users/username/Projects/Skill_Seekers/skill_seeker_mcp/server.py"
      ],
      "cwd": "/Users/username/Projects/Skill_Seekers",
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-your-key-here"
      }
    }
  }
}
```

--------------------------------

### Skill Seekers Documentation Scraping Examples

Source: https://github.com/zeeeepa/skill_seekers/blob/development/README.md

Provides examples of using the Skill Seekers CLI for scraping website documentation. Includes basic usage with a config file, quick scraping via URL, and utilizing async mode for faster processing.

```bash
# Scrape documentation website
skill-seekers scrape --config configs/react.json

# Quick scrape without config
skill-seekers scrape --url https://react.dev --name react

# With async mode (3x faster)
skill-seekers scrape --config configs/godot.json --async --workers 8
```

--------------------------------

### Reference File Code Examples

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/PDF_SCRAPER.md

Provides examples of code snippets found within reference markdown files, including bash for installation and YAML for configuration.

```bash
curl -O https://example.com/install.sh
bash install.sh
```

```yaml
server:
  port: 8080
  host: localhost
```

--------------------------------

### Quick Start: Single-Source Scraping

Source: https://github.com/zeeeepa/skill_seekers/blob/development/CLAUDE.md

Demonstrates how to perform single-source scraping using pre-defined configuration files for various frameworks like Godot, React, Vue, Django, Laravel, and FastAPI. This method focuses on scraping documentation only.

```bash
# Single-source scraping (documentation only)
skill-seekers scrape --config configs/godot.json
skill-seekers scrape --config configs/react.json
skill-seekers scrape --config configs/vue.json
skill-seekers scrape --config configs/django.json
skill-seekers scrape --config configs/laravel.json
skill-seekers scrape --config configs/fastapi.json
```

--------------------------------

### Install Python Dependencies (Bash)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/TROUBLESHOOTING.md

Installs necessary Python packages like 'requests' and 'beautifulsoup4' using pip. This command is crucial for resolving 'Module Not Found' errors.

```bash
pip3 install requests beautifulsoup4
pip3 install -r mcp/requirements.txt
```

--------------------------------

### Run Skill Seeker Tests with Options

Source: https://github.com/zeeeepa/skill_seekers/blob/development/docs/TESTING.md

Command-line interface for running tests in the Skill Seeker project. Supports various options like verbose output, specific test suites, stopping on failure, and listing available tests.

```bash
# Run all tests
python3 run_tests.py

# Run all tests with verbose output
python3 run_tests.py -v

# Run specific test suite
python3 run_tests.py --suite config
python3 run_tests.py --suite features
python3 run_tests.py --suite integration

# Stop on first failure
python3 run_tests.py --failfast

# List all available tests
python3 run_tests.py --list
```

--------------------------------

### Run Skill Seeker Scraper with Configuration

Source: https://github.com/zeeeepa/skill_seekers/blob/development/BULLETPROOF_QUICKSTART.md

Executes the skill-seekers scraper using a specified JSON configuration file. This command initiates the process of scraping web content to generate a skill.

```bash
# Run the scraper
skill-seekers scrape --config configs/test.json
```

--------------------------------

### Use Skill Seekers from Claude Code (MCP Integration)

Source: https://github.com/zeeeepa/skill_seekers/blob/development/README.md

Guides through the setup and usage of Skill Seekers within Claude Code via MCP integration. After a one-time setup script, users can interact with Skill Seekers using natural language prompts.

```bash
# One-time setup (5 minutes)
./setup_mcp.sh

# Then in Claude Code, just ask:
"Generate a React skill from https://react.dev/"
"Scrape PDF at docs/manual.pdf and create skill"
```
Tokens:
Raw