Automatic MCP Discovery

Kit de automatización impulsado por IA que actúa como un agente que descubre servidores MCP por ti. Apúntalo a GitHub/npm/configura tu propio descubrimiento, deja que GPT o Claude analicen la API, MCP o cualquier herramienta, y obtén configuraciones de plugins listas para usar. Cero trabajo manual.

GitHub

Prueba este MCPPatrocinado

Documentación

🔮 Lyra Tool Discovery

Descubrimiento de herramientas impulsado por IA para el ecosistema MCP

Documentación · Referencia CLI · Ejemplos · Contribuciones

📖 Descripción general

Lyra Tool Discovery es una herramienta de automatización impulsada por IA diseñada específicamente para el ecosistema cripto, DeFi, blockchain y web3. Resuelve el doloroso problema de descubrir, evaluar e integrar manualmente servidores MCP (Model Context Protocol) en tus aplicaciones centradas en cripto. En lugar de pasar horas buscando en GitHub, leyendo READMEs y averiguando el enfoque de integración correcto, Lyra lo hace por ti en segundos.

La herramienta rastrea múltiples fuentes (GitHub y npm) para encontrar servidores MCP, APIs y plugins relacionados con cripto. Filtra los resultados para centrarse exclusivamente en herramientas de blockchain, DeFi, web3 y criptomonedas (incluyendo Ethereum, Solana, Bitcoin, wallets, tokens, NFTs, DEXs, staking, bridges y más). Lyra luego aprovecha IA de última generación (OpenAI GPT-4o o Anthropic Claude) para analizar cada herramienta descubierta y genera automáticamente configuraciones de plugins listas para usar.

🪙 Enfoque cripto

Lyra está optimizado para descubrir herramientas relacionadas con:

Redes blockchain — Ethereum, Solana, Bitcoin, capas 2, bridges
Protocolos DeFi — DEXs, préstamos, staking, yield farming, liquidez
Infraestructura Web3 — Wallets, proveedores RPC, indexadores, oráculos
Estándares de tokens — ERC-20, ERC-721, NFTs, swaps de tokens
Smart contracts — Herramientas de desarrollo, auditoría e implementación
Datos on-chain — Analítica, exploradores, seguimiento de transacciones

Lyra está construido para desarrolladores del ecosistema MCP cripto que necesitan incorporar rápidamente nuevas herramientas, operadores de marketplaces de plugins como plugin.delivery que seleccionan plugins cripto, e ingenieros de automatización que construyen pipelines de CI/CD para el descubrimiento e implementación de herramientas DeFi.

Esta herramienta es una pieza crítica del pipeline de descubrimiento a implementación: lyra-tool-discovery → github-to-mcp → plugin.delivery → usuarios de SperaxOS. Al automatizar la fase de descubrimiento y clasificación, Lyra permite la incorporación de plugins totalmente automatizada con una intervención humana mínima.

✨ Características

🤖 IA de múltiples proveedores

OpenAI — GPT-4o, GPT-4-turbo, GPT-3.5-turbo
Anthropic — Claude Sonnet 4, Claude Opus
Detección automática desde variables de entorno
Selección de modelo personalizada mediante CLI o configuración
Respaldo inteligente entre proveedores

📦 8 plantillas de plugins

mcp-http — Servidores MCP remotos (HTTP/SSE)
mcp-stdio — Servidores MCP locales (stdio)
openapi — Integraciones de API REST
standalone — Aplicaciones React completas
markdown — Texto enriquecido/documentación
default — Plugins configurables
settings — Plugins de preferencias de usuario
basic — Plugins de funciones simples

🔍 Fuentes de descubrimiento

GitHub — Búsqueda de repos, temas, READMEs
npm — Búsqueda en el registro de paquetes
🔜 Smithery (directorio MCP)
🔜 Directorio OpenAPI
🔜 RapidAPI

🪙 Filtrado cripto

Palabras clave — crypto, defi, blockchain, web3
Redes — ethereum, solana, bitcoin
Protocolos — wallet, token, nft, dex, staking
Filtro de antigüedad — Solo repos actualizados en los últimos 12 meses
Validación inteligente — La IA valida la relevancia cripto
Interfaz de línea de comandos con todas las funciones
SDK de Node.js/TypeScript para automatización
Salida JSON para pipelines de CI/CD
Modo de prueba en seco
Indicadores de progreso y salida enriquecida

🖥️ CLI y API programática

Interfaz de línea de comandos con todas las funciones
SDK de Node.js/TypeScript para automatización
Salida JSON para pipelines de CI/CD
Modo de prueba en seco
Indicadores de progreso y salida enriquecida

🧪 Pruebas y validación

Modo --dry-run para pruebas seguras
Lista herramientas descubiertas sin llamadas de IA
Valida configuraciones antes de la implementación
Registro de depuración para solución de problemas

📤 Salida flexible

