actionmcp 0.32.1 → 0.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54b807ad23c23796ef5495fb91afffb9ee10d998516a72d20897c519bed56c4c
-  data.tar.gz: e5ec996f8e8dcb73383de34fe5f851382961a74a27e3b28c26271aadb343c30f
+  metadata.gz: 49bbf32664efb30dff032e7ab8ff3e76d972016cc7cf1a1a966c61cc507d7680
+  data.tar.gz: 61182b5e6367ecbbe7db4446a8da8a7ae756dd164e6b302a99f5583be64b3c8c
 SHA512:
-  metadata.gz: 55938823b5df5d13b8ffe2adbb9e581331e60fabb2f7111807fa10b119cd898f2ab3dd695cbda8924af0b9be79cf9eb0767b18324a1042ac46fb4facb6562abe
-  data.tar.gz: 76c6c5a553e55f06b61165844a3d55e45854dffe515879f14eaaf5b1399aa8f3273563b3c78cf028bab54547cc3165947cd5e2606e19f96be55285c845c641ef
+  metadata.gz: c2eac5bcb5a430ae67223000f3741f15acf4d6e1fbdd9d9f240640768d4da6e9b62d2ca0ec303be327ae818f1af86ad458b22e30fed6312cb710d02710532b8c
+  data.tar.gz: a39eb66c2dd002fd821c2db65b3f848c2a68e5d219d46efb0736d5501572235021be2d188cffd6783a14d8e0704737f313f9f225c2542c2d5ca047af08b9193e

data/README.md

@@ -221,9 +221,136 @@ end
 
 For dynamic versioning, consider adding the `rails_app_version` gem.
 
