ruby-mcp-server-generator

Par github · awesome-copilot

Génère un projet serveur Model Context Protocol complet en Ruby en utilisant le gem officiel MCP Ruby SDK.

npx skills add https://github.com/github/awesome-copilot --skill ruby-mcp-server-generator

Générateur de serveur MCP Ruby

Générez un serveur MCP complet et prêt pour la production en Ruby en utilisant le SDK Ruby officiel.

Génération de projet

Quand on vous demande de créer un serveur MCP Ruby, générez un projet complet avec cette structure :

my-mcp-server/
├── Gemfile
├── Rakefile
├── lib/
│   ├── my_mcp_server.rb
│   ├── my_mcp_server/
│   │   ├── server.rb
│   │   ├── tools/
│   │   │   ├── greet_tool.rb
│   │   │   └── calculate_tool.rb
│   │   ├── prompts/
│   │   │   └── code_review_prompt.rb
│   │   └── resources/
│   │       └── example_resource.rb
├── bin/
│   └── mcp-server
├── test/
│   ├── test_helper.rb
│   └── tools/
│       ├── greet_tool_test.rb
│       └── calculate_tool_test.rb
└── README.md

Modèle Gemfile

source 'https://rubygems.org'

gem 'mcp', '~> 0.4.0'

group :development, :test do
  gem 'minitest', '~> 5.0'
  gem 'rake', '~> 13.0'
  gem 'rubocop', '~> 1.50'
end

Modèle Rakefile

require 'rake/testtask'
require 'rubocop/rake_task'

Rake::TestTask.new(:test) do |t|
  t.libs << 'test'
  t.libs << 'lib'
  t.test_files = FileList['test/**/*_test.rb']
end

RuboCop::RakeTask.new

task default: %i[test rubocop]

Modèle lib/my_mcp_server.rb

# frozen_string_literal: true

require 'mcp'
require_relative 'my_mcp_server/server'
require_relative 'my_mcp_server/tools/greet_tool'
require_relative 'my_mcp_server/tools/calculate_tool'
require_relative 'my_mcp_server/prompts/code_review_prompt'
require_relative 'my_mcp_server/resources/example_resource'

module MyMcpServer
  VERSION = '1.0.0'
end

Modèle lib/my_mcp_server/server.rb

# frozen_string_literal: true

module MyMcpServer
  class Server
    attr_reader :mcp_server

    def initialize(server_context: {})
      @mcp_server = MCP::Server.new(
        name: 'my_mcp_server',
        version: MyMcpServer::VERSION,
        tools: [
          Tools::GreetTool,
          Tools::CalculateTool
        ],
        prompts: [
          Prompts::CodeReviewPrompt
        ],
        resources: [
          Resources::ExampleResource.resource
        ],
        server_context: server_context
      )

      setup_resource_handler
    end

    def handle_json(json_string)
      mcp_server.handle_json(json_string)
    end

    def start_stdio
      transport = MCP::Server::Transports::StdioTransport.new(mcp_server)
      transport.open
    end

    private

    def setup_resource_handler
      mcp_server.resources_read_handler do |params|
        Resources::ExampleResource.read(params[:uri])
      end
    end
  end
end

Modèle lib/my_mcp_server/tools/greet_tool.rb

# frozen_string_literal: true

module MyMcpServer
  module Tools
    class GreetTool < MCP::Tool
      tool_name 'greet'
      description 'Generate a greeting message'

      input_schema(
        properties: {
          name: {
            type: 'string',
            description: 'Name to greet'
          }
        },
        required: ['name']
      )

      output_schema(
        properties: {
          message: { type: 'string' },
          timestamp: { type: 'string', format: 'date-time' }
        },
        required: ['message', 'timestamp']
      )

      annotations(
        read_only_hint: true,
        idempotent_hint: true
      )

      def self.call(name:, server_context:)
        timestamp = Time.now.iso8601
        message = "Hello, #{name}! Welcome to MCP."

        structured_data = {
          message: message,
          timestamp: timestamp
        }

        MCP::Tool::Response.new(
          [{ type: 'text', text: message }],
          structured_content: structured_data
        )
      end
    end
  end
end

Modèle lib/my_mcp_server/tools/calculate_tool.rb

# frozen_string_literal: true

