Back
Skyll

Documentation

Everything you need to know about Skyll - from quick start to advanced configuration.

Why Skyll?

Agent skills (SKILL.md files) are a powerful way to extend what AI agents can do. They're markdown files that teach agents how to complete specific tasks, following the Agent Skills specification.

The Problem

Today, skills only work with a handful of tools like Claude Code and Cursor. They require manual installation before a session, which means developers need to know in advance which skills they'll need.

The Solution

Skyll democratizes access to skills. Any agent, framework, or tool can discover and retrieve skills on demand. No pre-installation. No human intervention. Agents explore, choose based on context, and use skills autonomously.

Think of Skyll as a search engine for agent capabilities. Your agent asks "How do I do X?" and Skyll returns the relevant skill with full instructions, ready to use.

Features

Multi-Source Search

Query skills.sh, community registry, and extensible to more sources. Results are deduplicated automatically.

Full Content Retrieval

Get complete SKILL.md content with parsed YAML frontmatter, not just metadata. Ready for context injection.

Relevance Ranking

Skills scored 0-100 based on content availability, query match, references, and popularity (install count).

Aggressive Caching

Intelligent caching respects GitHub rate limits. Configure TTL via environment variables.

References Support

Optionally fetch additional .md files from references/, docs/, examples/ directories.

Dual Interface

Use as REST API for any integration, or as MCP server for Claude Desktop, Cursor, and more.

Install with pip

The easiest way to use Skyll in your agents. Uses the hosted API at api.skyll.app - no server setup required.

pip install skyll

Basic Usage

from skyll import Skyll

async with Skyll() as client:
    skills = await client.search("react performance", limit=5)
    
    for skill in skills:
        print(f"{skill.title}: {skill.description}")
        print(skill.content)  # Full SKILL.md content

Get a Specific Skill

async with Skyll() as client:
    skill = await client.get("anthropics/skills", "skill-creator")
    if skill:
        print(skill.content)

Include References

Some skills have additional documentation in references/ directories:

async with Skyll() as client:
    skills = await client.search("react", include_references=True)
    
    for skill in skills:
        for ref in skill.references:
            print(f"๐Ÿ“Ž {ref.name}: {len(ref.content)} chars")

Point to Self-Hosted Server

async with Skyll(base_url="http://localhost:8000") as client:
    skills = await client.search("testing")

REST API

The hosted API is available at https://api.skyll.app. For other languages or direct integration.

GET/search

Search for skills by query. Returns ranked results with full content.

Example

curl "https://api.skyll.app/search?q=react+performance&limit=5"

Query Parameters

qSearch query (required)
limitMax results (1-50, default 10)
include_contentFetch full SKILL.md (default: true)
include_referencesFetch reference files (default: false)

Example Response

{
  "query": "react performance",
  "count": 1,
  "skills": [
    {
      "id": "react-best-practices",
      "title": "React Best Practices",
      "description": "Guidelines for building performant React apps",
      "source": "vercel/ai-skills",
      "relevance_score": 85.5,
      "install_count": 1250,
      "content": "# React Best Practices\n\n## Performance\n...",
      "refs": {
        "skills_sh": "https://skills.sh/...",
        "github": "https://github.com/..."
      }
    }
  ]
}
GET/skill/{name}

Get the latest version of a skill by name. Similar to npx skills add but for runtime context injection.

Simple Name (Searches for Best Match)

curl "https://api.skyll.app/skill/react-best-practices"

Full Path (Direct Lookup)

curl "https://api.skyll.app/skill/vercel-labs/agent-skills/vercel-react-best-practices"

Always fetches fresh content from GitHub, ensuring you have the latest version.

GET/skills/{source}/{skill_id}

Get a specific skill by source and ID.

curl "https://api.skyll.app/skills/anthropics/skills/skill-creator"
GET/health

Health check endpoint. Returns service status.

Self-Hosted

Run your own Skyll server for full control, higher rate limits, or private deployments.

Step 1Clone & Install

git clone https://github.com/assafelovic/skyll.git
cd skyll
pip install -e ".[server]"

Step 2Configure (Optional but Recommended)

.env
# GitHub token for higher rate limits (5000 vs 60 requests/hour)
GITHUB_TOKEN=ghp_your_token_here

# Cache TTL in seconds (default: 86400 = 24 hours)
CACHE_TTL=86400

Get a GitHub token at github.com/settings/tokens

Step 3Start the Server

uvicorn src.main:app --port 8000

Step 4Point Client to Your Server

from skyll import Skyll

async with Skyll(base_url="http://localhost:8000") as client:
    skills = await client.search("testing")

Ranking Algorithm

Skyll uses a multi-signal ranking algorithm to order search results by relevance. Each skill receives a score from 0-100 based on weighted factors, with a small additional boost for curated registry skills.

Scoring Formula
score = content + references + query_match + popularity + curated_boost

Content Availability

40 pts max

Skills with successfully fetched SKILL.md content receive 40 points. Skills without content are sorted last (not filtered).

Has content+40
No content (sorted last)0

Query Match

30 pts max

How well the skill matches the query. Checks ID, title, description, and content in priority order, taking the best score.

Exact ID match+30
All query terms in ID+27
All query terms in title+24
All query terms in description+21
Partial / content matches0-15

References

15 pts max

When include_references=true, skills with additional .md files receive a boost.

Has references (when requested)+15
No references0

Popularity

15 pts max

Install count from skills.sh, using logarithmic scaling to prevent extremely popular skills from dominating.

10,000+ installs+15
1,000 installs+11.25
100 installs+7.5
0 installs0

Curated Registry Boost

