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/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 four weighted factors.

Scoring Formula
score = content + references + query_match + popularity

Content Availability

40 pts max

Skills with successfully fetched SKILL.md content receive 40 points. This ensures skills with actual content rank above those that failed to fetch.

Has content+40
No content (fetch failed)0

Query Match

30 pts max

How well the skill ID matches the search query.

Exact ID match+30
All query terms in ID+27
All ID terms in query+25.5
Partial 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
Example Scores
SkillContentRefsQueryPop.Total
Exact match, popular, with content40153015100
Good match, popular, with content400251277
Partial match, new skill40015055
No content (fetch failed)00301545

Design Rationale

1

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

2

Query relevance matters. Exact matches should rank above partial matches, regardless of popularity.

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

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 can run as an MCP (Model Context Protocol) server, making it available as a tool for Claude Desktop, Cursor, and other MCP-compatible clients.

Claude Desktop Configuration

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

# SSE transport (for web clients)
python -m src.mcp_server --transport sse --port 8080

Available MCP Tools

search_skills

Search for skills by query. Returns ranked results.

get_skill

Get a specific skill by source and ID.

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.