🔮 Lyra Tool Discovery

AI-powered tool discovery for the MCP ecosystem

Documentation · CLI Reference · Examples · Contributing

📖 Overview

Lyra Tool Discovery is an AI-powered automation tool designed specifically for the crypto, DeFi, blockchain, and web3 ecosystem. It solves the painful problem of manually discovering, evaluating, and integrating MCP (Model Context Protocol) servers into your crypto-focused applications. Instead of spending hours searching GitHub, reading READMEs, and figuring out the right integration approach, Lyra does it for you in seconds.

The tool crawls multiple sources—GitHub and npm—to find crypto-related MCP servers, APIs, and plugins. It filters results to focus exclusively on blockchain, DeFi, web3, and cryptocurrency tooling (including Ethereum, Solana, Bitcoin, wallets, tokens, NFTs, DEXs, staking, bridges, and more). Lyra then leverages state-of-the-art AI (OpenAI GPT-4o or Anthropic Claude) to analyze each discovered tool and automatically generates ready-to-use plugin configurations.

🪙 Crypto Focus

Lyra is optimized for discovering tools related to:

Blockchain Networks — Ethereum, Solana, Bitcoin, Layer 2s, bridges
DeFi Protocols — DEXs, lending, staking, yield farming, liquidity
Web3 Infrastructure — Wallets, RPC providers, indexers, oracles
Token Standards — ERC-20, ERC-721, NFTs, token swaps
Smart Contracts — Development, auditing, deployment tools
On-chain Data — Analytics, explorers, transaction tracking

Lyra is built for crypto MCP ecosystem developers who need to rapidly onboard new tools, plugin marketplace operators like plugin.delivery who curate crypto plugins, and automation engineers building CI/CD pipelines for DeFi tool discovery and deployment.

This tool is a critical piece of the discovery-to-deployment pipeline: lyra-tool-discovery → github-to-mcp → plugin.delivery → SperaxOS users. By automating the discovery and classification phase, Lyra enables fully automated plugin onboarding with minimal human intervention.

✨ Features

🤖 Multi-Provider AI

OpenAI — GPT-4o, GPT-4-turbo, GPT-3.5-turbo
Anthropic — Claude Sonnet 4, Claude Opus
Auto-detection from environment variables
Custom model selection via CLI or config
Intelligent fallback between providers

📦 8 Plugin Templates

mcp-http — Remote MCP servers (HTTP/SSE)
mcp-stdio — Local MCP servers (stdio)
openapi — REST API integrations
standalone — Full React applications
markdown — Rich text/documentation
default — Configurable plugins
settings — User preference plugins
basic — Simple function plugins

🔍 Discovery Sources

GitHub — Search repos, topics, READMEs
npm — Package registry search
🔜 Smithery (MCP directory)
🔜 OpenAPI Directory
🔜 RapidAPI

🪙 Crypto Filtering

Keywords — crypto, defi, blockchain, web3
Networks — ethereum, solana, bitcoin
Protocols — wallet, token, nft, dex, staking
Age Filter — Only repos updated within 12 months
Smart Validation — AI validates crypto relevance
Full-featured command-line interface
Node.js/TypeScript SDK for automation
JSON output for CI/CD pipelines
Dry-run mode for testing
Progress indicators and rich output

🖥️ CLI & Programmatic API

Full-featured command-line interface
Node.js/TypeScript SDK for automation
JSON output for CI/CD pipelines
Dry-run mode for testing
Progress indicators and rich output

🧪 Testing & Validation

--dry-run mode for safe testing
List discovered tools without AI calls
Validate configurations before deployment
Debug logging for troubleshooting

📤 Flexible Output

Structured JSON for piping to other tools
Quick Import format for SperaxOS
Plugin manifests for plugin.delivery
Console output with rich formatting

🪙 Crypto Discovery Keywords

Lyra automatically filters discovery results to focus on crypto/DeFi/blockchain/web3 tools. The following keywords are used for both search queries and result validation:

View all supported keywords

Category	Keywords
General	crypto, cryptocurrency, defi, blockchain, web3
Networks	ethereum, eth, solana, sol, bitcoin, btc, chain
Tokens	token, erc20, erc721, nft
DeFi	dex, swap, staking, yield, lending, liquidity, vault, bridge
Infrastructure	wallet, protocol, onchain, on-chain, smart contract
Libraries	web3.js, ethers, viem, wagmi, rainbowkit
Protocols	uniswap, aave, compound

Tools that don't match any of these keywords are automatically filtered out, ensuring you only discover crypto-relevant MCP servers.

