mcp_on_ruby 0.1.0

data/lib/ruby_mcp/server/generate_controller.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Server
+    class GenerateController < BaseController
+      def create
+        context_id = params[:context_id]
+        engine_id = params[:engine_id]
+
+        begin
+          # Get the context
+          context = storage.get_context(context_id)
+
+          # Find the provider
+          provider_name, model = parse_engine_id(engine_id)
+          provider = get_provider(provider_name)
+
+          # Generation options
+          options = {
+            model: model,
+            max_tokens: params[:max_tokens],
+            temperature: params[:temperature],
+            top_p: params[:top_p],
+            frequency_penalty: params[:frequency_penalty],
+            presence_penalty: params[:presence_penalty],
+            stop: params[:stop]
+          }.compact
+
+          # Generate the response
+          response = provider.generate(context, options)
+
+          # Add the assistant message to the context if requested
+          if params[:update_context] != false
+            message = RubyMCP::Models::Message.new(
+              role: 'assistant',
+              content: response[:content],
+              metadata: response[:metadata]
+            )
+            storage.add_message(context_id, message)
+          end
+
+          ok(response)
+        rescue RubyMCP::Errors::ContextError => e
+          not_found(e.message)
+        rescue RubyMCP::Errors::ProviderError, RubyMCP::Errors::EngineError => e
+          bad_request(e.message)
+        end
+      end
+
+      def stream
+        context_id = params[:context_id]
+        engine_id = params[:engine_id]
+
+        # Check that we have a streaming-compatible request
+        return bad_request('Streaming requires HTTP/1.1 or higher') unless request.env['HTTP_VERSION'] == 'HTTP/1.1'
+
+        begin
+          # Get the context
+          context = storage.get_context(context_id)
+
+          # Find the provider
+          provider_name, model = parse_engine_id(engine_id)
+          provider = get_provider(provider_name)
+
+          # Generation options
+          options = {
+            model: model,
+            max_tokens: params[:max_tokens],
+            temperature: params[:temperature],
+            top_p: params[:top_p],
+            frequency_penalty: params[:frequency_penalty],
+            presence_penalty: params[:presence_penalty],
+            stop: params[:stop]
+          }.compact
+
+          # Prepare streaming response
+          headers = {
+            'Content-Type' => 'text/event-stream',
+            'Cache-Control' => 'no-cache',
+            'Connection' => 'keep-alive'
+          }
+
+          # Start streaming
+          chunked_body = Enumerator.new do |yielder|
+            complete_message = ''
+
+            # Stream the response
+            provider.generate_stream(context, options) do |chunk|
+              data = chunk.to_json
+              yielder << "data: #{data}\n\n"
+
+              # Accumulate content for final message
+              complete_message += chunk[:content] if chunk[:content]
+            end
+
+            # Add the complete message to context if requested
+            if params[:update_context] != false && !complete_message.empty?
+              message = RubyMCP::Models::Message.new(
+                role: 'assistant',
+                content: complete_message
+              )
+              storage.add_message(context_id, message)
+            end
+
+            # End the stream
+            yielder << "data: [DONE]\n\n"
+          end
+
+          [200, headers, chunked_body]
+        rescue RubyMCP::Errors::ContextError => e
+          not_found(e.message)
+        rescue RubyMCP::Errors::ProviderError, RubyMCP::Errors::EngineError => e
+          bad_request(e.message)
+        end
+      end
+
+      private
+
+      def parse_engine_id(engine_id)
+        parts = engine_id.to_s.split('/', 2)
+        raise RubyMCP::Errors::ValidationError, 'Invalid engine_id format' unless parts.length == 2
+
+        parts
+      end
+
+      def get_provider(provider_name)
+        provider_config = RubyMCP.configuration.providers[provider_name.to_sym]
+        raise RubyMCP::Errors::ProviderError, "Provider not configured: #{provider_name}" unless provider_config
+
+        class_name = provider_name.to_s.capitalize
+        unless RubyMCP::Providers.const_defined?(class_name)
+          raise RubyMCP::Errors::ProviderError, "Provider not found: #{provider_name}"
+        end
+
+        provider_class = RubyMCP::Providers.const_get(class_name)
+        provider_class.new(provider_config)
+      end
+    end
+  end
+end

data/lib/ruby_mcp/server/messages_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Server
+    class MessagesController < BaseController
+      def create
+        context_id = params[:context_id]
+
+        begin
+          # Create the message
+          message = RubyMCP::Models::Message.new(
+            role: params[:role],
+            content: params[:content],
+            id: params[:id],
+            metadata: params[:metadata]
+          )
+
+          # Add to the context
+          storage.add_message(context_id, message)
+
+          created(message.to_h)
+        rescue RubyMCP::Errors::ContextError => e
+          not_found(e.message)
+        rescue RubyMCP::Errors::ValidationError => e
+          bad_request(e.message)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mcp/server/router.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Server
+    class Router
+      Route = Struct.new(:http_method, :path, :controller, :action)
+
+      def initialize
+        @routes = []
+      end
+
+      def add(method, path, controller, action)
+        @routes << Route.new(method, path, controller, action)
+      end
+
+      def route(request)
+        route = find_route(request.request_method, request.path)
+        return nil unless route
+
+        params = extract_params(route.path, request.path)
+
+        # Add body params for non-GET requests
+        if request.post? || request.put?
+          begin
+            body_params = JSON.parse(request.body.read, symbolize_names: true)
+            params.merge!(body_params)
+          rescue JSON::ParserError
+            # Handle empty or invalid JSON
+          end
+        end
+
+        # Add query params
+        params.merge!(extract_query_params(request))
+
+        # Initialize the controller and call the action
+        controller = route.controller.new(request, params)
+        controller.send(route.action)
+      end
+
+      private
+
+      def find_route(method, path)
+        @routes.find do |route|
+          route.http_method == method && path_matches?(route.path, path)
+        end
+      end
+
+      def path_matches?(route_path, request_path)
+        route_parts = route_path.split('/')
+        request_parts = request_path.split('/')
+
+        return false if route_parts.length != request_parts.length
+
+        route_parts.zip(request_parts).all? do |route_part, request_part|
+          route_part.start_with?(':') || route_part == request_part
+        end
+      end
+
+      def extract_params(route_path, request_path)
+        params = {}
+
+        route_parts = route_path.split('/')
+        request_parts = request_path.split('/')
+
+        route_parts.zip(request_parts).each do |route_part, request_part|
+          if route_part.start_with?(':')
+            param_name = route_part[1..].to_sym
+            params[param_name] = request_part
+          end
+        end
+
+        params
+      end
+
+      def extract_query_params(request)
+        params = {}
+        request.params.each do |key, value|
+          params[key.to_sym] = value
+        end
+        params
+      end
+    end
+  end
+end

data/lib/ruby_mcp/storage/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Storage
+    class Base
+      def initialize(options = {})
+        @options = options
+      end
+
+      def create_context(context)
+        raise NotImplementedError, "#{self.class.name} must implement #create_context"
+      end
+
+      def get_context(context_id)
+        raise NotImplementedError, "#{self.class.name} must implement #get_context"
+      end
+
+      def update_context(context)
+        raise NotImplementedError, "#{self.class.name} must implement #update_context"
+      end
+
+      def delete_context(context_id)
+        raise NotImplementedError, "#{self.class.name} must implement #delete_context"
+      end
+
+      def list_contexts(limit: 100, offset: 0)
+        raise NotImplementedError, "#{self.class.name} must implement #list_contexts"
+      end
+
+      def add_message(context_id, message)
+        raise NotImplementedError, "#{self.class.name} must implement #add_message"
+      end
+
+      def add_content(context_id, content_id, content_data)
+        raise NotImplementedError, "#{self.class.name} must implement #add_content"
+      end
+
+      def get_content(context_id, content_id)
+        raise NotImplementedError, "#{self.class.name} must implement #get_content"
+      end
+    end
+  end
+end

data/lib/ruby_mcp/storage/memory.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RubyMCP
+  module Storage
+    class Memory < Base
+      def initialize(options = {})
+        super
+        @contexts = {}
+        @contents = {}
+      end
+
+      def create_context(context)
+        @contexts[context.id] = context
+        context
+      end
+
+      def get_context(context_id)
+        context = @contexts[context_id]
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless context
+
+        context
+      end
+
+      def update_context(context)
+        @contexts[context.id] = context
+        context
+      end
+
+      def delete_context(context_id)
+        context = get_context(context_id)
+        @contexts.delete(context_id)
+        @contents.delete(context_id)
+        context
+      end
+
+      def list_contexts(limit: 100, offset: 0)
+        @contexts.values
+                 .sort_by(&:updated_at)
+                 .reverse
+                 .slice(offset, limit) || []
+      end
+
+      def add_message(context_id, message)
+        context = get_context(context_id)
+        context.add_message(message)
+        update_context(context)
+        message
+      end
+
+      def add_content(context_id, content_id, content_data)
+        get_context(context_id)
+        @contents[context_id] ||= {}
+        @contents[context_id][content_id] = content_data
+        content_id
+      end
+
+      def get_content(context_id, content_id)
+        get_context(context_id)
+        contents = @contents[context_id] || {}
+        content = contents[content_id]
+        raise RubyMCP::Errors::ContentError, "Content not found: #{content_id}" unless content
+
+        content
+      end
+    end
+  end
+end

data/lib/ruby_mcp/validator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'schemas'
+
+module RubyMCP
+  class Validator
+    def self.validate_context(params)
+      validate(params, Schemas::ContextSchema)
+    end
+
+    def self.validate_message(params)
+      validate(params, Schemas::MessageSchema)
+    end
+
+    def self.validate_generate(params)
+      validate(params, Schemas::GenerateSchema)
+    end
+
+    def self.validate_content(params)
+      validate(params, Schemas::ContentSchema)
+    end
+
+    def self.validate(params, schema)
+      result = schema.call(params)
+
+      if result.success?
+        true
+      else
+        # This converts nested error hashes to strings properly
+        error_messages = format_errors(result.errors.to_h)
+        raise RubyMCP::Errors::ValidationError, "Validation failed: #{error_messages}"
+      end
+    end
+
+    def self.format_errors(errors, prefix = '')
+      errors.map do |key, value|
+        if value.is_a?(Hash)
+          format_errors(value, "#{prefix}#{key}.")
+        else
+          "#{prefix}#{key}: #{Array(value).join(', ')}"
+        end
+      end.join('; ')
+    end
+  end
+end

data/lib/ruby_mcp/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# lib/ruby_mcp/version.rb
+module RubyMCP
+  VERSION = '0.1.0'
+end

data/lib/ruby_mcp.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'jwt'
+require 'json'
+
+require 'concurrent'
+require 'logger'
+require 'dry-schema'
+
+require_relative 'ruby_mcp/version'
+require_relative 'ruby_mcp/errors'
+require_relative 'ruby_mcp/configuration'
+
+require_relative 'ruby_mcp/models/context'
+require_relative 'ruby_mcp/models/message'
+require_relative 'ruby_mcp/models/engine'
+require_relative 'ruby_mcp/providers/base'
+require_relative 'ruby_mcp/storage/base'
+require_relative 'ruby_mcp/storage/memory'
+require_relative 'ruby_mcp/server/router'
+require_relative 'ruby_mcp/server/base_controller'
+require_relative 'ruby_mcp/server/app'
+require_relative 'ruby_mcp/server/controller'
+require_relative 'ruby_mcp/server/engines_controller'
+require_relative 'ruby_mcp/server/contexts_controller'
+require_relative 'ruby_mcp/server/messages_controller'
+require_relative 'ruby_mcp/server/content_controller'
+require_relative 'ruby_mcp/server/generate_controller'
+require_relative 'ruby_mcp/providers/openai'
+require_relative 'ruby_mcp/providers/anthropic'
+
+require_relative 'ruby_mcp/schemas'
+require_relative 'ruby_mcp/validator'
+
+module RubyMCP
+  class << self
+    attr_accessor :configuration
+    attr_writer :logger
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+
+    def logger
+      @logger ||= Logger.new($stdout).tap do |log|
+        log.progname = name
+      end
+    end
+  end
+end