+### PubSub Configuration
+
+ActionMCP uses a pub/sub system for real-time communication. You can choose between several adapters:
+
+1. **SolidCable** - Database-backed pub/sub (no Redis required)
+2. **Simple** - In-memory pub/sub for development and testing
+3. **Redis** - Redis-backed pub/sub (if you prefer Redis)
+
+#### Migrating from ActionCable
+
+If you were previously using ActionCable with ActionMCP, you will need to migrate to the new PubSub system. Here's how:
+
+1. Remove the ActionCable dependency from your Gemfile (if you don't need it for other purposes)
+2. Install one of the PubSub adapters (SolidCable recommended)
+3. Create a configuration file at `config/mcp.yml` (you can use the generator: `bin/rails g action_mcp:config`)
+4. Run your tests to ensure everything works correctly
+
+The new PubSub system maintains the same API as the previous ActionCable-based implementation, so your existing code should continue to work without changes.
+
+Configure your adapter in `config/mcp.yml`:
+
+```yaml
+development:
+  adapter: solid_cable
+  polling_interval: 0.1.seconds
+  # Thread pool configuration (optional)
+  # min_threads: 5     # Minimum number of threads in the pool
+  # max_threads: 10    # Maximum number of threads in the pool
+  # max_queue: 100     # Maximum number of tasks that can be queued
+
+test:
+  adapter: test    # Uses the simple in-memory adapter
+
+production:
+  adapter: solid_cable
+  polling_interval: 0.5.seconds
+  # Optional: connects_to: cable  # If using a separate database
+  
+  # Thread pool configuration for high-traffic environments
+  min_threads: 10     # Minimum number of threads in the pool
+  max_threads: 20     # Maximum number of threads in the pool
+  max_queue: 500      # Maximum number of tasks that can be queued
+```
+
+#### SolidCable (Database-backed, Recommended)
+
+For SolidCable, add it to your Gemfile:
+
+```ruby
+gem "solid_cable"  # Database-backed adapter (no Redis needed)
+```
+
+Then install it:
+
+```bash
+bundle install
+bin/rails solid_cable:install
+```
+
+The installer will create the necessary database migration. You'll need to configure it in your `config/mcp.yml`. You can create this file with `bin/rails g action_mcp:config`.
+
+#### Redis Adapter
+
+If you prefer Redis, add it to your Gemfile:
+
+```ruby
+gem "redis", "~> 5.0"
+```
+
+Then configure the Redis adapter in your `config/mcp.yml`:
+
+```yaml
+production:
+  adapter: redis
+  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  channel_prefix: your_app_production
+  
+  # Thread pool configuration for high-traffic environments
+  min_threads: 10     # Minimum number of threads in the pool
+  max_threads: 20     # Maximum number of threads in the pool
+  max_queue: 500      # Maximum number of tasks that can be queued
+```
+
+## Thread Pool Management
+
+ActionMCP uses thread pools to efficiently handle message callbacks. This prevents the system from being overwhelmed by too many threads under high load.
+
+### Thread Pool Configuration
+
+You can configure the thread pool in your `config/mcp.yml`:
+
+```yaml
+production:
+  adapter: solid_cable
+  # Thread pool configuration
+  min_threads: 10    # Minimum number of threads to keep in the pool
+  max_threads: 20    # Maximum number of threads the pool can grow to
+  max_queue: 500     # Maximum number of tasks that can be queued
+```
+
+The thread pool will automatically:
+- Start with `min_threads` threads
+- Scale up to `max_threads` as needed
+- Queue tasks up to `max_queue` limit
+- Use caller's thread if queue is full (fallback policy)
+
+### Graceful Shutdown
+
+When your application is shutting down, you should call:
+
+```ruby
+ActionMCP::Server.shutdown
+```
+
+This ensures all thread pools are properly terminated and tasks are completed.
+
 ## Engine and Mounting
 
-**ActionMCP** runs as a standalone Rack application, similar to **ActionCable**. It is **not** mounted in `routes.rb`.
+**ActionMCP** runs as a standalone Rack application. It is **not** mounted in `routes.rb`.
+
+### Installing the Configuration Generator
+
+ActionMCP includes a generator to help you create the configuration file:
+
+```bash
+# Generate the mcp.yml configuration file
+bin/rails generate action_mcp:config
+```
+
+This will create `config/mcp.yml` with example configurations for all environments.
 
 > **Note:** Authentication and authorization are not included. You are responsible for securing the endpoint.
 

data/lib/action_mcp/server/configuration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "erb"
+
+module ActionMCP
+  module Server
+    # Configuration loader for ActionMCP server
+    class Configuration
+      attr_reader :config
+
+      def initialize(config_path = nil)
+        @config_path = config_path || default_config_path
+        @config = load_config
+      end
+
+      # Get the configuration for the current environment
+      def for_env(env = nil)
+        environment = env || (defined?(Rails) ? Rails.env : "development")
+        config[environment] || config["development"] || {}
+      end
+
+      # Get the adapter name for the current environment
+      def adapter_name(env = nil)
+        env_config = for_env(env)
+        env_config["adapter"]
+      end
+
+      # Get the adapter options for the current environment
+      def adapter_options(env = nil)
+        env_config = for_env(env)
+        env_config.except("adapter")
+      end
+
+      private
+
+      def load_config
+        return {} unless File.exist?(@config_path.to_s)
+
+        yaml = ERB.new(File.read(@config_path)).result
+        YAML.safe_load(yaml, aliases: true) || {}
+      rescue => e
+        Rails.logger.error("Error loading ActionMCP config: #{e.message}") if defined?(Rails) && Rails.respond_to?(:logger)
+        {}
+      end
+
+      def default_config_path
+        return Rails.root.join("config", "mcp.yml") if defined?(Rails) && Rails.respond_to?(:root)
+
+        # Fallback to looking for a mcp.yml in the current directory or parent directories
+        path = Dir.pwd
+        while path != "/"
+          config_path = File.join(path, "config", "mcp.yml")
+          return config_path if File.exist?(config_path)
+          path = File.dirname(path)
+        end
+
+        # Default to an empty config if no mcp.yml found
+        nil
+      end
+    end
+  end
+end

data/lib/action_mcp/server/simple_pub_sub.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "concurrent/map"
+require "concurrent/array"
+require "concurrent/executor/thread_pool_executor"
+
+module ActionMCP
+  module Server
+    # Simple in-memory PubSub implementation for testing and development
+    class SimplePubSub
+      # Thread pool configuration
+      DEFAULT_MIN_THREADS = 5
+      DEFAULT_MAX_THREADS = 10
+      DEFAULT_MAX_QUEUE = 100
+      DEFAULT_THREAD_TIMEOUT = 60  # seconds
+
+      def initialize(options = {})
+        @subscriptions = Concurrent::Map.new
+        @channels = Concurrent::Map.new
+
+        # Initialize thread pool for callbacks
+        pool_options = {
+          min_threads: options["min_threads"] || DEFAULT_MIN_THREADS,
+          max_threads: options["max_threads"] || DEFAULT_MAX_THREADS,
+          max_queue: options["max_queue"] || DEFAULT_MAX_QUEUE,
+          fallback_policy: :caller_runs, # Execute in the caller's thread if queue is full
+          idletime: DEFAULT_THREAD_TIMEOUT
+        }
+        @thread_pool = Concurrent::ThreadPoolExecutor.new(pool_options)
+      end
+
+      # Subscribe to a channel
+      # @param channel [String] The channel name
+      # @param message_callback [Proc] Callback for received messages
+      # @param success_callback [Proc] Callback for successful subscription
+      # @return [String] Subscription ID
+      def subscribe(channel, message_callback, success_callback = nil)
+        subscription_id = SecureRandom.uuid
+
+        @subscriptions[subscription_id] = {
+          channel: channel,
+          message_callback: message_callback
+        }
+
+        @channels[channel] ||= Concurrent::Array.new
+        @channels[channel] << subscription_id
+
+        log_subscription_event(channel, "Subscribed", subscription_id)
+        success_callback&.call
+
+        subscription_id
+      end
+
+      # Check if we're already subscribed to a channel
+      # @param channel [String] The channel name
+      # @return [Boolean] True if we're already subscribed
+      def subscribed_to?(channel)
+        channel_subs = @channels[channel]
+        return false if channel_subs.nil?
+        !channel_subs.empty?
+      end
+
+      # Unsubscribe from a channel
+      # @param channel [String] The channel name
+      # @param callback [Proc] Optional callback for unsubscribe completion
+      def unsubscribe(channel, callback = nil)
+        # Remove our subscriptions
+        subscription_ids = @channels[channel] || []
+        subscription_ids.each do |subscription_id|
+          @subscriptions.delete(subscription_id)
+        end
+
+        @channels.delete(channel)
+
+        log_subscription_event(channel, "Unsubscribed")
+        callback&.call
+      end
+
+      # Broadcast a message to a channel
+      # @param channel [String] The channel name
+      # @param message [String] The message to broadcast
+      def broadcast(channel, message)
+        subscription_ids = @channels[channel] || []
+        return if subscription_ids.empty?
+
+        log_broadcast_event(channel, message)
+
+        subscription_ids.each do |subscription_id|
+          subscription = @subscriptions[subscription_id]
+          next unless subscription && subscription[:message_callback]
+
+          @thread_pool.post do
+            begin
+              subscription[:message_callback].call(message)
+            rescue StandardError => e
+              log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
+            end
+          end
+        end
+      end
+
+      # Check if a channel has subscribers
+      # @param channel [String] The channel name
+      # @return [Boolean] True if channel has subscribers
+      def has_subscribers?(channel)
+        subscribers = @channels[channel]
+        return false unless subscribers
+        !subscribers.empty?
+      end
+
+      # Shut down the thread pool gracefully
+      def shutdown
+        @thread_pool.shutdown
+        @thread_pool.wait_for_termination(5) # Wait up to 5 seconds for tasks to complete
+      end
+
+      private
+
+      def log_subscription_event(channel, action, subscription_id = nil)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+        message = "SimplePubSub: #{action} channel=#{channel}"
+        message += " subscription_id=#{subscription_id}" if subscription_id
+
+        Rails.logger.debug(message)
+      end
+
+      def log_broadcast_event(channel, message)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+        # Truncate the message for logging
+        truncated_message = message.to_s[0..100]
+        truncated_message += "..." if message.to_s.length > 100
+
+        Rails.logger.debug("SimplePubSub: Broadcasting to channel=#{channel} message=#{truncated_message}")
+      end
+
+      def log_error(message)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.error("SimplePubSub: #{message}")
+      end
+    end
+  end
+end

data/lib/action_mcp/server/solid_cable_adapter.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "concurrent/map"
+require "concurrent/array"
+require "concurrent/executor/thread_pool_executor"
+
+module ActionMCP
+  module Server
+    # Mock SolidCable::PubSub for testing
+    class MockSolidCablePubSub
+      attr_reader :subscriptions, :messages
+
+      def initialize(options = {})
+        @options = options
+        @subscriptions = Concurrent::Map.new
+        @messages = Concurrent::Array.new
+      end
+
+      def subscribe(channel, &block)
+        @subscriptions[channel] ||= Concurrent::Array.new
+        @subscriptions[channel] << block
+      end
+
+      def unsubscribe(channel)
+        @subscriptions.delete(channel)
+      end
+
+      def broadcast(channel, message)
+        @messages << { channel: channel, message: message }
+        callbacks = @subscriptions[channel] || []
+        callbacks.each { |callback| callback.call(message) }
+      end
+    end
+
+    # Adapter for SolidCable PubSub
+    class SolidCableAdapter
+      # Thread pool configuration
+      DEFAULT_MIN_THREADS = 5
+      DEFAULT_MAX_THREADS = 10
+      DEFAULT_MAX_QUEUE = 100
+      DEFAULT_THREAD_TIMEOUT = 60  # seconds
+
+      def initialize(options = {})
+        @options = options
+        @subscriptions = Concurrent::Map.new
+        @channels = Concurrent::Map.new
+        @channel_subscribed = Concurrent::Map.new  # Track channel subscription status
+
+        # Initialize thread pool for callbacks
+        pool_options = {
+          min_threads: options["min_threads"] || DEFAULT_MIN_THREADS,
+          max_threads: options["max_threads"] || DEFAULT_MAX_THREADS,
+          max_queue: options["max_queue"] || DEFAULT_MAX_QUEUE,
+          fallback_policy: :caller_runs, # Execute in the caller's thread if queue is full
+          idletime: DEFAULT_THREAD_TIMEOUT
+        }
+        @thread_pool = Concurrent::ThreadPoolExecutor.new(pool_options)
+
+        # Configure SolidCable with options from mcp.yml
+        # The main option we care about is polling_interval
+        pubsub_options = {}
+
+        if @options["polling_interval"]
+          # Convert from ActiveSupport::Duration if needed (e.g., "0.1.seconds")
+          interval = @options["polling_interval"]
+          interval = interval.to_f if interval.respond_to?(:to_f)
+          pubsub_options[:polling_interval] = interval
+        end
+
+        # If there's a connects_to option, pass it along
+        if @options["connects_to"]
+          pubsub_options[:connects_to] = @options["connects_to"]
+        end
+
+        # Use mock version for testing or real version in production
+        if defined?(SolidCable) && !testing?
+          @solid_cable_pubsub = SolidCable::PubSub.new(pubsub_options)
+        else
+          @solid_cable_pubsub = MockSolidCablePubSub.new(pubsub_options)
+        end
+      end
+
+      # Subscribe to a channel
+      # @param channel [String] The channel name
+      # @param message_callback [Proc] Callback for received messages
+      # @param success_callback [Proc] Callback for successful subscription
+      # @return [String] Subscription ID
+      def subscribe(channel, message_callback, success_callback = nil)
+        subscription_id = SecureRandom.uuid
+
+        @subscriptions[subscription_id] = {
+          channel: channel,
+          message_callback: message_callback
+        }
+
+        @channels[channel] ||= Concurrent::Array.new
+        @channels[channel] << subscription_id
+
+        # Subscribe to SolidCable only if we haven't already subscribed to this channel
+        unless subscribed_to_solid_cable?(channel)
+          @solid_cable_pubsub.subscribe(channel) do |message|
+            dispatch_message(channel, message)
+          end
+          @channel_subscribed[channel] = true
+        end
+
+        log_subscription_event(channel, "Subscribed", subscription_id)
+        success_callback&.call
+
+        subscription_id
+      end
+
+      # Unsubscribe from a channel
+      # @param channel [String] The channel name
+      # @param callback [Proc] Optional callback for unsubscribe completion
+      def unsubscribe(channel, callback = nil)
+        # Remove our subscriptions
+        subscription_ids = @channels[channel] || []
+        subscription_ids.each do |subscription_id|
+          @subscriptions.delete(subscription_id)
+        end
+
+        @channels.delete(channel)
+
+        # Only unsubscribe from SolidCable if we're actually subscribed
+        if subscribed_to_solid_cable?(channel)
+          @solid_cable_pubsub.unsubscribe(channel)
+          @channel_subscribed.delete(channel)
+        end
+
+        log_subscription_event(channel, "Unsubscribed")
+        callback&.call
+      end
+
+      # Broadcast a message to a channel
+      # @param channel [String] The channel name
+      # @param message [String] The message to broadcast
+      def broadcast(channel, message)
+        @solid_cable_pubsub.broadcast(channel, message)
+        log_broadcast_event(channel, message)
+      end
+
+      # Check if a channel has subscribers
+      # @param channel [String] The channel name
+      # @return [Boolean] True if channel has subscribers
+      def has_subscribers?(channel)
+        subscribers = @channels[channel]
+        return false unless subscribers
+        !subscribers.empty?
+      end
+
+      # Check if we're already subscribed to a channel
+      # @param channel [String] The channel name
+      # @return [Boolean] True if we're already subscribed
+      def subscribed_to?(channel)
+        channel_subs = @channels[channel]
+        return false if channel_subs.nil?
+        !channel_subs.empty?
+      end
+
+      # Shut down the thread pool gracefully
+      def shutdown
+        @thread_pool.shutdown
+        @thread_pool.wait_for_termination(5) # Wait up to 5 seconds for tasks to complete
+      end
+
+      private
+
+      # Check if we're in a testing environment
+      def testing?
+        defined?(Minitest) || ENV["RAILS_ENV"] == "test"
+      end
+
+      # Check if we're already subscribed to this channel in SolidCable
+      def subscribed_to_solid_cable?(channel)
+        @channel_subscribed[channel] == true
+      end
+
+      def dispatch_message(channel, message)
+        subscription_ids = @channels[channel] || []
+
+        subscription_ids.each do |subscription_id|
+          subscription = @subscriptions[subscription_id]
+          next unless subscription && subscription[:message_callback]
+
+          @thread_pool.post do
+            begin
+              subscription[:message_callback].call(message)
+            rescue StandardError => e
+              log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
+            end
+          end
+        end
+      end
+
+      def log_subscription_event(channel, action, subscription_id = nil)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+        message = "SolidCableAdapter: #{action} channel=#{channel}"
+        message += " subscription_id=#{subscription_id}" if subscription_id
+
+        Rails.logger.debug(message)
+      end
+
+      def log_broadcast_event(channel, message)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+        # Truncate the message for logging
+        truncated_message = message.to_s[0..100]
+        truncated_message += "..." if message.to_s.length > 100
+
+        Rails.logger.debug("SolidCableAdapter: Broadcasting to channel=#{channel} message=#{truncated_message}")
+      end
+
+      def log_error(message)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.error("SolidCableAdapter: #{message}")
+      end
+    end
+  end
+end

data/lib/action_mcp/server.rb

@@ -1,13 +1,95 @@
 # frozen_string_literal: true
 
-# TODO: move all server related code here before version 1.0.0
+require_relative "server/simple_pub_sub"
+require_relative "server/configuration"
+
+# Conditionally load adapters based on available gems
+begin
+  require "solid_cable/pubsub"
+  require_relative "server/solid_cable_adapter"
+rescue LoadError
+  # SolidCable not available
+end
+
 module ActionMCP
   # Module for server-related functionality.
   module Server
     module_function
 
     def server
-      @server ||= ActionCable::Server::Base.new
+      @server ||= ServerBase.new
+    end
+
+    # Shut down the server and clean up resources
+    def shutdown
+      return unless @server
+      @server.shutdown
+      @server = nil
+    end
+
+    # Available pubsub adapter types
+    ADAPTERS = {
+      "test" => "SimplePubSub",
+      "simple" => "SimplePubSub",
+      "solid_cable" => "SolidCableAdapter" # Will use mock version in tests
+    }.compact.freeze
+
+    # Custom server base class for PubSub functionality
+    class ServerBase
+      def initialize(config_path = nil)
+        @configuration = Configuration.new(config_path)
+      end
+
+      def pubsub
+        @pubsub ||= create_pubsub
+      end
+
+      # Allow manual override of the configuration
+      # @param config_path [String] Path to a cable.yml configuration file
+      def configure(config_path)
+        shutdown_pubsub if @pubsub
+        @configuration = Configuration.new(config_path)
+        @pubsub = nil  # Reset pubsub so it will be recreated with new config
+      end
+
+      # Gracefully shut down the server and its resources
+      def shutdown
+        shutdown_pubsub
+      end
+
+      private
+
+      # Shut down the pubsub adapter gracefully
+      def shutdown_pubsub
+        return unless @pubsub && @pubsub.respond_to?(:shutdown)
+
+        begin
+          @pubsub.shutdown
+        rescue => e
+          message = "Error shutting down pubsub adapter: #{e.message}"
+          Rails.logger.error(message) if defined?(Rails) && Rails.respond_to?(:logger)
+        ensure
+          @pubsub = nil
+        end
+      end
+
+      def create_pubsub
+        adapter_name = @configuration.adapter_name
+        adapter_options = @configuration.adapter_options
+
+        # Default to simple if adapter not found
+        adapter_class_name = ADAPTERS[adapter_name] || "SimplePubSub"
+
+        begin
+          # Create an instance of the adapter class with the configuration options
+          adapter_class = ActionMCP::Server.const_get(adapter_class_name)
+          adapter_class.new(adapter_options)
+        rescue NameError, LoadError => e
+          message = "Error creating adapter #{adapter_name}: #{e.message}"
+          Rails.logger.error(message) if defined?(Rails) && Rails.respond_to?(:logger)
+          SimplePubSub.new  # Fallback to simple pubsub
+        end
+      end
     end
   end
 end

data/lib/action_mcp/sse_listener.rb

@@ -4,7 +4,7 @@ require "concurrent/atomic/atomic_boolean"
 require "concurrent/promise"
 
 module ActionMCP
-  # Listener class to subscribe to session messages via Action Cable adapter.
+  # Listener class to subscribe to session messages via PubSub adapter.
   class SSEListener
     delegate :session_key, :adapter, to: :@session
 
@@ -15,7 +15,7 @@ module ActionMCP
       @subscription_active = Concurrent::AtomicBoolean.new
     end
 
-    # Start listening using ActionCable's adapter
+    # Start listening using PubSub adapter
     # @yield [Hash] Yields parsed message received from the pub/sub channel
     # @return [Boolean] True if subscription was successful within timeout, false otherwise.
     def start(&callback)
@@ -30,7 +30,7 @@ module ActionMCP
         process_message(raw_message, callback)
       }
 
-      # Subscribe using the ActionCable adapter
+      # Subscribe using the PubSub adapter
       adapter.subscribe(session_key, message_callback, success_callback)
 
       wait_for_subscription

data/lib/action_mcp/version.rb

@@ -2,7 +2,7 @@
 
 require_relative "gem_version"
 module ActionMCP
-  VERSION = "0.32.1"
+  VERSION = "0.33.0"
 
   class << self
     alias version gem_version

data/lib/generators/action_mcp/config/config_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates ActionMCP configuration file (config/mcp.yml)"
+
+      def create_mcp_yml
+        template "mcp.yml", "config/mcp.yml"
+      end
+
+      def show_instructions
+        say "ActionMCP configuration file created at config/mcp.yml"
+        say "You can customize your PubSub adapters and other settings in this file."
+        say ""
+        say "Available adapters:"
+        say "  - simple   : In-memory adapter for development"
+        say "  - test     : Test adapter"
+        say "  - solid_cable : Database-backed adapter (requires solid_cable gem)"
+        say "  - redis    : Redis-backed adapter (requires redis gem)"
+        say ""
+        say "Example usage:"
+        say "  rails g action_mcp:install  # Main generator"
+      end
+    end
+  end
+end

data/lib/generators/action_mcp/config/templates/mcp.yml

@@ -0,0 +1,36 @@
+# ActionMCP Configuration
+# This file contains configuration for the ActionMCP pub/sub system.
+# Different environments can use different adapters.
+
+development:
+  # In-memory adapter for development
+  adapter: simple
+  # Thread pool configuration (optional)
+  # min_threads: 5     # Minimum number of threads in the pool
+  # max_threads: 10    # Maximum number of threads in the pool
+  # max_queue: 100     # Maximum number of tasks that can be queued
+
+test:
+  # Test adapter for testing
+  adapter: test
+
+production:
+  # Choose one of the following adapters:
+  
+  # 1. Database-backed adapter (recommended)
+  adapter: solid_cable
+  polling_interval: 0.5.seconds
+  # connects_to: cable  # Optional: specify a different database connection
+  
+  # Thread pool configuration (optional)
+  min_threads: 10     # Minimum number of threads in the pool
+  max_threads: 20     # Maximum number of threads in the pool
+  max_queue: 500      # Maximum number of tasks that can be queued
+
+  # 2. Redis-backed adapter (alternative)
+  # adapter: redis
+  # url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
+  # channel_prefix: <%= Rails.application.class.module_parent_name.underscore %>_production
+  # min_threads: 10    # Minimum number of threads in the pool
+  # max_threads: 20    # Maximum number of threads in the pool
+  # max_queue: 500     # Maximum number of tasks that can be queued

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.32.1
+  version: 0.33.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -9,20 +9,6 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: actioncable
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 8.0.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 8.0.1
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
 description: It offers base classes and helpers for creating MCP applications, making
   it easier to integrate your Ruby/Rails application with the MCP standard
 email:
@@ -177,6 +177,7 @@ files:
 - lib/action_mcp/resource_templates_registry.rb
 - lib/action_mcp/server.rb
 - lib/action_mcp/server/capabilities.rb
+- lib/action_mcp/server/configuration.rb
 - lib/action_mcp/server/json_rpc_handler.rb
 - lib/action_mcp/server/messaging.rb
 - lib/action_mcp/server/notifications.rb
@@ -186,6 +187,8 @@ files:
 - lib/action_mcp/server/roots.rb
 - lib/action_mcp/server/sampling.rb
 - lib/action_mcp/server/sampling_request.rb
+- lib/action_mcp/server/simple_pub_sub.rb
+- lib/action_mcp/server/solid_cable_adapter.rb
 - lib/action_mcp/server/tools.rb
 - lib/action_mcp/server/transport_handler.rb
 - lib/action_mcp/sse_listener.rb
@@ -199,6 +202,8 @@ files:
 - lib/action_mcp/uri_ambiguity_checker.rb
 - lib/action_mcp/version.rb
 - lib/actionmcp.rb
+- lib/generators/action_mcp/config/config_generator.rb
+- lib/generators/action_mcp/config/templates/mcp.yml
 - lib/generators/action_mcp/install/install_generator.rb
 - lib/generators/action_mcp/install/templates/application_mcp_prompt.rb
 - lib/generators/action_mcp/install/templates/application_mcp_res_template.rb