Skip to main content
New to FastSkill? Start with the Welcome Page to learn about the problems FastSkill solves and how it expands the Claude Code skill standard.
FastSkill Architecture Overview

​
What is FastSkill?

FastSkill is a high-performance Rust service layer that enables AI agents and agent frameworks to discover, load, and execute skills directly. It provides comprehensive services that agents integrate with to access skill functionality without requiring a tool calling layer.
FastSkill is built with Rust for maximum performance, memory safety, and reliability. The service layer provides async/await support via tokio and can be used as a library or through the CLI.

​
Key Features

Semantic Search

Find skills using OpenAI embeddings for semantic understanding, not just keyword matching.

Cursor Integration

Automatically generate skill registries for Cursor IDE integration and AI agent tool discovery.

Progressive Loading

Load skill metadata first, then content on demand for optimal performance and memory usage.

Keyword Search

Traditional text-based search for reliable, predictable skill discovery.

Multiple Output Formats

Export results as tables, JSON, or XML for different integration needs.

Local Vector Index

Store embeddings locally in SQLite for fast, offline semantic search.

​
Quick Start

Get up and running with FastSkill in under 5 minutes: 
use fastskill::{FastSkillService, ServiceConfig};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create service with default configuration
    let config = ServiceConfig {
        skill_storage_path: PathBuf::from("./skills"),
        ..Default::default()
    };

    let service = FastSkillService::new(config).await?;
    service.initialize().await?;

    // List available skills
    let skills = service.skill_manager().list_skills(None).await?;
    println!("Found {} skills", skills.len());

    // Discover relevant skills using semantic search
    let relevant_skills = service.metadata_service()
        .discover_skills("extract text from PDF")
        .await?;

    println!("Found {} relevant skills", relevant_skills.len());

    Ok(())
}
Your FastSkill service is now running! Check out the Getting Started guide to learn more.

​
Architecture Overview

FastSkill follows a modular Rust architecture designed for scalability and performance:

​
Core Components

  • CLI Tool: Rust-based command-line interface for indexing and searching skills
  • Vector Index: SQLite-based storage for skill embeddings and metadata
  • Embedding Service: OpenAI integration for semantic text vectorization
  • Search Engine: Hybrid search supporting both semantic and keyword matching
  • Markdown Export: Automatic generation of Cursor-compatible skill registries
  • Rust Library: High-performance API for programmatic skill management with async/await support

​
Use Cases

FastSkill is perfect for:
  • AI Agent Development: Enable agents to discover and use skills through direct service integration
  • Service Integration: Provide comprehensive services that agents can use directly
  • Skill Marketplaces: Build platforms where users can share and consume skills
  • Enterprise Integration: Standardize skill access across different agent frameworks
  • Development Workflows: Hot reload skills during development without service restart

​
Next Steps

1

Install FastSkill

Install the Rust CLI and library following the installation guide.
2

Create your first skill

Learn how to define and register skills in the skill management section.
3

Integrate with your agent

Connect FastSkill to your AI agent or framework using our integration tutorials.
4

Explore advanced features

Dive into progressive loading and intelligent routing for optimal performance.
FastSkill focuses on skill discovery and search capabilities. For skill execution, read the generated SKILL.md files directly. FastSkill does not provide execution services.

​
Getting Help

Ready to get started? Jump to the Quick Start guide or installation instructions.