Age Filtering

By default, Lyra only discovers tools that have been updated within the last 12 months. This ensures you're finding actively maintained projects. Use --max-age to adjust:

bash

# Only tools updated in the last 6 months
lyra-discover discover --max-age 6

# Only tools updated in the last 3 months (bleeding edge)
lyra-discover discover --max-age 3

# Tools up to 24 months old
lyra-discover discover --max-age 24

Quick Start

Installation

bash

# Global install (recommended for CLI usage)
pnpm add -g @nirholas/lyra-tool-discovery

# Or with npm
npm install -g @nirholas/lyra-tool-discovery

# Or as a project dependency
pnpm add @nirholas/lyra-tool-discovery

# Or run directly with npx (no install)
npx @nirholas/lyra-tool-discovery discover --help

Environment Setup

server.ts

# Using OpenAI (default when both keys present)
export OPENAI_API_KEY="sk-..."

# Or using Anthropic
export ANTHROPIC_API_KEY="sk-ant-..."

# Optional: Force a specific provider
export AI_PROVIDER="anthropic"  # or "openai"

# Optional: Specify a model
export AI_MODEL="claude-sonnet-4-20250514"

# Optional: GitHub token for higher rate limits
export GITHUB_TOKEN="ghp_..."

First Discovery

bash

# Discover MCP servers from GitHub and npm
lyra-discover discover --sources github,npm --limit 10

# Run in dry-run mode (no AI calls)
lyra-discover discover --dry-run --limit 20

# Analyze a specific GitHub repository
lyra-discover analyze-repo anthropics claude-mcp

# Analyze an npm package
lyra-discover analyze-npm @modelcontextprotocol/server-github

# Check available AI providers
lyra-discover providers

# View all plugin templates
lyra-discover templates

📖 CLI Reference

Global Options

Flag	Alias	Description	Default
`--provider`	`-p`	AI provider (`openai` or `anthropic`)	Auto-detect from env
`--model`	`-m`	AI model to use	Provider default
`--version`	`-V`	Show version number	—
`--help`	`-h`	Show help	—

Commands

`discover`

Search for MCP tools and APIs across configured sources.

bash

lyra-discover discover [options]

Option	Alias	Description	Default
`--sources`	`-s`	Comma-separated sources: `github`, `npm`, `awesome-list`	`github,npm`
`--limit`	`-l`	Maximum tools to discover per source	`5`
`--max-age`	`-a`	Maximum age in months for discovered repos	`12`
`--dry-run`	`-d`	List tools without AI analysis	`false`
`--provider`	`-p`	AI provider to use	Auto-detect
`--model`	`-m`	AI model to use	Provider default

Examples:

bash

# Discover crypto MCP tools from GitHub only, limit 10 results
lyra-discover discover --sources github --limit 10

# Find tools updated in the last 6 months only
lyra-discover discover --max-age 6 --limit 20

# Dry run to preview what would be analyzed
lyra-discover discover --dry-run --sources npm --limit 20

# Use Anthropic Claude for analysis
lyra-discover discover --provider anthropic --model claude-sonnet-4-20250514

# Use OpenAI GPT-4o for analysis
lyra-discover discover --provider openai --model gpt-4o

Example Output:

Code

🔍 Discovering crypto/DeFi/web3 tools from: github, npm
📅 Max age: 12 months
  Found 5 from github
  Found 3 from npm

📊 Total discovered: 8 tools
🪙 Crypto-related: 6 tools
🔌 MCP-compatible: 5 tools

🤖 Analyzing: mcp-server-ethereum...
  Template: mcp-stdio
  Reasoning: Has MCP SDK dependency and bin entry for local execution

✅ Analyzed 5 tools

📦 Generated Configs:

--- mcp-server-ethereum ---
Template: mcp-stdio
Config: {
  "identifier": "mcp-server-ethereum",
  "customParams": {
    "mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "mcp-server-ethereum"]
    }
  }
}

`analyze-repo`

Analyze a specific GitHub repository.

bash

lyra-discover analyze-repo <owner> <repo> [options]

Argument	Description
`owner`	GitHub repository owner/organization
`repo`	Repository name

Option	Alias	Description
`--provider`	`-p`	AI provider to use
`--model`	`-m`	AI model to use

Examples:

bash

# Analyze the official MCP GitHub server
lyra-discover analyze-repo modelcontextprotocol servers

# Analyze with specific model
lyra-discover analyze-repo anthropics claude-mcp --model gpt-4o

