actionmcp 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1183f05df43cca3948c84aa105f6e38c5f7cd414c1b38619cfb6c9afa528d442
-  data.tar.gz: 02bdfed4f0a3b26d04203430c4b62183c615fb0a47a3b28d281b42f07928e5a8
+  metadata.gz: 6c2f845436205ecdf42bff99aa7e2d8557f715f943dfdf787d138ef1791e150c
+  data.tar.gz: dd4487fec77766938bc440b238b74fe12719b378d408bc9835ca4b443fe232e2
 SHA512:
-  metadata.gz: 77b9a85435b5e19a35268db9fbcc3139222c01abc7c67e5af61a44a460d55fe5ec6b9819209fa8bfd493a3d0c648ba7d7fa5c440f889871556880f5f961a1da0
-  data.tar.gz: e77783308752dbbe95498ca9d3548471b44bafbfe72a130f6e070c906220eeeecd48fb8d719f150d2f69a14a416d7f0cba19c3fd33b6479eab54f564633eed73
+  metadata.gz: 2b04ab72e098936f9395e20b7cfa51372855b7020682e41f775f437da58009798ae6848584c88b9313d965fb576cda2a02c207847bad4d8b47c117c3ca9a91bb
+  data.tar.gz: f66a011bbd7b0fc1eeda252a73d27867b9dd44a7c400ec3caa980ba0008a27e5fb68928e74e0cd1f29202326bb8ee3928f20d48b28d26348c94a36429b8b6559

data/README.md

@@ -1,7 +1,9 @@
 # ActionMCP
 
 **ActionMCP** is a Ruby gem that provides essential tooling for building Model Context Protocol (MCP) capable servers. 
+
 It offers base classes and helpers for creating MCP applications, making it easier to integrate your Ruby/Rails application with the MCP standard. 
+
 With ActionMCP, you can focus on your app's logic while it handles the boilerplate for MCP compliance.
 
 ## Introduction
@@ -44,6 +46,80 @@ ActionMCP provides three core abstractions to streamline MCP server development:
 These correspond to key MCP concepts and let you define what context or capabilities your server exposes to LLMs. 
 Below is an overview of each component and how you might use it:
 
+### Configuration
+ActionMCP is configured via config.action_mcp in your Rails application. 
+By default, the name is set to your application's name and the version defaults to "0.0.1". 
+You can override these settings in your configuration (e.g., in config/application.rb):
+```ruby
+module Tron
+  class Application < Rails::Application
+    config.action_mcp.name = "Friendly MCP (Master Control Program)"  # defaults to Rails.application.name
+    config.action_mcp.version = "1.2.3"                 # defaults to "0.0.1"
+    config.action_mcp.logging_enabled = true            # defaults to true
+  end
+end
+```
+For dynamic versioning, consider adding the rails_app_version gem.
+
+## Generators
+
+ActionMCP includes Rails generators to help you quickly set up your MCP server components. You can generate the base classes for your MCP Prompt and Tool using the following commands.
+
+To generate both the ApplicationPrompt and ApplicationTool files in your application, run:
+
+```bash
+bin/rails generate action_mcp:install 
+```
+
+This command will create:
+•	app/prompts/application_prompt.rb
+•	app/tools/application_tool.rb
+
+### Generate a New Prompt
+
+Run the following command to generate a new prompt class:
+
+```bash
+bin/rails generate action_mcp:prompt AnalyzeCode
+```
+This command will create a file at app/prompts/analyze_code_prompt.rb with content similar to:
+
+```ruby
+class AnalyzeCodePrompt < ApplicationPrompt
+  # Override the prompt_name (otherwise we'd get "analyze-code")
+  prompt_name "analyze-code"
+
+  # Provide a user-facing description for your prompt.
+  description "Analyze code for potential improvements"
+
+  # Configure arguments via the new DSL
+  argument :language, description: "Programming language", default: "Ruby"
+  argument :code, description: "Code to explain", required: true
+
+  # Add validations (note: "Ruby" is not allowed per the validation)
+  validates :language, inclusion: { in: %w[C Cobol FORTRAN] }
+end
+```
+
+## Generate a New Tool
+Similarly, run the following command to generate a new tool class:
+
+```bash
+bin/rails generate action_mcp:tool CalculateSum
+```
+
+This command will create a file at app/tools/calculate_sum_tool.rb with content similar to:
+
+```ruby
+class CalculateSumTool < ApplicationTool
+  tool_name "calculate-sum"
+  description "Calculate the sum of two numbers"
+
+  property :a, type: "number", description: "First number", required: true
+  property :b, type: "number", description: "Second number", required: true
+end
+```
+
 ### ActionMCP::Prompt
 
 Make Rails Say Sexy stuff 

