active_mcp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9f18994ffb431e43b365012a42a156596c09d0b1fef51352c7280363df3baddc
+  data.tar.gz: ab39f6b59b7a14510d1f3bc1c18b8f8e854de8ec6055d7592671b7fa1e586382
+SHA512:
+  metadata.gz: b9cf091830ad128b958570361b252a396d9778d6eeaec596bbc22e88dd53bd16770726320928600c8d5e6ec7adc1adf436ab574a6355ec21a276ee15e4b6ccc1
+  data.tar.gz: e7f65722c824d17de80903e899efa552733e747b64ca5abfdc8c44dc73e37ae74d50d7481974dc543c3daed0315050a761115956233f78ccfc1fd55f7eb9a23c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2024 Moeki Kawakami
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,309 @@
+# Active Context
+
+A Ruby on Rails engine that provides [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) capabilities to Rails applications. This gem allows you to easily create and expose MCP-compatible tools from your Rails application.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_mcp'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install active_mcp
+```
+
+## Setup
+
+1. Mount the ActiveMcp engine in your `config/routes.rb`:
+
+```ruby
+Rails.application.routes.draw do
+  mount ActiveMcp::Engine, at: "/mcp"
+
+  # Your other routes
+end
+```
+
+2. Create a tool by inheriting from `ActiveMcp::Tool`:
+
+```ruby
+class CreateNoteTool < ActiveMcp::Tool
+  description "Create Note!!"
+
+  property :title, :string
+  property :content, :string
+
+  def call(title:, content:)
+    Note.create(title:, content:)
+
+    "Created!"
+  end
+end
+```
+
+3. Start the MCP server:
+
+```ruby
+server = ActiveMcp::Server.new(
+  name: "ActiveMcp DEMO",
+  uri: 'https://your-app.example.com/mcp'
+)
+server.start
+```
+
+## Rails Generators
+
+MCP Rails provides generators to help you quickly create new MCP tools:
+
+```bash
+# Generate a new MCP tool
+$ rails generate active_mcp:tool search_users
+```
+
+This creates a new tool file at `app/models/tools/search_users_tool.rb` with the following starter code:
+
+```ruby
+class SearchUsersTool < ActiveMcp::Tool
+  description 'Search users'
+
+  property :param1, :string, required: true, description: 'First parameter description'
+  property :param2, :string, required: false, description: 'Second parameter description'
+  # Add more parameters as needed
+
+  def call(param1:, param2: nil, auth_info: nil, **args)
+    # auth_info = { type: :bearer, token: 'xxx', header: 'Bearer xxx' }
+
+    # Implement your tool logic here
+    "Tool executed successfully with #{param1}"
+  end
+end
+```
+
+You can then customize the generated tool to fit your needs.
+
+## Input Schema
+
+```ruby
+property :name, :string, required: true, description: 'User name'
+property :age, :integer, required: false, description: 'User age'
+property :addresses, :array, required: false, description: 'User addresses'
+property :preferences, :object, required: false, description: 'User preferences'
+```
+
+Supported types include:
+
+- `:string`
+- `:integer`
+- `:number` (float/decimal)
+- `:boolean`
+- `:array`
+- `:object` (hash/dictionary)
+- `:null`
+
+## Using with MCP Clients
+
+Any MCP-compatible client can connect to your server. The most common way is to provide the MCP server URL:
+
+```
+http://your-app.example.com/mcp
+```
+
+Clients will discover the available tools and their input schemas automatically through the MCP protocol.
+
+## Authentication Flow
+
+ActiveMcp supports receiving authentication credentials from MCP clients and forwarding them to your Rails application. There are two ways to handle authentication:
+
+### 1. Using Server Configuration
+
+When creating your MCP server, you can pass authentication options that will be included in every request:
+
+```ruby
+server = ActiveMcp::Server.new(
+  name: "ActiveMcp DEMO",
+  uri: 'http://localhost:3000/mcp',
+  auth: {
+    type: :bearer, # or :basic
+    token: ENV[:ACCESS_TOKEN]
+  }
+)
+server.start
+```
+
+### 2. Custom Controller with Auth Handling
+
+For more advanced authentication, create a custom controller that handles the authentication flow:
+
+```ruby
+class CustomController < ActiveMcpController
+  before_action :authenticate
+
+  private
+
+  def authenticate
+    # Extract auth from MCP request
+    auth_header = request.headers['Authorization']
+
+    if auth_header.present?
+      # Process the auth header (Bearer token, etc.)
+      token = auth_header.split(' ').last
+
+      # Validate the token against your auth system
+      user = User.find_by_token(token)
+
+      unless user
+        render_error(-32600, "Authentication failed")
+        return false
+      end
+
+      # Set current user for tool access
+      Current.user = user
+    else
+      render_error(-32600, "Authentication required")
+      return false
+    end
+  end
+end
+```
+
+### 3. Using Auth in Tools
+
+Authentication information is automatically passed to your tools through the `auth_info` parameter:
+
+```ruby
+class SecuredDataTool < ActiveMcp::Tool
+  description 'Access secured data'
+
+  property :resource_id, :string, required: true, description: 'ID of the resource to access'
+
+  def call(resource_id:, auth_info: nil, **args)
+    # Check if auth info exists
+    unless auth_info.present?
+      raise "Authentication required to access this resource"
+    end
+
+    # Extract token from auth info
+    token = auth_info[:token]
+
+    # Validate token and get user
+    user = User.authenticate_with_token(token)
+
+    unless user
+      raise "Invalid authentication token"
+    end
+
+    # Check if user has access to the resource
+    resource = Resource.find(resource_id)
+
+    if resource.user_id != user.id
+      raise "Access denied to this resource"
+    end
+
+    # Return the secured data
+    {
+      type: "text",
+      content: resource.to_json
+    }
+  end
+end
+```
+
+## Advanced Configuration
+
+### Custom Controller
+
+If you need to customize the MCP controller behavior, you can create your own controller that inherits from `ActiveMcpController`:
+
+```ruby
+class CustomController < ActiveContexController
+  # Add custom behavior, authentication, etc.
+end
+```
+
+And update your routes:
+
+```ruby
+Rails.application.routes.draw do
+  post "/mcp", to: "custom_mcp#index"
+end
+```
+
+## Best Practices
+
+### Create a Tool for Each Model
+
+For security reasons, it's recommended to create specific tools for each model rather than generic tools that dynamically determine the model class. This approach:
+
+1. Increases security by avoiding dynamic class loading
+2. Makes your tools more explicit and easier to understand
+3. Provides better validation and error handling specific to each model
+
+For example, instead of creating a generic search tool, create specific search tools for each model:
+
+```ruby
+# Good: Specific tool for searching users
+class SearchUsersTool < ActiveMcp::Tool
+  description 'Search users by criteria'
+
+  property :email, :string, required: false, description: 'Email to search for'
+  property :name, :string, required: false, description: 'Name to search for'
+  property :limit, :integer, required: false, description: 'Maximum number of records to return'
+
+  def call(email: nil, name: nil, limit: 10)
+    criteria = {}
+    criteria[:email] = email if email.present?
+    criteria[:name] = name if name.present?
+
+    users = User.where(criteria).limit(limit)
+
+    {
+      type: "text",
+      content: users.to_json(only: [:id, :name, :email, :created_at])
+    }
+  end
+end
+
+# Good: Specific tool for searching posts
+class SearchPostsTool < ActiveMcp::Tool
+  description 'Search posts by criteria'
+
+  property :title, :string, required: false, description: 'Title to search for'
+  property :author_id, :integer, required: false, description: 'Author ID to filter by'
+  property :limit, :integer, required: false, description: 'Maximum number of records to return'
+
+  def call(title: nil, author_id: nil, limit: 10)
+    criteria = {}
+    criteria[:title] = title if title.present?
+    criteria[:author_id] = author_id if author_id.present?
+
+    posts = Post.where(criteria).limit(limit)
+
+    {
+      type: "text",
+      content: posts.to_json(only: [:id, :title, :author_id, :created_at])
+    }
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kawakamimoeki/active_mcp. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/kawakamimoeki/active_mcp/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,31 @@
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "ActiveMcp"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+require "bundler/gem_tasks"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+load "rails/tasks/statistics.rake"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/active_mcp/base_controller.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ActiveMcp
+  class BaseController < ActionController::Base
+    protect_from_forgery with: :null_session
+    skip_before_action :verify_authenticity_token
+    before_action :process_authentication, only: [:index]
+
+    def index
+      case params[:method]
+      when Method::TOOLS_LIST
+        render_tools_list
+      when Method::TOOLS_CALL
+        call_tool(params)
+      else
+        render json: {error: "Method not found: #{params[:method]}"}, status: 404
+      end
+    end
+
+    private
+
+    def process_authentication
+      auth_header = request.headers["Authorization"]
+      if auth_header.present?
+        @auth_info = {
+          header: auth_header,
+          type: if auth_header.start_with?("Bearer ")
+                  :bearer
+                elsif auth_header.start_with?("Basic ")
+                  :basic
+                else
+                  :unknown
+                end,
+          token: auth_header.split(" ").last
+        }
+      end
+    end
+
+    def render_tools_list
+      tools = Tool.registered_tools.map do |tool_class|
+        {
+          name: tool_class.tool_name,
+          description: tool_class.desc,
+          inputSchema: tool_class.schema
+        }
+      end
+
+      render json: {result: tools}
+    end
+
+    def call_tool(params)
+      tool_name = params[:name]
+      arguments = JSON.parse(params[:arguments] || "{}")
+
+      unless tool_name
+        render json: {error: "Invalid params: missing tool name"}, status: 422
+        return
+      end
+
+      tool_class = Tool.registered_tools.find do |tc|
+        tc.tool_name == tool_name
+      end
+
+      unless tool_class
+        render json: {error: "Tool not found: #{tool_name}"}, status: 404
+        return
+      end
+
+      tool = tool_class.new
+      validation_result = tool.validate_arguments(arguments)
+
+      if validation_result.is_a?(Hash) && validation_result[:error]
+        render json: {result: validation_result[:error]}
+        return
+      end
+
+      begin
+        arguments[:auth_info] = @auth_info if @auth_info.present?
+
+        result = tool.call(**arguments.symbolize_keys)
+        render json: {result: result}
+      rescue => e
+        render json: {error: "Error: #{e.message}"}
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,4 @@
+ActiveMcp::Engine.routes.draw do
+  post "/", to: "base#index"
+  get "/health", to: proc { [200, {}, ["OK"]] }
+end

data/lib/active_mcp/engine.rb

@@ -0,0 +1,14 @@
+module ActiveMcp
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveMcp
+
+    initializer "active_mcp.eager_load_tools" do |app|
+      tools_path = Rails.root.join("app", "tools")
+      if Dir.exist?(tools_path)
+        Dir[tools_path.join("*.rb")].sort.each do |file|
+          require_dependency file
+        end
+      end
+    end
+  end
+end

data/lib/active_mcp/server/error_codes.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveMcp
+  module ErrorCode
+    NOT_INITIALIZED = -32_002
+    ALREADY_INITIALIZED = -32_002
+
+    PARSE_ERROR = -32_700
+    INVALID_REQUEST = -32_600
+    METHOD_NOT_FOUND = -32_601
+    INVALID_PARAMS = -32_602
+    INTERNAL_ERROR = -32_603
+  end
+end

data/lib/active_mcp/server/methods.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveMcp
+  module Method
+    INITIALIZE = "initialize"
+    INITIALIZED = "notifications/initialized"
+    PING = "ping"
+    TOOLS_LIST = "tools/list"
+    TOOLS_CALL = "tools/call"
+    RESOURCES_LIST = "resources/list"
+    RESOURCES_READ = "resources/read"
+    RESOURCES_TEMPLATES_LIST = "resources/list"
+  end
+end