# Analyze a community MCP server
lyra-discover analyze-repo punkpeye mcp-server-obsidian

Example Output:

Code

🔍 Fetching modelcontextprotocol/servers...
🤖 Analyzing...

✅ Analysis complete:
  Template: mcp-stdio
  Reasoning: Repository contains multiple MCP servers with bin entries, using @modelcontextprotocol/sdk

📋 Quick Import JSON:
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    }
  }
}

`analyze-npm`

Analyze a specific npm package.

bash

lyra-discover analyze-npm <package> [options]

Argument	Description
`package`	npm package name (with or without scope)

Option	Alias	Description
`--provider`	`-p`	AI provider to use
`--model`	`-m`	AI model to use

Examples:

bash

# Analyze official MCP server packages
lyra-discover analyze-npm @modelcontextprotocol/server-github
lyra-discover analyze-npm @modelcontextprotocol/server-filesystem
lyra-discover analyze-npm @modelcontextprotocol/server-slack

# Analyze community packages
lyra-discover analyze-npm mcp-server-sqlite

`providers`

Show available AI providers based on configured environment variables.

bash

lyra-discover providers

Example Output (with keys configured):

Code

🤖 AI Provider Configuration

Available providers (based on env vars):
  ✅ openai
  ✅ anthropic

Override with env vars or CLI flags:
  AI_PROVIDER=openai|anthropic
  AI_MODEL=gpt-4o|claude-sonnet-4-20250514|etc.
  --provider openai --model gpt-4o

Example Output (no keys):

Code

🤖 AI Provider Configuration

Available providers (based on env vars):
  ⚠️  No API keys found!

Set one of these environment variables:
  - OPENAI_API_KEY     → Use OpenAI (gpt-4o, gpt-4-turbo, etc.)
  - ANTHROPIC_API_KEY  → Use Anthropic (claude-sonnet-4-20250514, etc.)

`templates`

Display all available plugin templates with descriptions.

bash

lyra-discover templates

Output:

Code

╔═══════════════════════════════════════════════════════════════════════════════╗
║                     plugin.delivery Plugin Templates                          ║
╠════════════╦════════════╦═══════════════════════════════════════════════════════╣
║ Template   ║ Type       ║ Description                   ║ Use Case           ║
╠════════════╬════════════╬═══════════════════════════════╬════════════════════╣
║ basic      ║ Default    ║ Standard plugin with API      ║ Simple data lookups║
║ default    ║ Default    ║ Plugin with settings UI       ║ Configurable tools ║
║ markdown   ║ Markdown   ║ Rich text output              ║ Formatted reports  ║
║ openapi    ║ OpenAPI    ║ Auto-generated from spec      ║ Existing APIs      ║
║ settings   ║ Default    ║ Plugin with user preferences  ║ Personalized tools ║
║ standalone ║ Standalone ║ Full React application        ║ Interactive UIs    ║
╠════════════╬════════════╬═══════════════════════════════╬════════════════════╣
║ mcp-http   ║ MCP        ║ Streamable HTTP MCP server    ║ Remote MCP tools   ║
║ mcp-stdio  ║ MCP        ║ STDIO-based MCP server        ║ Local npm MCP      ║
╚════════════╩════════════╩═══════════════════════════════╩════════════════════╝

🔧 Programmatic API

Use Lyra as a library in your Node.js/TypeScript projects:

server.ts

import { 
  ToolDiscovery, 
  GitHubSource, 
  NpmSource,
  AIAnalyzer 
} from '@nirholas/lyra-tool-discovery';

// Initialize with default settings (auto-detect AI provider)
const discovery = new ToolDiscovery();

// Or with specific configuration
const discovery = new ToolDiscovery({
  provider: 'anthropic',
  model: 'claude-sonnet-4-20250514',
  apiKey: process.env.ANTHROPIC_API_KEY // Optional, uses env var by default
});

// Discover from all sources
const results = await discovery.discover({
  sources: ['github', 'npm'],
  limit: 20,
  dryRun: false
});

// Process results
for (const result of results) {
  console.log(`Tool: ${result.tool.name}`);
  console.log(`Template: ${result.decision.template}`);
  console.log(`Config:`, result.generated.pluginConfig);
}

// Analyze a specific GitHub repo
const repoResult = await discovery.analyzeGitHubRepo('owner', 'repo');
console.log(repoResult?.decision.template);

// Analyze a specific npm package
const npmResult = await discovery.analyzeNpmPackage('@scope/package-name');
console.log(npmResult?.decision.template);