JSON estructurado para canalizar a otras herramientas
Formato de importación rápida para SperaxOS
Manifiestos de plugins para plugin.delivery
Salida de consola con formato enriquecido

🪙 Palabras clave de descubrimiento cripto

Lyra filtra automáticamente los resultados de descubrimiento para centrarse en herramientas cripto/DeFi/blockchain/web3. Las siguientes palabras clave se utilizan tanto para consultas de búsqueda como para validación de resultados:

Ver todas las palabras clave admitidas

Categoría	Palabras clave
General	crypto, cryptocurrency, defi, blockchain, web3
Redes	ethereum, eth, solana, sol, bitcoin, btc, chain
Tokens	token, erc20, erc721, nft
DeFi	dex, swap, staking, yield, lending, liquidity, vault, bridge
Infraestructura	wallet, protocol, onchain, on-chain, smart contract
Bibliotecas	web3.js, ethers, viem, wagmi, rainbowkit
Protocolos	uniswap, aave, compound

Las herramientas que no coinciden con ninguna de estas palabras clave se filtran automáticamente, lo que garantiza que solo descubras servidores MCP relevantes para cripto.

Filtro de antigüedad

De forma predeterminada, Lyra solo descubre herramientas que se han actualizado en los últimos 12 meses. Esto garantiza que encuentres proyectos mantenidos activamente. Usa --max-age para ajustar:

# 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

Inicio rápido

Instalación

# 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

Configuración del entorno

# 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_..."

Primer descubrimiento

# 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

📖 Referencia CLI

Opciones globales

Indicador	Alias	Descripción	Predeterminado
`--provider`	`-p`	Proveedor de IA (`openai` o `anthropic`)	Detección automática desde env
`--model`	`-m`	Modelo de IA a usar	Predeterminado del proveedor
`--version`	`-V`	Mostrar número de versión	—
`--help`	`-h`	Mostrar ayuda	—

Comandos

`discover`

Busca herramientas y APIs MCP en las fuentes configuradas.

lyra-discover discover [options]

Opción	Alias	Descripción	Predeterminado
`--sources`	`-s`	Fuentes separadas por comas: `github`, `npm`, `awesome-list`	`github,npm`
`--limit`	`-l`	Máximo de herramientas a descubrir por fuente	`5`
`--max-age`	`-a`	Antigüedad máxima en meses para repos descubiertos	`12`
`--dry-run`	`-d`	Lista herramientas sin análisis de IA	`false`
`--provider`	`-p`	Proveedor de IA a usar	Detección automática
`--model`	`-m`	Modelo de IA a usar	Predeterminado del proveedor

Ejemplos:

# 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

Ejemplo de salida:

🔍 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`

Analiza un repositorio específico de GitHub.

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

Argumento	Descripción
`owner`	Propietario/organización del repositorio de GitHub
`repo`	Nombre del repositorio

Opción	Alias	Descripción
`--provider`	`-p`	Proveedor de IA a usar
`--model`	`-m`	Modelo de IA a usar

Ejemplos:

# 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

Ejemplo de salida:

🔍 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`

Analiza un paquete npm específico.

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

Argumento	Descripción
`package`	Nombre del paquete npm (con o sin ámbito)

Opción	Alias	Descripción
`--provider`	`-p`	Proveedor de IA a usar
`--model`	`-m`	Modelo de IA a usar

Ejemplos:

# 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`

Muestra los proveedores de IA disponibles según las variables de entorno configuradas.

lyra-discover providers

Ejemplo de salida (con claves configuradas):

🤖 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

Ejemplo de salida (sin claves):

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

Muestra todas las plantillas de plugins disponibles con descripciones.

lyra-discover templates

Salida:

╔═══════════════════════════════════════════════════════════════════════════════╗
║                     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      ║
╚════════════╩════════════╩═══════════════════════════════╩════════════════════╝

🔧 API programática

Usa Lyra como biblioteca en tus proyectos Node.js/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 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);

Uso de componentes individuales

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);

Definiciones de tipos

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';

🏗️ Arquitectura

┌─────────────────────────────────────────────────────────────────────────────┐
│                          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)    │                       │
│                    └───────────────────────────────┘                       │
└─────────────────────────────────────────────────────────────────────────────┘

📋 Plantillas de plugins

Lyra analiza herramientas y selecciona automáticamente entre 8 plantillas de plugins:

Plantilla	Transporte	Tipo	Caso de uso	Criterios de selección de IA
`mcp-http`	HTTP/SSE	MCP	Servidores MCP remotos	Tiene SDK MCP + código de servidor HTTP, URL accesible públicamente
`mcp-stdio`	stdio	MCP	Servidores MCP locales	Tiene SDK MCP + entrada `bin` en package.json, se ejecuta mediante npx
`openapi`	HTTP	OpenAPI	Integraciones de API REST	Tiene especificación OpenAPI/Swagger o documentación
`standalone`	—	Independiente	Aplicaciones interactivas	Necesita UI compleja, componentes React, visualización de datos
`markdown`	—	Markdown	Documentación/contenido	Genera texto formateado, informes, documentación
`default`	—	Predeterminado	Plugins configurables	Necesita UI de configuración, opciones de configuración
`settings`	—	Predeterminado	Preferencias de usuario	Almacena preferencias de usuario, personalización
`basic`	—	Predeterminado	Funciones simples	Búsquedas de datos simples, llamadas API básicas

Prioridad de decisión de IA

La IA sigue este orden de prioridad al seleccionar plantillas:

Detección MCP → Si la herramienta usa @modelcontextprotocol/sdk:
- Tiene servidor HTTP → mcp-http
- Tiene entrada bin → mcp-stdio
Detección OpenAPI → Si tiene especificación openapi.json/yaml o Swagger → openapi
UI compleja → Si necesita panel interactivo → standalone
Salida formateada → Si genera texto enriquecido/markdown → markdown
Configuración → Si necesita configuración de usuario → default o settings
Predeterminado → Función simple → basic

🔗 Pipeline de integración

Lyra Tool Discovery es parte de una cadena de herramientas de automatización más grande para el ecosistema SperaxOS:

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

Descubrimiento (esta herramienta) — Encuentra herramientas en GitHub/npm, analiza con IA, genera configuraciones
Conversión — github-to-mcp convierte repos en servidores MCP
Registro — plugin.delivery aloja el marketplace de plugins
Consumo — Los usuarios de SperaxOS descubren e instalan plugins

Flujo de trabajo automatizado de PR

Puedes configurar una GitHub Action para automatizar todo el pipeline:

# .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

⚙️ Configuración

Variables de entorno

Variable	Descripción	Ejemplo
`OPENAI_API_KEY`	Clave API de OpenAI	`sk-...`
`ANTHROPIC_API_KEY`	Clave API de Anthropic	`sk-ant-...`
`AI_PROVIDER`	Forzar proveedor específico	`openai` o `anthropic`
`AI_MODEL`	Anular modelo predeterminado	`gpt-4o`, `claude-sonnet-4-20250514`
`GITHUB_TOKEN`	Token de GitHub para límites de tasa más altos	`ghp_...`

Archivo de configuración (próximamente)

Soporte para discovery.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
  }
}

📚 Ejemplos

Ejemplo 1: Descubrir y guardar resultados

# 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}'

Ejemplo 2: Analizar repositorios por lotes

# 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

Ejemplo 3: Analizar paquetes npm en CI

// 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();

Ejemplo 4: Integración de fuentes personalizadas

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}`);

Ejemplo 5: Prueba en seco con filtrado

# 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
# ...

Ejemplo 6: Generar importación rápida para SperaxOS

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));

🤝 Contribuciones

¡Agradecemos las contribuciones! Así es como puedes comenzar:

Configuración de desarrollo

# 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

Estilo de código

Usamos TypeScript con modo estricto
ESLint para linting
Prettier para formateo
Escribe comentarios JSDoc para APIs públicas
Sigue conventional commits para mensajes de commit

Proceso de Pull Request

Haz un fork del repositorio
Crea una rama de características: git checkout -b feature/amazing-feature
Realiza tus cambios
Agrega pruebas si corresponde
Ejecuta pnpm build y pnpm test
Haz commit con un mensaje de conventional commit: feat: add amazing feature
Sube a tu fork: git push origin feature/amazing-feature
Abre un Pull Request

Áreas para contribuir

🔌 Nuevas fuentes — Agrega soporte para Smithery, OpenAPI Directory, RapidAPI
🤖 Proveedores de IA — Agrega soporte para Gemini, Mistral, modelos locales
📝 Documentación — Mejora ejemplos, agrega tutoriales
🧪 Pruebas — Agrega pruebas unitarias, pruebas de integración
🐛 Correcciones de errores — Revisa la pestaña de issues

🔗 Proyectos relacionados

Proyecto	Descripción
github-to-mcp	Convierte repos de GitHub en servidores MCP
plugin.delivery	Marketplace de plugins para SperaxOS
SperaxOS	Sistema operativo nativo de IA
lyra-registry	Registro curado de plugins descubiertos
UCAI	Framework de IA de Contexto Universal
MCP SDK	SDK oficial del Protocolo de Contexto de Modelos

📄 Licencia

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.

🙏 Créditos

Hecho por nich Model Context Protocol ecosistema
Impulsado por OpenAI y Anthropic
Inspirado por la necesidad de automatizar el descubrimiento de plugins para SperaxOS

⬆ Volver al inicio

Documentación

Sitio de documentación completo: https://nirholas.github.io/lyra-tool-discovery/

Primeros pasos cubre la instalación y la primera ejecución.
Ejemplos tiene fragmentos de copiar y pegar.