ruby_llm-mcp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0de5a83b2962398c602fe95d3b1c606bf3c0d1b8367209b70f9ef1f41a7f1e2
+  data.tar.gz: 65c1a8c158efc387d9bec8ee67b701432cc605fd276647496d0825d0d83cafb3
+SHA512:
+  metadata.gz: 416161bdd8d22711c144dd7bf3460e27f01cd57f764ebc5d024748bcdcc4fcf279898da28fefcba1ae31546f8b001d48798c7f9e48a0c1bc7b1ad555e2334fcd
+  data.tar.gz: f9a6cbabf0e78aa89268c0cbbdaa2e07e9b33497cf47d1eab7282f60c6bfa161e4d5cbb7a1e6694de93ed18988318c1040ee0e3ffcd363b5d2d761e40158ce1b

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Patrick Vice
+
+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,183 @@
+# RubyLLM::MCP
+
+Aiming to make using MCP with RubyLLM as easy as possible.
+
+This project is a Ruby client for the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/), designed to work seamlessly with [RubyLLM](https://github.com/patvice/ruby_llm). This gem enables Ruby applications to connect to MCP servers and use their tools as part of LLM conversations.
+
+**Note:** This project is still under development and the API is subject to change. Currently supports the connecting workflow, tool lists and tool execution.
+
+## Features
+
+- 🔌 **Multiple Transport Types**: Support for SSE (Server-Sent Events) and stdio transports
+- 🛠️ **Tool Integration**: Automatically converts MCP tools into RubyLLM-compatible tools
+- 🔄 **Real-time Communication**: Efficient bidirectional communication with MCP servers
+- 🎯 **Simple API**: Easy-to-use interface that integrates seamlessly with RubyLLM
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruby_llm-mcp'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install ruby_llm-mcp
+```
+
+## Usage
+
+### Basic Setup
+
+First, configure your RubyLLM client and create an MCP connection:
+
+```ruby
+require 'ruby_llm/mcp'
+
+# Configure RubyLLM
+RubyLLM.configure do |config|
+  config.openai_api_key = "your-api-key"
+end
+
+# Connect to an MCP server via SSE
+client = RubyLLM::MCP.client(
+  name: "my-mcp-server",
+  transport_type: "sse",
+  config: {
+    url: "http://localhost:9292/mcp/sse"
+  }
+)
+
+# Or connect via stdio
+client = RubyLLM::MCP.client(
+  name: "my-mcp-server",
+  transport_type: "stdio",
+  config: {
+    command: "node",
+    args: ["path/to/mcp-server.js"],
+    env: { "NODE_ENV" => "production" }
+  }
+)
+```
+
+### Using MCP Tools with RubyLLM
+
+```ruby
+# Get available tools from the MCP server
+tools = client.tools
+puts "Available tools:"
+tools.each do |tool|
+  puts "- #{tool.name}: #{tool.description}"
+end
+
+# Create a chat session with MCP tools
+chat = RubyLLM.chat(model: "gpt-4")
+chat.with_tools(*client.tools)
+
+# Ask a question that will use the MCP tools
+response = chat.ask("Can you help me search for recent files in my project?")
+puts response
+```
+
+### Streaming Responses with Tool Calls
+
+```ruby
+chat = RubyLLM.chat(model: "gpt-4")
+chat.with_tools(*client.tools)
+
+chat.ask("Analyze my project structure") do |chunk|
+  if chunk.tool_call?
+    chunk.tool_calls.each do |key, tool_call|
+      puts "\n🔧 Using tool: #{tool_call.name}"
+    end
+  else
+    print chunk.content
+  end
+end
+```
+
+### Manual Tool Execution
+
+You can also execute MCP tools directly:
+
+```ruby
+# Execute a specific tool
+result = client.execute_tool(
+  name: "search_files",
+  parameters: {
+    query: "*.rb",
+    directory: "/path/to/search"
+  }
+)
+
+puts result
+```
+
+## Transport Types
+
+### SSE (Server-Sent Events)
+
+Best for web-based MCP servers or when you need HTTP-based communication:
+
+```ruby
+client = RubyLLM::MCP.client(
+  name: "web-mcp-server",
+  transport_type: "sse",
+  config: {
+    url: "https://your-mcp-server.com/mcp/sse"
+  }
+)
+```
+
+### Stdio
+
+Best for local MCP servers or command-line tools:
+
+```ruby
+client = RubyLLM::MCP.client(
+  name: "local-mcp-server",
+  transport_type: "stdio",
+  config: {
+    command: "python",
+    args: ["-m", "my_mcp_server"],
+    env: { "DEBUG" => "1" }
+  }
+)
+```
+
+## Configuration Options
+
+- `name`: A unique identifier for your MCP client
+- `transport_type`: Either `:sse` or `:stdio`
+- `request_timeout`: Timeout for requests in milliseconds (default: 8000)
+- `config`: Transport-specific configuration
+  - For SSE: `{ url: "http://..." }`
+  - For stdio: `{ command: "...", args: [...], env: {...} }`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Examples
+
+Check out the `examples/` directory for more detailed usage examples:
+
+- `examples/test_local_mcp.rb` - Complete example with SSE transport
+
+## Contributing
+
+We welcome contributions! Bug reports and pull requests are welcome on GitHub at https://github.com/patvice/ruby_llm-mcp.
+
+## License
+
+Released under the MIT License.

data/lib/ruby_llm/mcp/client.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Client
+      PROTOCOL_VERSION = "2025-03-26"
+
+      def initialize(name:, transport_type:, request_timeout: 8000, reverse_proxy_url: nil, config: {})
+        @name = name
+        @config = config
+        @transport_type = transport_type.to_sym
+
+        # TODO: Add streamable HTTP
+        case @transport_type
+        when :sse
+          @transport = RubyLLM::MCP::Transport::SSE.new(config[:url])
+        when :stdio
+          @transport = RubyLLM::MCP::Transport::Stdio.new(config[:command], args: config[:args], env: config[:env])
+        else
+          raise "Invalid transport type: #{transport_type}"
+        end
+
+        @request_timeout = request_timeout
+        @reverse_proxy_url = reverse_proxy_url
+
+        initialize_request
+        notification_request
+      end
+
+      def request(body, wait_for_response: true)
+        @transport.request(body, wait_for_response: wait_for_response)
+      end
+
+      def tools(refresh: false)
+        @tools = nil if refresh
+        @tools ||= fetch_and_create_tools
+      end
+
+      def execute_tool(name:, parameters:)
+        response = execute_tool_request(name: name, parameters: parameters)
+        result = response["result"]
+        # TODO: handle tool error when "isError" is true in result
+        #
+        # TODO: Implement "type": "image" and "type": "resource"
+        result["content"].map { |content| content["text"] }.join("\n")
+      end
+
+      private
+
+      def initialize_request
+        @initialize_response = RubyLLM::MCP::Requests::Initialization.new(self).call
+      end
+
+      def notification_request
+        @notification_response = RubyLLM::MCP::Requests::Notification.new(self).call
+      end
+
+      def tool_list_request
+        @tool_request = RubyLLM::MCP::Requests::ToolList.new(self).call
+      end
+
+      def execute_tool_request(name:, parameters:)
+        @execute_tool_response = RubyLLM::MCP::Requests::ToolCall.new(self, name: name, parameters: parameters).call
+      end
+
+      def fetch_and_create_tools
+        tools_response = tool_list_request
+        tools_response = tools_response["result"]["tools"]
+
+        @tools = tools_response.map do |tool|
+          RubyLLM::MCP::Tool.new(self, tool)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Errors
+      class TimeoutError < StandardError
+        attr_reader :message
+
+        def initialize(message:)
+          @message = message
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyLLM
+  module MCP
+    module Requests
+      class Base
+        attr_reader :client
+
+        def initialize(client)
+          @client = client
+        end
+
+        def call
+          raise "Not implemented"
+        end
+
+        private
+
+        def validate_response!(response, body)
+          # TODO: Implement response validation
+        end
+
+        def raise_error(error)
+          raise "MCP Error: code: #{error['code']} message: #{error['message']} data: #{error['data']}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/initialization.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class RubyLLM::MCP::Requests::Initialization < RubyLLM::MCP::Requests::Base
+  def call
+    client.request(initialize_body)
+  end
+
+  private
+
+  def initialize_body
+    {
+      jsonrpc: "2.0",
+      method: "initialize",
+      params: {
+        protocolVersion: RubyLLM::MCP::Client::PROTOCOL_VERSION,
+        capabilities: {
+          tools: {
+            listChanged: true
+          }
+        },
+        clientInfo: {
+          name: "RubyLLM MCP Client",
+          version: RubyLLM::MCP::VERSION
+        }
+      }
+    }
+  end
+end

data/lib/ruby_llm/mcp/requests/notification.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class RubyLLM::MCP::Requests::Notification < RubyLLM::MCP::Requests::Base
+  def call
+    client.request(notification_body, wait_for_response: false)
+  end
+
+  def notification_body
+    {
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    }
+  end
+end

data/lib/ruby_llm/mcp/requests/tool_call.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ToolCall
+        def initialize(client, name:, parameters: {})
+          @client = client
+          @name = name
+          @parameters = parameters
+        end
+
+        def call
+          @client.request(request_body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            method: "tools/call",
+            params: {
+              name: @name,
+              arguments: @parameters
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/tool_list.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class RubyLLM::MCP::Requests::ToolList < RubyLLM::MCP::Requests::Base
+  def call
+    client.request(tool_list_body)
+  end
+
+  private
+
+  def tool_list_body
+    {
+      jsonrpc: "2.0",
+      method: "tools/list",
+      params: {}
+    }
+  end
+end

data/lib/ruby_llm/mcp/tool.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Tool < RubyLLM::Tool
+      attr_reader :name, :description, :parameters, :mcp_client, :tool_response
+
+      # @tool_response = {
+      #   name: string;          // Unique identifier for the tool
+      #   description?: string;  // Human-readable description
+      #   inputSchema: {         // JSON Schema for the tool's parameters
+      #     type: "object",
+      #     properties: { ... }  // Tool-specific parameters
+      #   },
+      #   annotations?: {        // Optional hints about tool behavior
+      #     title?: string;      // Human-readable title for the tool
+      #     readOnlyHint?: boolean;    // If true, the tool does not modify its environment
+      #     destructiveHint?: boolean; // If true, the tool may perform destructive updates
+      #     idempotentHint?: boolean;  // If true, repeated calls with same args have no additional effect
+      #     openWorldHint?: boolean;   // If true, tool interacts with external entities
+      #   }
+      # }
+      def initialize(mcp_client, tool_response)
+        super()
+        @mcp_client = mcp_client
+
+        @name = tool_response["name"]
+        @description = tool_response["description"]
+        @parameters = create_parameters(tool_response["inputSchema"])
+      end
+
+      def execute(**params)
+        @mcp_client.execute_tool(
+          name: @name,
+          parameters: params
+        )
+      end
+
+      private
+
+      def create_parameters(input_schema)
+        params = {}
+        input_schema["properties"].each_key do |key|
+          param = RubyLLM::Parameter.new(
+            key,
+            type: input_schema["properties"][key]["type"],
+            desc: input_schema["properties"][key]["description"],
+            required: input_schema["properties"][key]["required"]
+          )
+
+          params[key] = param
+        end
+
+        params
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/transport/sse.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "faraday"
+require "timeout"
+require "securerandom"
+
+module RubyLLM
+  module MCP
+    module Transport
+      class SSE
+        attr_reader :headers, :id
+
+        def initialize(url, headers: {})
+          @event_url = url
+          @messages_url = url.gsub("sse", "messages")
+          @client_id = SecureRandom.uuid
+          @headers = headers.merge({
+                                     "Accept" => "text/event-stream",
+                                     "Cache-Control" => "no-cache",
+                                     "Connection" => "keep-alive",
+                                     "X-CLIENT-ID" => @client_id
+                                   })
+
+          @id_counter = 0
+          @id_mutex = Mutex.new
+          @pending_requests = {}
+          @pending_mutex = Mutex.new
+          @connection_mutex = Mutex.new
+          @running = true
+          @sse_thread = nil
+
+          # Start the SSE listener thread
+          start_sse_listener
+        end
+
+        def request(body, wait_for_response: true)
+          # Generate a unique request ID
+          @id_mutex.synchronize { @id_counter += 1 }
+          request_id = @id_counter
+          body["id"] = request_id
+
+          # Create a queue for this request's response
+          response_queue = Queue.new
+          if wait_for_response
+            @pending_mutex.synchronize do
+              @pending_requests[request_id.to_s] = response_queue
+            end
+          end
+
+          # Send the request using Faraday
+          begin
+            conn = Faraday.new do |f|
+              f.options.timeout = 30
+              f.options.open_timeout = 5
+            end
+
+            response = conn.post(@messages_url) do |req|
+              @headers.each do |key, value|
+                req.headers[key] = value
+              end
+              req.headers["Content-Type"] = "application/json"
+              req.body = JSON.generate(body)
+            end
+
+            unless response.status == 200
+              @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+              raise "Failed to request #{@messages_url}: #{response.status} - #{response.body}"
+            end
+          rescue StandardError => e
+            @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+            raise e
+          end
+          return unless wait_for_response
+
+          begin
+            Timeout.timeout(30) do
+              response_queue.pop
+            end
+          rescue Timeout::Error
+            @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+            raise RubyLLM::MCP::Errors::TimeoutError.new(message: "Request timed out after 30 seconds")
+          end
+        end
+
+        def close
+          @running = false
+          @sse_thread&.join(1) # Give the thread a second to clean up
+          @sse_thread = nil
+        end
+
+        private
+
+        def start_sse_listener
+          @connection_mutex.synchronize do
+            return if sse_thread_running?
+
+            @sse_thread = Thread.new do
+              listen_for_events while @running
+            end
+
+            @sse_thread.abort_on_exception = true
+            sleep 0.1 # Wait for the SSE connection to be established
+          end
+        end
+
+        def sse_thread_running?
+          @sse_thread && @sse_thread.alive?
+        end
+
+        def listen_for_events
+          stream_events_from_server
+        rescue Faraday::Error => e
+          handle_connection_error("SSE connection failed", e)
+        rescue StandardError => e
+          handle_connection_error("SSE connection error", e)
+        end
+
+        def stream_events_from_server
+          buffer = +""
+          create_sse_connection.get(@event_url) do |req|
+            setup_request_headers(req)
+            setup_streaming_callback(req, buffer)
+          end
+        end
+
+        def create_sse_connection
+          Faraday.new do |f|
+            f.options.timeout = 300 # 5 minutes
+            f.response :raise_error # raise errors on non-200 responses
+          end
+        end
+
+        def setup_request_headers(request)
+          @headers.each do |key, value|
+            request.headers[key] = value
+          end
+        end
+
+        def setup_streaming_callback(request, buffer)
+          request.options.on_data = proc do |chunk, _size, _env|
+            buffer << chunk
+            process_buffer_events(buffer)
+          end
+        end
+
+        def process_buffer_events(buffer)
+          while (event = extract_event(buffer))
+            event_data, buffer = event
+            process_event(event_data) if event_data
+          end
+        end
+
+        def handle_connection_error(message, error)
+          puts "#{message}: #{error.message}. Reconnecting in 3 seconds..."
+          sleep 3
+        end
+
+        def process_event(raw_event)
+          return if raw_event[:data].nil?
+
+          event = begin
+            JSON.parse(raw_event[:data])
+          rescue StandardError
+            nil
+          end
+          return if event.nil?
+
+          request_id = event["id"]&.to_s
+
+          @pending_mutex.synchronize do
+            if request_id && @pending_requests.key?(request_id)
+              response_queue = @pending_requests.delete(request_id)
+              response_queue&.push(event)
+            end
+          end
+        rescue JSON::ParserError => e
+          puts "Error parsing event data: #{e.message}"
+        end
+
+        def extract_event(buffer)
+          return nil unless buffer.include?("\n\n")
+
+          raw, rest = buffer.split("\n\n", 2)
+          [parse_event(raw), rest]
+        end
+
+        def parse_event(raw)
+          event = {}
+          raw.each_line do |line|
+            case line
+            when /^data:\s*(.*)/
+              (event[:data] ||= []) << ::Regexp.last_match(1)
+            when /^event:\s*(.*)/
+              event[:event] = ::Regexp.last_match(1)
+            when /^id:\s*(.*)/
+              event[:id] = ::Regexp.last_match(1)
+            end
+          end
+          event[:data] = event[:data]&.join("\n")
+          event
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/transport/stdio.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "open3"
+require "json"
+require "timeout"
+require "securerandom"
+
+module RubyLLM
+  module MCP
+    module Transport
+      class Stdio
+        attr_reader :command, :stdin, :stdout, :stderr, :id
+
+        def initialize(command, args: [], env: {})
+          @command = command
+          @args = args
+          @env = env
+          @client_id = SecureRandom.uuid
+
+          # Initialize state variables
+          @id_counter = 0
+          @id_mutex = Mutex.new
+          @pending_requests = {}
+          @pending_mutex = Mutex.new
+          @running = true
+          @reader_thread = nil
+
+          # Start the process
+          start_process
+        end
+
+        def request(body, wait_for_response: true)
+          # Generate a unique request ID
+          @id_mutex.synchronize { @id_counter += 1 }
+          request_id = @id_counter
+          body["id"] = request_id
+
+          # Create a queue for this request's response
+          response_queue = Queue.new
+          if wait_for_response
+            @pending_mutex.synchronize do
+              @pending_requests[request_id.to_s] = response_queue
+            end
+          end
+
+          # Send the request to the process
+          begin
+            @stdin.puts(JSON.generate(body))
+            @stdin.flush
+          rescue IOError, Errno::EPIPE => e
+            @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+            restart_process
+            raise "Failed to send request: #{e.message}"
+          end
+
+          return unless wait_for_response
+
+          # Wait for the response with matching ID using a timeout
+          begin
+            Timeout.timeout(30) do
+              response_queue.pop
+            end
+          rescue Timeout::Error
+            @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+            raise RubyLLM::MCP::Errors::TimeoutError.new(message: "Request timed out after 30 seconds")
+          end
+        end
+
+        def close
+          @running = false
+
+          # Close stdin to signal the process to exit
+          begin
+            @stdin&.close
+          rescue StandardError
+            nil
+          end
+
+          # Wait for process to exit
+          begin
+            @wait_thread&.join(1)
+          rescue StandardError
+            nil
+          end
+
+          # Close remaining IO streams
+          begin
+            @stdout&.close
+          rescue StandardError
+            nil
+          end
+          begin
+            @stderr&.close
+          rescue StandardError
+            nil
+          end
+
+          # Wait for reader thread to finish
+          begin
+            @reader_thread&.join(1)
+          rescue StandardError
+            nil
+          end
+
+          @stdin = nil
+          @stdout = nil
+          @stderr = nil
+          @wait_thread = nil
+          @reader_thread = nil
+        end
+
+        private
+
+        def start_process
+          # Close any existing process
+          close if @stdin || @stdout || @stderr || @wait_thread
+
+          # Start a new process
+          @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(@env, @command, *@args)
+
+          # Start a thread to read responses
+          start_reader_thread
+        end
+
+        def restart_process
+          puts "Process connection lost. Restarting..."
+          start_process
+        end
+
+        def start_reader_thread
+          @reader_thread = Thread.new do
+            while @running
+              begin
+                if @stdout.closed? || @wait_thread.nil? || !@wait_thread.alive?
+                  sleep 1
+                  restart_process if @running
+                  next
+                end
+
+                # Read a line from the process
+                line = @stdout.gets
+
+                # Skip empty lines
+                next unless line && !line.strip.empty?
+
+                # Process the response
+                process_response(line.strip)
+              rescue IOError, Errno::EPIPE => e
+                puts "Reader error: #{e.message}. Restarting in 1 second..."
+                sleep 1
+                restart_process if @running
+              rescue StandardError => e
+                puts "Error in reader thread: #{e.message}, #{e.backtrace.join("\n")}"
+                sleep 1
+              end
+            end
+          end
+
+          @reader_thread.abort_on_exception = true
+        end
+
+        def process_response(line)
+          # Try to parse the response as JSON
+          response = begin
+            JSON.parse(line)
+          rescue JSON::ParserError => e
+            puts "Error parsing response as JSON: #{e.message}"
+            puts "Raw response: #{line}"
+            return
+          end
+
+          # Extract the request ID
+          request_id = response["id"]&.to_s
+
+          # Find and fulfill the matching request
+          @pending_mutex.synchronize do
+            if request_id && @pending_requests.key?(request_id)
+              response_queue = @pending_requests.delete(request_id)
+              response_queue&.push(response)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/transport/streamable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Transport
+      class Streamable
+        def initialize(url, headers: {})
+          @url = url
+          @headers = headers
+        end
+
+        def request(messages)
+          # TODO: Implement streaming
+        end
+
+        def close
+          # TODO: Implement closing
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    VERSION = "0.0.1"
+  end
+end

data/lib/ruby_llm/mcp.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem_extension(RubyLLM)
+loader.inflector.inflect("mcp" => "MCP")
+loader.inflector.inflect("sse" => "SSE")
+loader.setup
+
+module RubyLLM
+  module MCP
+    def self.client(*args, **kwargs)
+      @client ||= Client.new(*args, **kwargs)
+    end
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: ruby_llm-mcp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Patrick Vice
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: |
+  A Ruby client for the Model Context Protocol (MCP) that seamlessly integrates with RubyLLM.
+  Connect to MCP servers via SSE or stdio transports, automatically convert MCP tools into
+  RubyLLM-compatible tools, and enable AI models to interact with external data sources and
+  services. Makes using MCP with RubyLLM as easy as possible.
+email:
+- patrickgvice@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/ruby_llm/mcp.rb
+- lib/ruby_llm/mcp/client.rb
+- lib/ruby_llm/mcp/errors.rb
+- lib/ruby_llm/mcp/requests/base.rb
+- lib/ruby_llm/mcp/requests/initialization.rb
+- lib/ruby_llm/mcp/requests/notification.rb
+- lib/ruby_llm/mcp/requests/tool_call.rb
+- lib/ruby_llm/mcp/requests/tool_list.rb
+- lib/ruby_llm/mcp/tool.rb
+- lib/ruby_llm/mcp/transport/sse.rb
+- lib/ruby_llm/mcp/transport/stdio.rb
+- lib/ruby_llm/mcp/transport/streamable.rb
+- lib/ruby_llm/mcp/version.rb
+homepage: https://github.com/patvice/ruby_llm-mcp
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/patvice/ruby_llm-mcp
+  source_code_uri: https://github.com/patvice/ruby_llm-mcp
+  changelog_uri: https://github.com/patvice/ruby_llm-mcp/commits/main
+  documentation_uri: https://github.com/patvice/ruby_llm-mcp
+  bug_tracker_uri: https://github.com/patvice/ruby_llm-mcp/issues
+  rubygems_mfa_required: 'true'
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: A RubyLLM MCP Client
+test_files: []