model-context-protocol-rb 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99ee11ebae0c9c984a15954b386e89489f6715a1d371b288ece0438d066436d7
-  data.tar.gz: cdf41e8742941e9a0a41c714127d02f5a189d901a95a35e6f61a16f1f7b8a704
+  metadata.gz: 5cce144594a63393d124f7edc41428730824f2e5df282b21458b506d1ac59376
+  data.tar.gz: f7a1de949d083fbcf9df57f500cad32869aa2c42b7dda17726509bab58ffc0b2
 SHA512:
-  metadata.gz: aad64bd6e42b2ecea2b742bb23b902ea1bfae3e77cffc5009b0a83712df7efac417b680bb460649bb73fff31d2d554d33a17d6fe96adb35f3cc9d0addbbcf9be
-  data.tar.gz: 6fa834a1c2bf4494748474dc26a29bede650b1a1913c7c543a7c195fd24fe99eda5f1610c40a63067f454b50f669b1fb47030e106fa6ba80cbde522bccfb9518
+  metadata.gz: f374a5e4cf00d1f905f86c51be35c812b6074c188dca28e2724a9e478afdba641337b4f17404ed44cdb22a86baf88dbcaf03df4896e5b039f1717eb3c8afbb71
+  data.tar.gz: 8bb5dd4e584f9df32265d1a88d9469e73b2c70225a88da510240bb5b7f80ef4f94b13738ed66a1f1bcec39012832efc0032d72d7ff93ede737ec31d737589243

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.3.3] - 2025-09-02
+
+- (Breaking) Added logging support.
+  - Requires updating the `enable_log` configuration option to `logging_enabled`.
+- Added experimental Streamable HTTP transport.
+- (Breaking) Renamed params to arguments in prompts, resources, and tools.
+  - Requires updating all references to `params` in prompts, resources, and tools to `arguments` with symbolized keys.
+- Improved ergonomics of completions and resource templates.
+- Added support for providing context to prompts, resources, and tools.
+
 ## [0.3.2] - 2025-05-10
 
 - Added resource template support.
@@ -37,8 +47,9 @@
 
 - Initial release
 
-[Unreleased]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.2...HEAD
-[0.3.1]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.1...v0.3.2
+[Unreleased]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.3...HEAD
+[0.3.3]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.2...v0.3.3
+[0.3.2]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.1.0...v0.2.0

data/README.md

@@ -30,7 +30,7 @@ Build a simple MCP server by registering your prompts, resources, resource templ
 server = ModelContextProtocol::Server.new do |config|
   config.name = "MCP Development Server"
   config.version = "1.0.0"
-  config.enable_log = true
+  config.logging_enabled = true
 
   # Environment Variables - https://modelcontextprotocol.io/docs/tools/debugging#environment-variables
   # Require specific environment variables to be set
@@ -39,6 +39,12 @@ server = ModelContextProtocol::Server.new do |config|
   # Set environment variables programmatically
   config.set_environment_variable("DEBUG_MODE", "true")
 
+  # Provide prompts, resources, and tools with contextual variables
+  config.context = {
+    user_id: "123456",
+    request_id: SecureRandom.uuid
+  }
+
   config.registry = ModelContextProtocol::Server::Registry.new do
     prompts list_changed: true do
       register TestPrompt
@@ -61,45 +67,159 @@ end
 server.start
 ```
 
+### Transport Configuration
+
+The MCP server supports different transport mechanisms for communication with clients. By default, it uses stdio (standard input/output), but you can also configure it to use streamable HTTP transport for distributed deployments.
+
+#### Stdio Transport (Default)
+
+When no transport is specified, the server uses stdio transport, which is suitable for single-process communication:
+
+```ruby
+server = ModelContextProtocol::Server.new do |config|
+  config.name = "MCP Development Server"
+  config.version = "1.0.0"
+  # No transport specified - uses stdio by default
+  config.registry = ModelContextProtocol::Server::Registry.new
+end
+
+server.start
+```
+
+#### Streamable HTTP Transport
+
+For distributed deployments with load balancers and multiple server instances, use the streamable HTTP transport with Redis-backed session management:
+
+```ruby
+require 'redis'
+
+server = ModelContextProtocol::Server.new do |config|
+  config.name = "MCP Development Server"
+  config.version = "1.0.0"
+
+  # Configure streamable HTTP transport
+  config.transport = {
+    type: :streamable_http,
+    redis_client: Redis.new(url: ENV['REDIS_URL']),
+    session_ttl: 3600 # Optional: session timeout in seconds (default: 3600)
+  }
+
+  config.registry = ModelContextProtocol::Server::Registry.new
+end
+
+# For HTTP frameworks, handle the request and return the response
+result = server.start
+# result will be a hash like: {json: {...}, status: 200, headers: {...}}
+```
+
+**Key Features:**
+- **Distributed Sessions**: Redis-backed session storage enables multiple server instances
+- **Load Balancer Support**: Sessions persist across different server instances  
+- **HTTP Methods**: Supports POST (requests), GET (Server-Sent Events), DELETE (cleanup)
+- **Cross-Server Routing**: Messages are routed between servers via Redis pub/sub
+
+**Integration Example (Rails):**
+
+```ruby
+class McpController < ApplicationController
+  def handle
+    server = ModelContextProtocol::Server.new do |config|
+      config.name = "Rails MCP Server"
+      config.version = "1.0.0"
+      config.transport = {
+        type: :streamable_http,
+        redis_client: Redis.new(url: ENV['REDIS_URL']),
+        request: request,
+        response: response
+      }
+      config.registry = build_registry
+    end
+
+    result = server.start
+    render json: result[:json], status: result[:status], headers: result[:headers]
+  end
+end
+```
+
 Messages from the MCP client will be routed to the appropriate custom handler. This SDK provides several classes that should be used to build your handlers.
 
+### Server features
+
 #### Prompts
 
 The `ModelContextProtocol::Server::Prompt` base class allows subclasses to define a prompt that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/prompts/) in the `with_metadata` block.
 
-Define any arguments using the `with_argument` block. You can mark an argument as required, and you can optionally provide the class name of a service object that provides completions. See [Completions](#completions) for more information.
+Define any arguments using the `with_argument` block. You can mark an argument as required, and you can optionally provide a completion class. See [Completions](#completions) for more information.
+
+Then implement the `call` method to build your prompt. Any arguments passed to the tool from the MCP client will be available in the `arguments` hash with symbol keys (e.g., `arguments[:argument_name]`), and any context values provided in the server configuration will be available in the `context` hash. Use the `respond_with` instance method to ensure your prompt responds with appropriately formatted response data.
 
-Then implement the `call` method to build your prompt. Use the `respond_with` instance method to ensure your prompt responds with appropriately formatted response data.
+You can also log from within your prompt by calling a valid logger level method on the `logger` and passing a string message.
 
 This is an example prompt that returns a properly formatted response:
 
 ```ruby
 class TestPrompt < ModelContextProtocol::Server::Prompt
