SDKs & Libraries

npm install asterloader

import { SkillsLoader } from 'asterloader';

// Initialize the loader
const loader = new SkillsLoader({
  apiKey: process.env.ASTER_API_KEY, // Optional for public skills
});

// Search for skills (returns an array of SkillMetadata)
const results = await loader.search('bug analysis');
for (const skill of results) {
  console.log(`${skill.fullName}: ${skill.description}`);
}

// Load a skill (metadata, contract, and full SKILL.md content)
const skill = await loader.load('analyzing-bugs');
console.log(skill.metadata.name, skill.metadata.description);

// Access the raw SKILL.md content
console.log(skill.fullContent); // SKILL.md content

import { SkillsLoader } from 'asterloader';

const loader = new SkillsLoader({
  apiKey: process.env.ASTER_API_KEY, // Optional for public skills
});

// Progressive disclosure — load only what you need.
// Levels: 'metadata' | 'contract' | 'summary' | 'full'
const meta = await loader.load('analyzing-bugs', { level: 'metadata' });
console.log(meta.metadata.version, meta.metadata.securityScore);

// Load the contract (inputs/outputs) to drive tool calling
const withContract = await loader.load('analyzing-bugs', { level: 'contract' });
console.log(withContract.contract);

// Execute a skill in the hosted runtime
const result = await loader.execute('analyzing-bugs', {
  input: 'Null pointer on the checkout page',
});
console.log(result.status, result.outputs);

import { createTools, loadSkill, toFrameworkTool } from 'asterloader';

// Load skills and convert them to framework tool definitions in one call.
// Frameworks: 'langchain' | 'openai' | 'anthropic' | 'generic'
const tools = await createTools(['analyzing-bugs', 'code-review'], 'anthropic');

// Pass the returned tools straight to your model's tool-calling API,
// e.g. anthropic.messages.create({ tools, ... })

// Or convert a single loaded skill yourself
const skill = await loadSkill('analyzing-bugs', { level: 'contract' });
const openaiTool = toFrameworkTool(skill, 'openai');

// Prefer runtime loading? Use the built-in MCP server instead:
// npx astermcp

pip install asterskills

import asyncio
from asterskills import searchSkills, loadSkill

async def main():
    # Search for skills (returns a list of SkillMetadata)
    results = await searchSkills("bug analysis")
    for skill in results:
        print(f"{skill.full_name}: {skill.description}")

    # Load a skill (metadata, contract, and full SKILL.md content)
    skill = await loadSkill("analyzing-bugs")
    print(skill.metadata.name, skill.metadata.version, skill.metadata.security_score)

    # Access the raw SKILL.md content
    print(skill.full_content)  # SKILL.md content

asyncio.run(main())

import asyncio
from asterskills import SkillsLoader, LoaderConfig, LoadLevel

async def main():
    loader = SkillsLoader(LoaderConfig(api_key="aster_live_xxx"))

    # Search for skills
    results = await loader.search("debugging")

    # Load multiple skills concurrently
    analyzing, review = await asyncio.gather(
        loader.load("analyzing-bugs"),
        loader.load("code-review"),
    )

    for skill in (analyzing, review):
        print(skill.metadata.full_name)
        print(skill.full_content[:100])

    # Progressive disclosure — load only the contract for tool calling
    contract_only = await loader.load("analyzing-bugs", level=LoadLevel.CONTRACT)
    print(contract_only.contract)

    await loader.close()

asyncio.run(main())

import asyncio
from asterskills import createTools, loadSkill, toFrameworkTool, LoadLevel

async def main():
    # Load skills and convert them to framework tool definitions.
    # Frameworks: "langchain" | "openai" | "anthropic" | "generic"
    tools = await createTools(
        ["analyzing-bugs", "code-review"],
        framework="anthropic",
    )
    # Pass the returned tools to your model's tool-calling API

    # Or convert a single loaded skill yourself
    skill = await loadSkill("analyzing-bugs", level=LoadLevel.CONTRACT)
    openai_tool = toFrameworkTool(skill, "openai")
    print(openai_tool)

asyncio.run(main())

# Search skills
curl "https://api.joinasterism.com/v1/skills?q=debugging&limit=10"

# Get skill details
curl "https://api.joinasterism.com/v1/skills/analyzing-bugs"

# Get skill content
curl "https://api.joinasterism.com/v1/skills/analyzing-bugs/skill.md"

# Authenticated request (for private skills or publishing)
curl "https://api.joinasterism.com/v1/skills" \
  -H "Authorization: Bearer aster_live_xxx"

// Search skills
const response = await fetch(
  'https://api.joinasterism.com/v1/skills?q=debugging&limit=10'
);
const data = await response.json();
console.log(data.skills);

// Get skill content
const skillResponse = await fetch(
  'https://api.joinasterism.com/v1/skills/analyzing-bugs/skill.md'
);
const content = await skillResponse.text();
console.log(content);

type LoadLevel = 'metadata' | 'contract' | 'summary' | 'full';

interface LoaderConfig {
  apiKey?: string;       // For accessing private skills
  baseUrl?: string;      // Default: https://api.joinasterism.com/v1
  cacheTtl?: number;     // Cache TTL in seconds (default: 3600)
  debug?: boolean;       // Enable debug logging
}

// Returned by loader.search() and loader.list()
interface SkillMetadata {
  name: string;
  fullName: string;
  version: string;
  description: string;
  author: string;
  downloads: number;
  securityScore: number | null;
  verified: boolean;
  deprecated: boolean;
  keywords: string[];
}

interface LoadOptions {
  level?: LoadLevel;     // Progressive disclosure level
  version?: string;      // Specific version (default: latest)
  maxTokens?: number;    // Truncate content to a token budget
  priority?: string[];   // Priority sections when truncating
}

// Returned by loader.load()
interface LoadedSkill {
  metadata: SkillMetadata;
  contract: SkillContract | null;
  capabilities: CapabilityDeclaration[];
  summary: string;
  fullContent: string;   // Full SKILL.md content
  toolDefinition: ToolDefinition;
  frontmatter: Record<string, unknown>;
}