fast-mcp 0.1.0 → 1.1.0

data/lib/generators/fast_mcp/install/install_generator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module FastMcp
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Creates a FastMcp initializer for Rails applications'
+
+      def copy_initializer
+        template 'fast_mcp_initializer.rb', 'config/initializers/fast_mcp.rb'
+      end
+
+      def create_directories
+        empty_directory 'app/tools'
+        empty_directory 'app/resources'
+      end
+
+      def copy_application_tool
+        template 'application_tool.rb', 'app/tools/application_tool.rb'
+      end
+
+      def copy_application_resource
+        template 'application_resource.rb', 'app/resources/application_resource.rb'
+      end
+
+      def copy_sample_tool
+        template 'sample_tool.rb', 'app/tools/sample_tool.rb'
+      end
+
+      def copy_sample_resource
+        template 'sample_resource.rb', 'app/resources/sample_resource.rb'
+      end
+
+      def display_post_install_message
+        say "\n========================================================="
+        say 'FastMcp was successfully installed! 🎉'
+        say "=========================================================\n"
+        say 'You can now create:'
+        say '  • Tools in app/tools/'
+        say '  • Resources in app/resources/'
+        say "\n"
+        say 'Check config/initializers/fast_mcp.rb to configure the middleware.'
+        say "=========================================================\n"
+      end
+    end
+  end
+end

data/lib/generators/fast_mcp/install/templates/application_resource.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationResource < ActionResource::Base
+  # write your custom logic to be shared across all resources here
+end

data/lib/generators/fast_mcp/install/templates/application_tool.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationTool < ActionTool::Base
+  # write your custom logic to be shared across all tools here
+end

data/lib/generators/fast_mcp/install/templates/fast_mcp_initializer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# FastMcp - Model Context Protocol for Rails
+# This initializer sets up the MCP middleware in your Rails application.
+#
+# In Rails applications, you can use:
+# - ActionTool::Base as an alias for FastMcp::Tool
+# - ActionResource::Base as an alias for FastMcp::Resource
+#
+# All your tools should inherit from ApplicationTool which already uses ActionTool::Base,
+# and all your resources should inherit from ApplicationResource which uses ActionResource::Base.
+
+# Mount the MCP middleware in your Rails application
+# You can customize the options below to fit your needs.
+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/],
+  # 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

data/lib/generators/fast_mcp/install/templates/sample_resource.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class SampleResource < ApplicationResource
+  uri 'examples/users'
+  resource_name 'Users'
+  description 'A user resource for demonstration'
+  mime_type 'application/json'
+
+  def content
+    JSON.generate(User.all.as_json)
+  end
+end

data/lib/generators/fast_mcp/install/templates/sample_tool.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class SampleTool < ApplicationTool
+  description 'Greet a user'
+
+  arguments do
+    required(:id).filled(:integer).description('ID of the user to greet')
+    optional(:prefix).filled(:string).description('Prefix to add to the greeting')
+  end
+
+  def call(id:, prefix: 'Hey')
+    user = User.find(id)
+
+    "#{prefix} #{user.first_name} !"
+  end
+end

data/lib/mcp/logger.rb

@@ -1,33 +1,32 @@
 # frozen_string_literal: true
 
 # This class is not used yet.
-module MCP
+module FastMcp
   class Logger < Logger
-    def initialize
+    def initialize(transport: :stdio)
       @client_initialized = false
-      @transport = nil
+      @transport = transport
 
-      super($stdout)
+      # we don't want to log to stdout if we're using the stdio transport
+      super($stdout) unless stdio_transport?
     end
 
     attr_accessor :transport, :client_initialized
-
-    def client_initialized?
-      client_initialized
-    end
+    alias client_initialized? client_initialized
 
     def stdio_transport?
       transport == :stdio
     end
 
+    def add(severity, message = nil, progname = nil, &block)
+      return if stdio_transport? # we don't want to log to stdout if we're using the stdio transport
+
+      # TODO: implement logging as the specification requires
+      super
+    end
+
     def rack_transport?
       transport == :rack
     end
-
-    # def add(severity, message = nil, progname = nil, &block)
-    #   # return unless client_initialized? && rack_transport?
-
-    #   super
-    # end
   end
 end

data/lib/mcp/railtie.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'fileutils'
+require_relative '../mcp/server'
+
+# Create ActionTool and ActionResource modules at load time
+unless defined?(ActionTool)
+  module ::ActionTool
+    Base = FastMcp::Tool
+  end
+end
+
+unless defined?(ActionResource)
+  module ::ActionResource
+    Base = FastMcp::Resource
+  end
+end
+
+module FastMcp
+  # Railtie for integrating Fast MCP with Rails applications
+  class Railtie < Rails::Railtie
+    # Add tools and resources directories to autoload paths
+    initializer 'fast_mcp.setup_autoload_paths' do |app|
+      app.config.autoload_paths += %W[
+        #{app.root}/app/tools
+        #{app.root}/app/resources
+      ]
+    end
+
+    # Auto-register all tools and resources after the application is fully loaded
+    config.after_initialize do
+      # Load all files in app/tools and app/resources directories
+      Dir[Rails.root.join('app', 'tools', '**', '*.rb')].each { |f| require f }
+      Dir[Rails.root.join('app', 'resources', '**', '*.rb')].each { |f| require f }
+    end
+
+    # Add rake tasks
+    rake_tasks do
+      # Path to the tasks directory in the gem
+      path = File.expand_path('../tasks', __dir__)
+      Dir.glob("#{path}/**/*.rake").each { |f| load f }
+    end
+  end
+end

data/lib/mcp/resource.rb

@@ -5,11 +5,13 @@ require 'base64'
 require 'mime/types'
 require 'singleton'
 
-module MCP
+module FastMcp
   # Resource class for MCP Resources feature
   # Represents a resource that can be exposed to clients
   class Resource
     class << self
+      attr_accessor :server
+
       # Define URI for this resource
       # @param value [String, nil] The URI for this resource
       # @return [String] The URI for this resource
@@ -74,7 +76,7 @@ module MCP
           end
 
           # Override content method to load from file
-          define_method :default_content do
+          define_method :content do
             if binary?
               File.binread(file_path)
             else
@@ -87,13 +89,6 @@ module MCP
 
     include Singleton
 
-    attr_accessor :content
-
-    # Initialize a resource singleton instance
-    def initialize
-      @content = default_content
-    end
-
     # URI of the resource - delegates to class method
     # @return [String, nil] The URI for this resource
     def uri
@@ -120,7 +115,7 @@ module MCP
 
     # Method to be overridden by subclasses to dynamically generate content
     # @return [String, nil] Generated content for this resource
-    def default_content
+    def content
       raise NotImplementedError, 'Subclasses must implement content'
     end
 

data/lib/mcp/server.rb

@@ -9,9 +9,9 @@ require_relative 'transports/rack_transport'
 require_relative 'transports/authenticated_rack_transport'
 require_relative 'logger'
 
-module MCP
+module FastMcp
   class Server
-    attr_reader :name, :version, :tools, :resources, :logger, :transport, :capabilities
+    attr_reader :name, :version, :tools, :resources, :capabilities
 
     DEFAULT_CAPABILITIES = {
       resources: {
@@ -23,7 +23,7 @@ module MCP
       }
     }.freeze
 
-    def initialize(name:, version:, logger: MCP::Logger.new, capabilities: {})
+    def initialize(name:, version:, logger: FastMcp::Logger.new, capabilities: {})
       @name = name
       @version = version
       @tools = {}
@@ -32,13 +32,17 @@ module MCP
       @logger = logger
       @logger.level = Logger::INFO
       @request_id = 0
+      @transport_klass = nil
       @transport = nil
       @capabilities = DEFAULT_CAPABILITIES.dup
 
       # Merge with provided capabilities
       @capabilities.merge!(capabilities) if capabilities.is_a?(Hash)
     end
+    attr_accessor :transport, :transport_klass, :logger
 
+    # Register multiple tools at once
+    # @param tools [Array<Tool>] Tools to register
     def register_tools(*tools)
       tools.each do |tool|
         register_tool(tool)
@@ -49,6 +53,7 @@ module MCP
     def register_tool(tool)
       @tools[tool.tool_name] = tool
       @logger.info("Registered tool: #{tool.tool_name}")
+      tool.server = self
     end
 
     # Register multiple resources at once
@@ -63,7 +68,7 @@ module MCP
     def register_resource(resource)
       @resources[resource.uri] = resource
       @logger.info("Registered resource: #{resource.name} (#{resource.uri})")
-
+      resource.server = self
       # Notify subscribers about the list change
       notify_resource_list_changed if @transport
 
@@ -93,7 +98,8 @@ module MCP
       @logger.info("Available resources: #{@resources.keys.join(', ')}")
 
       # Use STDIO transport by default
-      @transport = MCP::Transports::StdioTransport.new(self, logger: @logger)
+      @transport_klass = FastMcp::Transports::StdioTransport
+      @transport = @transport_klass.new(self, logger: @logger)
       @transport.start
     end
 
@@ -104,7 +110,8 @@ module MCP
       @logger.info("Available resources: #{@resources.keys.join(', ')}")
 
       # Use Rack transport
-      @transport = MCP::Transports::RackTransport.new(self, app, options.merge(logger: @logger))
+      transport_klass = FastMcp::Transports::RackTransport
+      @transport = transport_klass.new(app, self, options.merge(logger: @logger))
       @transport.start
 
       # Return the transport as middleware
@@ -117,7 +124,8 @@ module MCP
       @logger.info("Available resources: #{@resources.keys.join(', ')}")
 
       # Use Rack transport
-      @transport = MCP::Transports::AuthenticatedRackTransport.new(self, app, options.merge(logger: @logger))
+      transport_klass = FastMcp::Transports::AuthenticatedRackTransport
+      @transport = transport_klass.new(app, self, options.merge(logger: @logger))
       @transport.start
 
       # Return the transport as middleware
@@ -180,47 +188,6 @@ module MCP
       end
     end
 
-    # Register a callback for resource updates
-    def on_resource_update(&block)
-      @resource_update_callbacks ||= []
-      callback_id = SecureRandom.uuid
-      @resource_update_callbacks << { id: callback_id, callback: block }
-      callback_id
-    end
-
-    # Remove a resource update callback
-    def remove_resource_update_callback(callback_id)
-      @resource_update_callbacks ||= []
-      @resource_update_callbacks.reject! { |cb| cb[:id] == callback_id }
-    end
-
-    # Update a resource and notify subscribers
-    def update_resource(uri, content)
-      return false unless @resources.key?(uri)
-
-      resource = @resources[uri]
-      resource.instance.content = content
-
-      # Notify subscribers
-      notify_resource_updated(uri) if @transport && @resource_subscriptions.key?(uri)
-
-      # Notify resource update callbacks
-      if @resource_update_callbacks && !@resource_update_callbacks.empty?
-        @resource_update_callbacks.each do |cb|
-          cb[:callback].call(
-            {
-              uri: uri,
-              name: resource.name,
-              mime_type: resource.mime_type,
-              content: content
-            }
-          )
-        end
-      end
-
-      true
-    end
-
     # Read a resource directly
     def read_resource(uri)
       resource = @resources[uri]
@@ -229,13 +196,32 @@ module MCP
       resource
     end
 
+    # Notify subscribers about a resource update
+    def notify_resource_updated(uri)
+      @logger.warn("Notifying subscribers about resource update: #{uri}, #{@resource_subscriptions.inspect}")
+      return unless @client_initialized && @resource_subscriptions.key?(uri)
+
+      resource = @resources[uri]
+      notification = {
+        jsonrpc: '2.0',
+        method: 'notifications/resources/updated',
+        params: {
+          uri: uri,
+          name: resource.name,
+          mimeType: resource.mime_type
+        }
+      }
+
+      @transport.send_message(notification)
+    end
+
     private
 
     PROTOCOL_VERSION = '2024-11-05'
 
     def handle_initialize(params, id)
-      params['protocolVersion']
-      client_capabilities = params['capabilities'] || {}
+      # Store client capabilities for later use
+      @client_capabilities = params['capabilities'] || {}
       client_info = params['clientInfo'] || {}
 
       # Log client information
@@ -254,9 +240,6 @@ module MCP
 
       @logger.info("Server response: #{response.inspect}")
 
-      # Store client capabilities for later use
-      @client_capabilities = client_capabilities
-
       send_result(response, id)
     end
 
@@ -290,8 +273,9 @@ module MCP
       # The client is now ready for normal operation
       # No response needed for notifications
       @client_initialized = true
-      @logger.set_client_initialized
       @logger.info('Client initialized, beginning normal operation')
+
+      send_result({}, nil)
     end
 
     # Handle tools/list request
@@ -324,7 +308,7 @@ module MCP
 
         # Format and send the result
         send_formatted_result(result, id)
-      rescue MCP::Tool::InvalidArgumentsError => e
+      rescue FastMcp::Tool::InvalidArgumentsError => e
         @logger.error("Invalid arguments for tool #{tool_name}: #{e.message}")
         send_error_result(e.message, id)
       rescue StandardError => e
@@ -410,24 +394,6 @@ module MCP
       send_result({ unsubscribed: true }, id)
     end
 
-    # Notify subscribers about a resource update
-    def notify_resource_updated(uri)
-      return unless @client_initialized && @resource_subscriptions.key?(uri)
-
-      resource = @resources[uri]
-      notification = {
-        jsonrpc: '2.0',
-        method: 'notifications/resources/updated',
-        params: {
-          uri: uri,
-          name: resource.name,
-          mimeType: resource.mime_type
-        }
-      }
-
-      @transport.send_message(notification)
-    end
-
     # Notify clients about resource list changes
     def notify_resource_list_changed
       return unless @client_initialized
@@ -470,10 +436,10 @@ module MCP
     def send_response(response)
       if @transport
         @logger.info("Sending response: #{response.inspect}")
-        @logger.info("Transport: #{@transport.inspect}")
         @transport.send_message(response)
       else
         @logger.warn("No transport available to send response: #{response.inspect}")
+        @logger.warn("Transport: #{@transport.inspect}, transport_klass: #{@transport_klass.inspect}")
       end
     end
 

data/lib/mcp/tool.rb

@@ -62,12 +62,14 @@ module Dry
   end
 end
 
-module MCP
+module FastMcp
   # Main Tool class that represents an MCP Tool
   class Tool
     class InvalidArgumentsError < StandardError; end
 
     class << self
+      attr_accessor :server
+
       def arguments(&block)
         @input_schema = Dry::Schema.JSON(&block)
       end
@@ -100,6 +102,10 @@ module MCP
       end
     end
 
+    def notify_resource_updated(uri)
+      self.class.server.notify_resource_updated(uri)
+    end
+
     def call_with_schema_validation!(**args)
       arg_validation = self.class.input_schema.call(args)
       raise InvalidArgumentsError, arg_validation.errors.to_h.to_json if arg_validation.errors.any?
@@ -788,7 +794,7 @@ module MCP
 end
 
 # Example
-# class ExampleTool < MCP::Tool
+# class ExampleTool < FastMcp::Tool
 #   description 'An example tool'
 
 #   arguments do

data/lib/mcp/transports/authenticated_rack_transport.rb

@@ -2,10 +2,10 @@
 
 require_relative 'rack_transport'
 
-module MCP
+module FastMcp
   module Transports
     class AuthenticatedRackTransport < RackTransport
-      def initialize(server, app, options = {})
+      def initialize(app, server, options = {})
         super
 
         @auth_token = options[:auth_token]

data/lib/mcp/transports/base_transport.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module MCP
+module FastMcp
   module Transports
     # Base class for all MCP transports
     # This defines the interface that all transports must implement