ruby-mcp-server-generator
Generate a complete Model Context Protocol server project in Ruby using the official MCP Ruby SDK gem.
소스 정보
- 저장소
- github/awesome-copilot
- 최근 소스 활동
- 2026년 8월 7일 02:01
- 감지된 SKILL.md 언어
- 영어
- 스타
- 40,553
- 포크
- 5,230
설치 방법
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
소스 파일 검토
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
SKILL.md 표시 중
SKILL.md
소스 지침 · 읽기 전용 미리보기- name
- ruby-mcp-server-generator
- description
- Generate a complete Model Context Protocol server project in Ruby using the official MCP Ruby SDK gem.
# Ruby MCP Server Generator
Generate a complete, production-ready MCP server in Ruby using the official Ruby SDK.
## Project Generation
When asked to create a Ruby MCP server, generate a complete project with this 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
```
## Gemfile Template
```ruby
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
```
## Rakefile Template
```ruby
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]
```
## lib/my_mcp_server.rb Template
```ruby
# 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
```
## lib/my_mcp_server/server.rb Template
```ruby
# 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
```
## lib/my_mcp_server/tools/greet_tool.rb Template
```ruby
# 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
```
## lib/my_mcp_server/tools/calculate_tool.rb Template
```ruby
# 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
```
## lib/my_mcp_server/prompts/code_review_prompt.rb Template
```ruby
# 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
```
## lib/my_mcp_server/resources/example_resource.rb Template
```ruby
# 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
```
## bin/mcp-server Template
```ruby
#!/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
```
Make the file executable:
```bash
chmod +x bin/mcp-server
```
## test/test_helper.rb Template
```ruby
# frozen_string_literal: true
$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
require 'my_mcp_server'
require 'minitest/autorun'
```
## test/tools/greet_tool_test.rb Template
```ruby
# 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
```
## test/tools/calculate_tool_test.rb Template
```ruby
# 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
```
## README.md Template
````markdown
# My MCP Server
A Model Context Protocol server built with Ruby and the official MCP Ruby SDK.
## Features
- ✅ Tools: greet, calculate
- ✅ Prompts: code_review
- ✅ Resources: example-data
- ✅ Input/output schemas
- ✅ Tool annotations
- ✅ Structured content
- ✅ Full test coverage
## Requirements
- Ruby 3.0 or later
## Installation
```bash
bundle install
```
## Usage
### Stdio Transport
Run the server:
```bash
bundle exec bin/mcp-server
```
Then send JSON-RPC requests:
```bash
GitHub에서 보기이 SKILL.md는 매우 커서 SkillsMP가 여기에는 첫 섹션만 미리 보여줍니다. GitHub에서 보기
