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 分

    请在仓库或注册中心条目中声明许可证。