module MyMcpServer
  module Tools
    class CalculateTool < MCP::Tool
      tool_name 'calculate'
      description 'Perform mathematical calculations'

      input_schema(
        properties: {
          operation: {
            type: 'string',
            description: 'Operation to perform',
            enum: ['add', 'subtract', 'multiply', 'divide']
          },
          a: {
            type: 'number',
            description: 'First operand'
          },
          b: {
            type: 'number',
            description: 'Second operand'
          }
        },
        required: ['operation', 'a', 'b']
      )

      output_schema(
        properties: {
          result: { type: 'number' },
          operation: { type: 'string' }
        },
        required: ['result', 'operation']
      )

      annotations(
        read_only_hint: true,
        idempotent_hint: true
      )

      def self.call(operation:, a:, b:, server_context:)
        result = case operation
                 when 'add' then a + b
                 when 'subtract' then a - b
                 when 'multiply' then a * b
                 when 'divide'
                   return error_response('Division by zero') if b.zero?
                   a / b.to_f
                 else
                   return error_response("Unknown operation: #{operation}")
                 end

        structured_data = {
          result: result,
          operation: operation
        }

        MCP::Tool::Response.new(
          [{ type: 'text', text: "Result: #{result}" }],
          structured_content: structured_data
        )
      end

      def self.error_response(message)
        MCP::Tool::Response.new(
          [{ type: 'text', text: message }],
          is_error: true
        )
      end
    end
  end
end

Modèle lib/my_mcp_server/prompts/code_review_prompt.rb

# frozen_string_literal: true

module MyMcpServer
  module Prompts
    class CodeReviewPrompt < MCP::Prompt
      prompt_name 'code_review'
      description 'Generate a code review prompt'

      arguments [
        MCP::Prompt::Argument.new(
          name: 'language',
          description: 'Programming language',
          required: true
        ),
        MCP::Prompt::Argument.new(
          name: 'focus',
          description: 'Review focus area (e.g., performance, security)',
          required: false
        )
      ]

      meta(
        version: '1.0',
        category: 'development'
      )

      def self.template(args, server_context:)
        language = args['language'] || 'Ruby'
        focus = args['focus'] || 'general quality'

        MCP::Prompt::Result.new(
          description: "Code review for #{language} with focus on #{focus}",
          messages: [
            MCP::Prompt::Message.new(
              role: 'user',
              content: MCP::Content::Text.new(
                "Please review this #{language} code with focus on #{focus}."
              )
            ),
            MCP::Prompt::Message.new(
              role: 'assistant',
              content: MCP::Content::Text.new(
                "I'll review the code focusing on #{focus}. Please share the code."
              )
            ),
            MCP::Prompt::Message.new(
              role: 'user',
              content: MCP::Content::Text.new(
                '[paste code here]'
              )
            )
          ]
        )
      end
    end
  end
end

Modèle lib/my_mcp_server/resources/example_resource.rb

# frozen_string_literal: true

module MyMcpServer
  module Resources
    class ExampleResource
      RESOURCE_URI = 'resource://data/example'

      def self.resource
        MCP::Resource.new(
          uri: RESOURCE_URI,
          name: 'example-data',
          description: 'Example resource data',
          mime_type: 'application/json'
        )
      end

      def self.read(uri)
        return [] unless uri == RESOURCE_URI

        data = {
          message: 'Example resource data',
          timestamp: Time.now.iso8601,
          version: MyMcpServer::VERSION
        }

        [{
          uri: uri,
          mimeType: 'application/json',
          text: data.to_json
        }]
      end
    end
  end
end

Modèle bin/mcp-server

#!/usr/bin/env ruby
# frozen_string_literal: true

require_relative '../lib/my_mcp_server'

begin
  server = MyMcpServer::Server.new
  server.start_stdio
rescue Interrupt
  warn "\nShutting down server..."
  exit 0
rescue StandardError => e
  warn "Error: #{e.message}"
  warn e.backtrace.join("\n")
  exit 1
end

Rendez le fichier exécutable :

chmod +x bin/mcp-server

Modèle test/test_helper.rb

# frozen_string_literal: true

$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
require 'my_mcp_server'
require 'minitest/autorun'

Modèle test/tools/greet_tool_test.rb

# frozen_string_literal: true

require 'test_helper'

module MyMcpServer
  module Tools
    class GreetToolTest < Minitest::Test
      def test_greet_with_name
        response = GreetTool.call(
          name: 'Ruby',
          server_context: {}
        )

        refute response.is_error
        assert_equal 1, response.content.length
        assert_match(/Ruby/, response.content.first[:text])

        assert response.structured_content
        assert_equal 'Hello, Ruby! Welcome to MCP.', response.structured_content[:message]
      end

      def test_output_schema_validation
        response = GreetTool.call(
          name: 'Test',
          server_context: {}
        )

        assert response.structured_content.key?(:message)
        assert response.structured_content.key?(:timestamp)
      end
    end
  end
end

Modèle test/tools/calculate_tool_test.rb

# frozen_string_literal: true

require 'test_helper'

module MyMcpServer
  module Tools
    class CalculateToolTest < Minitest::Test
      def test_addition
        response = CalculateTool.call(
          operation: 'add',
          a: 5,
          b: 3,
          server_context: {}
        )

        refute response.is_error
        assert_equal 8, response.structured_content[:result]
      end

      def test_subtraction
        response = CalculateTool.call(
          operation: 'subtract',
          a: 10,
          b: 4,
          server_context: {}
        )

        refute response.is_error
        assert_equal 6, response.structured_content[:result]
      end

      def test_multiplication
        response = CalculateTool.call(
          operation: 'multiply',
          a: 6,
          b: 7,
          server_context: {}
        )

        refute response.is_error
        assert_equal 42, response.structured_content[:result]
      end

      def test_division
        response = CalculateTool.call(
          operation: 'divide',
          a: 15,
          b: 3,
          server_context: {}
        )

        refute response.is_error
        assert_equal 5.0, response.structured_content[:result]
      end

      def test_division_by_zero
        response = CalculateTool.call(
          operation: 'divide',
          a: 10,
          b: 0,
          server_context: {}
        )

        assert response.is_error
        assert_match(/Division by zero/, response.content.first[:text])
      end

      def test_unknown_operation
        response = CalculateTool.call(
          operation: 'modulo',
          a: 10,
          b: 3,
          server_context: {}
        )

        assert response.is_error
        assert_match(/Unknown operation/, response.content.first[:text])
      end
    end
  end
end

Modèle README.md

# Mon serveur MCP

Un serveur Model Context Protocol construit avec Ruby et le SDK Ruby MCP officiel.

## Fonctionnalités

- ✅ Tools : greet, calculate
- ✅ Prompts : code_review
- ✅ Resources : example-data
- ✅ Schémas d'entrée/sortie
- ✅ Annotations d'outils
- ✅ Contenu structuré
- ✅ Couverture de tests complète

## Prérequis

- Ruby 3.0 ou plus récent

## Installation

```bash
bundle install

Utilisation

Transport Stdio

Lancez le serveur :

bundle exec bin/mcp-server

Puis envoyez des requêtes JSON-RPC :

{"jsonrpc":"2.0","id":"1","method":"ping"}
{"jsonrpc":"2.0","id":"2","method":"tools/list"}
{"jsonrpc":"2.0","id":"3","method":"tools/call","params":{"name":"greet","arguments":{"name":"Ruby"}}}

Intégration Rails

Ajoutez à votre contrôleur Rails :

class McpController < ApplicationController
  def index
    server = MyMcpServer::Server.new(
      server_context: { user_id: current_user.id }
    )
    render json: server.handle_json(request.body.read)
  end
end

Tests

Exécutez les tests :

bundle exec rake test

Exécutez le linter :

bundle exec rake rubocop

Exécutez tous les vérifications :

bundle exec rake

Intégration avec Claude Desktop

Ajoutez à claude_desktop_config.json :

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "bundle",
      "args": ["exec", "bin/mcp-server"],
      "cwd": "/path/to/my-mcp-server"
    }
  }
}

Structure du projet

my-mcp-server/
├── Gemfile              # Dépendances
├── Rakefile             # Tâches de build
├── lib/                 # Code source
│   ├── my_mcp_server.rb # Point d'entrée principal
│   └── my_mcp_server/   # Espace de noms du module
│       ├── server.rb    # Configuration du serveur
│       ├── tools/       # Implémentations des outils
│       ├── prompts/     # Modèles de prompts
│       └── resources/   # Gestionnaires de ressources
├── bin/                 # Exécutables
│   └── mcp-server       # Serveur Stdio
├── test/                # Suite de tests
│   ├── test_helper.rb   # Configuration des tests
│   └── tools/           # Tests des outils
└── README.md            # Ce fichier

Licence

MIT



## Instructions de génération

1. **Demandez le nom du projet et la description**
2. **Générez tous les fichiers** avec une dénomination appropriée et une structure de modules
3. **Utilisez des classes pour les outils et prompts** pour une meilleure organisation
4. **Incluez des schémas d'entrée/sortie** pour la sécurité des types
5. **Ajoutez des annotations d'outils** pour des indices de comportement
6. **Incluez du contenu structuré** dans les réponses
7. **Implémentez des tests complets** pour tous les outils
8. **Suivez les conventions Ruby** (snake_case, modules, frozen_string_literal)
9. **Ajoutez une gestion des erreurs appropriée** avec le drapeau is_error
10. **Fournissez des exemples d'utilisation stdio et HTTP**

Skills similaires

quality-playbook
github / awesome-copilot

Générer un système qualité complet et personnalisé pour tout projet logiciel.

33 044
aiconfig-migrate
launchdarkly / agent-skills

Migrer une application d'invites LLM codées en dur vers LaunchDarkly AI Configs en cinq étapes.

10
context-driven-development
wshobson / agents

Structurer le contexte projet comme artefact vivant pour aligner les interactions IA.

35 431
java-mcp-server-generator
github / awesome-copilot

Générer un serveur MCP Java complet et prêt pour la production avec Maven ou Gradle.

33 044
mcp-apps-builder
mcp-use / mcp-use

Construire des serveurs MCP production-ready avec outils, ressources et authentification.

9 956