up to 8 pts

Skills from the curated registry/SKILLS.md receive a boost scaled by query relevance. This rewards hand-picked quality skills without letting irrelevant registry entries jump the ranks.

curated_boost = is_curated ร— 8 ร— query_match

A curated skill with a strong ID match gets +7.2 pts, a description match gets +5.6 pts, and a weak partial match gets just +2 pts.

Example Scores
SkillContentRefsQueryPop.CuratedTotal
Exact match, popular, with content401530150100
Good match, popular, with content4002512077
Curated, description match4002105.666.6
Partial match, new skill400150055
No content (fetch failed)003015045

Design Rationale

1

Content is king. Skills without content are less useful, so content availability dominates the score.

2

Multi-field matching. Skills match via ID, title, description, or content. A skill about "deep research" surfaces even if its ID is "gpt-researcher".

3

Popularity is a signal, not the answer. Log scaling prevents extremely popular skills from dominating. A skill with 100 installs and good query match can outrank a skill with 10,000 installs and poor match.

4

Curated skills get a nudge. Registry skills are hand-picked for quality. The boost is scaled by relevance to prevent irrelevant registry skills from jumping the ranks.

5

References add value. When users request references, skills that provide them are more valuable.

Create a Custom Ranker

The ranking algorithm is modular. Implement the Ranker protocol to create your own:

from src.ranking.base import Ranker

class MyCustomRanker(Ranker):
    def rank(self, skills, query="", include_references=False):
        for skill in skills:
            # Your scoring logic
            skill.relevance_score = ...
        return sorted(skills, key=lambda s: s.relevance_score, reverse=True)

# Register in src/core/service.py:
self._ranker = MyCustomRanker()

Future Enhancements

The ranking system is designed for extension. We welcome community contributions:

  • Semantic search: Use embeddings to match query intent, not just keywords
  • Recency: Boost recently updated skills
  • Quality signals: Factor in documentation completeness, test coverage
  • User feedback: Learn from click-through rates

Open an issue or PR to discuss!

MCP Server

Skyll provides a hosted MCP server at api.skyll.app/mcp - no installation required. Works with Claude Desktop, Cursor, and other MCP-compatible clients.

RecommendedHosted MCP

claude_desktop_config.json
{
  "mcpServers": {
    "skyll": {
      "url": "https://api.skyll.app/mcp"
    }
  }
}

That's it! The hosted server is always up-to-date with the latest features.

Available MCP Tools

add_skill

Get a skill by name. Like npx skills add for runtime.

search_skills

Search for skills by query. Returns ranked results.

get_skill

Get a specific skill by source and ID.

get_cache_stats

Get cache statistics for debugging.

Example: add_skill

The simplest way for agents to learn skills:

# Simple name - searches and returns best match
add_skill("react-best-practices")

# Full path - direct lookup
add_skill("vercel-labs/agent-skills/vercel-react-best-practices")

Self-Hosted MCP

If you prefer to run your own MCP server:

claude_desktop_config.json
{
  "mcpServers": {
    "skyll": {
      "command": "/path/to/skyll/venv/bin/python",
      "args": ["-m", "src.mcp_server"],
      "cwd": "/path/to/skyll"
    }
  }
}

Standalone Mode

# Stdio transport (for MCP clients)
python -m src.mcp_server

# HTTP transport (for web clients)
python -m src.mcp_server --transport http --port 8080

# SSE transport (legacy)
python -m src.mcp_server --transport sse --port 8080

Use Cases

Real examples of how agents can use Skyll to discover and apply skills dynamically.

Web Research

tavily-search

User asks 'Find the latest news on AI agents' โ†’ Agent searches Skyll for web search skills โ†’ Discovers tavily-search โ†’ Uses Tavily's LLM-optimized search API to fetch real-time results.

Deep Research

gpt-researcher

User needs comprehensive market analysis โ†’ Agent queries Skyll โ†’ Finds gpt-researcher โ†’ Runs autonomous multi-step research with citations and detailed reports.

Testing Workflows

test-driven-development

User says 'Add tests for this feature' โ†’ Agent doesn't know TDD โ†’ Searches Skyll โ†’ Retrieves test-driven-development skill โ†’ Follows TDD workflow.

Building Integrations

mcp-builder

User wants to connect app to external APIs โ†’ Agent needs MCP knowledge โ†’ Finds mcp-builder on Skyll โ†’ Creates Model Context Protocol servers following best practices.

Why Options Matter

Skyll returns a ranked list of skills, not just one result. This gives agents the freedom to:

  • Choose based on the specific context of the user's request
  • Prefer popular, well-tested skills (high install count)
  • Discover new skills they weren't pre-configured with
  • Let developers filter/sort based on their own criteria

Contributing

Add Your Skill to the Registry

The community registry at registry/SKILLS.md is the easiest way to make your skill discoverable.

registry/SKILLS.md
- your-skill-id | your-username/your-repo | path/to/skill | Short description of what it does

Requirements

  • Valid SKILL.md following the Agent Skills Spec
  • Public GitHub repository
  • Description under 80 characters
  • Skill should be useful and well-documented

Add a New Skill Source

Want to add a new source beyond skills.sh and the registry? Implement the SkillSource protocol:

from src.sources.base import SkillSource, SkillSearchResult

class MyCustomSource(SkillSource):
    @property
    def name(self) -> str:
        return "my-source"
    
    async def search(self, query: str, limit: int) -> list[SkillSearchResult]:
        # Your search logic here
        ...
    
    async def initialize(self) -> None:
        # Setup (called on startup)
        ...

See docs/sources.md for full documentation.