AI Tool Discovery Agent

io.github.nirholasPublished by GitHub account nirholasv1.0.0Updated Oct 24, 2026

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

VerifiedSTDIODesktop onlyWeb Search & ScrapingDeveloper ToolsAI & ML

Overview

AI-generated overview

A local CLI and TypeScript library that searches GitHub and npm for MCP servers and APIs, uses an AI provider to analyze them, and generates plugin or MCP quick

What you can do
Search GitHub repositories and npm packages for MCP servers and APIs, with optional crypto keyword filtering and an age filter for recently updated projects. Analyze a specific GitHub repository or npm package and have an AI model pick a suitable plugin template. Generate configuration output such as MCP quick-import JSON, plugin manifests and structured JSON for pipelines. List available AI providers and plugin templates, and run dry-run discovery without AI calls.
When to use it
Useful when you want to find candidate MCP servers or API integrations and get ready-made configuration snippets, or when building an automated discovery pipeline that feeds a plugin marketplace or MCP setup.
Requirements
Runs locally as a Node.js process (npm or pnpm package, or npx). Needs an AI provider key: OPENAI_API_KEY or ANTHROPIC_API_KEY, with optional AI_PROVIDER and AI_MODEL. GITHUB_TOKEN is optional for higher GitHub rate limits. Network access to GitHub, npm and the AI provider.
Before you install
Sends repository and package metadata, including README content, to the selected AI provider for analysis. Requires an AI API key, which incurs provider usage costs. GITHUB_TOKEN grants broader GitHub access and should be scoped minimally. Generated configurations are suggestions and should be reviewed before use.

Installation

In SourceWeft

  1. Open AI Tool Discovery Agent in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

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]

Source: README.md at commit cff9201

Tools

0
SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

1
  1. v1.0.0LatestSep 16, 2026

Score

40% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.