+  ToneCompletion = ModelContextProtocol::Server::Completion.define do
+    hints = ["whiny", "angry", "callous", "desperate", "nervous", "sneaky"]
+    values = hints.grep(/#{argument_value}/)
+
+    respond_with values:
+  end
+
   with_metadata do
-    name "test_prompt"
-    description "A test prompt"
+    name "brainstorm_excuses"
+    description "A prompt for brainstorming excuses to get out of something"
   end
 
   with_argument do
-    name "message"
-    description "The thing to do"
+    name "undesirable_activity"
+    description "The thing to get out of"
     required true
-    completion TestCompletion
   end
 
   with_argument do
-    name "other"
-    description "Another thing to do"
+    name "tone"
+    description "The general tone to be used in the generated excuses"
     required false
+    completion ToneCompletion
   end
 
   def call
+    logger.info("Brainstorming excuses...")
     messages = [
       {
         role: "user",
         content: {
           type: "text",
-          text: "Do this: #{params["message"]}"
+          text: "My wife wants me to: #{arguments[:undesirable_activity]}... Can you believe it?"
+        }
+      },
+      {
+        role: "assistant",
+        content: {
+          type: "text",
+          text: "Oh, that's just downright awful. What are you going to do?"
+        }
+      },
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: "Well, I'd like to get out of it, but I'm going to need your help."
+        }
+      },
+      {
+        role: "assistant",
+        content: {
+          type: "text",
+          text: "Anything for you."
+        }
+      },
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: "Can you generate some excuses for me?" + (arguments[:tone] ? "Make them as #{arguments[:tone]} as possible." : "")
         }
       }
     ]
@@ -113,21 +233,35 @@ end
 
 The `ModelContextProtocol::Server::Resource` base class allows subclasses to define a resource that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/) in the `with_metadata` block.
 
-Then, implement the `call` method to build your resource. Use the `respond_with` instance method to ensure your resource responds with appropriately formatted response data.
+Then, implement the `call` method to build your resource. Any context values provided in the server configuration will be available in the `context` hash. Use the `respond_with` instance method to ensure your resource responds with appropriately formatted response data.
+
+You can also log from within your resource by calling a valid logger level method on the `logger` and passing a string message.
 
 This is an example resource that returns a text response:
 
 ```ruby
 class TestResource < ModelContextProtocol::Server::Resource
   with_metadata do
-    name "Test Resource"
-    description "A test resource"
+    name "top-secret-plans.txt"
+    description "Top secret plans to do top secret things"
     mime_type "text/plain"
-    uri "resource://test-resource"
+    uri "file:///top-secret-plans.txt"
   end
 
   def call
-    respond_with :text, text: "Here's the data"
+    unless authorized?(context[:user_id])
+      logger.info("This fool thinks he can get my top secret plans...")
+      return respond_with :text, text: "Nothing to see here, move along."
+    end
+
+    respond_with :text, text: "I'm finna eat all my wife's leftovers."
+  end
+
+  private
+
+  def authorized?(user_id)
+    authorized_users = ["42", "123456"]
+    authorized_users.any?(user_id)
   end
 end
 ```
@@ -137,14 +271,15 @@ This is an example resource that returns binary data:
 ```ruby
 class TestBinaryResource < ModelContextProtocol::Server::Resource
   with_metadata do
-    name "Project Logo"
+    name "project-logo.png"
     description "The logo for the project"
-    mime_type "image/jpeg"
-    uri "resource://project-logo"
+    mime_type "image/png"
+    uri "file:///project-logo.png"
   end
 
   def call
     # In a real implementation, we would retrieve the binary resource
+    # This is a small valid base64 encoded string (represents "test")
     data = "dGVzdA=="
     respond_with :binary, blob: data
   end
@@ -158,24 +293,22 @@ The `ModelContextProtocol::Server::ResourceTemplate` base class allows subclasse
 This is an example resource template that provides a completion for a parameter of the URI template:
 
 ```ruby