data/lib/action_mcp/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Configuration class to hold settings for the ActionMCP server.
+  class Configuration
+    attr_accessor :name, :version, :logging_enabled
+
+    def initialize
+      # Use Rails.application values if available, or fallback to defaults.
+      @name = defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:name) ? Rails.application.name : "ActionMCP"
+      @version = defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:version) ? Rails.application.version.to_s.presence : "0.0.1"
+      @logging_enabled = true
+    end
+  end
+end

data/lib/action_mcp/content.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Content
     extend ActiveSupport::Autoload

data/lib/action_mcp/gem_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   # Returns the currently loaded version of Active MCP as a +Gem::Version+.
   def self.gem_version

data/lib/action_mcp/json_rpc/notification.rb

@@ -2,19 +2,19 @@
 
 module ActionMCP
   module JsonRpc
-  Notification = Data.define(:method, :params) do
-    def initialize(method:, params: nil)
-      super(method: method, params: params)
-    end
+    Notification = Data.define(:method, :params) do
+      def initialize(method:, params: nil)
+        super(method: method, params: params)
+      end
 
-    def to_h
-      hash = {
-        jsonrpc: "2.0",
-        method: method
-      }
-      hash[:params] = params if params
-      hash
+      def to_h
+        hash = {
+          jsonrpc: "2.0",
+          method: method
+        }
+        hash[:params] = params if params
+        hash
+      end
     end
   end
-  end
 end

data/lib/action_mcp/json_rpc/request.rb

@@ -2,21 +2,21 @@
 
 module ActionMCP
   module JsonRpc
-      Request = Data.define(:jsonrpc, :id, :method, :params) do
-        def initialize(id:, method:, params: nil)
-          validate_id(id)
-          super(id: id, method: method, params: params)
-        end
+    Request = Data.define(:jsonrpc, :id, :method, :params) do
+      def initialize(id:, method:, params: nil)
+        validate_id(id)
+        super(id: id, method: method, params: params)
+      end
 
-        def to_h
-          hash = {
-            jsonrpc: "2.0",
-            id: id,
-            method: method
-          }
-          hash[:params] = params if params
-          hash
-        end
+      def to_h
+        hash = {
+          jsonrpc: "2.0",
+          id: id,
+          method: method
+        }
+        hash[:params] = params if params
+        hash
       end
+    end
   end
 end

data/lib/action_mcp/json_rpc/response.rb

@@ -2,52 +2,52 @@
 
 module ActionMCP
   module JsonRpc
-  Response = Data.define(:id, :result, :error) do
-    def initialize(id:, result: nil, error: nil)
-      processed_error = process_error(error)
-      processed_result = error ? nil : result
-      validate_result_error!(processed_result, processed_error)
-      super(id: id, result: processed_result, error: processed_error)
-    end
+    Response = Data.define(:id, :result, :error) do
+      def initialize(id:, result: nil, error: nil)
+        processed_error = process_error(error)
+        processed_result = error ? nil : result
+        validate_result_error!(processed_result, processed_error)
+        super(id: id, result: processed_result, error: processed_error)
+      end
 