data/lib/active_mcp/server/protocol_handler.rb

@@ -0,0 +1,167 @@
+require "json"
+
+module ActiveMcp
+  class Server
+    class ProtocolHandler
+      attr_reader :initialized
+
+      def initialize(server)
+        @server = server
+        @initialized = false
+        @supported_protocol_versions = [PROTOCOL_VERSION]
+      end
+
+      def process_message(message)
+        message = message.to_s.force_encoding("UTF-8")
+        result = begin
+          request = JSON.parse(message, symbolize_names: true)
+          handle_request(request)
+        rescue JSON::ParserError => e
+          error_response(nil, ErrorCode::PARSE_ERROR, "Invalid JSON: #{e.message}")
+        rescue => e
+          error_response(nil, ErrorCode::INTERNAL_ERROR, e.message)
+        end
+
+        json_result = JSON.generate(result).force_encoding("UTF-8") if result
+        json_result
+      end
+
+      private
+
+      def handle_request(request)
+        allowed_methods = [
+          Method::INITIALIZE,
+          Method::INITIALIZED,
+          Method::PING
+        ]
+
+        if !@initialized && !allowed_methods.include?(request[:method])
+          return error_response(request[:id], ErrorCode::NOT_INITIALIZED, "Server not initialized")
+        end
+
+        case request[:method]
+        when Method::INITIALIZE
+          handle_initialize(request)
+        when Method::INITIALIZED
+          handle_initialized(request)
+        when Method::PING
+          handle_ping(request)
+        when Method::TOOLS_LIST
+          handle_list_tools(request)
+        when Method::TOOLS_CALL
+          handle_use_tool(request)
+        when Method::RESOURCES_LIST
+          handle_list_resources(request)
+        when Method::RESOURCES_READ
+          handle_read_resource(request)
+        else
+          error_response(request[:id], ErrorCode::METHOD_NOT_FOUND, "Unknown method: #{request[:method]}")
+        end
+      end
+
+      def handle_initialize(request)
+        return error_response(request[:id], ErrorCode::ALREADY_INITIALIZED, "Server already initialized") if @initialized
+
+        client_version = request.dig(:params, :protocolVersion)
+
+        unless @supported_protocol_versions.include?(client_version)
+          return error_response(
+            request[:id],
+            ErrorCode::INVALID_PARAMS,
+            "Unsupported protocol version",
+            {
+              supported: @supported_protocol_versions,
+              requested: client_version
+            }
+          )
+        end
+
+        response = {
+          jsonrpc: JSON_RPC_VERSION,
+          id: request[:id],
+          result: {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {
+              resources: {
+                subscribe: false,
+                listChanged: false
+              },
+              tools: {
+                listChanged: false
+              }
+            },
+            serverInfo: {
+              name: @server.name,
+              version: @server.version
+            }
+          }
+        }
+
+        @initialized = true
+        response
+      end
+
+      def handle_initialized(request)
+        @initialized = true
+        nil
+      end
+
+      def handle_ping(request)
+        success_response(request[:id], {})
+      end
+
+      def handle_list_tools(request)
+        success_response(request[:id], {tools: @server.tool_manager.tools})
+      end
+
+      def handle_use_tool(request)
+        name = request.dig(:params, :name)
+        arguments = request.dig(:params, :arguments) || {}
+
+        begin
+          result = @server.tool_manager.call_tool(name, arguments)
+
+          success_response(request[:id], result)
+        rescue => e
+          error_response(request[:id], ErrorCode::INTERNAL_ERROR, e.message)
+        end
+      end
+
+      def handle_list_resources(request)
+        success_response(
+          request[:id],
+          {
+            resources: [],
+            nextCursor: "0"
+          }
+        )
+      end
+
+      def handle_read_resource(request)
+        uri = request.dig(:params, :uri)
+        error_response(request[:id], ErrorCode::INVALID_REQUEST, "Resource not found", {uri: uri})
+      end
+
+      def success_response(id, result)
+        {
+          jsonrpc: JSON_RPC_VERSION,
+          id: id,
+          result: result
+        }
+      end
+
+      def error_response(id, code, message, data = nil)
+        response = {
+          jsonrpc: JSON_RPC_VERSION,
+          id: id || 0,
+          error: {
+            code: code,
+            message: message
+          }
+        }
+        response[:error][:data] = data if data
+        response
+      end
+    end
+  end
+end

data/lib/active_mcp/server/stdio_connection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveMcp
+  class StdioConnection
+    def initialize
+      $stdout.sync = true
+    end
+
+    def read_next_message
+      message = $stdin.gets&.chomp
+      message.to_s.force_encoding("UTF-8")
+    end
+
+    def send_message(message)
+      message = message.to_s.force_encoding("UTF-8")
+      $stdout.binmode
+      $stdout.write(message + "\n")
+      $stdout.flush
+    end
+  end
+end

data/lib/active_mcp/server/tool_manager.rb

@@ -0,0 +1,114 @@
+require "json"
+
+module ActiveMcp
+  class Server
+    class ToolManager
+      attr_reader :tools
+
+      def initialize(uri: nil, auth: nil)
+        @tools = {}
+        @uri = uri
+
+        if auth
+          @auth_header = "#{auth[:type] == :bearer ? "Bearer" : "Basic"} #{auth[:token]}"
+        end
+      end
+
+      def call_tool(name, arguments = {})
+        tool_info = @tools.find { _1[:name] == name }
+
+        unless tool_info
+          return {
+            isError: true,
+            content: [{type: "text", text: "Tool not found: #{name}"}]
+          }
+        end
+
+        invoke_tool(name, arguments)
+      end
+
+      def load_registered_tools
+        fetch_tools
+      end
+
+      private
+
+      def invoke_tool(name, arguments)
+        require "net/http"
+        uri = URI.parse(@uri.to_s)
+        request = Net::HTTP::Post.new(uri)
+        request.body = JSON.generate({
+          method: "tools/call",
+          name:,
+          arguments: arguments.to_json
+        })
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = @auth_header
+
+        begin
+          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+            http.request(request)
+          end
+
+          if response.code == "200"
+            body = JSON.parse(response.body, symbolize_names: true)
+            if body[:error]
+              {
+                isError: true,
+                content: [{type: "text", text: body[:error]}]
+              }
+            else
+              format_result(body[:result])
+            end
+          else
+            {
+              isError: true,
+              content: [{type: "text", text: "HTTP Error: #{response.code}"}]
+            }
+          end
+        rescue => e
+          {
+            isError: true,
+            content: [{type: "text", text: "Error calling tool: #{e.message}"}]
+          }
+        end
+      end
+
+      def fetch_tools
+        return unless @uri
+
+        require "net/http"
+        uri = URI.parse(@uri.to_s)
+        request = Net::HTTP::Post.new(uri)
+        request.body = JSON.generate({
+          method: "tools/list",
+          arguments: "{}"
+        })
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = @auth_header
+
+        begin
+          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+            http.request(request)
+          end
+
+          result = JSON.parse(response.body, symbolize_names: true)
+          @tools = result[:result]
+        rescue
+          @tools = []
+        end
+      end
+
+      def format_result(result)
+        case result
+        when String
+          {content: [{type: "text", text: result}]}
+        when Hash
+          {content: [{type: "text", text: result.to_json}]}
+        else
+          {content: [{type: "text", text: result.to_s}]}
+        end
+      end
+    end
+  end
+end

data/lib/active_mcp/server.rb

@@ -0,0 +1,55 @@
+require "json"
+require "English"
+require_relative "server/methods"
+require_relative "server/error_codes"
+require_relative "server/stdio_connection"
+require_relative "server/tool_manager"
+require_relative "server/protocol_handler"
+
+module ActiveMcp
+  class Server
+    attr_reader :name, :version, :uri, :tool_manager, :protocol_handler
+
+    def initialize(
+      version: ActiveMcp::VERSION,
+      name: "ActiveMcp",
+      uri: nil,
+      auth: nil
+    )
+      @name = name
+      @version = version
+      @uri = uri
+      @tool_manager = ToolManager.new(uri: uri, auth:)
+      @protocol_handler = ProtocolHandler.new(self)
+      @tool_manager.load_registered_tools
+    end
+
+    def start
+      serve_stdio
+    end
+
+    def serve_stdio
+      serve(StdioConnection.new)
+    end
+
+    def serve(connection)
+      loop do
+        message = connection.read_next_message
+        break if message.nil?
+
+        response = @protocol_handler.process_message(message)
+        next if response.nil?
+
+        connection.send_message(response)
+      end
+    end
+
+    def initialized
+      @protocol_handler.initialized
+    end
+
+    def tools
+      @tool_manager.tools
+    end
+  end
+end