-class TestResourceTemplateCompletion < ModelContextProtocol::Server::Completion
-  def call
+class TestResourceTemplate < ModelContextProtocol::Server::ResourceTemplate
+  Completion = ModelContextProtocol::Server::Completion.define do
     hints = {
-      "name" => ["test-resource", "project-logo"]
+      "name" => ["top-secret-plans.txt"]
     }
     values = hints[argument_name].grep(/#{argument_value}/)
 
     respond_with values:
   end
-end
 
-class TestResourceTemplate < ModelContextProtocol::Server::ResourceTemplate
   with_metadata do
-    name "Test Resource Template"
-    description "A test resource template"
+    name "project-document-resource-template"
+    description "A resource template for retrieving project documents"
     mime_type "text/plain"
-    uri_template "resource://{name}" do
-      completion :name, TestResourceTemplateCompletion
+    uri_template "file:///{name}" do
+      completion :name, Completion
     end
   end
 end
@@ -185,7 +318,9 @@ end
 
 The `ModelContextProtocol::Server::Tool` base class allows subclasses to define a tool that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/tools/) in the `with_metadata` block.
 
-Then implement the `call` method to build your tool. Use the `respond_with` instance method to ensure your tool responds with appropriately formatted response data.
+Then, implement the `call` method to build your tool. Any arguments passed to the tool from the MCP client will be available in the `arguments` hash with symbol keys (e.g., `arguments[:argument_name]`), and any context values provided in the server configuration will be available in the `context` hash. Use the `respond_with` instance method to ensure your tool responds with appropriately formatted response data.
+
+You can also log from within your tool by calling a valid logger level method on the `logger` and passing a string message.
 
 This is an example tool that returns a text response:
 
@@ -208,9 +343,12 @@ class TestToolWithTextResponse < ModelContextProtocol::Server::Tool
   end
 
   def call
