AI Tool Discovery Agent

io.github.nirholas由 GitHub 帳號 nirholas 發布v1.0.0更新於 Oct 24, 2026

AI agent discovers MCP servers from GitHub npm - analyzes APIs configs

已驗證STDIO僅桌面網頁搜尋與抓取開發者工具AI 與機器學習

概覽

AI 產生的概覽

一個本機 CLI 與 TypeScript 函式庫，在 GitHub 和 npm 上搜尋 MCP 伺服器與 API，用 AI 分析並產生外掛或 MCP 快速匯入設定。

可以做什麼
搜尋 GitHub 儲存庫和 npm 套件中的 MCP 伺服器與 API，可依加密關鍵字過濾並依更新時間篩選。分析指定的 GitHub 儲存庫或 npm 套件，由 AI 模型挑選合適的外掛範本。產生 MCP 快速匯入 JSON、外掛清單和供流程使用的結構化 JSON 等設定輸出。列出可用的 AI 供應商和外掛範本，並支援不呼叫 AI 的試跑探索。
適用情境
適合需要尋找候選 MCP 伺服器或 API 整合並取得現成設定片段的場合，也適合建立向此外掛市場或 MCP 環境提供資料的自動探索流程。
執行需求
以 Node.js 本機程序執行（npm 或 pnpm 套件，或使用 npx）。需要 AI 供應商金鑰：OPENAI_API_KEY 或 ANTHROPIC_API_KEY，可選 AI_PROVIDER 和 AI_MODEL。GITHUB_TOKEN 為選用，用於提高 GitHub 速率限制。需要連線至 GitHub、npm 和 AI 供應商的網路。
安裝前請注意
會將儲存庫和套件中繼資料（包括 README 內容）傳送給所選 AI 供應商分析。需要 AI API 金鑰，會產生供應商使用費用。GITHUB_TOKEN 具有較廣的 GitHub 存取權限，應盡量縮小範圍。產生的設定僅為建議，使用前應自行確認。

安裝

在 SourceWeft 中

  1. 開啟 儀表板中的 AI Tool Discovery Agent，將其新增到工作區。
  2. 為需要使用其工具的對話啟用該服務。

Desktop only，透過 STDIO。 STDIO 服務會啟動本機處理程序，因此需要 SourceWeft 桌面主機。

其他 MCP 客戶端

參照 儲存庫 中的啟動說明。

README

🔮 Lyra Tool Discovery

AI-powered tool discovery for the MCP ecosystem

[TypeScript] [PRs Welcome] [AI Powered]

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
CategoryKeywords
Generalcrypto, cryptocurrency, defi, blockchain, web3
Networksethereum, eth, solana, sol, bitcoin, btc, chain
Tokenstoken, erc20, erc721, nft
DeFidex, swap, staking, yield, lending, liquidity, vault, bridge
Infrastructurewallet, protocol, onchain, on-chain, smart contract
Librariesweb3.js, ethers, viem, wagmi, rainbowkit
Protocolsuniswap, 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 monthslyra-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 oldlyra-discover discover --max-age 24

Quick Start

Installation

bash
# Global install (recommended for CLI usage)pnpm add -g @nirholas/lyra-tool-discovery
# Or with npmnpm install -g @nirholas/lyra-tool-discovery
# Or as a project dependencypnpm add @nirholas/lyra-tool-discovery
# Or run directly with npx (no install)npx @nirholas/lyra-tool-discovery discover --help

Environment Setup

bash
# Using OpenAI (default when both keys present)export OPENAI_API_KEY="sk-..."
# Or using Anthropicexport ANTHROPIC_API_KEY="sk-ant-..."
# Optional: Force a specific providerexport AI_PROVIDER="anthropic"  # or "openai"
# Optional: Specify a modelexport AI_MODEL="claude-sonnet-4-20250514"
# Optional: GitHub token for higher rate limitsexport GITHUB_TOKEN="ghp_..."

First Discovery

bash
# Discover MCP servers from GitHub and npmlyra-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 repositorylyra-discover analyze-repo anthropics claude-mcp
# Analyze an npm packagelyra-discover analyze-npm @modelcontextprotocol/server-github
# Check available AI providerslyra-discover providers
# View all plugin templateslyra-discover templates

📖 CLI Reference

Global Options

FlagAliasDescriptionDefault
--provider-pAI provider (openai or anthropic)Auto-detect from env
--model-mAI model to useProvider default
--version-VShow version number—
--help-hShow help—

Commands

discover

Search for MCP tools and APIs across configured sources.

bash
lyra-discover discover [options]
OptionAliasDescriptionDefault
--sources-sComma-separated sources: github, npm, awesome-listgithub,npm
--limit-lMaximum tools to discover per source5
--max-age-aMaximum age in months for discovered repos12
--dry-run-dList tools without AI analysisfalse
--provider-pAI provider to useAuto-detect
--model-mAI model to useProvider default

Examples:

bash
# Discover crypto MCP tools from GitHub only, limit 10 resultslyra-discover discover --sources github --limit 10
# Find tools updated in the last 6 months onlylyra-discover discover --max-age 6 --limit 20
# Dry run to preview what would be analyzedlyra-discover discover --dry-run --sources npm --limit 20
# Use Anthropic Claude for analysislyra-discover discover --provider anthropic --model claude-sonnet-4-20250514
# Use OpenAI GPT-4o for analysislyra-discover discover --provider openai --model gpt-4o

Example Output:

🔍 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-stdioConfig: {  "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]
ArgumentDescription
ownerGitHub repository owner/organization
repoRepository name
OptionAliasDescription
--provider-pAI provider to use
--model-mAI model to use

Examples:

bash
# Analyze the official MCP GitHub serverlyra-discover analyze-repo modelcontextprotocol servers
# Analyze with specific modellyra-discover analyze-repo anthropics claude-mcp --model gpt-4o
# Analyze a community MCP serverlyra-discover analyze-repo punkpeye mcp-server-obsidian

Example Output:

🔍 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]
ArgumentDescription
packagenpm package name (with or without scope)
OptionAliasDescription
--provider-pAI provider to use
--model-mAI model to use

Examples:

bash
# Analyze official MCP server packageslyra-discover analyze-npm @modelcontextprotocol/server-githublyra-discover analyze-npm @modelcontextprotocol/server-filesystemlyra-discover analyze-npm @modelcontextprotocol/server-slack
# Analyze community packageslyra-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):

🤖 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):

🤖 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:

╔═══════════════════════════════════════════════════════════════════════════════╗║                     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:

typescript
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 configurationconst 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 sourcesconst results = await discovery.discover({  sources: ['github', 'npm'],  limit: 20,  dryRun: false});
// Process resultsfor (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 repoconst repoResult = await discovery.analyzeGitHubRepo('owner', 'repo');console.log(repoResult?.decision.template);
// Analyze a specific npm packageconst npmResult = await discovery.analyzeNpmPackage('@scope/package-name');console.log(npmResult?.decision.template);

Using Individual Components

typescript
import { GitHubSource, NpmSource, AIAnalyzer } from '@nirholas/lyra-tool-discovery';
// Use GitHub source directlyconst 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 directlyconst npm = new NpmSource();const npmTools = await npm.searchMCPServers(10);const specificPackage = await npm.getPackageAsTool('@modelcontextprotocol/server-github');
// Use AI analyzer directlyconst ai = new AIAnalyzer({ provider: 'openai', model: 'gpt-4o' });const decision = await ai.analyzeAndDecide(discoveredTool);const quickImport = ai.generateQuickImport(decision);

Type Definitions

typescript
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

┌─────────────────────────────────────────────────────────────────────────────┐│                          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:

TemplateTransportTypeUse CaseAI Selection Criteria
mcp-httpHTTP/SSEMCPRemote MCP serversHas MCP SDK + HTTP server code, publicly accessible URL
mcp-stdiostdioMCPLocal MCP serversHas MCP SDK + bin entry in package.json, runs via npx
openapiHTTPOpenAPIREST API integrationsHas OpenAPI/Swagger spec file or documentation
standalone—StandaloneInteractive applicationsNeeds complex UI, React components, data visualization
markdown—MarkdownDocumentation/contentOutputs formatted text, reports, documentation
default—DefaultConfigurable pluginsNeeds settings UI, configuration options
settings—DefaultUser preferencesStores user preferences, personalization
basic—DefaultSimple functionsSimple data lookups, basic API calls

AI Decision Priority

The AI follows this priority order when selecting templates:

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