Using Individual Components

server.ts

import { GitHubSource, NpmSource, AIAnalyzer } from '@nirholas/lyra-tool-discovery';

// Use GitHub source directly
const github = new GitHubSource(process.env.GITHUB_TOKEN);
const mcpTools = await github.searchMCPServers(10);
const openApiTools = await github.searchOpenAPISpecs(10);
const specificRepo = await github.getRepo('owner', 'repo');

// Use npm source directly
const npm = new NpmSource();
const npmTools = await npm.searchMCPServers(10);
const specificPackage = await npm.getPackageAsTool('@modelcontextprotocol/server-github');

// Use AI analyzer directly
const ai = new AIAnalyzer({ provider: 'openai', model: 'gpt-4o' });
const decision = await ai.analyzeAndDecide(discoveredTool);
const quickImport = ai.generateQuickImport(decision);

Type Definitions

server.ts

import type {
  // Discovery types
  DiscoveredTool,
  DiscoveryResult,
  DiscoverySource,
  
  // Template types
  PluginTemplate,
  TemplateDecision,
  
  // MCP types
  MCPConnection,
  MCPHttpConnection,
  MCPStdioConnection,
  MCPAuthConfig,
  
  // Plugin types
  CustomPlugin,
  PluginManifest,
  PluginIndexEntry,
  MCPQuickImportConfig
} from '@nirholas/lyra-tool-discovery';

🏗️ Architecture

Code

┌─────────────────────────────────────────────────────────────────────────────┐
│                          LYRA TOOL DISCOVERY                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌────────────────┐     ┌────────────────┐     ┌────────────────────────┐  │
│  │    Sources     │     │  AI Analyzer   │     │   Template Engine      │  │
│  ├────────────────┤     ├────────────────┤     ├────────────────────────┤  │
│  │                │     │                │     │                        │  │
│  │ • GitHub API   │────▶│ • OpenAI       │────▶│ • basic                │  │
│  │   - Repos      │     │   - GPT-4o     │     │ • default              │  │
│  │   - Topics     │     │   - GPT-4-turbo│     │ • markdown             │  │
│  │   - READMEs    │     │                │     │ • openapi              │  │
│  │                │     │ • Anthropic    │     │ • settings             │  │
│  │ • npm Registry │     │   - Claude     │     │ • standalone           │  │
│  │   - Packages   │     │   - Sonnet     │     │ • mcp-http             │  │
│  │   - Keywords   │     │   - Opus       │     │ • mcp-stdio            │  │
│  │                │     │                │     │                        │  │
│  └────────────────┘     └────────────────┘     └────────────────────────┘  │
│          │                      │                         │                │
│          │                      │                         │                │
│          ▼                      ▼                         ▼                │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                         Discovery Result                            │   │
│  ├─────────────────────────────────────────────────────────────────────┤   │
│  │  {                                                                  │   │
│  │    tool: DiscoveredTool,     // Source metadata                     │   │
│  │    decision: TemplateDecision, // AI analysis result                │   │
│  │    generated: {                                                     │   │
│  │      pluginConfig: CustomPlugin | PluginIndexEntry                  │   │
│  │    }                                                                │   │
│  │  }                                                                  │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                    │                                       │
│                                    ▼                                       │
│                    ┌───────────────────────────────┐                       │
│                    │        Output Formats         │                       │
│                    ├───────────────────────────────┤                       │
│                    │ • JSON (for pipelines)        │                       │
│                    │ • Quick Import (SperaxOS)     │                       │
│                    │ • Plugin Manifests            │                       │
│                    │ • Console (human-readable)    │                       │
│                    └───────────────────────────────┘                       │
└─────────────────────────────────────────────────────────────────────────────┘

📋 Plugin Templates

Lyra analyzes tools and automatically selects from 8 plugin templates:

Template	Transport	Type	Use Case	AI Selection Criteria
`mcp-http`	HTTP/SSE	MCP	Remote MCP servers	Has MCP SDK + HTTP server code, publicly accessible URL
`mcp-stdio`	stdio	MCP	Local MCP servers	Has MCP SDK + `bin` entry in package.json, runs via npx
`openapi`	HTTP	OpenAPI	REST API integrations	Has OpenAPI/Swagger spec file or documentation
`standalone`	—	Standalone	Interactive applications	Needs complex UI, React components, data visualization
`markdown`	—	Markdown	Documentation/content	Outputs formatted text, reports, documentation
`default`	—	Default	Configurable plugins	Needs settings UI, configuration options
`settings`	—	Default	User preferences	Stores user preferences, personalization
`basic`	—	Default	Simple functions	Simple data lookups, basic API calls

AI Decision Priority

The AI follows this priority order when selecting templates:

MCP Detection → If tool uses @modelcontextprotocol/sdk:
- Has HTTP server → mcp-http
- Has bin entry → mcp-stdio
OpenAPI Detection → If has openapi.json/yaml or Swagger spec → openapi
Complex UI → If needs interactive dashboard → standalone
Formatted Output → If outputs rich text/markdown → markdown
Configuration → If needs user settings → default or settings
Default → Simple function → basic

🔗 Integration Pipeline

Lyra Tool Discovery is part of a larger automation toolchain for the SperaxOS ecosystem:

Code

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│                 │     │                 │     │                 │     │                 │
│  lyra-discover  │────▶│  github-to-mcp  │────▶│ plugin.delivery │────▶│    SperaxOS     │
│                 │     │                 │     │                 │     │                 │
│  Discovery &    │     │   Conversion    │     │   Marketplace   │     │   End Users     │
│   Analysis      │     │                 │     │                 │     │                 │
└─────────────────┘     └─────────────────┘     └─────────────────┘     └─────────────────┘

Discovery (this tool) — Finds tools on GitHub/npm, analyzes with AI, generates configs
Conversion — github-to-mcp converts repos to MCP servers
Registry — plugin.delivery hosts the plugin marketplace
Consumption — SperaxOS users discover and install plugins

Automated PR Workflow

You can set up a GitHub Action to automate the entire pipeline:

yaml

# .github/workflows/discover-tools.yml
name: Discover New Tools

on:
  schedule:
    - cron: '0 0 * * *'  # Daily at midnight
  workflow_dispatch:

jobs:
  discover:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install Lyra
        run: npm install -g @nirholas/lyra-tool-discovery
      
      - name: Discover new MCP servers
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          lyra-discover discover \
            --sources github,npm \
            --limit 50 \
            > discovered-tools.json
      
      - name: Create PR with new tools
        uses: peter-evans/create-pull-request@v5
        with:
          title: '🔮 New tools discovered by Lyra'
          body: 'Automated discovery run found new MCP servers and APIs.'
          branch: lyra/discovered-tools

⚙️ Configuration

Environment Variables

Variable	Description	Example
`OPENAI_API_KEY`	OpenAI API key	`sk-...`
`ANTHROPIC_API_KEY`	Anthropic API key	`sk-ant-...`
`AI_PROVIDER`	Force specific provider	`openai` or `anthropic`
`AI_MODEL`	Override default model	`gpt-4o`, `claude-sonnet-4-20250514`
`GITHUB_TOKEN`	GitHub token for higher rate limits	`ghp_...`

Configuration File (Coming Soon)

Support for discovery.config.json:

config.json

{
  "sources": {
    "github": {
      "enabled": true,
      "searchQueries": [
        "mcp server in:name,description",
        "modelcontextprotocol in:readme",
        "@modelcontextprotocol in:readme"
      ],
      "minStars": 10
    },
    "npm": {
      "enabled": true,
      "keywords": ["mcp", "model-context-protocol", "mcp-server"],
      "scopes": ["@modelcontextprotocol"]
    }
  },
  "ai": {
    "provider": "anthropic",
    "model": "claude-sonnet-4-20250514",
    "maxTokens": 4096
  },
  "output": {
    "format": "json",
    "path": "./data/discovered-tools.json",
    "includeMetadata": true
  },
  "filters": {
    "requireMCPSupport": true,
    "requireLicense": true,
    "excludeArchived": true
  }
}

📚 Examples

Example 1: Discover and Save Results

bash

# Discover tools and save to file
lyra-discover discover --sources github,npm --limit 20 > tools.json

# Parse with jq
cat tools.json | jq '.[] | {name: .tool.name, template: .decision.template}'

Example 2: Batch Analyze Repositories

bash

# Create a list of repos to analyze
repos=(
  "modelcontextprotocol/servers"
  "anthropics/claude-mcp"
  "punkpeye/mcp-server-obsidian"
)

# Analyze each repo
for repo in "${repos[@]}"; do
  owner=$(echo $repo | cut -d'/' -f1)
  name=$(echo $repo | cut -d'/' -f2)
  lyra-discover analyze-repo $owner $name
  echo "---"
done

Example 3: Analyze npm Packages in CI

server.ts