-    number = params["number"].to_i
-    result = number * 2
-    respond_with :text, text: "#{number} doubled is #{result}"
+    user_id = context[:user_id]
+    number = arguments[:number].to_i
+    logger.info("Silly user doesn't know how to double a number")
+    calculation = number * 2
+    salutation = user_id ? "User #{user_id}, " : ""
+    respond_with :text, text: salutation << "#{number} doubled is #{calculation}"
   end
 end
 ```
@@ -242,7 +380,7 @@ class TestToolWithImageResponse < ModelContextProtocol::Server::Tool
 
   def call
     # Map format to mime type
-    mime_type = case params["format"].downcase
+    mime_type = case arguments[:format].downcase
     when "svg"
       "image/svg+xml"
     when "jpg", "jpeg"
@@ -311,7 +449,7 @@ class TestToolWithResourceResponse < ModelContextProtocol::Server::Tool
   end
 
   def call
-    title = params["title"].downcase
+    title = arguments[:title].downcase
     # In a real implementation, we would do a lookup to get the document data
     document = "richtextdata"
     respond_with :resource, uri: "resource://document/#{title}", text: document, mime_type: "application/rtf"

data/lib/model_context_protocol/server/completion.rb

@@ -15,6 +15,12 @@ module ModelContextProtocol
       new(...).call
     end
 
+    def self.define(&block)
+      Class.new(self) do
+        define_method(:call, &block)
+      end
+    end
+
     private
 
     Response = Data.define(:values, :total, :hasMore) do

data/lib/model_context_protocol/server/configuration.rb

@@ -1,3 +1,5 @@
+require_relative "mcp_logger"
+
 module ModelContextProtocol
   class Server::Configuration
     # Raised when configured with invalid name.
@@ -12,16 +14,74 @@ module ModelContextProtocol
     # Raised when a required environment variable is not set
     class MissingRequiredEnvironmentVariable < StandardError; end
 
-    attr_accessor :enable_log, :name, :registry, :version
+    # Raised when transport configuration is invalid
+    class InvalidTransportError < StandardError; end
+
+    # Raised when an invalid log level is provided
+    class InvalidLogLevelError < StandardError; end
+
+    # Valid MCP log levels per the specification
+    VALID_LOG_LEVELS = %w[debug info notice warning error critical alert emergency].freeze
+
+    attr_accessor :name, :registry, :version, :transport
+    attr_reader :logger
+
+    def initialize
+      # Always create a logger - enabled by default
+      @logging_enabled = true
+      @default_log_level = "info"
+      @logger = ModelContextProtocol::Server::MCPLogger.new(
+        logger_name: "server",
+        level: @default_log_level,
+        enabled: @logging_enabled
+      )
+    end
 
     def logging_enabled?
-      enable_log || false
+      @logging_enabled
+    end
+
+    def logging_enabled=(value)
+      @logging_enabled = value
+      @logger = ModelContextProtocol::Server::MCPLogger.new(
+        logger_name: "server",
+        level: @default_log_level,
+        enabled: value
+      )
+    end
+
+    def default_log_level=(level)
+      unless VALID_LOG_LEVELS.include?(level.to_s)
+        raise InvalidLogLevelError, "Invalid log level: #{level}. Valid levels are: #{VALID_LOG_LEVELS.join(", ")}"
+      end
+
+      @default_log_level = level.to_s
+      @logger.set_mcp_level(@default_log_level)
+    end
+
+    def transport_type
+      case transport
+      when Hash
+        transport[:type] || transport["type"]
+      when Symbol, String
+        transport.to_sym
+      end
+    end
+
+    def transport_options
+      case transport
+      when Hash
+        transport.except(:type, "type").transform_keys(&:to_sym)
+      else
+        {}
+      end
     end
 
     def validate!
       raise InvalidServerNameError unless valid_name?
       raise InvalidRegistryError unless valid_registry?
       raise InvalidServerVersionError unless valid_version?
+      validate_transport!
 
       validate_environment_variables!
     end
@@ -51,6 +111,14 @@ module ModelContextProtocol
       environment_variables[key.to_s.upcase] = value
     end
 
+    def context
+      @context ||= {}
+    end
+
+    def context=(context_hash = {})
+      @context = context_hash
+    end
+
     private
 
     def required_environment_variables
@@ -74,5 +142,29 @@ module ModelContextProtocol
     def valid_version?
       version&.is_a?(String)
     end
+
+    def validate_transport!
+      case transport_type
+      when :streamable_http
+        validate_streamable_http_transport!
+      when :stdio, nil
+        # stdio transport has no required options
+      else
+        raise InvalidTransportError, "Unknown transport type: #{transport_type}" if transport_type
+      end
+    end
+
+    def validate_streamable_http_transport!
+      options = transport_options
+
+      unless options[:redis_client]
+        raise InvalidTransportError, "streamable_http transport requires redis_client option"
+      end
+
+      redis_client = options[:redis_client]
+      unless redis_client.respond_to?(:hset) && redis_client.respond_to?(:expire)
+        raise InvalidTransportError, "redis_client must be a Redis-compatible client"
+      end
+    end
   end
 end

data/lib/model_context_protocol/server/mcp_logger.rb

@@ -0,0 +1,109 @@
+require "logger"
+require "forwardable"
+require "json"
+
+module ModelContextProtocol
+  class Server::MCPLogger
+    extend Forwardable
+
+    def_delegators :@internal_logger, :datetime_format=, :formatter=, :progname, :progname=
+
+    LEVEL_MAP = {
+      "debug" => Logger::DEBUG,
+      "info" => Logger::INFO,
+      "notice" => Logger::INFO,
+      "warning" => Logger::WARN,
+      "error" => Logger::ERROR,
+      "critical" => Logger::FATAL,
+      "alert" => Logger::FATAL,
+      "emergency" => Logger::UNKNOWN
+    }.freeze
+
+    REVERSE_LEVEL_MAP = {
+      Logger::DEBUG => "debug",
+      Logger::INFO => "info",
+      Logger::WARN => "warning",
+      Logger::ERROR => "error",
+      Logger::FATAL => "critical",
+      Logger::UNKNOWN => "emergency"
+    }.freeze
+
+    attr_accessor :transport
+    attr_reader :logger_name, :enabled
+
+    def initialize(logger_name: "server", level: "info", enabled: true)
+      @logger_name = logger_name
+      @enabled = enabled
+      @internal_logger = Logger.new(nil)
+      @internal_logger.level = LEVEL_MAP[level] || Logger::INFO
+      @transport = nil
+      @queued_messages = []
+    end
+
+    %i[debug info warn error fatal unknown].each do |severity|
+      define_method(severity) do |message = nil, **data, &block|
+        return true unless @enabled
+        add(Logger.const_get(severity.to_s.upcase), message, data, &block)
+      end
+    end
+
+    def add(severity, message = nil, data = {}, &block)
+      return true unless @enabled
+      return true if severity < @internal_logger.level
+
+      message = block.call if message.nil? && block_given?
+      send_notification(severity, message, data)
+      true
+    end
+
+    def level=(value)
+      @internal_logger.level = value
+    end
+
+    def level
+      @internal_logger.level
+    end
+
+    def set_mcp_level(mcp_level)
+      self.level = LEVEL_MAP[mcp_level] || Logger::INFO
+    end
+
+    def connect_transport(transport)
+      @transport = transport
+      flush_queued_messages if @enabled
+    end
+
+    private
+
+    def send_notification(severity, message, data)
+      return unless @enabled
+
+      notification_params = {
+        level: REVERSE_LEVEL_MAP[severity] || "info",
+        logger: @logger_name,
+        data: format_data(message, data)
+      }
+
+      if @transport
+        @transport.send_notification("notifications/message", notification_params)
+      else
+        @queued_messages << notification_params
+      end
+    end
+
+    def format_data(message, additional_data)
+      data = {}
+      data[:message] = message.to_s if message
+      data.merge!(additional_data) unless additional_data.empty?
+      data
+    end
+
+    def flush_queued_messages
+      return unless @transport && @enabled
+      @queued_messages.each do |params|
+        @transport.send_notification("notifications/message", params)
+      end
+      @queued_messages.clear
+    end
+  end
+end

data/lib/model_context_protocol/server/prompt.rb

@@ -1,10 +1,12 @@
 module ModelContextProtocol
   class Server::Prompt
-    attr_reader :params
+    attr_reader :params, :context, :logger
 
-    def initialize(params)
+    def initialize(params, logger, context = {})
       validate!(params)
       @params = params
+      @context = context
+      @logger = logger
     end
 
     def call
@@ -24,8 +26,8 @@ module ModelContextProtocol
 
     private def validate!(params = {})
       arguments = self.class.arguments || []
-      required_args = arguments.select { |arg| arg[:required] }.map { |arg| arg[:name] }
-      valid_arg_names = arguments.map { |arg| arg[:name] }
+      required_args = arguments.select { |arg| arg[:required] }.map { |arg| arg[:name].to_sym }
+      valid_arg_names = arguments.map { |arg| arg[:name].to_sym }
 
       missing_args = required_args - params.keys
       unless missing_args.empty?
@@ -73,8 +75,8 @@ module ModelContextProtocol
         subclass.instance_variable_set(:@arguments, @arguments&.dup)
       end
 
-      def call(params)
-        new(params).call
+      def call(params, logger, context = {})
+        new(params, logger, context).call
       rescue ArgumentError => error
         raise ModelContextProtocol::Server::ParameterValidationError, error.message
       end

data/lib/model_context_protocol/server/resource.rb

@@ -1,10 +1,12 @@
 module ModelContextProtocol
   class Server::Resource
-    attr_reader :mime_type, :uri
+    attr_reader :mime_type, :uri, :context, :logger
 
-    def initialize
+    def initialize(logger, context = {})
       @mime_type = self.class.mime_type
       @uri = self.class.uri
+      @context = context
+      @logger = logger
     end
 
     def call
@@ -56,8 +58,8 @@ module ModelContextProtocol
         subclass.instance_variable_set(:@uri, @uri)
       end
 
-      def call
-        new.call
+      def call(logger, context = {})
+        new(logger, context).call
       end
 
       def metadata

data/lib/model_context_protocol/server/session_store.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+
+module ModelContextProtocol
+  class Server
+    class SessionStore
+      def initialize(redis_client, ttl: 3600)
+        @redis = redis_client
+        @ttl = ttl
+      end
+
+      def create_session(session_id, data)
+        session_data = {
+          id: session_id,
+          server_instance: data[:server_instance],
+          context: data[:context] || {},
+          created_at: data[:created_at] || Time.now.to_f,
+          last_activity: Time.now.to_f,
+          active_stream: false
+        }
+
+        @redis.hset("session:#{session_id}", session_data.transform_values(&:to_json))
+        @redis.expire("session:#{session_id}", @ttl)
+        session_id
+      end
+
+      def mark_stream_active(session_id, server_instance)
+        @redis.multi do |multi|
+          multi.hset("session:#{session_id}",
+            "active_stream", true.to_json,
+            "stream_server", server_instance.to_json,
+            "last_activity", Time.now.to_f.to_json)
+          multi.expire("session:#{session_id}", @ttl)
+        end
+      end
+
+      def mark_stream_inactive(session_id)
+        @redis.multi do |multi|
+          multi.hset("session:#{session_id}",
+            "active_stream", false.to_json,
+            "stream_server", nil.to_json,
+            "last_activity", Time.now.to_f.to_json)
+          multi.expire("session:#{session_id}", @ttl)
+        end
+      end
+
+      def get_session_server(session_id)
+        server_data = @redis.hget("session:#{session_id}", "stream_server")
+        server_data ? JSON.parse(server_data) : nil
+      end
+
+      def session_exists?(session_id)
+        @redis.exists("session:#{session_id}") == 1
+      end
+
+      def session_has_active_stream?(session_id)
+        stream_data = @redis.hget("session:#{session_id}", "active_stream")
+        stream_data ? JSON.parse(stream_data) : false
+      end
+
+      def get_session_context(session_id)
+        context_data = @redis.hget("session:#{session_id}", "context")
+        context_data ? JSON.parse(context_data) : {}
+      end
+
+      def cleanup_session(session_id)
+        @redis.del("session:#{session_id}")
+      end
+
+      def route_message_to_session(session_id, message)
+        server_instance = get_session_server(session_id)
+        return false unless server_instance
+
+        # Publish to server-specific channel
+        @redis.publish("server:#{server_instance}:messages", {
+          session_id: session_id,
+          message: message
+        }.to_json)
+        true
+      end
+
+      def subscribe_to_server(server_instance, &block)
+        @redis.subscribe("server:#{server_instance}:messages") do |on|
+          on.message do |channel, message|
+            data = JSON.parse(message)
+            yield(data)
+          end
+        end
+      end
+
+      def get_all_active_sessions
+        keys = @redis.keys("session:*")
+        active_sessions = []
+
+        keys.each do |key|
+          session_id = key.sub("session:", "")
+          if session_has_active_stream?(session_id)
+            active_sessions << session_id
+          end
+        end
+
+        active_sessions
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/stdio_transport.rb

@@ -12,16 +12,19 @@ module ModelContextProtocol
       end
     end
 
-    attr_reader :logger, :router
+    attr_reader :router, :configuration
 
-    def initialize(logger:, router:)
-      @logger = logger
+    def initialize(router:, configuration:)
       @router = router
+      @configuration = configuration
     end
 
-    def begin
+    def handle
+      # Connect logger to transport
+      @configuration.logger.connect_transport(self)
+
       loop do
-        line = $stdin.gets
+        line = receive_message
         break unless line
 
         begin
@@ -31,18 +34,17 @@ module ModelContextProtocol
           result = router.route(message)
           send_message(Response[id: message["id"], result: result.serialized])
         rescue ModelContextProtocol::Server::ParameterValidationError => validation_error
-          log("Validation error: #{validation_error.message}")
+          @configuration.logger.error("Validation error", error: validation_error.message)
           send_message(
             ErrorResponse[id: message["id"], error: {code: -32602, message: validation_error.message}]
           )
         rescue JSON::ParserError => parser_error
-          log("Parser error: #{parser_error.message}")
+          @configuration.logger.error("Parser error", error: parser_error.message)
           send_message(
             ErrorResponse[id: "", error: {code: -32700, message: parser_error.message}]
           )
         rescue => error
-          log("Internal error: #{error.message}")
-          log(error.backtrace)
+          @configuration.logger.error("Internal error", error: error.message, backtrace: error.backtrace.first(5))
           send_message(
             ErrorResponse[id: message["id"], error: {code: -32603, message: error.message}]
           )
@@ -50,10 +52,23 @@ module ModelContextProtocol
       end
     end
 
+    def send_notification(method, params)
+      notification = {
+        jsonrpc: "2.0",
+        method: method,
+        params: params
+      }
+      $stdout.puts(JSON.generate(notification))
+      $stdout.flush
+    rescue IOError => e
+      # Handle broken pipe gracefully
+      @configuration.logger.debug("Failed to send notification", error: e.message) if @configuration.logging_enabled?
+    end
+
     private
 
-    def log(output, level = :error)
-      logger.send(level.to_sym, output)
+    def receive_message
+      $stdin.gets
     end
 
     def send_message(message)

data/lib/model_context_protocol/server/streamable_http_transport.rb

@@ -0,0 +1,291 @@
+require "json"
+require "securerandom"
+
+module ModelContextProtocol
+  class Server::StreamableHttpTransport
+    Response = Data.define(:id, :result) do
+      def serialized
+        {jsonrpc: "2.0", id:, result:}
+      end
+    end
+
+    ErrorResponse = Data.define(:id, :error) do
+      def serialized
+        {jsonrpc: "2.0", id:, error:}
+      end
+    end
+    def initialize(router:, configuration:)
+      @router = router
+      @configuration = configuration
+
+      transport_options = @configuration.transport_options
+      @redis = transport_options[:redis_client]
+
+      @session_store = ModelContextProtocol::Server::SessionStore.new(
+        @redis,
+        ttl: transport_options[:session_ttl] || 3600
+      )
+
+      @server_instance = "#{Socket.gethostname}-#{Process.pid}-#{SecureRandom.hex(4)}"
+      @local_streams = {}
+      @notification_queue = []
+
+      setup_redis_subscriber
+    end
+
+    def handle
+      @configuration.logger.connect_transport(self)
+
+      request = @configuration.transport_options[:request]
+      response = @configuration.transport_options[:response]
+
+      unless request && response
+        raise ArgumentError, "StreamableHTTP transport requires request and response objects in transport_options"
+      end
+
+      case request.method
+      when "POST"
+        handle_post_request(request)
+      when "GET"
+        handle_sse_request(request, response)
+      when "DELETE"
+        handle_delete_request(request)
+      else
+        error_response = ErrorResponse[id: nil, error: {code: -32601, message: "Method not allowed"}]
+        {json: error_response.serialized, status: 405}
+      end
+    end
+
+    def send_notification(method, params)
+      notification = {
+        jsonrpc: "2.0",
+        method: method,
+        params: params
+      }
+
+      if has_active_streams?
+        deliver_to_active_streams(notification)
+      else
+        @notification_queue << notification
+      end
+    end
+
+    private
+
+    def handle_post_request(request)
+      body_string = request.body.read
+      body = JSON.parse(body_string)
+      session_id = request.headers["Mcp-Session-Id"]
+
+      case body["method"]
+      when "initialize"
+        handle_initialization(body)
+      else
+        handle_regular_request(body, session_id)
+      end
+    rescue JSON::ParserError
+      error_response = ErrorResponse[id: "", error: {code: -32700, message: "Parse error"}]
+      {json: error_response.serialized, status: 400}
+    rescue ModelContextProtocol::Server::ParameterValidationError => validation_error
+      @configuration.logger.error("Validation error", error: validation_error.message)
+      error_response = ErrorResponse[id: body&.dig("id"), error: {code: -32602, message: validation_error.message}]
+      {json: error_response.serialized, status: 400}
+    rescue => e
+      @configuration.logger.error("Error handling POST request", error: e.message, backtrace: e.backtrace.first(5))
+      error_response = ErrorResponse[id: body&.dig("id"), error: {code: -32603, message: "Internal error"}]
+      {json: error_response.serialized, status: 500}
+    end
+
+    def handle_initialization(body)
+      session_id = SecureRandom.uuid
+
+      @session_store.create_session(session_id, {
+        server_instance: @server_instance,
+        context: @configuration.context || {},
+        created_at: Time.now.to_f
+      })
+
+      result = @router.route(body)
+      response = Response[id: body["id"], result: result.serialized]
+
+      {
+        json: response.serialized,
+        status: 200,
+        headers: {"Mcp-Session-Id" => session_id}
+      }
+    end
+
+    def handle_regular_request(body, session_id)
+      unless session_id && @session_store.session_exists?(session_id)
+        error_response = ErrorResponse[id: body["id"], error: {code: -32600, message: "Invalid or missing session ID"}]
+        return {json: error_response.serialized, status: 400}
+      end
+
+      result = @router.route(body)
+      response = Response[id: body["id"], result: result.serialized]
+
+      if @session_store.session_has_active_stream?(session_id)
+        deliver_to_session_stream(session_id, response.serialized)
+        {json: {accepted: true}, status: 200}
+      else
+        {json: response.serialized, status: 200}
+      end
+    end
+
+    def handle_sse_request(request, response)
+      session_id = request.headers["Mcp-Session-Id"]
+
+      unless session_id && @session_store.session_exists?(session_id)
+        error_response = ErrorResponse[id: nil, error: {code: -32600, message: "Invalid or missing session ID"}]
+        return {json: error_response.serialized, status: 400}
+      end
+
+      @session_store.mark_stream_active(session_id, @server_instance)
+
+      {
+        stream: true,
+        headers: {
+          "Content-Type" => "text/event-stream",
+          "Cache-Control" => "no-cache",
+          "Connection" => "keep-alive"
+        },
+        stream_proc: create_sse_stream_proc(session_id)
+      }
+    end
+
+    def handle_delete_request(request)
+      session_id = request.headers["Mcp-Session-Id"]
+
+      if session_id
+        cleanup_session(session_id)
+      end
+
+      {json: {success: true}, status: 200}
+    end
+
+    def create_sse_stream_proc(session_id)
+      proc do |stream|
+        register_local_stream(session_id, stream)
+
+        flush_notifications_to_stream(stream)
+
+        start_keepalive_thread(session_id, stream)
+
+        loop do
+          break unless stream_connected?(stream)
+          sleep 0.1
+        end
+      ensure
+        cleanup_local_stream(session_id)
+      end
+    end
+
+    def register_local_stream(session_id, stream)
+      @local_streams[session_id] = stream
+    end
+
+    def cleanup_local_stream(session_id)
+      @local_streams.delete(session_id)
+      @session_store.mark_stream_inactive(session_id)
+    end
+
+    def stream_connected?(stream)
+      return false unless stream
+
+      begin
+        stream.write(": ping\n\n")
+        stream.flush if stream.respond_to?(:flush)
+        true
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+        false
+      end
+    end
+
+    def start_keepalive_thread(session_id, stream)
+      Thread.new do
+        loop do
+          sleep 30
+          break unless stream_connected?(stream)
+
+          begin
+            send_ping_to_stream(stream)
+          rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+            break
+          end
+        end
+      rescue => e
+        @configuration.logger.error("Keepalive thread error", error: e.message)
+      ensure
+        cleanup_local_stream(session_id)
+      end
+    end
+
+    def send_ping_to_stream(stream)
+      stream.write(": ping #{Time.now.iso8601}\n\n")
+      stream.flush if stream.respond_to?(:flush)
+    end
+
+    def send_to_stream(stream, data)
+      message = data.is_a?(String) ? data : data.to_json
+      stream.write("data: #{message}\n\n")
+      stream.flush if stream.respond_to?(:flush)
+    end
+
+    def deliver_to_session_stream(session_id, data)
+      if @local_streams[session_id]
+        begin
+          send_to_stream(@local_streams[session_id], data)
+          return true
+        rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+          cleanup_local_stream(session_id)
+        end
+      end
+
+      @session_store.route_message_to_session(session_id, data)
+    end
+
+    def cleanup_session(session_id)
+      cleanup_local_stream(session_id)
+      @session_store.cleanup_session(session_id)
+    end
+
+    def setup_redis_subscriber
+      Thread.new do
+        @session_store.subscribe_to_server(@server_instance) do |data|
+          session_id = data["session_id"]
+          message = data["message"]
+
+          if @local_streams[session_id]
+            begin
+              send_to_stream(@local_streams[session_id], message)
+            rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+              cleanup_local_stream(session_id)
+            end
+          end
+        end
+      rescue => e
+        @configuration.logger.error("Redis subscriber error", error: e.message, backtrace: e.backtrace.first(5))
+        sleep 5
+        retry
+      end
+    end
+
+    def has_active_streams?
+      @local_streams.any?
+    end
+
+    def deliver_to_active_streams(notification)
+      @local_streams.each do |session_id, stream|
+        send_to_stream(stream, notification)
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+        cleanup_local_stream(session_id)
+      end
+    end
+
+    def flush_notifications_to_stream(stream)
+      while (notification = @notification_queue.shift)
+        send_to_stream(stream, notification)
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/tool.rb

@@ -2,11 +2,13 @@ require "json-schema"
 
 module ModelContextProtocol
   class Server::Tool
-    attr_reader :params
+    attr_reader :params, :context, :logger
 
-    def initialize(params)
+    def initialize(params, logger, context = {})
       validate!(params)
       @params = params
+      @context = context
+      @logger = logger
     end
 
     def call
@@ -90,8 +92,8 @@ module ModelContextProtocol
         subclass.instance_variable_set(:@input_schema, @input_schema)
       end
 
-      def call(params)
-        new(params).call
+      def call(params, logger, context = {})
+        new(params, logger, context).call
       rescue JSON::Schema::ValidationError => validation_error
         raise ModelContextProtocol::Server::ParameterValidationError, validation_error.message
       rescue ModelContextProtocol::Server::ResponseArgumentsError => response_arguments_error

data/lib/model_context_protocol/server.rb

@@ -19,13 +19,25 @@ module ModelContextProtocol
 
     def start
       configuration.validate!
-      logdev = configuration.logging_enabled? ? $stderr : File::NULL
-      StdioTransport.new(logger: Logger.new(logdev), router:).begin
+
+      transport = case configuration.transport_type
+      when :stdio, nil
+        StdioTransport.new(router: @router, configuration: @configuration)
+      when :streamable_http
+        StreamableHttpTransport.new(
+          router: @router,
+          configuration: @configuration
+        )
+      else
+        raise ArgumentError, "Unknown transport: #{configuration.transport_type}"
+      end
+
+      transport.handle
     end
 
     private
 
-    PROTOCOL_VERSION = "2024-11-05".freeze
+    PROTOCOL_VERSION = "2025-06-18".freeze
     private_constant :PROTOCOL_VERSION
 
     InitializeResponse = Data.define(:protocol_version, :capabilities, :server_info) do
@@ -44,6 +56,12 @@ module ModelContextProtocol
       end
     end
 
+    LoggingSetLevelResponse = Data.define do
+      def serialized
+        {}
+      end
+    end
+
     def map_handlers
       router.map("initialize") do |_message|
         InitializeResponse[
@@ -60,6 +78,17 @@ module ModelContextProtocol
         PingResponse[]
       end
 
+      router.map("logging/setLevel") do |message|
+        level = message["params"]["level"]
+
+        unless Configuration::VALID_LOG_LEVELS.include?(level)
+          raise ParameterValidationError, "Invalid log level: #{level}. Valid levels are: #{Configuration::VALID_LOG_LEVELS.join(", ")}"
+        end
+
+        configuration.logger.set_mcp_level(level)
+        LoggingSetLevelResponse[]
+      end
+
       router.map("completion/complete") do |message|
         type = message["params"]["ref"]["type"]
 
@@ -94,7 +123,7 @@ module ModelContextProtocol
           raise ModelContextProtocol::Server::ParameterValidationError, "resource not found for #{uri}"
         end
 
-        resource.call
+        resource.call(configuration.logger, configuration.context)
       end
 
       router.map("resources/templates/list") do |message|
@@ -106,7 +135,12 @@ module ModelContextProtocol
       end
 
       router.map("prompts/get") do |message|
-        configuration.registry.find_prompt(message["params"]["name"]).call(message["params"]["arguments"])
+        arguments = message["params"]["arguments"]
+        symbolized_arguments = arguments.transform_keys(&:to_sym)
+        configuration
+          .registry
+          .find_prompt(message["params"]["name"])
+          .call(symbolized_arguments, configuration.logger, configuration.context)
       end
 
       router.map("tools/list") do
@@ -114,7 +148,12 @@ module ModelContextProtocol
       end
 
       router.map("tools/call") do |message|
-        configuration.registry.find_tool(message["params"]["name"]).call(message["params"]["arguments"])
+        arguments = message["params"]["arguments"]
+        symbolized_arguments = arguments.transform_keys(&:to_sym)
+        configuration
+          .registry
+          .find_tool(message["params"]["name"])
+          .call(symbolized_arguments, configuration.logger, configuration.context)
       end
     end
 

data/lib/model_context_protocol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ModelContextProtocol
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

data/tasks/templates/dev.erb

@@ -1,6 +1,7 @@
 #!/usr/bin/env <%= @ruby_path %>
 
 require "bundler/setup"
+require "securerandom"
 require_relative "../lib/model_context_protocol"
 
 Dir[File.join(__dir__, "../spec/support/**/*.rb")].each { |file| require file }
@@ -8,7 +9,15 @@ Dir[File.join(__dir__, "../spec/support/**/*.rb")].each { |file| require file }
 server = ModelContextProtocol::Server.new do |config|
   config.name = "MCP Development Server"
   config.version = "1.0.0"
-  config.enable_log = true
+  config.logging_enabled = true
+
+  config.set_environment_variable("MCP_ENV", "development")
+
+  config.context = {
+    user_id: "123456",
+    request_id: SecureRandom.uuid
+  }
+
   config.registry = ModelContextProtocol::Server::Registry.new do
     prompts list_changed: true do
       register TestPrompt

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: model-context-protocol-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Dick Davis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-10 00:00:00.000000000 Z
+date: 2025-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -58,12 +58,15 @@ files:
 - lib/model_context_protocol/server.rb
 - lib/model_context_protocol/server/completion.rb
 - lib/model_context_protocol/server/configuration.rb
+- lib/model_context_protocol/server/mcp_logger.rb
 - lib/model_context_protocol/server/prompt.rb
 - lib/model_context_protocol/server/registry.rb
 - lib/model_context_protocol/server/resource.rb
 - lib/model_context_protocol/server/resource_template.rb
 - lib/model_context_protocol/server/router.rb
+- lib/model_context_protocol/server/session_store.rb
 - lib/model_context_protocol/server/stdio_transport.rb
+- lib/model_context_protocol/server/streamable_http_transport.rb
 - lib/model_context_protocol/server/tool.rb
 - lib/model_context_protocol/version.rb
 - tasks/mcp.rake