🔗 Integration Pipeline

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

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐│                 │     │                 │     │                 │     │                 ││  lyra-discover  │────▶│  github-to-mcp  │────▶│ plugin.delivery │────▶│    SperaxOS     ││                 │     │                 │     │                 │     │                 ││  Discovery &    │     │   Conversion    │     │   Marketplace   │     │   End Users     ││   Analysis      │     │                 │     │                 │     │                 │└─────────────────┘     └─────────────────┘     └─────────────────┘     └─────────────────┘
  1. Discovery (this tool) — Finds tools on GitHub/npm, analyzes with AI, generates configs
  2. Conversion — github-to-mcp converts repos to MCP servers
  3. Registry — plugin.delivery hosts the plugin marketplace
  4. 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.ymlname: 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

VariableDescriptionExample
OPENAI_API_KEYOpenAI API keysk-...
ANTHROPIC_API_KEYAnthropic API keysk-ant-...
AI_PROVIDERForce specific provideropenai or anthropic
AI_MODELOverride default modelgpt-4o, claude-sonnet-4-20250514
GITHUB_TOKENGitHub token for higher rate limitsghp_...

Configuration File (Coming Soon)

Support for discovery.config.json:

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 filelyra-discover discover --sources github,npm --limit 20 > tools.json
# Parse with jqcat tools.json | jq '.[] | {name: .tool.name, template: .decision.template}'

Example 2: Batch Analyze Repositories

bash
# Create a list of repos to analyzerepos=(  "modelcontextprotocol/servers"  "anthropics/claude-mcp"  "punkpeye/mcp-server-obsidian")
# Analyze each repofor 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

typescript
// scripts/analyze-packages.tsimport { 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

typescript
import { AIAnalyzer, type DiscoveredTool } from '@nirholas/lyra-tool-discovery';
// Create a custom discovered toolconst 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 AIconst 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 analyzedlyra-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

typescript
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 SperaxOSconsole.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 repositorygit clone https://github.com/nirholas/lyra-tool-discovery.gitcd lyra-tool-discovery
# Install dependenciespnpm install
# Set up environmentcp .env.example .env# Edit .env with your API keys
# Run in development modepnpm dev discover --dry-run
# Buildpnpm build
# Run testspnpm 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

  1. Fork the repository
  2. Create a feature branch: git checkout -b feature/amazing-feature
  3. Make your changes
  4. Add tests if applicable
  5. Run pnpm build and pnpm test
  6. Commit with conventional commit message: feat: add amazing feature
  7. Push to your fork: git push origin feature/amazing-feature
  8. 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

ProjectDescription
github-to-mcpConvert GitHub repos to MCP servers
plugin.deliveryPlugin marketplace for SperaxOS
SperaxOSAI-native operating system
lyra-registryCurated registry of discovered plugins
UCAIUniversal Context AI framework
MCP SDKOfficial Model Context Protocol SDK

📄 License

MIT License © 2024 nirholas

MIT License
Permission is hereby granted, free of charge, to any person obtaining a copyof this software and associated documentation files (the "Software"), to dealin the Software without restriction, including without limitation the rightsto use, copy, modify, merge, publish, distribute, sublicense, and/or sellcopies of the Software, and to permit persons to whom the Software isfurnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in allcopies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS ORIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THEAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHERLIABILITY, 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 THESOFTWARE.

🙏 Credits

Documentation

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

Star History

[Star History Chart]

來源：README.md，提交 cff9201

工具

0
SourceWeft 尚未在沙箱中啟動過該軟體包，因此其工具未知。

版本歷史

1
  1. v1.0.0最新Sep 16, 2026

評分

已滿足適用檢查項的 40%

該評分衡量此收錄條目的完整程度，依據註冊中心條目、端點與公開來源計算得出。它不是對伺服器本身的評價，也不表示伺服器安全或目前可用：可連通性是帶日期的檢查結果，評分也不包含安裝量或使用者評價。

  • 近 30 天內可連通25 分

    請保持端點能夠回應 MCP 握手；SourceWeft 每 30 天探測一次。

  • 已宣告認證方式10 分

    請在註冊中心條目中宣告憑證請求標頭，或保持端點能夠回應探測，以便判定其認證方式。

  • 已列出工具15 分

    請讓伺服器在無憑證時回應 tools/list，或發布可在沙箱中無憑證啟動的軟體包。

  • 描述必需15 分
  • 圖示10 分
  • 文件15 分
  • 授權條款10 分

    請在儲存庫或註冊中心條目中宣告授權條款。