Fast MCP provides a full implementation of the following Model Context Protocol features:

• JSON-RPC 2.0: Full implementation for communication.
• Tool Definition & Calling: Define and call tools with rich argument types.
• Resource & Resource Templates Management: Create, read, update, and subscribe to resources.
• Transport Options: Supports STDIO, HTTP, and SSE.
• Framework Integration: Compatible with Rails, Sinatra, Hanami, and any Rack-compatible framework.
• Authentication: Token-based security.
• Schema Support: Full JSON Schema for tool arguments with validation.

Resources provide data to clients. To create one, inherit from FastMcp::Resource and define its uri, name, description, and mime_type. The content method must return the data.

Because resources are stateless, you can use a Tool to update the underlying data and then call notify_resource_updated("your/uri") to signal clients that the resource has changed.

# Define a resource
class Counter < FastMcp::Resource
  uri "example/counter"
  resource_name "Counter"
  description "A simple counter resource"
  mime_type "application/json"

  def content
    JSON.generate({ count: 10 })
  end
end

# Register it
server.register_resource(Counter)

# Update pattern using a tool
class IncrementTool < FastMcp::Tool
  def call
    # ... update logic ...
    notify_resource_updated("example/counter")
    { success: true }
  end
end

Fast MCP uses a request-scoped filtering system to dynamically control which tools and resources are exposed to an LLM based on the incoming request context. This is ideal for implementing permission-based access control, multi-tenancy, feature flags, or API versioning.

The workflow follows three steps:

1. Define filters on the server that inspect the request context.
2. Generate request-scoped server instances that contain only the allowed tools/resources.
3. Handle requests using these filtered instances.

This system is completely thread-safe because each request receives its own isolated server instance, ensuring that concurrent requests with different permissions do not interfere with each other.

Because FastMcp::Resource objects are stateless, you do not 'update' the resource object itself. Instead, you use an FastMcp::Tool to modify the underlying external state (like a file or database) and then call notify_resource_updated(uri) to inform the MCP client that the resource content has changed.

# Example tool that updates the counter
class IncrementCounterTool < FastMcp::Tool
  description 'Increment the counter'

  def call
    # Read current value
    current_count = File.exist?('counter.txt') ? File.read('counter.txt').to_i : 0
    
    # Increment and save
    new_count = current_count + 1
    File.write('counter.txt', new_count.to_s)

    # Notify that the resource has been updated
    notify_resource_updated("example/counter")

    { count: new_count }
  end
end

You can control which tools or resources are visible to a client by using server.filter_tools. This block receives the current request and the list of available tools. You can use tags assigned to tools via the tags method to implement permission-based filtering.

class AdminTool < FastMcp::Tool
  tags :admin, :dangerous
  description "Perform admin operations"

  def call
    # Admin only functionality
  end
end

server.filter_tools do |request, tools|
  user_role = request.params['role']

  case user_role
  when 'admin'
    tools # Admins see all tools
  when 'user'
    tools.reject { |t| t.tags.include?(:admin) }
  else
    tools.select { |t| t.tags.include?(:public) }
  end
end

For standalone servers, authentication is typically handled within the tool's call method by requiring an authentication argument (like an api_key) and validating it against an environment variable or secure store.

class SecureTool < FastMcp::Tool
  description "A secure tool"
  arguments do
    required(:api_key).filled(:string).description("API key for authentication")
    required(:input).filled(:string).description("Input value")
  end
  
  def call(api_key:, input:)
    unless api_key == ENV['API_KEY']
      raise "Invalid API key"
    end
    
    { output: "Success: #{input}" }
  end
end

Secure your MCP endpoints by enabling token-based authentication using FastMcp.authenticated_rack_middleware. This ensures that only clients providing the correct auth_token can interact with your server.

# Enable authentication
FastMcp.authenticated_rack_middleware(app,
  auth_token: 'your-secret-token',
  # other options...
)

To use your Fast MCP server with Claude Desktop, add it to your claude_desktop_config.json file.

File Locations:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Configuration Example:

{
  "mcpServers": {
    "my-great-server": {
      "command": "ruby",
      "args": ["/Users/path/to/your/awesome/fast-mcp/server.rb"]
    }
  }
}