Automatic MCP Discovery

Kit de automação com inteligência artificial que atua como um agente que descobre servidores MCP para você. Aponte para GitHub/npm/configure sua própria descoberta, deixe o GPT ou Claude analisar a API, MCP ou qualquer ferramenta, e obtenha configurações de plugin prontas para uso. Zero trabalho manual.

GitHub

Experimente este MCPPatrocinado

Documentação

🔮 Lyra Tool Discovery

Descoberta de ferramentas com IA para o ecossistema MCP

Documentação · Referência CLI · Exemplos · Contribuindo

📖 Visão Geral

Lyra Tool Discovery é uma ferramenta de automação com IA projetada especificamente para o ecossistema crypto, DeFi, blockchain e web3. Ela resolve o problema doloroso de descobrir, avaliar e integrar manualmente servidores MCP (Model Context Protocol) em seus aplicativos focados em criptomoedas. Em vez de passar horas pesquisando no GitHub, lendo READMEs e descobrindo a abordagem de integração correta, a Lyra faz isso por você em segundos.

A ferramenta rastreia múltiplas fontes — GitHub e npm — para encontrar servidores MCP, APIs e plugins relacionados a criptomoedas. Ela filtra os resultados para focar exclusivamente em ferramentas de blockchain, DeFi, web3 e criptomoedas (incluindo Ethereum, Solana, Bitcoin, carteiras, tokens, NFTs, DEXs, staking, bridges e muito mais). A Lyra então utiliza IA de última geração (OpenAI GPT-4o ou Anthropic Claude) para analisar cada ferramenta descoberta e gerar automaticamente configurações de plugins prontas para uso.

🪙 Foco em Criptomoedas

A Lyra é otimizada para descobrir ferramentas relacionadas a:

Redes Blockchain — Ethereum, Solana, Bitcoin, Layer 2s, bridges
Protocolos DeFi — DEXs, empréstimos, staking, yield farming, liquidez
Infraestrutura Web3 — Carteiras, provedores RPC, indexadores, oráculos
Padrões de Token — ERC-20, ERC-721, NFTs, swaps de tokens
Contratos Inteligentes — Ferramentas de desenvolvimento, auditoria e implantação
Dados On-chain — Análises, exploradores, rastreamento de transações

A Lyra é construída para desenvolvedores do ecossistema MCP de criptomoedas que precisam integrar rapidamente novas ferramentas, operadores de marketplaces de plugins como plugin.delivery que curadoria plugins de criptomoedas, e engenheiros de automação que constroem pipelines de CI/CD para descoberta e implantação de ferramentas DeFi.

Esta ferramenta é uma peça crítica do pipeline de descoberta até implantação: lyra-tool-discovery → github-to-mcp → plugin.delivery → usuários SperaxOS. Ao automatizar a fase de descoberta e classificação, a Lyra permite a integração totalmente automatizada de plugins com intervenção humana mínima.

✨ Recursos

🤖 IA Multi-Provedor

OpenAI — GPT-4o, GPT-4-turbo, GPT-3.5-turbo
Anthropic — Claude Sonnet 4, Claude Opus
Detecção automática a partir de variáveis de ambiente
Seleção personalizada de modelo via CLI ou configuração
Fallback inteligente entre provedores

📦 8 Modelos de Plugin

mcp-http — Servidores MCP remotos (HTTP/SSE)
mcp-stdio — Servidores MCP locais (stdio)
openapi — Integrações de API REST
standalone — Aplicações React completas
markdown — Texto rico/documentação
default — Plugins configuráveis
settings — Plugins de preferências do usuário
basic — Plugins de funções simples

🔍 Fontes de Descoberta

GitHub — Pesquisar repositórios, tópicos, READMEs
npm — Pesquisa no registro de pacotes
🔜 Smithery (diretório MCP)
🔜 Diretório OpenAPI
🔜 RapidAPI

🪙 Filtragem de Criptomoedas

Palavras-chave — crypto, defi, blockchain, web3
Redes — ethereum, solana, bitcoin
Protocolos — wallet, token, nft, dex, staking
Filtro de Idade — Apenas repositórios atualizados nos últimos 12 meses
Validação Inteligente — IA valida a relevância para criptomoedas
Interface de linha de comando completa
SDK Node.js/TypeScript para automação
Saída JSON para pipelines de CI/CD
Modo de simulação para testes
Indicadores de progresso e saída rica

🖥️ CLI e API Programática

Interface de linha de comando completa
SDK Node.js/TypeScript para automação
Saída JSON para pipelines de CI/CD
Modo de simulação para testes
Indicadores de progresso e saída rica

🧪 Testes e Validação

Modo --dry-run para testes seguros
Listar ferramentas descobertas sem chamadas de IA
Validar configurações antes da implantação
Registro de depuração para solução de problemas

📤 Saída Flexível

JSON estruturado para encaminhar a outras ferramentas
Formato de Importação Rápida para SperaxOS
Manifestos de plugins para plugin.delivery
Saída de console com formatação rica

🪙 Palavras-chave de Descoberta de Criptomoedas

A Lyra filtra automaticamente os resultados de descoberta para focar em ferramentas de crypto/DeFi/blockchain/web3. As seguintes palavras-chave são usadas tanto para consultas de pesquisa quanto para validação de resultados:

Ver todas as palavras-chave suportadas

Categoria	Palavras-chave
Geral	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
Infraestrutura	wallet, protocol, onchain, on-chain, smart contract
Bibliotecas	web3.js, ethers, viem, wagmi, rainbowkit
Protocolos	uniswap, aave, compound

Ferramentas que não correspondem a nenhuma dessas palavras-chave são automaticamente filtradas, garantindo que você descubra apenas servidores MCP relevantes para criptomoedas.

Filtro de Idade

Por padrão, a Lyra descobre apenas ferramentas que foram atualizadas nos últimos 12 meses. Isso garante que você encontre projetos mantidos ativamente. Use --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

Início Rápido

Instalação

# 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

Configuração do Ambiente

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

Primeira Descoberta

# 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

📖 Referência CLI

Opções Globais

Flag	Alias	Descrição	Padrão
`--provider`	`-p`	Provedor de IA (`openai` ou `anthropic`)	Detecção automática do ambiente
`--model`	`-m`	Modelo de IA a usar	Padrão do provedor
`--version`	`-V`	Mostrar número da versão	—
`--help`	`-h`	Mostrar ajuda	—

Comandos

`discover`

Pesquisar ferramentas e APIs MCP nas fontes configuradas.

lyra-discover discover [options]

Opção	Alias	Descrição	Padrão
`--sources`	`-s`	Fontes separadas por vírgula: `github`, `npm`, `awesome-list`	`github,npm`
`--limit`	`-l`	Máximo de ferramentas a descobrir por fonte	`5`
`--max-age`	`-a`	Idade máxima em meses para repositórios descobertos	`12`
`--dry-run`	`-d`	Listar ferramentas sem análise de IA	`false`
`--provider`	`-p`	Provedor de IA a usar	Detecção automática
`--model`	`-m`	Modelo de IA a usar	Padrão do provedor

Exemplos:

# 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

Exemplo de Saída:

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

Analisar um repositório GitHub específico.

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

Argumento	Descrição
`owner`	Proprietário/organização do repositório GitHub
`repo`	Nome do repositório

Opção	Alias	Descrição
`--provider`	`-p`	Provedor de IA a usar
`--model`	`-m`	Modelo de IA a usar

Exemplos:

# 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

Exemplo de Saída:

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

Analisar um pacote npm específico.

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

Argumento	Descrição
`package`	Nome do pacote npm (com ou sem escopo)

Opção	Alias	Descrição
`--provider`	`-p`	Provedor de IA a usar
`--model`	`-m`	Modelo de IA a usar

Exemplos:

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

Mostrar provedores de IA disponíveis com base nas variáveis de ambiente configuradas.

lyra-discover providers

Exemplo de Saída (com chaves 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

Exemplo de Saída (sem chaves):

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

Exibir todos os modelos de plugins disponíveis com descrições.

lyra-discover templates

Saída:

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

Use a Lyra como biblioteca em seus projetos 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);

Usando Componentes Individuais

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

Definições de Tipo

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

🏗️ Arquitetura

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

📋 Modelos de Plugin

A Lyra analisa ferramentas e seleciona automaticamente entre 8 modelos de plugins:

Modelo	Transporte	Tipo	Caso de Uso	Critérios de Seleção da IA
`mcp-http`	HTTP/SSE	MCP	Servidores MCP remotos	Possui SDK MCP + código de servidor HTTP, URL publicamente acessível
`mcp-stdio`	stdio	MCP	Servidores MCP locais	Possui SDK MCP + entrada `bin` no package.json, executa via npx
`openapi`	HTTP	OpenAPI	Integrações de API REST	Possui arquivo de especificação OpenAPI/Swagger ou documentação
`standalone`	—	Standalone	Aplicações interativas	Precisa de UI complexa, componentes React, visualização de dados
`markdown`	—	Markdown	Documentação/conteúdo	Produz texto formatado, relatórios, documentação
`default`	—	Padrão	Plugins configuráveis	Precisa de UI de configurações, opções de configuração
`settings`	—	Padrão	Preferências do usuário	Armazena preferências do usuário, personalização
`basic`	—	Padrão	Funções simples	Consultas de dados simples, chamadas básicas de API

Prioridade de Decisão da IA

A IA segue esta ordem de prioridade ao selecionar modelos:

Detecção MCP → Se a ferramenta usa @modelcontextprotocol/sdk:
- Possui servidor HTTP → mcp-http
- Possui entrada bin → mcp-stdio
Detecção OpenAPI → Se possui especificação openapi.json/yaml ou Swagger → openapi
UI Complexa → Se precisa de dashboard interativo → standalone
Saída Formatada → Se produz texto rico/markdown → markdown
Configuração → Se precisa de configurações do usuário → default ou settings
Padrão → Função simples → basic

🔗 Pipeline de Integração

Lyra Tool Discovery faz parte de um conjunto maior de ferramentas de automação para o ecossistema SperaxOS:

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

Descoberta (esta ferramenta) — Encontra ferramentas no GitHub/npm, analisa com IA, gera configurações
Conversão — github-to-mcp converte repositórios em servidores MCP
Registro — plugin.delivery hospeda o marketplace de plugins
Consumo — Usuários SperaxOS descobrem e instalam plugins

Fluxo de Trabalho Automatizado com PR

Você pode configurar uma GitHub Action para automatizar todo o 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

⚙️ Configuração

Variáveis de Ambiente

Variável	Descrição	Exemplo
`OPENAI_API_KEY`	Chave da API OpenAI	`sk-...`
`ANTHROPIC_API_KEY`	Chave da API Anthropic	`sk-ant-...`
`AI_PROVIDER`	Forçar provedor específico	`openai` ou `anthropic`
`AI_MODEL`	Substituir modelo padrão	`gpt-4o`, `claude-sonnet-4-20250514`
`GITHUB_TOKEN`	Token GitHub para limites de taxa mais altos	`ghp_...`

Arquivo de Configuração (Em Breve)

Suporte 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
  }
}

📚 Exemplos

Exemplo 1: Descobrir e Salvar 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}'

Exemplo 2: Analisar Repositórios em Lote

# 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

Exemplo 3: Analisar Pacotes npm em 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();

Exemplo 4: Integração de Fonte Personalizada

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

Exemplo 5: Simulação com Filtragem

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

Exemplo 6: Gerar Importação 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));

🤝 Contribuindo

Aceitamos contribuições! Veja como começar:

Configuração de Desenvolvimento

# 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 com modo estrito
ESLint para linting
Prettier para formatação
Escreva comentários JSDoc para APIs públicas
Siga commits convencionais para mensagens de commit

Processo de Pull Request

Faça um fork do repositório
Crie um branch de feature: git checkout -b feature/amazing-feature
Faça suas alterações
Adicione testes se aplicável
Execute pnpm build e pnpm test
Faça commit com mensagem de commit convencional: feat: add amazing feature
Envie para o seu fork: git push origin feature/amazing-feature
Abra um Pull Request

Áreas para Contribuição

🔌 Novas Fontes — Adicione suporte para Smithery, OpenAPI Directory, RapidAPI
🤖 Provedores de IA — Adicione suporte para Gemini, Mistral, modelos locais
📝 Documentação — Melhore exemplos, adicione tutoriais
🧪 Testes — Adicione testes unitários, testes de integração
🐛 Correções de Bugs — Verifique a aba de issues

🔗 Projetos Relacionados

Projeto	Descrição
github-to-mcp	Converta repositórios do GitHub em servidores MCP
plugin.delivery	Marketplace de plugins para SperaxOS
SperaxOS	Sistema operacional nativo de IA
lyra-registry	Registro curado de plugins descobertos
UCAI	Framework de IA de Contexto Universal
MCP SDK	SDK oficial do Model Context Protocol

📄 Licença

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

feito por nich no ecossistema Model Context Protocol
Desenvolvido por OpenAI e Anthropic
Inspirado pela necessidade de automatizar a descoberta de plugins para SperaxOS

⬆ Voltar ao Topo

Documentação

Site de documentação completo: https://nirholas.github.io/lyra-tool-discovery/

Começando cobre instalação e primeira execução.
Exemplos tem trechos de copiar e colar.