-    def to_h
-      hash = {
-        jsonrpc: "2.0",
-        id: id
-      }
-      if error
-        hash[:error] = {
-          code: error[:code],
-          message: error[:message]
+      def to_h
+        hash = {
+          jsonrpc: "2.0",
+          id: id
         }
-        hash[:error][:data] = error[:data] if error[:data]
-      else
-        hash[:result] = result
+        if error
+          hash[:error] = {
+            code: error[:code],
+            message: error[:message]
+          }
+          hash[:error][:data] = error[:data] if error[:data]
+        else
+          hash[:result] = result
+        end
+        hash
       end
-      hash
-    end
 
-    private
+      private
 
-    def process_error(error)
-      case error
-      when Symbol
-        ErrorCodes[error]
-      when Hash
-        validate_error!(error)
-        error
+      def process_error(error)
+        case error
+        when Symbol
+          ErrorCodes[error]
+        when Hash
+          validate_error!(error)
+          error
+        end
       end
-    end
 
-    def validate_error!(error)
-      raise Error, "Error code must be an integer" unless error[:code].is_a?(Integer)
-      raise Error, "Error message is required" unless error[:message].is_a?(String)
-    end
+      def validate_error!(error)
+        raise Error, "Error code must be an integer" unless error[:code].is_a?(Integer)
+        raise Error, "Error message is required" unless error[:message].is_a?(String)
+      end
 
-    def validate_result_error!(result, error)
-      raise Error, "Either result or error must be set" unless result || error
-      raise Error, "Cannot set both result and error" if result && error
+      def validate_result_error!(result, error)
+        raise Error, "Either result or error must be set" unless result || error
+        raise Error, "Cannot set both result and error" if result && error
+      end
     end
   end
-  end
 end

data/lib/action_mcp/prompt.rb

@@ -15,7 +15,8 @@ module ActionMCP
     def self.inherited(subclass)
       super
       return if subclass == Prompt
-      return if "ApplicationPrompt" == subclass.name
+      return if subclass.name == "ApplicationPrompt"
+
       subclass.abstract_prompt = false
 
       # Automatically register the subclass with the PromptsRegistry
@@ -28,7 +29,7 @@ module ActionMCP
     end
 
     def self.abstract?
-      self.abstract_prompt
+      abstract_prompt
     end
 
     # ---------------------------------------------------
@@ -102,7 +103,7 @@ module ActionMCP
     #   ActionMCP::JsonRpc::JsonRpcError(:invalid_params) if validation fails.
     #
     def self.call(params)
-      prompt = new(params)  # Initialize an instance with provided params
+      prompt = new(params) # Initialize an instance with provided params
       unless prompt.valid?
         # Collect all validation errors into a single string or array
         errors_str = prompt.errors.full_messages.join(", ")

data/lib/action_mcp/prompts_registry.rb

@@ -3,8 +3,8 @@
 module ActionMCP
   class PromptsRegistry < RegistryBase
     class << self
-      alias_method :prompts, :items
-      alias_method :available_prompts, :enabled
+      alias prompts items
+      alias available_prompts enabled
     end
   end
 end

data/lib/action_mcp/railtie.rb

@@ -1,9 +1,22 @@
+# frozen_string_literal: true
+
 require "rails"
 require "active_model/railtie"
 
 module ActionMCP
   class Railtie < Rails::Railtie # :nodoc:
-    # TODO: fix this to be a proper railtie if you going to to opensource it
+    # Provide a configuration namespace for ActionMCP
+    config.action_mcp = ActiveSupport::OrderedOptions.new
+
+    config.after_initialize do |app|
+      options = app.config.action_mcp.to_h.symbolize_keys
+
+      # Override the default configuration if specified in the Rails app.
+      ActionMCP.configuration.name = options[:name] if options.key?(:name)
+      ActionMCP.configuration.version = options[:version] if options.key?(:version)
+      ActionMCP.configuration.logging_enabled = options.fetch(:logging_enabled, true)
+    end
+
     initializer "action_mcp.clear_registry" do |app|
       app.config.to_prepare do
         ActionMCP::ToolsRegistry.clear!

data/lib/action_mcp/resources_bank.rb

@@ -38,17 +38,17 @@ module ActionMCP
       def register_source(source_uri, path, watch: false)
         reload_source(source_uri, path) # Initial load
 
-        if watch
-          require "active_support/evented_file_update_checker"
-          # Watch all files under the given path (recursive)
-          file_paths = Dir.glob("#{path}/**/*")
-          watcher = ActiveSupport::EventedFileUpdateChecker.new(file_paths) do |modified, added, removed|
-            Rails.logger.info("Files changed in #{path} - Modified: #{modified.inspect}, Added: #{added.inspect}, Removed: #{removed.inspect}")
-            # Reload resources for this source when changes occur.
-            reload_source(source_uri, path)
-          end
-          @watchers[source_uri] = { path: path, watcher: watcher }
+        return unless watch
+
+        require "active_support/evented_file_update_checker"
+        # Watch all files under the given path (recursive)
+        file_paths = Dir.glob("#{path}/**/*")
+        watcher = ActiveSupport::EventedFileUpdateChecker.new(file_paths) do |modified, added, removed|
+          Rails.logger.info("Files changed in #{path} - Modified: #{modified.inspect}, Added: #{added.inspect}, Removed: #{removed.inspect}")
+          # Reload resources for this source when changes occur.
+          reload_source(source_uri, path)
         end
+        @watchers[source_uri] = { path: path, watcher: watcher }
       end
 
       # Unregisters a source and stops watching it.
@@ -68,6 +68,7 @@ module ActionMCP
         Rails.logger.info("Reloading resources from #{path} for #{source_uri}")
         Dir.glob("#{path}/**/*").each do |file|
           next unless File.file?(file)
+
           # Create a resource URI from the source and file path.
           relative_path = file.sub(%r{\A#{Regexp.escape(path)}/?}, "")
           resource_uri = "#{source_uri}://#{relative_path}"

data/lib/action_mcp/tool.rb

@@ -16,8 +16,9 @@ module ActionMCP
     def self.inherited(subclass)
       super
       return if subclass == Tool
+
       subclass.abstract_tool = false
-      return if "ApplicationTool" == subclass.name
+      return if subclass.name == "ApplicationTool"
 
       ToolsRegistry.register(subclass.tool_name, subclass)
     end
@@ -25,11 +26,11 @@ module ActionMCP
     # Mark this tool as abstract so it won’t be available for use.
     def self.abstract!
       self.abstract_tool = true
-      ToolsRegistry.unregister(self.tool_name) if ToolsRegistry.items.key?(self.tool_name)
+      ToolsRegistry.unregister(tool_name) if ToolsRegistry.items.key?(tool_name)
     end
 
     def self.abstract?
-      self.abstract_tool
+      abstract_tool
     end
 
     # ---------------------------------------------------
@@ -66,7 +67,7 @@ module ActionMCP
 
       self._schema_properties = _schema_properties.merge(prop_name.to_s => prop_definition)
       self._required_properties = _required_properties.dup
-      self._required_properties << prop_name.to_s if required
+      _required_properties << prop_name.to_s if required
 
       # Map our DSL type to an ActiveModel attribute type.
       am_type = case type.to_s
@@ -92,7 +93,7 @@ module ActionMCP
     #      property :file, required: true, description: 'file uri'
     #      property :checksum, required: true, description: 'checksum to verify'
     #    end
-    def self.collection(prop_name, type: nil, description: nil, required: false, default: nil, **opts, &block)
+    def self.collection(prop_name, type: nil, description: nil, required: false, default: nil, **_opts, &block)
       if block_given?
         # Build nested schema for an object.
         nested_schema = { type: "object", properties: {}, required: [] }
@@ -101,12 +102,13 @@ module ActionMCP
         collection_definition = { type: "array", description: description, items: nested_schema }
       else
         raise ArgumentError, "Type is required for a collection without a block" if type.nil?
+
         collection_definition = { type: "array", description: description, items: { type: type } }
       end
 
       self._schema_properties = _schema_properties.merge(prop_name.to_s => collection_definition)
       self._required_properties = _required_properties.dup
-      self._required_properties << prop_name.to_s if required
+      _required_properties << prop_name.to_s if required
 
       # Register the property as an attribute.
       # (Mapping for a collection can be customized; here we use :string to mimic previous behavior.)
@@ -135,11 +137,11 @@ module ActionMCP
     # Convert Tool Definition to Hash
     # ---------------------------------------------------
     def self.to_h
-      schema = { type: "object", properties: self._schema_properties }
-      schema[:required] = self._required_properties if self._required_properties.any?
+      schema = { type: "object", properties: _schema_properties }
+      schema[:required] = _required_properties if _required_properties.any?
       {
-        name: self.tool_name,
-        description: self.description.presence,
+        name: tool_name,
+        description: description.presence,
         inputSchema: schema
       }.compact
     end

data/lib/action_mcp/tools_registry.rb

@@ -5,8 +5,8 @@
 module ActionMCP
   class ToolsRegistry < RegistryBase
     class << self
-      alias_method :tools, :items
-      alias_method :available_tools, :enabled
+      alias tools items
+      alias available_tools enabled
     end
   end
 end

data/lib/action_mcp/transport.rb

@@ -14,17 +14,24 @@ module ActionMCP
     #
     # @param request_id [String, Integer] The request identifier.
     def send_capabilities(request_id)
+      capabilities = {}
+
+      # Only include each capability if the corresponding registry is non-empty.
+      capabilities[:tools] = { listChanged: true } if ActionMCP::ToolsRegistry.available_tools.any?
+
+      capabilities[:prompts] = { listChanged: true } if ActionMCP::PromptsRegistry.available_prompts.any?
+
+      capabilities[:resources] = { listChanged: true } if ActionMCP::ResourcesBank.all_resources.any?
+
+      # Add logging capability only if enabled by configuration.
+      capabilities[:logging] = {} if ActionMCP.configuration.logging_enabled
+
       payload = {
         protocolVersion: "2024-11-05",
-        capabilities: {
-          tools: { listChanged: true },
-          prompts: { listChanged: true },
-          resources: { listChanged: true },
-          logging: {}
-        },
+        capabilities: capabilities,
         serverInfo: {
-          name: Rails.application.name,
-          version: Rails.application.version.to_s
+          name: ActionMCP.configuration.name,
+          version: ActionMCP.configuration.version
         }
       }
       send_jsonrpc_response(request_id, result: payload)
@@ -42,38 +49,34 @@ module ActionMCP
     #
     # @param request_id [String, Integer] The request identifier.
     def send_resources_list(request_id)
-      begin
-        resources = ActionMCP::ResourcesRegistry.all_resources  # fetch all resources
-        result_data = { "resources" => resources }
-        send_jsonrpc_response(request_id, result: result_data)
-        Rails.logger.info("resources/list: Returned #{resources.size} resources.")
-      rescue StandardError => e
-        Rails.logger.error("resources/list failed: #{e.message}")
-        error_obj = JsonRpcError.new(
-          :internal_error,
-          message: "Failed to list resources: #{e.message}"
-        ).as_json
-        send_jsonrpc_response(request_id, error: error_obj)
-      end
+      resources = ActionMCP::ResourcesBank.all_resources # fetch all resources
+      result_data = { "resources" => resources }
+      send_jsonrpc_response(request_id, result: result_data)
+      Rails.logger.info("resources/list: Returned #{resources.size} resources.")
+    rescue StandardError => e
+      Rails.logger.error("resources/list failed: #{e.message}")
+      error_obj = JsonRpcError.new(
+        :internal_error,
+        message: "Failed to list resources: #{e.message}"
+      ).as_json
+      send_jsonrpc_response(request_id, error: error_obj)
     end
 
     # Sends the resource templates list JSON-RPC response.
     #
     # @param request_id [String, Integer] The request identifier.
     def send_resource_templates_list(request_id)
-      begin
-        templates = ActionMCP::ResourcesRegistry.all_templates  # get all resource templates
-        result_data = { "resourceTemplates" => templates }
-        send_jsonrpc_response(request_id, result: result_data)
-        Rails.logger.info("resources/templates/list: Returned #{templates.size} resource templates.")
-      rescue StandardError => e
-        Rails.logger.error("resources/templates/list failed: #{e.message}")
-        error_obj = JsonRpcError.new(
-          :internal_error,
-          message: "Failed to list resource templates: #{e.message}"
-        ).as_json
-        send_jsonrpc_response(request_id, error: error_obj)
-      end
+      templates = ActionMCP::ResourcesBank.all_templates # get all resource templates
+      result_data = { "resourceTemplates" => templates }
+      send_jsonrpc_response(request_id, result: result_data)
+      Rails.logger.info("resources/templates/list: Returned #{templates.size} resource templates.")
+    rescue StandardError => e
+      Rails.logger.error("resources/templates/list failed: #{e.message}")
+      error_obj = JsonRpcError.new(
+        :internal_error,
+        message: "Failed to list resource templates: #{e.message}"
+      ).as_json
+      send_jsonrpc_response(request_id, error: error_obj)
     end
 
     # Sends the resource read JSON-RPC response.
@@ -92,7 +95,7 @@ module ActionMCP
       end
 
       begin
-        content = ActionMCP::ResourcesRegistry.read(uri)  # Expecting an instance of an ActionMCP::Content subclass
+        content = ActionMCP::ResourcesBank.read(uri) # Expecting an instance of an ActionMCP::Content subclass
         if content.nil?
           Rails.logger.error("resources/read: Resource not found for URI #{uri}")
           error_obj = JsonRpcError.new(
@@ -119,42 +122,37 @@ module ActionMCP
       end
     end
 
-
     # Sends a call to a tool. Currently logs the call details.
     #
     # @param request_id [String, Integer] The request identifier.
     # @param tool_name [String] The name of the tool.
     # @param params [Hash] The parameters for the tool.
     def send_tools_call(request_id, tool_name, params)
-      begin
-        tool = ActionMCP::ToolsRegistry.fetch_available_tool(tool_name.to_s)
-        Rails.logger.info("Sending tool call: #{tool_name} with params: #{params}")
-        # TODO: Implement tool call handling and response if needed.
-      rescue StandardError => e
-        Rails.logger.error("tools/call: Failed to call tool #{tool_name} - #{e.message}")
-        error_obj = JsonRpcError.new(
-          :internal_error,
-          message: "Failed to call tool #{tool_name}: #{e.message}"
-        ).as_json
-        send_jsonrpc_response(request_id, error: error_obj)
-      end
+      ActionMCP::ToolsRegistry.fetch_available_tool(tool_name.to_s)
+      Rails.logger.info("Sending tool call: #{tool_name} with params: #{params}")
+      # TODO: Implement tool call handling and response if needed.
+    rescue StandardError => e
+      Rails.logger.error("tools/call: Failed to call tool #{tool_name} - #{e.message}")
+      error_obj = JsonRpcError.new(
+        :internal_error,
+        message: "Failed to call tool #{tool_name}: #{e.message}"
+      ).as_json
+      send_jsonrpc_response(request_id, error: error_obj)
     end
 
     # Sends the prompts list JSON-RPC notification.
     #
     # @param request_id [String, Integer] The request identifier.
     def send_prompts_list(request_id)
-      begin
-        prompts = format_registry_items(ActionMCP::PromptsRegistry.available_prompts)
-        send_jsonrpc_response(request_id, result: {prompts: prompts} )
-      rescue StandardError => e
-        Rails.logger.error("prompts/list failed: #{e.message}")
-        error_obj = JsonRpcError.new(
-          :internal_error,
-          message: "Failed to list prompts: #{e.message}"
-        ).as_json
-        send_jsonrpc_response(request_id, error: error_obj)
-      end
+      prompts = format_registry_items(ActionMCP::PromptsRegistry.available_prompts)
+      send_jsonrpc_response(request_id, result: { prompts: prompts })
+    rescue StandardError => e
+      Rails.logger.error("prompts/list failed: #{e.message}")
+      error_obj = JsonRpcError.new(
+        :internal_error,
+        message: "Failed to list prompts: #{e.message}"
+      ).as_json
+      send_jsonrpc_response(request_id, error: error_obj)
     end
 
     def send_prompts_get(request_id, params)
@@ -193,7 +191,6 @@ module ActionMCP
       end
     end
 
-
     # Sends a JSON-RPC pong response.
     # We don't actually to send any data back because the spec are not fun anymore.
     #

data/lib/action_mcp/version.rb

@@ -3,7 +3,7 @@
 require_relative "gem_version"
 
 module ActionMCP
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
   # Returns the currently loaded version of Active MCP as a +Gem::Version+.
   def self.version
     gem_version

data/lib/action_mcp.rb

@@ -19,8 +19,21 @@ module ActionMCP
   autoload :Tool
   autoload :Prompt
   autoload :JsonRpc
+  eager_autoload do
+    autoload :Configuration
+  end
+
+  # Accessor for the configuration instance.
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
 
   module_function
+
   def tools
     ToolsRegistry.tools
   end

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

@@ -0,0 +1,16 @@
+module ActionMCP
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      namespace "action_mcp:install"
+      source_root File.expand_path("templates", __dir__)
+      desc "Installs both ApplicationPrompt and ApplicationTool"
+      def create_application_prompt
+        template "application_prompt.rb", "app/prompts/application_prompt.rb"
+      end
+
+      def create_application_tool
+        template "application_tool.rb", "app/tools/application_tool.rb"
+      end
+    end
+  end
+end

data/lib/generators/action_mcp/install/templates/application_prompt.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationPrompt < ActionMCP::Prompt
+  abstract!
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationTool < ActionMCP::Tool
+  abstract!
+end

data/lib/generators/action_mcp/prompt/prompt_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Generators
+    class PromptGenerator < Rails::Generators::Base
+      namespace "action_mcp:prompt"
+      source_root File.expand_path("templates", __dir__)
+      desc "Creates a Prompt (in app/prompts) that inherits from ApplicationPrompt"
+
+      # The generator takes one argument, e.g. "AnalyzeCode"
+      argument :name, type: :string, required: true, banner: "PromptName"
+
+      def create_prompt_file
+        template "prompt.rb.erb", "app/prompts/#{file_name}.rb"
+      end
+
+      private
+
+      # Build the class name, ensuring it ends with "Prompt"
+      def class_name
+        "#{name.camelize}#{name.camelize.end_with?('Prompt') ? '' : 'Prompt'}"
+      end
+
+      # Build the file name (underscore and ensure it ends with _prompt)
+      def file_name
+        base = name.underscore
+        base.end_with?("_prompt") ? base : "#{base}_prompt"
+      end
+
+      # Build the DSL prompt name (a dashed version, without the "Prompt" suffix)
+      def prompt_name
+        base = name.to_s
+        base = base[0...-6] if base.end_with?("Prompt")
+        base.underscore.dasherize
+      end
+    end
+  end
+end

data/lib/generators/action_mcp/prompt/templates/prompt.rb.erb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class <%= class_name %> < ApplicationPrompt
+  prompt_name "<%= prompt_name %>"
+
+  # Provide a user-facing description for your prompt.
+  description "Analyze code for potential improvements"
+
+  # Configure arguments via the new DSL
+  argument :language, description: "Programming language", default: "Ruby"
+  argument :code, description: "Code to explain", required: true
+
+  # Add validations (note: "Ruby" is not allowed per the validation)
+  validates :language, inclusion: { in: %w[Ruby C Cobol FORTRAN] }
+
+  def call
+    # Implement your prompt's behavior here
+  end
+end

data/lib/generators/action_mcp/tool/templates/tool.rb.erb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class <%= class_name %> < ApplicationTool
+  tool_name "<%= tool_name %>"
+  description "Calculate the sum of two numbers"
+
+  property :a, type: "number", description: "First number", required: true
+  property :b, type: "number", description: "Second number", required: true
+
+  def call
+    a + b
+  end
+end

data/lib/generators/action_mcp/tool/tool_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Generators
+    class ToolGenerator < Rails::Generators::Base
+      namespace "action_mcp:tool"
+      source_root File.expand_path("templates", __dir__)
+      desc "Creates a Tool (in app/tools) that inherits from ApplicationTool"
+
+      # The generator takes one argument, e.g. "CalculateSum"
+      argument :name, type: :string, required: true, banner: "ToolName"
+
+      def create_tool_file
+        template "tool.rb.erb", "app/tools/#{file_name}.rb"
+      end
+
+      private
+
+      # Compute the class name ensuring it ends with "Tool"
+      def class_name
+        "#{name.camelize}#{name.camelize.end_with?('Tool') ? '' : 'Tool'}"
+      end
+
+      # Compute the file name ensuring it ends with _tool.rb
+      def file_name
+        base = name.underscore
+        base.end_with?("_tool") ? base : "#{base}_tool"
+      end
+
+      # Compute the DSL tool name (a dashed version, without the "Tool" suffix)
+      def tool_name
+        base = name.to_s
+        base = base[0...-4] if base.end_with?("Tool")
+        base.underscore.dasherize
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -65,6 +65,7 @@ files:
 - Rakefile
 - exe/action_mcp_stdio
 - lib/action_mcp.rb
+- lib/action_mcp/configuration.rb
 - lib/action_mcp/content.rb
 - lib/action_mcp/content/audio.rb
 - lib/action_mcp/content/image.rb
@@ -88,6 +89,13 @@ files:
 - lib/action_mcp/transport.rb
 - lib/action_mcp/version.rb
 - lib/actionmcp.rb
+- lib/generators/action_mcp/install/install_generator.rb
+- lib/generators/action_mcp/install/templates/application_prompt.rb
+- lib/generators/action_mcp/install/templates/application_tool.rb
+- lib/generators/action_mcp/prompt/prompt_generator.rb
+- lib/generators/action_mcp/prompt/templates/prompt.rb.erb
+- lib/generators/action_mcp/tool/templates/tool.rb.erb
+- lib/generators/action_mcp/tool/tool_generator.rb
 - lib/tasks/action_mcp_tasks.rake
 homepage: https://github.com/seuros/action_mcp
 licenses: