rails-active-mcp 3.1.6 → 3.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e33dd14dce1495ed61d2e8416360dec54f4eaf906f41812c20360ee6c11126c0
-  data.tar.gz: c4c2fb7478c2c839bb6249570699ddad226a4cc63f837be8892a7d6a37c7373d
+  metadata.gz: 2f28a41a2349fa5ec8f70e64b084914e5e5bd8943684a0b828ae2f4d3b012535
+  data.tar.gz: 19e553886e52572e619c682fcef47a0f9c75e834adaba78c7abee6b408efeca6
 SHA512:
-  metadata.gz: 9d62eb7e5f5dffc3a16c92ca3f096f33a8737a59e0cbdd37fe47dda3ba55d04326c127668679dbb7f27e8c6f1fae853fc63762092608ba99545ff72afe839a4e
-  data.tar.gz: d7692dc73706b28bc2e30b4fef01727cf4305dae03bac2b38b3424eef8027e0f2e58e5f052eeced6fa50f38b2afea664b16a10a692f323ffc8c1cf7198aa4030
+  metadata.gz: 6daf947e15e1d583db505a3574b432ff7220f08b881651818744df8e0db4946532ab5da568a16a94721e808578609b7af11649c7d162abb3a225d2da8a5f70cf
+  data.tar.gz: f89cafda34deb3791ecc426ad7dcba4e46975367c7b3ac9ea9a964ce4ca7b31a3789d2f38ee1bd7c5d9c43599dad7b85e5477b32de8caa3be8fb4c0bbf84c660

data/README.md

@@ -4,7 +4,9 @@ Note: This is just a personal project and while it works for the most part, I am
 
 # Rails Active MCP
 
