ruby-mcp-client 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e71d5420a77345079ef2da077240e6a578900c3acfd2c16c904b0a2bf84a8bb7
-  data.tar.gz: ea4f41ebef3d5898d3dd0786d50d08dbbd19057bbbd5b7aa8cc046d5a1608d7c
+  metadata.gz: 27b97462ec0c99d98299df120726f90944f495aaddf198272d72725544240ec0
+  data.tar.gz: b58b8a6ba53f698abe1cb3576fba8030d66cb0bd7eafa2e39e28943e7ef1337f
 SHA512:
-  metadata.gz: a837ba7337913a453e5ae2567c67fed453b5e1cab3712705689c74b2efff27fa5c257750c834b5ac5bfff04333f08f1999b6813982d0c548ee92f4992c4d6aad
-  data.tar.gz: e10f2262b5dd10f0323dbbf870daa9f2d25d2d9f6a7f0c053870a8e0a5453ed9c5ed2c667211dfcf094c4fd56e7c12fbc1407c358e955fb14b4cbf4601312226
+  metadata.gz: 50d5791642a74f521133a057d924d3daf14e657ec617e73ad8f95510b4d97f3d52742c5a467c54d75dc02030a087f29e63ee346429271e8c80eb71cb96e38f94
+  data.tar.gz: 5f92d87a5d176e3271a11e9bbea7eafc6720107c6ae795601250e088cde69e6d6340911eecd6ea8ab32776d97d9bfb0b4d3740087509eb704cb400bf4e23e5aa

data/README.md

@@ -49,6 +49,8 @@ This Ruby MCP Client implements key features from the latest MCP specification (
 - **Streamable HTTP Transport** - Enhanced transport with Server-Sent Event formatted responses and session management
 - **HTTP Redirect Support** - Automatic redirect handling for both SSE and HTTP transports with configurable limits
 - **FastMCP Compatibility** - Full compatibility with FastMCP servers including proper line ending handling
+- **Prompts Support** - Full implementation of MCP prompts for dynamic content generation
+- **Resources Support** - Complete resources implementation for accessing files and data with URI-based identification
 
 ## Usage
 
@@ -87,6 +89,17 @@ client = MCPClient.create_client(
       retries: 3,       # Optional number of retry attempts (default: 3)
       retry_backoff: 1, # Optional backoff delay in seconds (default: 1)
       logger: Logger.new($stdout, level: Logger::INFO) # Optional logger for this server
+    ),
+    # Streamable HTTP server (HTTP POST with SSE responses and session management)
+    MCPClient.streamable_http_config(
+      base_url: 'https://api.example.com/mcp',
+      endpoint: '/rpc', # Optional JSON-RPC endpoint path (default: '/rpc')
+      headers: { 'Authorization' => 'Bearer YOUR_TOKEN' },
+      name: 'streamable_api', # Optional name for this server
+      read_timeout: 60, # Optional timeout in seconds (default: 30)
+      retries: 3,       # Optional number of retry attempts (default: 3)
+      retry_backoff: 1, # Optional backoff delay in seconds (default: 1)
+      logger: Logger.new($stdout, level: Logger::INFO) # Optional logger for this server
     )
   ],
   # Optional logger for the client and all servers without explicit loggers
@@ -100,13 +113,14 @@ client = MCPClient.create_client(
 )
 
 # MCP server configuration JSON format can be:
-# 1. A single server object: 
+# 1. A single server object:
 #    { "type": "sse", "url": "http://example.com/sse" }
 #    { "type": "http", "url": "http://example.com", "endpoint": "/rpc" }
-# 2. An array of server objects: 
-#    [{ "type": "stdio", "command": "npx server" }, { "type": "sse", "url": "http://..." }, { "type": "http", "url": "http://..." }]
+#    { "type": "streamable_http", "url": "http://example.com/mcp", "endpoint": "/rpc" }
+# 2. An array of server objects:
+#    [{ "type": "stdio", "command": "npx server" }, { "type": "sse", "url": "http://..." }, { "type": "streamable_http", "url": "http://..." }]
 # 3. An object with "mcpServers" key containing named servers:
-#    { "mcpServers": { "server1": { "type": "sse", "url": "http://..." }, "server2": { "type": "http", "url": "http://..." } } }
+#    { "mcpServers": { "server1": { "type": "sse", "url": "http://..." }, "server2": { "type": "streamable_http", "url": "http://..." } } }
 #    Note: When using this format, server1/server2 will be accessible by name
 
 # List available tools
@@ -140,6 +154,26 @@ client.call_tool_streaming('streaming_tool', { param: 'value' }, server: 'api').
   puts chunk
 end
 
+# === Working with Prompts ===
+# List available prompts from all servers
+prompts = client.list_prompts
+
+# Get a specific prompt with parameters
+result = client.get_prompt('greeting', { name: 'Ruby Developer' })
+
+# Get a prompt from a specific server
+result = client.get_prompt('greeting', { name: 'Ruby Developer' }, server: 'filesystem')
+
+# === Working with Resources ===
+# List available resources from all servers
+resources = client.list_resources
+
+# Read a specific resource by URI
+contents = client.read_resource('file:///example.txt')
+
+# Read a resource from a specific server
+contents = client.read_resource('file:///example.txt', server: 'filesystem')
+
 # Format tools for specific AI services
 openai_tools = client.to_openai_tools
 anthropic_tools = client.to_anthropic_tools
@@ -288,12 +322,12 @@ require 'logger'
 logger = Logger.new($stdout)
 logger.level = Logger::INFO
 
-# Create an MCP client that connects to a Playwright MCP server via SSE
+# Create an MCP client that connects to a Playwright MCP server via Streamable HTTP
 # First run: npx @playwright/mcp@latest --port 8931
-sse_client = MCPClient.create_client(
+mcp_client = MCPClient.create_client(
   mcp_server_configs: [
-    MCPClient.sse_config(
-      base_url: 'http://localhost:8931/sse',
+    MCPClient.streamable_http_config(
+      base_url: 'http://localhost:8931/mcp',
       read_timeout: 30,  # Timeout in seconds for request fulfillment
       ping: 10,          # Send ping after 10 seconds of inactivity
                          # Connection closes automatically after inactivity (2.5x ping interval)
@@ -304,44 +338,50 @@ sse_client = MCPClient.create_client(
 )
 
 # List available tools
-tools = sse_client.list_tools
+tools = mcp_client.list_tools
 
 # Launch a browser
-result = sse_client.call_tool('browser_install', {})
-result = sse_client.call_tool('browser_navigate', { url: 'about:blank' })
+result = mcp_client.call_tool('browser_install', {})
+result = mcp_client.call_tool('browser_navigate', { url: 'about:blank' })
 # No browser ID needed with these tool names
 
 # Create a new page
-page_result = sse_client.call_tool('browser_tab_new', {})
+page_result = mcp_client.call_tool('browser_tab', {action: 'create'})
 # No page ID needed with these tool names
 
 # Navigate to a website
-sse_client.call_tool('browser_navigate', { url: 'https://example.com' })
+mcp_client.call_tool('browser_navigate', { url: 'https://example.com' })
 
 # Get page title
-title_result = sse_client.call_tool('browser_snapshot', {})
+title_result = mcp_client.call_tool('browser_snapshot', {})
 puts "Page snapshot: #{title_result}"
 
 # Take a screenshot
-screenshot_result = sse_client.call_tool('browser_take_screenshot', {})
+screenshot_result = mcp_client.call_tool('browser_take_screenshot', {})
 
 # Ping the server to verify connectivity
-ping_result = sse_client.ping
+ping_result = mcp_client.ping
 puts "Ping successful: #{ping_result.inspect}"
 
 # Clean up
-sse_client.cleanup
+mcp_client.cleanup
 ```
 
-See `examples/mcp_sse_server_example.rb` for the full Playwright SSE example.
+See `examples/streamable_http_example.rb` for the full Playwright SSE example.
 
 ### FastMCP Example
 
-The repository includes a complete FastMCP server example that demonstrates the Ruby MCP client working with a Python FastMCP server:
+The repository includes complete FastMCP server examples that demonstrate the Ruby MCP client working with Python FastMCP servers, including full MCP protocol support with tools, prompts, and resources:
+
+#### Basic FastMCP Example
+
+**For FastMCP server with SSE transport (includes tools, prompts, and resources):**
+```bash
+# From the ruby-mcp-client directory
+python examples/echo_server.py
+```
 
 ```ruby
-# Start the FastMCP server
-# python examples/echo_server.py
 
 # Run the Ruby client
 # bundle exec ruby examples/echo_server_client.rb
@@ -352,17 +392,72 @@ require 'mcp_client'
 client = MCPClient.create_client(
   mcp_server_configs: [
     MCPClient.sse_config(
-      base_url: 'http://127.0.0.1:8000/sse/',
+      base_url: 'http://127.0.0.1:8000/sse',
       read_timeout: 30
     )
   ]
 )
 
-# List available tools
+# List and use tools
 tools = client.list_tools
 puts "Found #{tools.length} tools:"
 tools.each { |tool| puts "- #{tool.name}: #{tool.description}" }
 
+result = client.call_tool('echo', { message: 'Hello FastMCP!' })
+
+# List and use prompts
+prompts = client.list_prompts
+puts "Found #{prompts.length} prompts:"
+prompts.each { |prompt| puts "- #{prompt.name}: #{prompt.description}" }
+
+greeting = client.get_prompt('greeting', { name: 'Ruby Developer' })
+
+# List and read resources
+resources = client.list_resources
+puts "Found #{resources.length} resources:"
+resources.each { |resource| puts "- #{resource.name} (#{resource.uri})" }
+
+readme_content = client.read_resource('file:///sample/README.md')
+```
+
+#### Streamable HTTP Example
+
+**For FastMCP server with Streamable HTTP transport (includes tools, prompts, and resources):**
+```bash
+# From the ruby-mcp-client directory
+python examples/echo_server_streamable.py
+```
+
+```ruby
+
+# Run the streamable HTTP client
+# bundle exec ruby examples/echo_server_streamable_client.rb
+
+require 'mcp_client'
+
+# Connect to streamable HTTP server with full MCP protocol support
+client = MCPClient.create_client(
+  mcp_server_configs: [
+    MCPClient.streamable_http_config(
+      base_url: 'http://localhost:8931/mcp',
+      read_timeout: 60
+    )
+  ]
+)
+
+# Full protocol support including real-time notifications
+client.on_notification do |method, params|
+  puts "Server notification: #{method} - #{params}"
+end
+
+# Use all MCP features: tools, prompts, resources
+tools = client.list_tools
+prompts = client.list_prompts
+resources = client.list_resources
+
+# Real-time progress notifications for long-running tasks
+result = client.call_tool('long_task', { duration: 5, steps: 5 })
+
 # Use the tools
 result = client.call_tool('echo', { message: 'Hello from Ruby!' })
 result = client.call_tool('reverse', { text: 'FastMCP rocks!' })
@@ -371,8 +466,10 @@ client.cleanup
 ```
 
 The FastMCP example includes:
-- **`echo_server.py`** - A Python FastMCP server with 4 interactive tools
-- **`echo_server_client.rb`** - Ruby client demonstrating all features
+- **`echo_server.py`** - A Python FastMCP server with tools, prompts, and resources
+- **`echo_server_client.rb`** - Ruby client demonstrating all features including prompts and resources
+- **`echo_server_streamable.py`** - Enhanced streamable HTTP server with tools, prompts, and resources
+- **`echo_server_streamable_client.rb`** - Ruby client demonstrating streamable HTTP transport
 - **`README_ECHO_SERVER.md`** - Complete setup and usage instructions
 
 This example showcases redirect support, proper line ending handling, and seamless integration between Ruby and Python MCP implementations.
@@ -464,8 +561,9 @@ Complete examples can be found in the `examples/` directory:
 - `openai_ruby_mcp.rb` - Integration with official openai/openai-ruby gem
 - `ruby_anthropic_mcp.rb` - Integration with alexrudall/ruby-anthropic gem
 - `gemini_ai_mcp.rb` - Integration with Google Vertex AI and Gemini models
-- `mcp_sse_server_example.rb` - SSE transport with Playwright MCP
+- `streamable_http_example.rb` - Streamable HTTP transport with Playwright MCP
 - `echo_server.py` & `echo_server_client.rb` - FastMCP server example with full setup
+- `echo_server_streamable.py` & `echo_server_streamable_client.rb` - Enhanced streamable HTTP server example
 
 ## MCP Server Compatibility
 
@@ -485,7 +583,7 @@ You can define MCP server configurations in JSON files for easier management:
   "mcpServers": {
     "playwright": {
       "type": "sse",
-      "url": "http://localhost:8931/sse",
+      "url": "http://localhost:8931/mcp",
       "headers": {
         "Authorization": "Bearer TOKEN"
       }
@@ -517,7 +615,7 @@ A simpler example used in the Playwright demo (found in `examples/sample_server_
 {
   "mcpServers": {
     "playwright": {
-      "url": "http://localhost:8931/sse",
+      "url": "http://localhost:8931/mcp",
       "headers": {},
       "comment": "Local Playwright MCP Server running on port 8931"
     }
@@ -679,6 +777,8 @@ For complete OAuth documentation, see [OAUTH.md](OAUTH.md).
 - **Server disambiguation** - Specify which server to use when tools with same name exist in multiple servers
 - **Atomic tool calls** - Simple API for invoking tools with parameters
 - **Batch support** - Call multiple tools in a single operation
+- **Prompts support** - List and get prompts with parameters from MCP servers
+- **Resources support** - List and read resources by URI from MCP servers
 - **API conversions** - Built-in format conversion for OpenAI, Anthropic, and Google Vertex AI APIs
 - **Thread safety** - Synchronized access for thread-safe operation
 - **Server notifications** - Support for JSON-RPC notifications

data/lib/mcp_client/client.rb

@@ -9,10 +9,14 @@ module MCPClient
     # @!attribute [r] servers
     #   @return [Array<MCPClient::ServerBase>] list of servers
     # @!attribute [r] tool_cache
-    #   @return [Hash<String, MCPClient::Tool>] cache of tools by name
+    #   @return [Hash<String, MCPClient::Tool>] cache of tools by composite key (server_id:name)
+    # @!attribute [r] prompt_cache
+    #   @return [Hash<String, MCPClient::Prompt>] cache of prompts by composite key (server_id:name)
+    # @!attribute [r] resource_cache
+    #   @return [Hash<String, MCPClient::Resource>] cache of resources by composite key (server_id:uri)
     # @!attribute [r] logger
     #   @return [Logger] logger for client operations
-    attr_reader :servers, :tool_cache, :logger
+    attr_reader :servers, :tool_cache, :prompt_cache, :resource_cache, :logger
 
     # Initialize a new MCPClient::Client
     # @param mcp_server_configs [Array<Hash>] configurations for MCP servers
@@ -26,6 +30,8 @@ module MCPClient
         MCPClient::ServerFactory.create(config, logger: @logger)
       end
       @tool_cache = {}
+      @prompt_cache = {}
+      @resource_cache = {}
       # JSON-RPC notification listeners
       @notification_listeners = []
       # Register default and user-defined notification handlers on each server
@@ -39,6 +45,163 @@ module MCPClient
       end
     end
 
+    # Lists all available prompts from all connected MCP servers
+    # @param cache [Boolean] whether to use cached prompts or fetch fresh
+    # @return [Array<MCPClient::Prompt>] list of available prompts
+    # @raise [MCPClient::Errors::ConnectionError] on authorization failures
+    # @raise [MCPClient::Errors::PromptGetError] if no prompts could be retrieved from any server
+    def list_prompts(cache: true)
+      return @prompt_cache.values if cache && !@prompt_cache.empty?
+
+      prompts = []
+      connection_errors = []
+
+      servers.each do |server|
+        server.list_prompts.each do |prompt|
+          cache_key = cache_key_for(server, prompt.name)
+          @prompt_cache[cache_key] = prompt
+          prompts << prompt
+        end
+      rescue MCPClient::Errors::ConnectionError => e
+        # Fast-fail on authorization errors for better user experience
+        # If this is the first server or we haven't collected any prompts yet,
+        # raise the auth error directly to avoid cascading error messages
+        raise e if e.message.include?('Authorization failed') && prompts.empty?
+
+        # Store the error and try other servers
+        connection_errors << e
+        @logger.error("Server error: #{e.message}")
+      end
+
+      prompts
+    end
+
+    # Gets a specific prompt by name with the given parameters
+    # @param prompt_name [String] the name of the prompt to get
+    # @param parameters [Hash] the parameters to pass to the prompt
+    # @param server [String, Symbol, Integer, MCPClient::ServerBase, nil] optional server to use
+    # @return [Object] the final prompt
+    def get_prompt(prompt_name, parameters, server: nil)
+      prompts = list_prompts
+
+      if server
+        # Use the specified server
+        srv = select_server(server)
+        # Find the prompt on this specific server
+        prompt = prompts.find { |t| t.name == prompt_name && t.server == srv }
+        unless prompt
+          raise MCPClient::Errors::PromptNotFound,
+                "Prompt '#{prompt_name}' not found on server '#{srv.name || srv.class.name}'"
+        end
+      else
+        # Find the prompt across all servers
+        matching_prompts = prompts.select { |t| t.name == prompt_name }
+
+        if matching_prompts.empty?
+          raise MCPClient::Errors::PromptNotFound, "Prompt '#{prompt_name}' not found"
+        elsif matching_prompts.size > 1
+          # If multiple matches, disambiguate with server names
+          server_names = matching_prompts.map { |t| t.server&.name || 'unnamed' }
+          raise MCPClient::Errors::AmbiguousPromptName,
+                "Multiple prompts named '#{prompt_name}' found across servers (#{server_names.join(', ')}). " \
+                "Please specify a server using the 'server' parameter."
+        end
+
+        prompt = matching_prompts.first
+      end
+
+      # Use the prompt's associated server
+      server = prompt.server
+      raise MCPClient::Errors::ServerNotFound, "No server found for prompt '#{prompt_name}'" unless server
+
+      begin
+        server.get_prompt(prompt_name, parameters)
+      rescue MCPClient::Errors::ConnectionError => e
+        # Add server identity information to the error for better context
+        server_id = server.name ? "#{server.class}[#{server.name}]" : server.class.name
+        raise MCPClient::Errors::PromptGetError,
+              "Error getting prompt '#{prompt_name}': #{e.message} (Server: #{server_id})"
+      end
+    end
+
+    # Lists all available resources from all connected MCP servers
+    # @param cache [Boolean] whether to use cached resources or fetch fresh
+    # @return [Array<MCPClient::Resource>] list of available resources
+    # @raise [MCPClient::Errors::ConnectionError] on authorization failures
+    # @raise [MCPClient::Errors::ResourceReadError] if no resources could be retrieved from any server
+    def list_resources(cache: true)
+      return @resource_cache.values if cache && !@resource_cache.empty?
+
+      resources = []
+      connection_errors = []
+
+      servers.each do |server|
+        server.list_resources.each do |resource|
+          cache_key = cache_key_for(server, resource.uri)
+          @resource_cache[cache_key] = resource
+          resources << resource
+        end
+      rescue MCPClient::Errors::ConnectionError => e
+        # Fast-fail on authorization errors for better user experience
+        # If this is the first server or we haven't collected any resources yet,
+        # raise the auth error directly to avoid cascading error messages
+        raise e if e.message.include?('Authorization failed') && resources.empty?
+
+        # Store the error and try other servers
+        connection_errors << e
+        @logger.error("Server error: #{e.message}")
+      end
+
+      resources
+    end
+
+    # Reads a specific resource by URI
+    # @param uri [String] the URI of the resource to read
+    # @param server [String, Symbol, Integer, MCPClient::ServerBase, nil] optional server to use
+    # @return [Object] the resource contents
+    def read_resource(uri, server: nil)
+      resources = list_resources
+
+      if server
+        # Use the specified server
+        srv = select_server(server)
+        # Find the resource on this specific server
+        resource = resources.find { |r| r.uri == uri && r.server == srv }
+        unless resource
+          raise MCPClient::Errors::ResourceNotFound,
+                "Resource '#{uri}' not found on server '#{srv.name || srv.class.name}'"
+        end
+      else
+        # Find the resource across all servers
+        matching_resources = resources.select { |r| r.uri == uri }
+
+        if matching_resources.empty?
+          raise MCPClient::Errors::ResourceNotFound, "Resource '#{uri}' not found"
+        elsif matching_resources.size > 1
+          # If multiple matches, disambiguate with server names
+          server_names = matching_resources.map { |r| r.server&.name || 'unnamed' }
+          raise MCPClient::Errors::AmbiguousResourceURI,
+                "Multiple resources with URI '#{uri}' found across servers (#{server_names.join(', ')}). " \
+                "Please specify a server using the 'server' parameter."
+        end
+
+        resource = matching_resources.first
+      end
+
+      # Use the resource's associated server
+      server = resource.server
+      raise MCPClient::Errors::ServerNotFound, "No server found for resource '#{uri}'" unless server
+
+      begin
+        server.read_resource(uri)
+      rescue MCPClient::Errors::ConnectionError => e
+        # Add server identity information to the error for better context
+        server_id = server.name ? "#{server.class}[#{server.name}]" : server.class.name
+        raise MCPClient::Errors::ResourceReadError,
+              "Error reading resource '#{uri}': #{e.message} (Server: #{server_id})"
+      end
+    end
+
     # Lists all available tools from all connected MCP servers
     # @param cache [Boolean] whether to use cached tools or fetch fresh
     # @return [Array<MCPClient::Tool>] list of available tools
@@ -52,7 +215,8 @@ module MCPClient
 
       servers.each do |server|
         server.list_tools.each do |tool|
-          @tool_cache[tool.name] = tool
+          cache_key = cache_key_for(server, tool.name)
+          @tool_cache[cache_key] = tool
           tools << tool
         end
       rescue MCPClient::Errors::ConnectionError => e
@@ -162,6 +326,8 @@ module MCPClient
     # @return [void]
     def clear_cache
       @tool_cache.clear
+      @prompt_cache.clear
+      @resource_cache.clear
     end
 
     # Register a callback for JSON-RPC notifications from servers
@@ -316,9 +482,11 @@ module MCPClient
       when 'notifications/resources/updated'
         logger.warn("[#{server_id}] Resource #{params['uri']} updated")
       when 'notifications/prompts/list_changed'
-        logger.warn("[#{server_id}] Prompt list has changed")
+        logger.warn("[#{server_id}] Prompt list has changed, clearing prompt cache")
+        @prompt_cache.clear
       when 'notifications/resources/list_changed'
-        logger.warn("[#{server_id}] Resource list has changed")
+        logger.warn("[#{server_id}] Resource list has changed, clearing resource cache")
+        @resource_cache.clear
       else
         # Log unknown notification types for debugging purposes
         logger.debug("[#{server_id}] Received unknown notification: #{method} - #{params}")
@@ -379,5 +547,14 @@ module MCPClient
         server.list_tools.any? { |t| t.name == tool.name }
       end
     end
+
+    # Generate a cache key for server-specific items
+    # @param server [MCPClient::ServerBase] the server
+    # @param item_id [String] the item identifier (name or URI)
+    # @return [String] composite cache key
+    def cache_key_for(server, item_id)
+      server_id = server.object_id.to_s
+      "#{server_id}:#{item_id}"
+    end
   end
 end

data/lib/mcp_client/errors.rb

@@ -9,12 +9,24 @@ module MCPClient
     # Raised when a tool is not found
     class ToolNotFound < MCPError; end
 
+    # Raised when a prompt is not found
+    class PromptNotFound < MCPError; end
+
+    # Raised when a resource is not found
+    class ResourceNotFound < MCPError; end
+
     # Raised when a server is not found
     class ServerNotFound < MCPError; end
 
     # Raised when there's an error calling a tool
     class ToolCallError < MCPError; end
 
+    # Raised when there's an error getting a prompt
+    class PromptGetError < MCPError; end
+
+    # Raised when there's an error reading a resource
+    class ResourceReadError < MCPError; end
+
     # Raised when there's a connection error with an MCP server
     class ConnectionError < MCPError; end
 
@@ -29,5 +41,11 @@ module MCPClient
 
     # Raised when multiple tools with the same name exist across different servers
     class AmbiguousToolName < MCPError; end
+
+    # Raised when multiple prompts with the same name exist across different servers
+    class AmbiguousPromptName < MCPError; end
+
+    # Raised when multiple resources with the same URI exist across different servers
+    class AmbiguousResourceURI < MCPError; end
   end
 end

data/lib/mcp_client/prompt.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Representation of an MCP prompt
+  class Prompt
+    # @!attribute [r] name
+    #   @return [String] the name of the prompt
+    # @!attribute [r] description
+    #   @return [String] the description of the prompt
+    # @!attribute [r] arguments
+    #   @return [Hash] the JSON arguments for the prompt
+    # @!attribute [r] server
+    #   @return [MCPClient::ServerBase, nil] the server this prompt belongs to
+    attr_reader :name, :description, :arguments, :server
+
+    # Initialize a new prompt
+    # @param name [String] the name of the prompt
+    # @param description [String] the description of the prompt
+    # @param arguments [Hash] the JSON arguments for the prompt
+    # @param server [MCPClient::ServerBase, nil] the server this prompt belongs to
+    def initialize(name:, description:, arguments: {}, server: nil)
+      @name = name
+      @description = description
+      @arguments = arguments
+      @server = server
+    end
+
+    # Create a Prompt instance from JSON data
+    # @param data [Hash] JSON data from MCP server
+    # @param server [MCPClient::ServerBase, nil] the server this prompt belongs to
+    # @return [MCPClient::Prompt] prompt instance
+    def self.from_json(data, server: nil)
+      new(
+        name: data['name'],
+        description: data['description'],
+        arguments: data['arguments'] || {},
+        server: server
+      )
+    end
+  end
+end

data/lib/mcp_client/resource.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Representation of an MCP resource
+  class Resource
+    # @!attribute [r] uri
+    #   @return [String] unique identifier for the resource
+    # @!attribute [r] name
+    #   @return [String] the name of the resource
+    # @!attribute [r] title
+    #   @return [String, nil] optional human-readable name of the resource for display purposes
+    # @!attribute [r] description
+    #   @return [String, nil] optional description
+    # @!attribute [r] mime_type
+    #   @return [String, nil] optional MIME type
+    # @!attribute [r] size
+    #   @return [Integer, nil] optional size in bytes
+    # @!attribute [r] annotations
+    #   @return [Hash, nil] optional annotations that provide hints to clients
+    # @!attribute [r] server
+    #   @return [MCPClient::ServerBase, nil] the server this resource belongs to
+    attr_reader :uri, :name, :title, :description, :mime_type, :size, :annotations, :server
+
+    # Initialize a new resource
+    # @param uri [String] unique identifier for the resource
+    # @param name [String] the name of the resource
+    # @param title [String, nil] optional human-readable name of the resource for display purposes
+    # @param description [String, nil] optional description
+    # @param mime_type [String, nil] optional MIME type
+    # @param size [Integer, nil] optional size in bytes
+    # @param annotations [Hash, nil] optional annotations that provide hints to clients
+    # @param server [MCPClient::ServerBase, nil] the server this resource belongs to
+    def initialize(uri:, name:, title: nil, description: nil, mime_type: nil, size: nil, annotations: nil, server: nil)
+      @uri = uri
+      @name = name
+      @title = title
+      @description = description
+      @mime_type = mime_type
+      @size = size
+      @annotations = annotations
+      @server = server
+    end
+
+    # Create a Resource instance from JSON data
+    # @param data [Hash] JSON data from MCP server
+    # @param server [MCPClient::ServerBase, nil] the server this resource belongs to
+    # @return [MCPClient::Resource] resource instance
+    def self.from_json(data, server: nil)
+      new(
+        uri: data['uri'],
+        name: data['name'],
+        title: data['title'],
+        description: data['description'],
+        mime_type: data['mimeType'],
+        size: data['size'],
+        annotations: data['annotations'],
+        server: server
+      )
+    end
+  end
+end