// scripts/analyze-packages.ts
import { ToolDiscovery } from '@nirholas/lyra-tool-discovery';

const packages = [
  '@modelcontextprotocol/server-github',
  '@modelcontextprotocol/server-filesystem',
  '@modelcontextprotocol/server-slack',
];

async function main() {
  const discovery = new ToolDiscovery({ provider: 'openai' });
  
  for (const pkg of packages) {
    const result = await discovery.analyzeNpmPackage(pkg);
    if (result) {
      console.log(JSON.stringify({
        package: pkg,
        template: result.decision.template,
        config: result.generated.pluginConfig
      }, null, 2));
    }
  }
}

main();

Example 4: Custom Source Integration

server.ts

import { AIAnalyzer, type DiscoveredTool } from '@nirholas/lyra-tool-discovery';

// Create a custom discovered tool
const customTool: DiscoveredTool = {
  id: 'custom:my-tool',
  name: 'my-custom-mcp-server',
  description: 'A custom MCP server for my application',
  source: 'github',
  sourceUrl: 'https://github.com/myorg/my-tool',
  hasMCPSupport: true,
  hasNpmPackage: true,
  readme: '# My Tool\n\nAn MCP server that does X, Y, Z...',
  packageJson: {
    name: 'my-custom-mcp-server',
    bin: { 'my-mcp': './dist/cli.js' },
    dependencies: { '@modelcontextprotocol/sdk': '^1.0.0' }
  }
};

// Analyze with AI
const ai = new AIAnalyzer({ provider: 'anthropic' });
const decision = await ai.analyzeAndDecide(customTool);
console.log(`Template: ${decision.template}`);
console.log(`Reasoning: ${decision.reasoning}`);

Example 5: Dry Run with Filtering

bash

# Discover in dry-run mode to see what would be analyzed
lyra-discover discover --dry-run --sources github --limit 50

# Output:
# [DRY RUN] Would analyze: mcp-server-github
#   Source: github
#   URL: https://github.com/modelcontextprotocol/servers
#   MCP: Yes
# [DRY RUN] Would analyze: claude-mcp
#   Source: github
#   URL: https://github.com/anthropics/claude-mcp
#   MCP: Yes
# ...

Example 6: Generate Quick Import for SperaxOS

server.ts

import { ToolDiscovery } from '@nirholas/lyra-tool-discovery';

const discovery = new ToolDiscovery();
const result = await discovery.analyzeNpmPackage('@modelcontextprotocol/server-github');

// The quick import format can be directly pasted into SperaxOS
console.log(`Add this to your MCP configuration:`);
console.log(JSON.stringify({
  mcpServers: {
    [result.tool.name]: result.decision.config.customParams?.mcp
  }
}, null, 2));

🤝 Contributing

We welcome contributions! Here's how to get started:

Development Setup

bash

# Clone the repository
git clone https://github.com/nirholas/lyra-tool-discovery.git
cd lyra-tool-discovery

# Install dependencies
pnpm install

# Set up environment
cp .env.example .env
# Edit .env with your API keys

# Run in development mode
pnpm dev discover --dry-run

# Build
pnpm build

# Run tests
pnpm test

Code Style

We use TypeScript with strict mode
ESLint for linting
Prettier for formatting
Write JSDoc comments for public APIs
Follow conventional commits for commit messages

Pull Request Process

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes
Add tests if applicable
Run pnpm build and pnpm test
Commit with conventional commit message: feat: add amazing feature
Push to your fork: git push origin feature/amazing-feature
Open a Pull Request

Areas for Contribution

🔌 New Sources — Add support for Smithery, OpenAPI Directory, RapidAPI
🤖 AI Providers — Add support for Gemini, Mistral, local models
📝 Documentation — Improve examples, add tutorials
🧪 Testing — Add unit tests, integration tests
🐛 Bug Fixes — Check the issues tab

🔗 Related Projects

Project	Description
github-to-mcp	Convert GitHub repos to MCP servers
plugin.delivery	Plugin marketplace for SperaxOS
SperaxOS	AI-native operating system
lyra-registry	Curated registry of discovered plugins
UCAI	Universal Context AI framework
MCP SDK	Official Model Context Protocol SDK

📄 License

Code

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

🙏 Credits

made by nich Model Context Protocol ecosystem
Powered by OpenAI and Anthropic
Inspired by the need to automate plugin discovery for SperaxOS

⬆ Back to Top

Documentation

Full documentation site: https://nirholas.github.io/lyra-tool-discovery/

Getting started covers install and first run.
Examples has copy-paste snippets.