mcp_on_ruby 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebcb9d413504e157ae357d8904fd719a2d5c264c2b483042e295848a91413960
-  data.tar.gz: 79f2057e8da7aefb9a093b079dc593a0d8aa786c53b1c54cec0654b485fef76f
+  metadata.gz: 04166e9711a0a9c233c43a2f1bba53b27d0a716a7cc996c52f597433e559909d
+  data.tar.gz: 588bbbd27e9bc620e4cf4ea14b97b4e8c5cd869b672f8956a2a17b16b179afdb
 SHA512:
-  metadata.gz: 50769ce05c60dfd97cc896f9259ef53f774f3fb4bb91accb05c37b0bba86e4829c208cd82c26367086a0ed4793b4e7dcd03d4a6074946ab5ed846cfef8715dc4
-  data.tar.gz: b34e216121ba7765d81234afcb373067f55d59dc7fe21141ca74fe3a205b0e6344d753c423f5b4fda128bf6f6d8b7af1dcea5cb0834fbc69d4f96aad669b1389
+  metadata.gz: c22a5a6e40162c8754975bb89288ee5147314e41564a97ea25ab7b85fae03eecfcdc7246a0567520d6813ead8bc22e88ffcfa265ccf16653c2da8f06da8adb28
+  data.tar.gz: e16b57bd9c57d50f1f9f46328d29b94986e54785b166cbf321db1d06366fcd0fa2d43dd7206468ac3671219be7800c8a1f8ccbaaea2eaa77ca4e95217c32da2f

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.3.0] - 2023-05-01
+
+### Added
+- ActiveRecord storage backend for database persistence
+- Support for Rails integration with ActiveRecord storage
+- Auto-creation of database tables with configurable prefixes
+- Proper handling of different data types (text, binary, JSON)
+- Symbolization of hash keys for consistent API
+- Comprehensive test suite for ActiveRecord storage
+
+### Changed
+- Enhanced `StorageFactory` to support ActiveRecord backend
+- Updated configuration system with ActiveRecord options
+- Improved documentation with ActiveRecord storage examples
+
 ## [0.2.0] - 2025-04-21
 
 ### Added

data/README.md

@@ -8,12 +8,12 @@
 [![Test](https://github.com/nagstler/ruby_mcp/actions/workflows/test.yml/badge.svg)](https://github.com/nagstler/ruby_mcp/actions/workflows/test.yml)
 [![codecov](https://codecov.io/github/nagstler/ruby_mcp/graph/badge.svg?token=SG4EJEIHW3)](https://codecov.io/github/nagstler/ruby_mcp)
 
-<strong>The Ruby way to build MCP servers and clients.</strong>
+<strong> **Turn your Rails APIs into an MCP server.**</strong> 
+
 </div>
 
 ## 🔍 Introduction
-
-The [Model Context Protocol](https://modelcontextprotocol.io) provides a standardized way for applications to interact with language models. Similar to how REST standardized web APIs, MCP creates a consistent interface for working with providers like OpenAI and Anthropic.
+The [Model Context Protocol](https://modelcontextprotocol.io) standardizes how applications interact with AI models, serving as the "REST for LLMs." **MCP on Ruby** brings this standard to the Ruby ecosystem. Create contexts, manage conversations, connect to multiple providers, and handle streaming responses with clean, Ruby code.
 
 ![System Component Flow (Horizontal)](https://github.com/user-attachments/assets/085ad9b8-bee0-4d60-a4b7-ecf02d07f53c)
 
@@ -36,7 +36,7 @@ The [Model Context Protocol](https://modelcontextprotocol.io) provides a standar
   - [Uploading Content](#uploading-content)
   - [Using Tool Calls](#using-tool-calls)
 - [🚄 Rails Integration](#-rails-integration)
-- [💾 Custom Storage Backend](#-storage-backends)
+- [💾 Storage Backend](#-storage-backends)
 - [🔒 Authentication](#-authentication)
 - [🛠️ Development](#️-development)
 - [🗺️ Roadmap](#️-roadmap)
@@ -110,6 +110,11 @@ ruby server.rb
 # Terminal 2: Run the client
 cd examples/simple_server
 ruby client.rb
+
+# ActiveRecord Storage Demo
+# Demonstrates database storage with SQLite
+cd examples/simple_server
+ruby activerecord_demo.rb
 ```
 
 This demo provides a guided tour of the MCP functionality, showing each step of creating contexts, adding messages, and generating responses with detailed explanations.
@@ -131,9 +136,31 @@ RubyMCP.configure do |config|
     }
   }
   
-  # Storage backend (:memory, :redis, :active_record, or custom)
+  # Storage backend
+  
+  # Option 1: Memory storage (default)
   config.storage = :memory
   
+  # Option 2: Redis storage
+  config.storage = :redis
+  config.redis = {
+    url: ENV.fetch('REDIS_URL', 'redis://localhost:6379/0'),
+    namespace: 'my_app_mcp',
+    ttl: 86400 # 1 day in seconds
+  }
+  
+  # Option 3: ActiveRecord storage
+  config.storage = :active_record
+  config.active_record = {
+    # Connection settings (not needed in Rails)
+    connection: {
+      adapter: 'sqlite3',
+      database: 'db/mcp.sqlite3'
+    },
+    # Table prefix to avoid name collisions
+    table_prefix: 'mcp_'
+  }
+  
   # Server settings
   config.server_port = 3000
   config.server_host = "0.0.0.0"
@@ -331,7 +358,11 @@ RubyMCP.configure do |config|
   if Rails.env.development? || Rails.env.test?
     config.storage = :memory
   else
-    config.storage = :memory  # Replace with persistent option when implemented
+    # Use ActiveRecord for production (uses your Rails database)
+    config.storage = :active_record
+    config.active_record = {
+      table_prefix: "mcp_#{Rails.env}_"  # Environment-specific prefix
+    }
   end
   
   # Enable authentication in production
@@ -390,6 +421,43 @@ MCP on Ruby supports Redis as a persistent storage backend:
 
 For detailed integration examples, see the [[Redis Storage](https://github.com/nagstler/mcp_on_ruby/wiki/Redis-Storage)] wiki page.
 
+### ActiveRecord Storage
+
+For integration with Rails or any app needing database storage:
+
+```ruby
+# Add to Gemfile
+gem 'activerecord', '~> 6.1'
+gem 'sqlite3', '~> 1.4'  # or pg, mysql2, etc.
+
+# Configure RubyMCP
+RubyMCP.configure do |config|
+  config.storage = :active_record
+  config.active_record = {
+    # Connection (not needed in Rails)
+    connection: {
+      adapter: 'sqlite3',
+      database: 'db/mcp.sqlite3'
+    },
+    # Table prefix to avoid name collisions
+    table_prefix: 'mcp_'
+  }
+end
+```
+
+In Rails applications, it uses your app's database connection automatically:
+
+```ruby
+# config/initializers/ruby_mcp.rb
+RubyMCP.configure do |config|
+  config.storage = :active_record
+  config.active_record = {
+    table_prefix: "mcp_#{Rails.env}_"  # Environment-specific prefix
+  }
+end
+```
+
+The ActiveRecord adapter automatically creates the necessary tables with appropriate indexes, and handles different types of data (text, binary, JSON) appropriately.
 
 ### Custom storage 
 You can implement custom storage backends by extending the base storage class:
@@ -497,7 +565,7 @@ bundle exec ruby examples/simple_server/server.rb
 While RubyMCP is functional for basic use cases, there are several areas planned for improvement:
 
 - [x] Redis persistent storage backend
-- [ ] ActiveRecord storage backend
+- [x] ActiveRecord storage backend
 - [ ] Complete test coverage, including integration tests
 - [ ] Improved error handling and recovery strategies
 - [ ] Rate limiting for provider APIs

data/lib/ruby_mcp/client.rb

@@ -9,7 +9,35 @@ module RubyMCP
       @storage = storage
     end
 
-    # You can add additional convenience methods here
-    # that delegate to storage or provide higher-level functionality
+    def create_context(messages = [], metadata = {})
+      context = RubyMCP::Models::Context.new(messages: messages, metadata: metadata)
+      storage.create_context(context)
+    end
+
+    def list_contexts(limit: 50, offset: 0)
+      storage.list_contexts(limit: limit, offset: offset)
+    end
+
+    def get_context(context_id)
+      storage.get_context(context_id)
+    end
+
+    def delete_context(context_id)
+      storage.delete_context(context_id)
+    end
+
+    def add_message(context_id, role, content, metadata: {})
+      message = RubyMCP::Models::Message.new(role: role, content: content, metadata: metadata)
+      storage.add_message(context_id, message)
+    end
+
+    def add_content(context_id, content_data, content_id = nil)
+      content_id ||= "cnt_#{SecureRandom.hex(10)}"
+      storage.add_content(context_id, content_id, content_data)
+    end
+
+    def get_content(context_id, content_id)
+      storage.get_content(context_id, content_id)
+    end
   end
 end

data/lib/ruby_mcp/configuration.rb

@@ -3,7 +3,8 @@
 module RubyMCP
   class Configuration
     attr_accessor :providers, :storage, :server_port, :server_host,
-                  :auth_required, :jwt_secret, :token_expiry, :max_contexts, :redis
+                  :auth_required, :jwt_secret, :token_expiry, :max_contexts,
+                  :redis, :active_record
 
     def initialize
       @providers = {}
@@ -14,18 +15,25 @@ module RubyMCP
       @jwt_secret = nil
       @token_expiry = 3600 # 1 hour
       @max_contexts = 1000
-      @storage = :memory  # Default to memory storage
       @redis = {}         # Default empty Redis config
+      @active_record = {} # Default empty ActiveRecord config
     end
 
     def storage_config
-      if @storage == :redis
+      case @storage
+      when :redis
         {
           type: :redis,
           connection: redis_connection_config,
           namespace: @redis[:namespace] || 'ruby_mcp',
           ttl: @redis[:ttl] || 86_400
         }
+      when :active_record
+        {
+          type: :active_record,
+          connection: @active_record[:connection],
+          table_prefix: @active_record[:table_prefix] || 'mcp_'
+        }
       else
         { type: @storage }
       end
@@ -36,18 +44,31 @@ module RubyMCP
                             when :memory
                               RubyMCP::Storage::Memory.new
                             when :redis
-                              # Future implementation
-                              raise RubyMCP::Errors::ConfigurationError, 'Redis storage not yet implemented'
+                              begin
+                                require 'redis'
+                                require_relative 'storage/redis'
+                                RubyMCP::Storage::Redis.new(storage_config)
+                              rescue LoadError
+                                raise RubyMCP::Errors::ConfigurationError,
+                                      "Redis storage requires the redis gem. Add it to your Gemfile with:
+                                      gem 'redis', '~> 5.0'"
+                              end
                             when :active_record
-                              # Future implementation
-                              raise RubyMCP::Errors::ConfigurationError, 'ActiveRecord storage not yet implemented'
+                              begin
+                                require 'active_record'
+                                require_relative 'storage/active_record'
+                                RubyMCP::Storage::ActiveRecord.new(storage_config)
+                              rescue LoadError
+                                raise RubyMCP::Errors::ConfigurationError,
+                                      "ActiveRecord storage requires the activerecord gem. Add it to your Gemfile with:
+                                      gem 'activerecord', '~> 6.0'"
+                              end
                             else
                               unless @storage.is_a?(RubyMCP::Storage::Base)
                                 raise RubyMCP::Errors::ConfigurationError, "Unknown storage type: #{@storage}"
                               end
 
                               @storage # Allow custom storage instance
-
                             end
     end
 

data/lib/ruby_mcp/models/context.rb

@@ -37,6 +37,7 @@ module RubyMCP
         {
           id: @id,
           messages: @messages.map(&:to_h),
+          content_map: @content_map,
           created_at: @created_at.iso8601,
           updated_at: @updated_at.iso8601,
           metadata: @metadata

data/lib/ruby_mcp/server/contexts_controller.rb

@@ -53,10 +53,14 @@ module RubyMCP
       end
 
       def destroy
-        context = storage.delete_context(params[:id])
-        ok(context.to_h)
-      rescue RubyMCP::Errors::ContextError => e
-        not_found(e.message)
+        context_id = params[:id]
+
+        begin
+          storage.delete_context(context_id)
+          ok({ success: true })
+        rescue RubyMCP::Errors::ContextError => e
+          not_found("Context not found: #{e.message}")
+        end
       end
     end
   end

data/lib/ruby_mcp/storage/active_record.rb

@@ -0,0 +1,414 @@
+# frozen_string_literal: true
+
+begin
+  require 'active_record'
+rescue LoadError
+  # ActiveRecord is an optional dependency
+  # This error will be handled by the storage factory
+end
+
+require 'securerandom'
+require 'json'
+require_relative 'base'
+
+module RubyMCP
+  module Storage
+    # ActiveRecord-based storage implementation for RubyMCP
+    class ActiveRecord < Base
+      # Initialize ActiveRecord storage with options
+      # @param options [Hash] Options for ActiveRecord storage
+      # @option options [Hash] :connection ActiveRecord connection configuration
+      # @option options [String] :table_prefix Prefix for table names (default: 'mcp_')
+      def initialize(options = {})
+        super
+        @table_prefix = options[:table_prefix] || 'mcp_'
+        @logger = options[:logger] || RubyMCP.logger
+
+        # Set up ActiveRecord connection if provided
+        ::ActiveRecord::Base.establish_connection(options[:connection]) if options[:connection].is_a?(Hash)
+
+        setup_models
+        ensure_tables_exist
+      end
+
+      # Create a new context
+      # @param context [RubyMCP::Models::Context] Context to create
+      # @return [RubyMCP::Models::Context] Created context
+      def create_context(context)
+        # Check if context already exists
+        if @context_model.exists?(external_id: context.id)
+          raise RubyMCP::Errors::ContextError, "Context already exists: #{context.id}"
+        end
+
+        # Create the context record
+        ar_context = @context_model.create!(
+          external_id: context.id,
+          metadata: JSON.generate(context.metadata || {}),
+          created_at: context.created_at,
+          updated_at: context.updated_at
+        )
+
+        # Create message records if any
+        context.messages.each do |message|
+          create_message_record(ar_context.id, message)
+        end
+
+        # Create content records if any
+        context.content_map.each do |content_id, content_data|
+          create_content_record(ar_context.id, content_id, content_data)
+        end
+
+        context
+      end
+
+      # Get a context by ID
+      # @param context_id [String] ID of the context to get
+      # @return [RubyMCP::Models::Context] Found context
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def get_context(context_id)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        # Parse metadata
+        metadata = begin
+          json = JSON.parse(ar_context.metadata)
+          symbolize_keys(json)
+        rescue JSON::ParserError => e
+          @logger.warn("Error parsing context metadata: #{e.message}")
+          {}
+        end
+
+        # Create a new context object
+        context = RubyMCP::Models::Context.new(
+          id: ar_context.external_id,
+          metadata: metadata
+        )
+
+        # Set timestamps
+        context.instance_variable_set(:@created_at, ar_context.created_at)
+        context.instance_variable_set(:@updated_at, ar_context.updated_at)
+
+        # Load messages
+        ar_messages = @message_model.where(context_id: ar_context.id).order(:created_at)
+        ar_messages.each do |ar_message|
+          # Parse message metadata
+          msg_metadata = begin
+            json = JSON.parse(ar_message.metadata)
+            symbolize_keys(json)
+          rescue JSON::ParserError => e
+            @logger.warn("Error parsing message metadata: #{e.message}")
+            {}
+          end
+
+          message = RubyMCP::Models::Message.new(
+            id: ar_message.external_id,
+            role: ar_message.role,
+            content: ar_message.content,
+            metadata: msg_metadata
+          )
+          message.instance_variable_set(:@created_at, ar_message.created_at)
+          context.instance_variable_get(:@messages) << message
+        end
+
+        # Load content
+        ar_contents = @content_model.where(context_id: ar_context.id)
+        ar_contents.each do |ar_content|
+          content_data = if ar_content.content_type == 'json'
+                           begin
+                             json = JSON.parse(ar_content.data_json)
+                             symbolize_keys(json)
+                           rescue JSON::ParserError => e
+                             @logger.warn("Error parsing content JSON: #{e.message}")
+                             {}
+                           end
+                         else
+                           ar_content.data_binary
+                         end
+          context.instance_variable_get(:@content_map)[ar_content.external_id] = content_data
+        end
+
+        context
+      end
+
+      # Update a context
+      # @param context [RubyMCP::Models::Context] Context to update
+      # @return [RubyMCP::Models::Context] Updated context
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def update_context(context)
+        ar_context = @context_model.find_by(external_id: context.id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context.id}" unless ar_context
+
+        # Update the context record
+        ar_context.update!(
+          metadata: JSON.generate(context.metadata || {}),
+          updated_at: context.updated_at
+        )
+
+        # We don't update messages or content here as they are added separately
+        context
+      end
+
+      # Delete a context
+      # @param context_id [String] ID of the context to delete
+      # @return [Boolean] True if deleted
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def delete_context(context_id)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        # Delete all related records manually since we can't rely on cascading in tests
+        @message_model.where(context_id: ar_context.id).delete_all
+        @content_model.where(context_id: ar_context.id).delete_all
+        ar_context.destroy
+
+        true
+      end
+
+      # List contexts with pagination
+      # @param limit [Integer] Maximum number of contexts to return
+      # @param offset [Integer] Number of contexts to skip
+      # @return [Array<RubyMCP::Models::Context>] List of contexts
+      def list_contexts(limit: 100, offset: 0)
+        ar_contexts = @context_model.order(updated_at: :desc).limit(limit).offset(offset)
+
+        ar_contexts.map do |ar_context|
+          get_context(ar_context.external_id)
+        end
+      end
+
+      # List all content for a context
+      # @param context_id [String] ID of the context
+      # @return [Hash] Map of content_id to content data
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def list_content(context_id)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        content_map = {}
+        ar_contents = @content_model.where(context_id: ar_context.id)
+
+        ar_contents.each do |ar_content|
+          content_data = if ar_content.content_type == 'json'
+                           begin
+                             json = JSON.parse(ar_content.data_json)
+                             symbolize_keys(json)
+                           rescue JSON::ParserError => e
+                             raise RubyMCP::Errors::ContentError,
+                                   "Invalid JSON in content #{ar_content.external_id}: #{e.message}"
+                           end
+                         else
+                           ar_content.data_binary
+                         end
+          content_map[ar_content.external_id] = content_data
+        end
+
+        content_map
+      end
+
+      # Add a message to a context
+      # @param context_id [String] ID of the context
+      # @param message [RubyMCP::Models::Message] Message to add
+      # @return [RubyMCP::Models::Message] Added message
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def add_message(context_id, message)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        # Create the message record
+        create_message_record(ar_context.id, message)
+
+        # Update the context's updated_at timestamp
+        ar_context.touch
+
+        message
+      end
+
+      # Add content to a context
+      # @param context_id [String] ID of the context
+      # @param content_id [String] ID of the content
+      # @param content_data [Object] Content data
+      # @return [String] Content ID
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def add_content(context_id, content_id, content_data)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        # Create the content record
+        create_content_record(ar_context.id, content_id, content_data)
+
+        # Update the context's updated_at timestamp
+        ar_context.touch
+
+        content_id
+      end
+
+      # Get content from a context
+      # @param context_id [String] ID of the context
+      # @param content_id [String] ID of the content
+      # @return [Object] Content data
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      # @raise [RubyMCP::Errors::ContentError] If content not found
+      def get_content(context_id, content_id)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        ar_content = @content_model.find_by(context_id: ar_context.id, external_id: content_id)
+        raise RubyMCP::Errors::ContentError, "Content not found: #{content_id}" unless ar_content
+
+        if ar_content.content_type == 'json'
+          begin
+            json = JSON.parse(ar_content.data_json)
+            symbolize_keys(json)
+          rescue JSON::ParserError => e
+            raise RubyMCP::Errors::ContentError, "Invalid JSON in content #{content_id}: #{e.message}"
+          end
+        else
+          ar_content.data_binary
+        end
+      end
+
+      private
+
+      # Setup model classes
+      def setup_models
+        prefix = @table_prefix
+
+        # Context model
+        @context_model = Class.new(::ActiveRecord::Base) do
+          self.table_name = "#{prefix}contexts"
+        end
+        Object.const_set("MCPContext#{SecureRandom.hex(4)}", @context_model)
+
+        # Message model
+        @message_model = Class.new(::ActiveRecord::Base) do
+          self.table_name = "#{prefix}messages"
+        end
+        Object.const_set("MCPMessage#{SecureRandom.hex(4)}", @message_model)
+
+        # Content model
+        @content_model = Class.new(::ActiveRecord::Base) do
+          self.table_name = "#{prefix}contents"
+        end
+        Object.const_set("MCPContent#{SecureRandom.hex(4)}", @content_model)
+      end
+
+      # Ensure necessary tables exist
+      def ensure_tables_exist
+        connection = ::ActiveRecord::Base.connection
+
+        # Drop tables if they exist (for clean setup)
+        connection.drop_table("#{@table_prefix}contents") if connection.table_exists?("#{@table_prefix}contents")
+
+        connection.drop_table("#{@table_prefix}messages") if connection.table_exists?("#{@table_prefix}messages")
+
+        connection.drop_table("#{@table_prefix}contexts") if connection.table_exists?("#{@table_prefix}contexts")
+
+        # Create tables in proper order
+        create_contexts_table
+        create_messages_table
+        create_contents_table
+      end
+
+      # Check if a table exists
+      def table_exists?(table_name)
+        ::ActiveRecord::Base.connection.table_exists?(table_name)
+      end
+
+      # Create the contexts table
+      def create_contexts_table
+        connection = ::ActiveRecord::Base.connection
+        connection.create_table("#{@table_prefix}contexts") do |t|
+          t.string :external_id, null: false
+          t.text :metadata, default: '{}'
+          t.timestamps
+        end
+        connection.add_index("#{@table_prefix}contexts", :external_id, unique: true)
+        connection.add_index("#{@table_prefix}contexts", :updated_at)
+      end
+
+      # Create the messages table
+      def create_messages_table
+        connection = ::ActiveRecord::Base.connection
+        connection.create_table("#{@table_prefix}messages") do |t|
+          t.bigint :context_id, null: false
+          t.string :external_id, null: false
+          t.string :role, null: false
+          t.text :content, null: false
+          t.text :metadata, default: '{}'
+          t.timestamps
+        end
+        connection.add_index("#{@table_prefix}messages", %i[context_id external_id], unique: true)
+        connection.add_index("#{@table_prefix}messages", :context_id)
+      end
+
+      # Create the contents table
+      def create_contents_table
+        connection = ::ActiveRecord::Base.connection
+        connection.create_table("#{@table_prefix}contents") do |t|
+          t.bigint :context_id, null: false
+          t.string :external_id, null: false
+          t.binary :data_binary
+          t.text :data_json
+          t.string :content_type
+          t.timestamps
+        end
+        connection.add_index("#{@table_prefix}contents", %i[context_id external_id], unique: true)
+        connection.add_index("#{@table_prefix}contents", :context_id)
+      end
+
+      # Create a message record
+      def create_message_record(context_id, message)
+        @message_model.create!(
+          context_id: context_id,
+          external_id: message.id,
+          role: message.role,
+          content: message.content.to_s,
+          metadata: JSON.generate(message.metadata || {}),
+          created_at: message.created_at
+        )
+      end
+
+      # Create a content record
+      def create_content_record(context_id, content_id, content_data)
+        # Validate data type first
+        unless content_data.is_a?(String) || content_data.is_a?(Hash) ||
+               content_data.is_a?(Array) || content_data.is_a?(Numeric) ||
+               content_data.is_a?(TrueClass) || content_data.is_a?(FalseClass) ||
+               content_data.is_a?(NilClass)
+          raise RubyMCP::Errors::ContentError,
+                "Invalid data type: #{content_data.class.name}. Must be String, Hash, Array, Numeric, Boolean, or nil."
+        end
+
+        if content_data.is_a?(Hash) || content_data.is_a?(Array)
+          @content_model.create!(
+            context_id: context_id,
+            external_id: content_id,
+            data_json: JSON.generate(content_data),
+            content_type: 'json'
+          )
+        else
+          @content_model.create!(
+            context_id: context_id,
+            external_id: content_id,
+            data_binary: content_data.to_s,
+            content_type: 'binary'
+          )
+        end
+      end
+
+      # Helper method to symbolize keys in hashes (including nested ones)
+      def symbolize_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(key, value), result|
+            result[key.to_sym] = symbolize_keys(value)
+          end
+        when Array
+          obj.map { |item| symbolize_keys(item) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mcp/storage_factory.rb

@@ -1,4 +1,3 @@
-# lib/ruby_mcp/storage_factory.rb
 # frozen_string_literal: true
 
 module RubyMCP
@@ -19,11 +18,23 @@ module RubyMCP
         begin
           require 'redis'
           require_relative 'storage/redis'
-        rescue LoadError => e
-          raise LoadError, "Redis storage requires the redis gem. Add it to your Gemfile: #{e.message}"
+        rescue LoadError
+          raise LoadError, "Redis storage requires the redis gem. Add it to your Gemfile with: gem 'redis', '~> 5.0'"
         end
 
         Storage::Redis.new(storage_config)
+      when :active_record
+        # Load ActiveRecord dependencies
+        begin
+          require 'active_record'
+          require_relative 'storage/active_record'
+        rescue LoadError
+          raise LoadError,
+                "ActiveRecord storage requires the activerecord gem. Add it to your Gemfile with:
+                gem 'activerecord', '~> 6.0'"
+        end
+
+        Storage::ActiveRecord.new(storage_config)
       else
         raise ArgumentError, "Unknown storage type: #{storage_config[:type]}"
       end

data/lib/ruby_mcp/version.rb

@@ -2,5 +2,5 @@
 
 # lib/ruby_mcp/version.rb
 module RubyMCP
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/ruby_mcp.rb

@@ -30,9 +30,13 @@ require_relative 'ruby_mcp/server/generate_controller'
 require_relative 'ruby_mcp/providers/openai'
 require_relative 'ruby_mcp/providers/anthropic'
 
+# Optional storage backends - don't require them directly
+# require_relative 'ruby_mcp/storage/redis'
+# require_relative 'ruby_mcp/storage/active_record'
+
 require_relative 'ruby_mcp/schemas'
 require_relative 'ruby_mcp/validator'
-
+require_relative 'ruby_mcp/storage_factory'
 require_relative 'ruby_mcp/client'
 
 module RubyMCP
@@ -61,7 +65,6 @@ module RubyMCP
     private
 
     def initialize_components
-      require_relative 'ruby_mcp/storage_factory'
       @storage = StorageFactory.create(configuration)
     end
   end

metadata

@@ -1,45 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: mcp_on_ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Nagendra Dhanakeerthi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-21 00:00:00.000000000 Z
+date: 2025-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: faraday-net_http
+  name: dry-schema
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.13'
 - !ruby/object:Gem::Dependency
-  name: jwt
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -53,75 +53,75 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.7'
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
+  name: faraday-net_http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: dry-schema
+  name: jwt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '2.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
-  name: webrick
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: rack-cors
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: rack-cors
+  name: webrick
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -129,7 +129,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -137,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: vcr
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -151,19 +151,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.1'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.18'
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.18'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: codecov
   requirement: !ruby/object:Gem::Requirement
@@ -220,6 +220,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
 description: |-
   A comprehensive Ruby gem for implementing Model Context Protocol servers
   to standardize interactions with AI language models
@@ -254,6 +282,7 @@ files:
 - lib/ruby_mcp/server/generate_controller.rb
 - lib/ruby_mcp/server/messages_controller.rb
 - lib/ruby_mcp/server/router.rb
+- lib/ruby_mcp/storage/active_record.rb
 - lib/ruby_mcp/storage/base.rb
 - lib/ruby_mcp/storage/error.rb
 - lib/ruby_mcp/storage/memory.rb