# Define tools for AI models to use server = FastMcp::Server.new(name: 'popular-users', version: '1.0.0') # Define a tool by inheriting from FastMcp::Tool class CreateUserTool < FastMcp::Tool description "Create a user" # These arguments will generate the needed JSON to be presented to the MCP Client # And they will be validated at run time. # The validation is based off Dry-Schema, with the addition of the description. arguments do required(:first_name).filled(:string).description("First name of the user") optional(:age).filled(:integer).description("Age of the user") required(:address).description("The shipping address").hash do required(:street).filled(:string).description("Street address") optional(:city).filled(:string).description("City name") optional(:zipcode).maybe(:string).description("Postal code") end end def call(first_name:, age: nil, address: {}) User.create!(first_name:, age:, address:) end end # Register the tool with the server server.register_tool(CreateUserTool) # Share data resources with AI models by inheriting from FastMcp::Resource class PopularUsers < FastMcp::Resource uri "myapp:///users/popular" resource_name "Popular Users" mime_type "application/json" def content JSON.generate(User.popular.limit(5).as_json) end end class User < FastMcp::Resource uri "myapp:///users/{id}" # This is a resource template resource_name "user" mime_type "application/json" def content id = params[:id] # params are computed from the uri pattern JSON.generate(User.find(id).as_json) end end # Register the resource with the server server.register_resources(PopularUsers, User) # Accessing the resource through the server server.read_resource(PopularUsers.uri) # Notify the resource content has been updated to clients server.notify_resource_updated(PopularUsers.variabilized_uri) # Notifiy the content of a resource from a template has been updated to clients server.notify_resource_updated(User.variabilized_uri(id: 1))

# Tag your tools for easy filtering class AdminTool < FastMcp::Tool tags :admin, :dangerous description "Perform admin operations" def call # Admin only functionality end end # Filter tools based on user permissions 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

require 'fast_mcp' FastMcp.mount_in_rails( Rails.application, name: Rails.application.class.module_parent_name.underscore.dasherize, version: '1.0.0', path_prefix: '/mcp', # This is the default path prefix messages_route: 'messages', # This is the default route for the messages endpoint sse_route: 'sse', # This is the default route for the SSE endpoint # Add allowed origins below, it defaults to Rails.application.config.hosts # allowed_origins: ['localhost', '127.0.0.1', 'example.com', /.*\.example\.com/], # localhost_only: true, # Set to false to allow connections from other hosts # whitelist specific ips to if you want to run on localhost and allow connections from other IPs # allowed_ips: ['127.0.0.1', '::1'] # authenticate: true, # Uncomment to enable authentication # auth_token: 'your-token' # Required if authenticate: true ) do |server| Rails.application.config.after_initialize do # FastMcp will automatically discover and register: # - All classes that inherit from ApplicationTool (which uses ActionTool::Base) # - All classes that inherit from ApplicationResource (which uses ActionResource::Base) server.register_tools(*ApplicationTool.descendants) server.register_resources(*ApplicationResource.descendants) # alternatively, you can register tools and resources manually: # server.register_tool(MyTool) # server.register_resource(MyResource) end end

# Using Rails-style naming: class MyTool < ActionTool::Base description "My awesome tool" arguments do required(:input).filled(:string) end def call(input:) # Your implementation end end # Using standard FastMcp naming: class AnotherTool < FastMcp::Tool # Both styles work interchangeably in Rails apps end

# app/tools/application_tool.rb class ApplicationTool < ActionTool::Base # Base methods for all tools end # app/resources/application_resource.rb class ApplicationResource < ActionResource::Base # Base methods for all resources end

require 'fast_mcp' # Create an MCP server server = FastMcp::Server.new(name: 'my-ai-server', version: '1.0.0') # Define a tool by inheriting from FastMcp::Tool class SummarizeTool < FastMcp::Tool description "Summarize a given text" arguments do required(:text).filled(:string).description("Text to summarize") optional(:max_length).filled(:integer).description("Maximum length of summary") end def call(text:, max_length: 100) # Your summarization logic here text.split('.').first(3).join('.') + '...' end end # Register the tool with the server server.register_tool(SummarizeTool) # Create a resource by inheriting from FastMcp::Resource class StatisticsResource < FastMcp::Resource uri "data/statistics" resource_name "Usage Statistics" description "Current system statistics" mime_type "application/json" def content JSON.generate({ users_online: 120, queries_per_minute: 250, popular_topics: ["Ruby", "AI", "WebDev"] }) end end # Register the resource with the server server.register_resource(StatisticsResource) # Start the server server.start

# app.rb require 'sinatra' require 'fast_mcp' use FastMcp::RackMiddleware.new(name: 'my-ai-server', version: '1.0.0') do |server| # Register tools and resources here server.register_tool(SummarizeTool) end get '/' do 'Hello World!' end

# Configure allowed origins (defaults to ['localhost', '127.0.0.1']) FastMcp.rack_middleware(app, allowed_origins: ['localhost', '127.0.0.1', 'your-domain.com', /.*\.your-domain\.com/], localhost_only: false, allowed_ips: ['192.168.1.1', '10.0.0.1'], # other options... )

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