data/lib/active_mcp/tool.rb

@@ -0,0 +1,54 @@
+require "json-schema"
+
+module ActiveMcp
+  class Tool
+    class << self
+      attr_reader :desc, :schema
+
+      def tool_name
+        name ? name.underscore.sub(/_tool$/, "") : ""
+      end
+
+      def description(value)
+        @desc = value
+      end
+
+      def property(name, type, required: false, description: nil)
+        @schema ||= {
+          "type" => "object",
+          "properties" => {},
+          "required" => []
+        }
+
+        @schema["properties"][name.to_s] = {"type" => type.to_s}
+        @schema["properties"][name.to_s]["description"] = description if description
+        @schema["required"] << name.to_s if required
+      end
+
+      def registered_tools
+        @registered_tools ||= []
+      end
+
+      attr_writer :registered_tools
+
+      def inherited(subclass)
+        registered_tools << subclass
+      end
+    end
+
+    def initialize
+    end
+
+    def call(**args)
+      raise NotImplementedError, "#{self.class.name}#call must be implemented"
+    end
+
+    def validate_arguments(args)
+      return true unless self.class.schema
+
+      JSON::Validator.validate!(self.class.schema, args)
+    rescue JSON::Schema::ValidationError => e
+      {error: e.message}
+    end
+  end
+end

data/lib/active_mcp/version.rb

@@ -0,0 +1,3 @@
+module ActiveMcp
+  VERSION = "0.1.0"
+end

data/lib/active_mcp.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "active_mcp/version"
+require_relative "active_mcp/tool"
+require_relative "active_mcp/server"
+
+if defined? ::Rails
+  require_relative "active_mcp/engine"
+end
+
+module ActiveMcp
+  JSON_RPC_VERSION = "2.0"
+  PROTOCOL_VERSION = "2024-11-05"
+end

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

@@ -0,0 +1,18 @@
+class <%= class_name %> < ActiveMcp::Tool
+  description "<%= file_name.humanize %>"
+  
+  property :param1, :string, required: true, description: "First parameter description"
+  property :param2, :string, required: false, description: "Second parameter description"
+  # Add more parameters as needed
+  
+  def call(param1:, param2: nil, auth_info: nil, **args)
+    # Authentication information can be accessed via _auth_info parameter
+    # auth_info = { type: :bearer, token: "xxx", header: "Bearer xxx" }
+    # or { type: :basic, token: "base64encoded", header: "Basic base64encoded" }
+
+    # Implement tool logic here
+
+    # Return a string, hash, or any JSON-serializable object
+    "Tool executed successfully with #{param1}"
+  end
+end

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

@@ -0,0 +1,17 @@
+module ActiveMcp
+  module Generators
+    class ToolGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      def create_tool_file
+        template "tool.rb.erb", File.join("app/tools", "#{file_name}_tool.rb")
+      end
+
+      private
+
+      def class_name
+        "#{file_name.camelize}Tool"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: active_mcp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Your Name
+bindir: bin
+cert_chain: []
+date: 2025-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Rails engine that provides MCP capabilities to your Rails application
+email:
+- your.email@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/active_mcp/base_controller.rb
+- config/routes.rb
+- lib/active_mcp.rb
+- lib/active_mcp/engine.rb
+- lib/active_mcp/server.rb
+- lib/active_mcp/server/error_codes.rb
+- lib/active_mcp/server/methods.rb
+- lib/active_mcp/server/protocol_handler.rb
+- lib/active_mcp/server/stdio_connection.rb
+- lib/active_mcp/server/tool_manager.rb
+- lib/active_mcp/tool.rb
+- lib/active_mcp/version.rb
+- lib/generators/active_mcp/tool/templates/tool.rb.erb
+- lib/generators/active_mcp/tool/tool_generator.rb
+homepage: https://github.com/moekiorg/active_mcp
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.6
+specification_version: 4
+summary: Rails engine for the Model Context Protocol (MCP)
+test_files: []