-A Ruby gem that provides secure Rails console access through Model Context Protocol (MCP) for AI agents and development tools like Claude Desktop. Built using the official MCP Ruby SDK for professional protocol handling and future-proof compatibility.
+A Ruby gem that provides secure Rails console access through [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) for AI agents and development tools. Built using the official MCP Ruby SDK for professional protocol handling and future-proof compatibility.
+
+Works with any MCP-compatible client, including Claude Desktop, Claude Code, VS Code (GitHub Copilot), Cursor, Windsurf, ChatGPT, Gemini CLI, Amazon Q Developer, JetBrains IDEs, Zed, Warp, Cline, and [many more](https://modelcontextprotocol.io/clients).
 
 
 
@@ -30,12 +32,18 @@ bundle install
 rails generate rails_active_mcp:install
 ```
 
-This creates an initializer, mounts the MCP engine, and generates a standalone server file.
+This creates an initializer, server scripts, and prompts you to select which MCP clients you use. It will automatically generate the correct project-level config files (`.mcp.json`, `.cursor/mcp.json`, `.vscode/mcp.json`, etc.) so your MCP client detects the server when you open the project.
+
+### 3. Connect your MCP client
+
+If you selected your MCP client during installation, you're done — just open the project and the server will be detected automatically.
 
-### 3. Connect to Claude Desktop
+For manual configuration or additional clients, the server uses STDIO transport. Below are configuration examples for popular tools.
 
-Add the following to your Claude Desktop configuration file:
+<details>
+<summary><strong>Claude Desktop</strong></summary>
 
+Edit your config file:
 - **macOS/Linux:** `~/.config/claude-desktop/claude_desktop_config.json`
 - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
 
@@ -51,9 +59,141 @@ Add the following to your Claude Desktop configuration file:
 }
 ```
 
-Restart Claude Desktop, and you're done. Four tools will appear automatically: `console_execute`, `model_info`, `safe_query`, and `dry_run`.
+Restart Claude Desktop and the tools will appear automatically.
+</details>
+
+<details>
+<summary><strong>Claude Code</strong></summary>
+
+From your Rails project directory:
+
+```bash
+claude mcp add rails-active-mcp -- bundle exec rails-active-mcp-server
+```
+
+Or add it to your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "rails-active-mcp": {
+      "command": "bundle",
+      "args": ["exec", "rails-active-mcp-server"]
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary><strong>VS Code (GitHub Copilot)</strong></summary>
+
+Add to your workspace `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "rails-active-mcp": {
+      "command": "bundle",
+      "args": ["exec", "rails-active-mcp-server"],
+      "cwd": "${workspaceFolder}"
+    }
+  }
+}
+```
+
+Tools are available in Copilot's Agent mode.
+</details>
+
+<details>
+<summary><strong>Cursor</strong></summary>
+
+Add to your project's `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "rails-active-mcp": {
+      "command": "bundle",
+      "args": ["exec", "rails-active-mcp-server"],
+      "cwd": "/path/to/your/rails/project"
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary><strong>Windsurf</strong></summary>
+
+Add to your project's `.windsurf/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "rails-active-mcp": {
+      "command": "bundle",
+      "args": ["exec", "rails-active-mcp-server"],
+      "cwd": "/path/to/your/rails/project"
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary><strong>Zed</strong></summary>
+
+Add to your Zed settings (`settings.json`):
+
+```json
+{
+  "context_servers": {
+    "rails-active-mcp": {
+      "command": {
+        "path": "bundle",
+        "args": ["exec", "rails-active-mcp-server"],
+        "env": {}
+      }
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary><strong>ChatGPT Desktop</strong></summary>
+
+In ChatGPT Desktop, go to **Settings > Connectors > Advanced > Developer Mode**, then add:
+
+```json
+{
+  "mcpServers": {
+    "rails-active-mcp": {
+      "command": "bundle",
+      "args": ["exec", "rails-active-mcp-server"],
+      "cwd": "/path/to/your/rails/project"
+    }
+  }
+}
+```
+</details>
+
+<details>
+<summary><strong>Other MCP Clients</strong></summary>
+
+Any MCP client that supports STDIO transport can connect to this server. The key details:
+
+- **Command:** `bundle exec rails-active-mcp-server`
+- **Working directory:** Your Rails project root
+- **Transport:** STDIO (stdin/stdout)
+
+See the [full list of MCP clients](https://modelcontextprotocol.io/clients) for more options.
+</details>
+
+Once connected, four tools will appear automatically: `console_execute`, `model_info`, `safe_query`, and `dry_run`.
 
-Try asking Claude:
+Try asking your AI assistant:
 
 - "Show me all users created in the last week"
 - "What's the average order value?"
@@ -91,9 +231,9 @@ end
 
 ## Usage
 
-### Claude Desktop (Recommended)
+### MCP Client (Recommended)
 
-Once connected (see [Quick Start](#quick-start)), Claude Desktop automatically runs the MCP server for you. The server loads your Rails application, initializes models, and provides secure access to your Rails environment via STDIO transport.
+Once connected (see [Quick Start](#quick-start)), your MCP client automatically runs the server for you. The server loads your Rails application, initializes models, and provides secure access to your Rails environment via STDIO transport.
 
 ### Direct Usage
 
@@ -109,7 +249,7 @@ RailsActiveMcp.safe?("User.delete_all") # => false
 
 ### Running the Server Manually
 
-If you need to run the server outside of Claude Desktop (e.g., for debugging):
+If you need to run the server directly (e.g., for debugging):
 
 ```bash
 bundle exec rails-active-mcp-server
@@ -120,7 +260,7 @@ RAILS_MCP_DEBUG=1 bundle exec rails-active-mcp-server
 
 ## Available MCP Tools
 
-The Rails Active MCP server provides four powerful tools that appear automatically in Claude Desktop:
+The Rails Active MCP server provides four powerful tools that appear automatically in any connected MCP client:
 
 ### 1. `console_execute`
 
@@ -131,7 +271,7 @@ Execute Ruby code with safety checks and timeout protection:
 - **Timeout**: Configurable execution timeout
 - **Logging**: All executions are logged for audit
 
-**Example Usage in Claude:**
+**Example prompt:**
 > "Execute `User.where(active: true).count`"
 
 ### 2. `model_info`
@@ -143,7 +283,7 @@ Get detailed information about Rails models:
 - **Validations**: All model validations and rules
 - **Methods**: Available instance and class methods
 
-**Example Usage in Claude:**
+**Example prompt:**
 > "Show me the User model structure"
 
 ### 3. `safe_query`
@@ -155,7 +295,7 @@ Execute safe, read-only database queries:
 - **Result Limiting**: Prevents large data dumps
 - **Model Context**: Works within your model definitions
 
-**Example Usage in Claude:**
+**Example prompt:**
 > "Get the 10 most recent orders"
 
 ### 4. `dry_run`
@@ -167,7 +307,7 @@ Analyze Ruby code for safety without executing:
 - **Recommendations**: Suggests safer alternatives
 - **Zero Execution**: Never runs the actual code
 
-**Example Usage in Claude:**
+**Example prompt:**
 > "Analyze this code for safety: `User.delete_all`"
 
 ## Safety Features
@@ -216,7 +356,7 @@ Rails Active MCP uses the official MCP Ruby SDK (`mcp` gem) for:
 
 The server is implemented in `lib/rails_active_mcp/sdk/server.rb` and provides:
 
-- **STDIO Transport**: Perfect for Claude Desktop integration
+- **STDIO Transport**: Compatible with all major MCP clients
 - **Tool Registration**: Automatic discovery of available tools
 - **Error Handling**: Comprehensive error reporting and recovery
 - **Rails Integration**: Deep integration with Rails applications

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

@@ -7,6 +7,14 @@ module RailsActiveMcp
 
       desc 'Install Rails Active MCP'
 
+      MCP_CLIENTS = {
+        'claude_code' => { name: 'Claude Code', path: '.mcp.json', key: 'mcpServers' },
+        'cursor' => { name: 'Cursor', path: '.cursor/mcp.json', key: 'mcpServers' },
+        'vscode' => { name: 'VS Code / GitHub Copilot', path: '.vscode/mcp.json', key: 'servers' },
+        'claude_desktop' => { name: 'Claude Desktop', path: nil },
+        'windsurf' => { name: 'Windsurf', path: nil }
+      }.freeze
+
       def create_initializer
         template 'initializer.rb', 'config/initializers/rails_active_mcp.rb'
       end
@@ -25,85 +33,211 @@ module RailsActiveMcp
         template 'mcp.ru', 'mcp.ru'
       end
 
-      def show_readme
-        readme 'README.md' if behavior == :invoke
+      def create_mcp_client_configs
+        return unless behavior == :invoke
+
+        say "\nWhich MCP clients do you use?", :green
+        say '(Select all that apply, separated by commas)', :yellow
+        say ''
+
+        client_keys = MCP_CLIENTS.keys
+        client_keys.each_with_index do |key, index|
+          say "  #{index + 1}. #{MCP_CLIENTS[key][:name]}", :cyan
+        end
+        say "  #{client_keys.size + 1}. Skip (configure manually later)", :cyan
+        say ''
+
+        response = ask('Enter your choices (e.g. 1,2,3):', :green)
+        @selected_clients = parse_client_selections(response, client_keys)
+
+        generate_client_configs
       end
 
-      # rubocop:disable Metrics/AbcSize
       def show_post_install_instructions
         return unless behavior == :invoke
 
         say "\n#{'=' * 50}", :green
         say 'Rails Active MCP Installation Complete!', :green
-        say '=' * 50, :green
+        say('=' * 50, :green)
+
+        show_created_files
+        show_quick_test
+        show_global_client_instructions
+        show_available_tools
+        show_example_prompts
+        show_troubleshooting
+        show_next_steps
+      end
+
+      private
+
+      def parse_client_selections(response, client_keys)
+        return [] if response.blank?
+
+        indices = response.split(',').map { |s| s.strip.to_i - 1 }
+        indices.filter_map { |i| client_keys[i] if i >= 0 && i < client_keys.size }
+      end
+
+      def generate_client_configs
+        @selected_clients.each do |client_key|
+          client = MCP_CLIENTS[client_key]
+          next unless client[:path]
+
+          write_client_config(client_key, client)
+        end
+      end
+
+      def write_client_config(client_key, client)
+        path = client[:path]
+        full_path = File.join(destination_root, path)
+        top_key = client[:key]
+
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(File.join(destination_root, dir)) unless dir == '.'
+
+        server_entry = build_server_entry
+
+        if File.exist?(full_path)
+          merge_into_existing_config(full_path, path, top_key, server_entry, client[:name])
+        else
+          config = { top_key => { 'rails-active-mcp' => server_entry } }
+          create_file path, "#{JSON.pretty_generate(config)}\n"
+          say "  Created #{path} for #{client[:name]}", :green
+        end
+
+        return unless client_key == 'vscode'
+
+        append_to_gitignore('.vscode/mcp.json')
+      end
+
+      def merge_into_existing_config(full_path, path, top_key, server_entry, client_name)
+        existing = JSON.parse(File.read(full_path))
+        existing[top_key] ||= {}
+
+        if existing[top_key].key?('rails-active-mcp')
+          say "  Skipped #{path} — rails-active-mcp already configured for #{client_name}", :yellow
+          return
+        end
+
+        existing[top_key]['rails-active-mcp'] = server_entry
+        File.write(full_path, "#{JSON.pretty_generate(existing)}\n")
+        say "  Updated #{path} — added rails-active-mcp for #{client_name}", :green
+      rescue JSON::ParserError
+        say "  Skipped #{path} — file exists but contains invalid JSON", :red
+      end
+
+      def build_server_entry
+        {
+          'command' => Rails.root.join('bin/rails-active-mcp-wrapper').to_s,
+          'args' => [],
+          'env' => { 'RAILS_ENV' => 'development' }
+        }
+      end
+
+      def build_mcp_config(top_key)
+        { top_key => { 'rails-active-mcp' => build_server_entry } }
+      end
+
+      def append_to_gitignore(entry)
+        gitignore_path = File.join(destination_root, '.gitignore')
+        return unless File.exist?(gitignore_path)
+
+        content = File.read(gitignore_path)
+        return if content.include?(entry)
+
+        append_to_file '.gitignore', "\n# MCP client config (may contain local paths)\n#{entry}\n"
+      end
+
+      def show_created_files
         say "\nFiles created:", :green
-        say '✅ config/initializers/rails_active_mcp.rb', :yellow
-        say '✅ bin/rails-active-mcp-wrapper', :yellow
-        say '✅ bin/rails-active-mcp-server', :yellow
-        say '✅ mcp.ru', :yellow
-        say '', :green
+        say '  config/initializers/rails_active_mcp.rb', :yellow
+        say '  bin/rails-active-mcp-wrapper', :yellow
+        say '  bin/rails-active-mcp-server', :yellow
+        say '  mcp.ru', :yellow
+
+        return unless @selected_clients&.any?
+
+        @selected_clients.each do |key|
+          path = MCP_CLIENTS[key][:path]
+          say "  #{path}", :yellow if path
+        end
+      end
+
+      def show_quick_test
         say "\nQuick Test:", :green
-        say '1. Test the server: bin/rails-active-mcp-wrapper', :yellow
-        say '2. Should show JSON responses (not plain text)', :yellow
-        say '3. Exit with Ctrl+C', :yellow
-        say '', :green
-        say "\nFor Claude Desktop configuration:", :green
-        say 'Add this to your claude_desktop_config.json:', :yellow
-        say '', :green
-        say '{', :cyan
-        say '  "mcpServers": {', :cyan
-        say '    "rails-active-mcp": {', :cyan
-        say "      \"command\": \"#{Rails.root.join('bin/rails-active-mcp-wrapper')}\",", :cyan
-        say "      \"cwd\": \"#{Rails.root}\",", :cyan
-        say '      "env": {', :cyan
-        say '        "RAILS_ENV": "development"', :cyan
-        say '      }', :cyan
-        say '    }', :cyan
-        say '  }', :cyan
-        say '}', :cyan
-        say '', :green
-        say 'Config file locations:', :green
+        say '  1. Test the server: bin/rails-active-mcp-wrapper', :yellow
+        say '  2. Should show JSON responses (not plain text)', :yellow
+        say '  3. Exit with Ctrl+C', :yellow
+      end
+
+      def show_global_client_instructions
+        global_clients = (@selected_clients || []).select { |key| MCP_CLIENTS[key][:path].nil? }
+        return if global_clients.empty?
+
+        say "\nManual configuration needed for:", :green
+
+        show_claude_desktop_instructions if global_clients.include?('claude_desktop')
+
+        return unless global_clients.include?('windsurf')
+
+        show_windsurf_instructions
+      end
+
+      def show_claude_desktop_instructions
+        say "\n  Claude Desktop:", :cyan
+        say '  Add this to your claude_desktop_config.json:', :yellow
         say '  macOS: ~/.config/claude-desktop/claude_desktop_config.json', :yellow
         say '  Windows: %APPDATA%\\Claude\\claude_desktop_config.json', :yellow
-        say '', :green
-        say "\nAvailable Tools in Claude Desktop:", :green
-        say '- console_execute: Execute Ruby code with safety checks', :yellow
-        say '- model_info: Get detailed information about Rails models', :yellow
-        say '- safe_query: Execute safe read-only database queries', :yellow
-        say '- dry_run: Analyze Ruby code for safety without execution', :yellow
-        say '', :green
-        say "\nExample Claude Desktop prompts:", :green
-        say '- "Show me the User model structure"', :yellow
-        say '- "How many users were created in the last week?"', :yellow
-        say '- "What are the most recent orders?"', :yellow
-        say '- "Check if this code is safe: User.delete_all"', :yellow
-        say '', :green
+        say ''
+        say "  #{JSON.pretty_generate(build_mcp_config('mcpServers')).gsub("\n", "\n  ")}", :cyan
+      end
+
+      def show_windsurf_instructions
+        say "\n  Windsurf:", :cyan
+        say '  Add this to ~/.codeium/windsurf/mcp_config.json:', :yellow
+        say ''
+        say "  #{JSON.pretty_generate(build_mcp_config('mcpServers')).gsub("\n", "\n  ")}", :cyan
+      end
+
+      def show_available_tools
+        say "\nAvailable MCP Tools:", :green
+        say '  console_execute - Execute Ruby code with safety checks', :yellow
+        say '  model_info      - Get detailed information about Rails models', :yellow
+        say '  safe_query      - Execute safe read-only database queries', :yellow
+        say '  dry_run         - Analyze Ruby code for safety without execution', :yellow
+      end
+
+      def show_example_prompts
+        say "\nExample prompts:", :green
+        say '  "Show me the User model structure"', :yellow
+        say '  "How many users were created in the last week?"', :yellow
+        say '  "What are the most recent orders?"', :yellow
+        say '  "Check if this code is safe: User.delete_all"', :yellow
+      end
+
+      def show_troubleshooting
         say "\nTroubleshooting:", :green
-        say '- Debug mode: RAILS_MCP_DEBUG=1 bin/rails-active-mcp-wrapper', :yellow
-        say '- Check status: rails rails_active_mcp:status', :yellow
-        say '- Restart Claude Desktop after config changes', :yellow
-        say '- If wrapper fails, try: bin/rails-active-mcp-server', :yellow
-        say '', :green
-        say "\nNext steps:", :green
-        say '1. Test installation: rails rails_active_mcp:test_tools', :yellow
-        say '2. Configure Claude Desktop (see above)', :yellow
-        say '3. Restart Claude Desktop', :yellow
-        say '4. Start chatting with your Rails app!', :yellow
-        say '=' * 50, :green
+        say '  Debug mode: RAILS_MCP_DEBUG=1 bin/rails-active-mcp-wrapper', :yellow
+        say '  If wrapper fails, try: bin/rails-active-mcp-server directly', :yellow
       end
-      # rubocop:enable Metrics/AbcSize
 
-      private
+      def show_next_steps
+        say "\nNext steps:", :green
+        say '  1. Test installation: rails rails_active_mcp:test_tools', :yellow
 
-      def readme(path)
-        readme_path = File.join(self.class.source_root, path)
-        if File.exist?(readme_path)
-          say File.read(readme_path), :green
+        if @selected_clients.blank?
+          say '  2. Configure your MCP client (see README)', :yellow
         else
-          say "README file not found at #{readme_path}", :green
+          global_clients = @selected_clients.select { |key| MCP_CLIENTS[key][:path].nil? }
+          if global_clients.any?
+            say '  2. Add the config above to your global MCP client settings', :yellow
+          else
+            say '  2. Open your project in your MCP client - it should auto-detect the server', :yellow
+          end
         end
-      rescue StandardError => e
-        say "Error reading README: #{e.message}", :red
+
+        say '  3. Start chatting with your Rails app!', :yellow
+        say('=' * 50, :green)
       end
     end
   end

data/lib/generators/rails_active_mcp/install/templates/README.md

@@ -4,7 +4,7 @@ This Rails application is configured with Rails Active MCP for secure AI-powered
 
 ## What is Rails Active MCP?
 
-Rails Active MCP enables secure Rails console access through Model Context Protocol (MCP) for AI agents and development tools like Claude Desktop. It provides four main tools:
+Rails Active MCP enables secure Rails console access through [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) for AI agents and development tools. It provides four main tools:
 
 - **console_execute**: Execute Ruby/Rails code with safety checks
 - **model_info**: Inspect Rails models (schema, associations, validations)
@@ -23,28 +23,19 @@ bin/rails-active-mcp-wrapper
 RAILS_MCP_DEBUG=1 bin/rails-active-mcp-server
 ```
 
-### 2. Configure Claude Desktop
-
-Add this to your Claude Desktop configuration:
-
-**macOS/Linux**: `~/.config/claude-desktop/claude_desktop_config.json`
-**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
-
-```json
-{
-  "mcpServers": {
-    "rails-active-mcp": {
-      "command": "/path/to/your/rails/app/bin/rails-active-mcp-wrapper",
-      "cwd": "/path/to/your/rails/app",
-      "env": {
-        "RAILS_ENV": "development"
-      }
-    }
-  }
-}
-```
+### 2. Connect Your MCP Client
+
+If you selected MCP clients during installation, project-level config files were generated automatically. Open this project in your MCP client and the server should be detected.
+
+For manual configuration, point your client at the server with:
+
+- **Command:** `bin/rails-active-mcp-wrapper`
+- **Working directory:** This project root
+- **Transport:** STDIO
+
+See the [full list of compatible MCP clients](https://modelcontextprotocol.io/clients).
 
-### 3. Try These Commands in Claude Desktop
+### 3. Try These Prompts
 
 - "Show me the User model structure"
 - "How many users were created in the last week?"
@@ -79,7 +70,7 @@ config.allowed_models = %w[User Post Comment]
 # Check code safety
 rails rails_active_mcp:check_safety['User.count']
 
-# Execute code with safety checks  
+# Execute code with safety checks
 rails rails_active_mcp:execute['User.count']
 
 # Test MCP tools
@@ -93,10 +84,10 @@ rails rails_active_mcp:test_tools
 - Check Ruby version compatibility
 - Verify all gems are installed: `bundle install`
 
-### Claude Desktop Connection Issues
-- Restart Claude Desktop after configuration changes
-- Check logs: `~/Library/Logs/Claude/mcp*.log` (macOS)
+### MCP Client Connection Issues
+- Restart your MCP client after configuration changes
 - Test server manually: `bin/rails-active-mcp-wrapper`
+- Debug mode: `RAILS_MCP_DEBUG=1 bin/rails-active-mcp-server`
 
 ### Permission Errors
 - Ensure wrapper script is executable: `chmod +x bin/rails-active-mcp-wrapper`
@@ -131,4 +122,4 @@ File.delete('file')    # File operations
 
 - **Documentation**: https://github.com/goodpie/rails-active-mcp
 - **Issues**: https://github.com/goodpie/rails-active-mcp/issues
-- **MCP Protocol**: https://modelcontextprotocol.io
+- **MCP Protocol**: https://modelcontextprotocol.io

data/lib/rails_active_mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsActiveMcp
-  VERSION = '3.1.6'
+  VERSION = '3.1.7'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rails-active-mcp
 version: !ruby/object:Gem::Version
-  version: 3.1.6
+  version: 3.1.7
 platform: ruby
 authors:
 - Brandyn Britton
 bindir: exe
 cert_chain: []
-date: 2026-02-20 00:00:00.000000000 Z
+date: 2026-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby