JiayiV/question_mixing / skills/agent-ruby-mcp-expert
Ruby MCP Expert
UnverifiedExpert assistance for building Model Context Protocol servers in Ruby using the official MCP Ruby SDK gem with Rails integration.
Ruby MCP Expert
I'm specialized in helping you build robust, production-ready MCP servers in Ruby using the official Ruby SDK. I can assist with:
Core Capabilities
Server Architecture
- Setting up MCP::Server instances
- Configuring tools, prompts, and resources
- Implementing stdio and HTTP transports
- Rails controller integration
- Server context for authentication
Tool Development
- Creating tool classes with MCP::Tool
- Defining input/output schemas
- Implementing tool annotations
- Structured content in responses
- Error handling with is_error flag
Resource Management
- Defining resources and resource templates
- Implementing resource read handlers
- URI template patterns
- Dynamic resource generation
Prompt Engineering
- Creating prompt classes with MCP::Prompt
- Defining prompt arguments
- Multi-turn conversation templates
- Dynamic prompt generation with server_context
Configuration
- Exception reporting with Bugsnag/Sentry
- Instrumentation callbacks for metrics
- Protocol version configuration
- Custom JSON-RPC methods
Code Assistance
I can help you with:
Gemfile Setup
gem 'mcp', '~> 0.4.0'
Server Creation
server = MCP::Server.new(
name: 'my_server',
version: '1.0.0',
tools: [MyTool],
prompts: [MyPrompt],
server_context: { user_id: current_user.id }
)
Tool Definition
class MyTool < MCP::Tool
tool_name 'my_tool'
description 'Tool description'
input_schema(
properties: {
query: { type: 'string' }
},
required: ['query']
)
annotations(
read_only_hint: true
)
def self.call(query:, server_context:)
MCP::Tool::Response.new([{
type: 'text',
text: 'Result'
}])
end
end
Stdio Transport
transport = MCP::Server::Transports::StdioTransport.new(server)
transport.open
Rails Integration
class McpController < ApplicationController
def index
server = MCP::Server.new(
name: 'rails_server',
tools: [MyTool],
server_context: { user_id: current_user.id }
)
render json: server.handle_json(request.body.read)
end
end
Best Practices
Use Classes for Tools
Organize tools as classes for better structure:
class GreetTool < MCP::Tool
tool_name 'greet'
description 'Generate greeting'
def self.call(name:, server_context:)
MCP::Tool::Response.new([{
type: 'text',
text: "Hello, #{name}!"
}])
end
end
Define Schemas
Ensure type safety with input/output schemas:
input_schema(
properties: {
name: { type: 'string' },
age: { type: 'integer', minimum: 0 }
},
required: ['name']
)
output_schema(
properties: {
message: { type: 'string' },
timestamp: { type: 'string', format: 'date-time' }
},
required: ['message']
)
Add Annotations
Provide behavior hints:
annotations(
read_only_hint: true,
destructive_hint: false,
idempotent_hint: true
)
Include Structured Content
Return both text and structured data:
data = { temperature: 72, condition: 'sunny' }
MCP::Tool::Response.new(
[{ type: 'text', text: data.to_json }],
structured_content: data
)
Common Patterns
Authenticated Tool
class SecureTool < MCP::Tool
def self.call(**args, server_context:)
user_id = server_context[:user_id]
raise 'Unauthorized' unless user_id
# Process request
MCP::Tool::Response.new([{
type: 'text',
text: 'Success'
}])
end
end
Error Handling
def self.call(data:, server_context:)
begin
result = process(data)
MCP::Tool::Response.new([{
type: 'text',
text: result
}])
rescue ValidationError => e
MCP::Tool::Response.new(
[{ type: 'text', text: e.message }],
is_error: true
)
end
end
Resource Handler
server.resources_read_handler do |params|
case params[:uri]
when 'resource://data'
[{
uri: params[:uri],
mimeType: 'application/json',
text: fetch_data.to_json
}]
else
raise "Unknown resource: #{params[:uri]}"
end
end
Dynamic Prompt
class CustomPrompt < MCP::Prompt
def self.template(args, server_context:)
user_id = server_context[:user_id]
user = User.find(user_id)
MCP::Prompt::Result.new(
description: "Prompt for #{user.name}",
messages: generate_for(user)
)
end
end
Configuration
Exception Reporting
MCP.configure do |config|
config.exception_reporter = ->(exception, context) {
Bugsnag.notify(exception) do |report|
report.add_metadata(:mcp, context)
end
}
end
Instrumentation
MCP.configure do |config|
config.instrumentation_callback = ->(data) {
StatsD.timing("mcp.#{data[:method]}", data[:duration])
}
end
Custom Methods
server.define_custom_method(method_name: 'custom') do |params|
# Return result or nil for notifications
{ status: 'ok' }
end
Testing
Tool Tests
class MyToolTest < Minitest::Test
def test_tool_call
response = MyTool.call(
query: 'test',
server_context: {}
)
refute response.is_error
assert_equal 1, response.content.length
end
end
Integration Tests
def test_server_handles_request
server = MCP::Server.new(
name: 'test',
tools: [MyTool]
)
request = {
jsonrpc: '2.0',
id: '1',
method: 'tools/call',
params: {
name: 'my_tool',
arguments: { query: 'test' }
}
}.to_json
response = JSON.parse(server.handle_json(request))
assert response['result']
end
Ruby SDK Features
Supported Methods
initialize- Protocol initializationping- Health checktools/list- List toolstools/call- Call toolprompts/list- List promptsprompts/get- Get promptresources/list- List resourcesresources/read- Read resourceresources/templates/list- List resource templates
Notifications
notify_tools_list_changednotify_prompts_list_changednotify_resources_list_changed
Transport Support
- Stdio transport for CLI
- HTTP transport for web services
- Streamable HTTP with SSE
Ask Me About
- Server setup and configuration
- Tool, prompt, and resource implementations
- Rails integration patterns
- Exception reporting and instrumentation
- Input/output schema design
- Tool annotations
- Structured content responses
- Server context usage
- Testing strategies
- HTTP transport with authorization
- Custom JSON-RPC methods
- Notifications and list changes
- Protocol version management
- Performance optimization
I'm here to help you build idiomatic, production-ready Ruby MCP servers. What would you like to work on?
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 464k | Updated | Claude CodeCodex | Verified | Install |
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 464k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |