mcp 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 984645dda3d0d04a93b2831354691c475b42d2826462156167a3f1e1104b85d0
-  data.tar.gz: 20f96310129418791e0f5ae7f11b8a67605ff82e7ad29dfdfc414fd24157cf97
+  metadata.gz: fa42259e96ff9b07eb17a7e65ec9ca1324a1cce6f969295a4cb452872302aee9
+  data.tar.gz: f353de6d9331617ae6bf14f559b6de94e45885ce16feabbb23f65996dc8a850f
 SHA512:
-  metadata.gz: e9c323d818625f25999d1a2bb7ed1f16783cc295f8676c47bb58a96c284da133a2a5cc5c17086bc72216783325317543031288f1f8f804165503286ec0b1d2e8
-  data.tar.gz: f0b2c995f44682257a642316c6df3aa20bde04db6de92842e35b323460238860890d3e197cc916ec68f96a57f8c24f12877805fc14b8fd27e46999bf4b3d2aa4
+  metadata.gz: 7b19b451b27926590498eb8320088cf8737c8b20e1897088f7a033e33fa8fec976c88c89e80d9e78d96202ae142e02c1698cc6ece52e9240085ad25b7fd5d4ac
+  data.tar.gz: 88f67864aecba8e4b475a53ba49a8651a10f8909c3c7e07138603ce4ea2c489580856494519a7cc6e7e6803e47bb99c38ae32a7802cb11fa268b5c18f9c40cb3

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

data/.github/workflows/ci.yml

@@ -7,13 +7,17 @@ jobs:
     strategy:
       matrix:
         entry:
-          - { ruby: 3.2, allowed-failure: false }
-          - { ruby: 3.3, allowed-failure: false }
-          - { ruby: 3.4, allowed-failure: false }
-          - { ruby: head, allowed-failure: true }
+          - { ruby: '2.7', allowed-failure: false }
+          - { ruby: '3.0', allowed-failure: false }
+          - { ruby: '3.1', allowed-failure: false }
+          - { ruby: '3.2', allowed-failure: false }
+          - { ruby: '3.3', allowed-failure: false }
+          - { ruby: '3.4', allowed-failure: false }
+          - { ruby: '4.0', allowed-failure: false }
+          - { ruby: 'head', allowed-failure: true }
     name: Test Ruby ${{ matrix.entry.ruby }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.entry.ruby }}
@@ -25,9 +29,20 @@ jobs:
     runs-on: ubuntu-latest
     name: RuboCop
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.2 # Specify the oldest supported Ruby version.
+          ruby-version: 4.0 # Specify the latest supported Ruby version.
           bundler-cache: true
       - run: bundle exec rake rubocop
+
+  yard:
+    runs-on: ubuntu-latest
+    name: YARD Documentation
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 4.0 # Specify the latest supported Ruby version.
+          bundler-cache: true
+      - run: bundle exec yard --no-output

data/.github/workflows/release.yml

@@ -16,10 +16,42 @@ jobs:
       id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
       contents: write # IMPORTANT: this permission is required for `rake release` to push the release tag
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
           bundler-cache: true
-          ruby-version: 3.4
+          ruby-version: 4.0
       - uses: rubygems/release-gem@v1
+
+  publish_gh_pages:
+    if: github.repository_owner == 'modelcontextprotocol'
+    name: Publish Documentation to GitHub Pages
+    runs-on: ubuntu-latest
+    needs: [publish_gem]
+
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0 # Fetch all history for all branches and tags
+
+      - name: Configure Git
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Get version tag
+        id: version
+        run: |
+          git fetch --tags
+          TAG=$(git describe --tags --exact-match HEAD)
+          echo "tag=${TAG}" >> $GITHUB_OUTPUT
+
+      - name: Generate GitHub Pages
+        run: ./bin/generate-gh-pages.sh ${{ steps.version.outputs.tag }}
+
+      - name: Push to gh-pages
+        run: git push origin gh-pages

data/.rubocop.yml

@@ -5,6 +5,9 @@ plugins:
   - rubocop-minitest
   - rubocop-rake
 
+AllCops:
+  TargetRubyVersion: 2.7
+
 Gemspec/DevelopmentDependencies:
   Enabled: true
 

data/AGENTS.md

@@ -0,0 +1,107 @@
+# AGENTS.md
+
+## Project overview
+
+This is the official Ruby SDK for the Model Context Protocol (MCP), implementing both server and client functionality for JSON-RPC 2.0 based communication between LLM applications and context providers.
+
+## Dev environment setup
+
+- Ruby 3.2.0+ required to run the full test suite, including all Sorbet-related features
+- Run `bundle install` to install dependencies
+- Dependencies: `json-schema` >= 4.1 - Schema validation
+
+## Build and test commands
+
+- `bundle install` - Install dependencies
+- `rake test` - Run all tests
+- `rake rubocop` - Run linter
+- `rake` - Run tests and linting (default task)
+- `ruby -I lib -I test test/path/to/specific_test.rb` - Run single test file
+- `gem build mcp.gemspec` - Build the gem
+
+## Testing instructions
+
+- Test files are in `test/` directory with `_test.rb` suffix
+- Run full test suite with `rake test`
+- Run individual tests with `ruby -I lib -I test test/path/to/file_test.rb`
+- Tests should pass before submitting PRs
+
+## Code style guidelines
+
+- Follow RuboCop rules (run `rake rubocop`)
+- Use frozen string literals
+- Follow Ruby community conventions
+- Keep dependencies minimal
+
+## Commit message conventions
+
+- Use conventional commit format when possible
+- Include clear, descriptive commit messages
+- Releases are triggered by updating version in `lib/mcp/version.rb` and merging to main
+
+## Release process
+
+- Follow [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) format in CHANGELOG.md
+- Update CHANGELOG.md before cutting releases
+- Use git history and PR merge commits to construct changelog entries
+- Format entries as: "Terse description of the change (#nnn)"
+- Keep entries in flat list format (no nesting)
+- Git tags mark commits that cut new releases
+- Exclude maintenance PRs that don't concern end users
+- Check upstream remote for PRs if available
+
+## Architecture overview
+
+### Core Components
+
+**MCP::Server** (`lib/mcp/server.rb`):
+
+- Main server class handling JSON-RPC requests
+- Implements MCP protocol methods: initialize, ping, tools/list, tools/call, prompts/list, prompts/get, resources/list, resources/read
+- Supports custom method registration via `define_custom_method`
+- Handles instrumentation, exception reporting, and notifications
+- Uses JsonRpcHandler for request processing
+
+**MCP::Client** (`lib/mcp/client.rb`):
+
+- Client interface for communicating with MCP servers
+- Transport-agnostic design with pluggable transport layers
+- Supports tool listing and invocation
+
+**Transport Layer**:
+
+- `MCP::Server::Transports::StdioTransport` - Command-line stdio transport
+- `MCP::Server::Transports::StreamableHttpTransport` - HTTP with streaming support
+- `MCP::Client::HTTP` - HTTP client transport (requires faraday gem)
+
+**Protocol Components**:
+
+- `MCP::Tool` - Tool definition with input/output schemas and annotations
+- `MCP::Prompt` - Prompt templates with argument validation
+- `MCP::Resource` - Resource registration and retrieval
+- `MCP::Configuration` - Global configuration with exception reporting and instrumentation
+
+### Key Patterns
+
+**Three Ways to Define Components**:
+
+1. Class inheritance (e.g., `class MyTool < MCP::Tool`)
+2. Define methods (e.g., `MCP::Tool.define(name: "my_tool") { ... }`)
+3. Server registration (e.g., `server.define_tool(name: "my_tool") { ... }`)
+
+**Schema Validation**:
+
+- Tools support input_schema and output_schema for JSON Schema validation
+- Protocol version 2025-03-26+ supports tool annotations (destructive_hint, idempotent_hint, etc.)
+- Validation is configurable via `configuration.validate_tool_call_arguments`
+
+**Context Passing**:
+
+- `server_context` hash passed through tool/prompt calls for request-specific data
+- Methods can accept `server_context:` keyword argument for accessing context
+
+### Integration patterns
+
+- **Rails controllers**: Use `server.handle_json(request.body.read)` for HTTP endpoints
+- **Command-line tools**: Use `StdioTransport.new(server).open` for CLI applications
+- **HTTP services**: Use `StreamableHttpTransport` for web-based servers

data/CHANGELOG.md

@@ -7,6 +7,64 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-01-11
+
+### Added
+
+- Protocol specification version "2025-11-25" support (#184)
+- `icons` parameter support (#205)
+- `websiteUrl` parameter in `serverInfo` (#188)
+- `description` parameter in `serverInfo` (#201)
+- `additionalProperties` support for schema validation (#198)
+- "Draft" protocol version to supported versions (#179)
+- `stateless` mode for high availability (#101)
+- Exception messages for tool call errors (#194)
+- Elicitation skeleton (#178)
+- `prompts/list` and `prompts/get` support to client (#163)
+- Accept header validation for HTTP client transport (#207)
+- Ruby 2.7 - Ruby 3.1 support (#206)
+
+### Changed
+
+- Make tool names stricter (#204)
+
+### Fixed
+
+- Symlink path comparison in schema validation (#193)
+- Duplicate tool names across namespaces now raise an error (#199)
+- Tool error handling to follow MCP spec (#165)
+- XSS vulnerability in json_rpc_handler (#175)
+
+## [0.4.0] - 2025-10-15
+
+### Added
+
+- Client resources support with `resources/list` and `resources/read` methods (#160)
+- `_meta` field support for Tool schema (#124)
+- `_meta` field support for Prompt
+- `title` field support for prompt arguments
+- `call_tool_raw` method to client for accessing full tool responses (#149)
+- Structured content support in tool responses (#147)
+- AGENTS.md development guidance documentation (#134)
+- Dependabot configuration for automated dependency updates (#138)
+
+### Changed
+
+- Set default `content` to empty array instead of `nil` (#150)
+- Improved prompt spec compliance (#153)
+- Allow output schema to be array of objects (#144)
+- Return 202 response code for accepted JSON-RPC notifications (#114)
+- Added validation to `MCP::Configuration` setters (#145)
+- Updated metaschema URI format for cross-OS compatibility
+
+### Fixed
+
+- Client tools functionality and test coverage (#166)
+- Client resources test for empty responses (#162)
+- Documentation typos and incorrect examples (#157, #146)
+- Removed redundant transport requires (#154)
+- Cleaned up unused block parameters and magic comments
+
 ## [0.3.0] - 2025-09-14
 
 ### Added

data/Gemfile

@@ -8,16 +8,18 @@ gemspec
 # Specify development dependencies below
 gem "rubocop-minitest", require: false
 gem "rubocop-rake", require: false
-gem "rubocop-shopify", require: false
+gem "rubocop-shopify", ">= 2.18", require: false if RUBY_VERSION >= "3.1"
 
 gem "puma", ">= 5.0.0"
-gem "rack", ">= 2.0.0"
 gem "rackup", ">= 2.1.0"
 
 gem "activesupport"
-gem "debug"
+# Fix io-console install error when Ruby 3.0.
+gem "debug" if RUBY_VERSION >= "3.1"
 gem "rake", "~> 13.0"
-gem "sorbet-static-and-runtime"
+gem "sorbet-static-and-runtime" if RUBY_VERSION >= "3.0"
+gem "yard", "~> 0.9"
+gem "yard-sorbet", "~> 0.9" if RUBY_VERSION >= "3.1"
 
 group :test do
   gem "faraday", ">= 2.0"

data/README.md

@@ -131,7 +131,10 @@ Notifications follow the JSON-RPC 2.0 specification and use these method names:
 
 ```ruby
 server = MCP::Server.new(name: "my_server")
-transport = MCP::Transports::HTTP.new(server)
+
+# Default Streamable HTTP - session oriented
+transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
+
 server.transport = transport
 
 # When tools change, notify clients
@@ -139,18 +142,28 @@ server.define_tool(name: "new_tool") { |**args| { result: "ok" } }
 server.notify_tools_list_changed
 ```
 
-### Unsupported Features ( to be implemented in future versions )
+You can use Stateless Streamable HTTP, where notifications are not supported and all calls are request/response interactions.
+This mode allows for easy multi-node deployment.
+Set `stateless: true` in `MCP::Server::Transports::StreamableHTTPTransport.new` (`stateless` defaults to `false`):
+
+```ruby
+# Stateless Streamable HTTP - session-less
+transport = MCP::Server::Transports::StreamableHTTPTransport.new(server, stateless: true)
+```
+
+### Unsupported Features (to be implemented in future versions)
 
 - Log Level
 - Resource subscriptions
 - Completions
+- Elicitation
 
 ### Usage
 
 #### Rails Controller
 
 When added to a Rails controller on a route that handles POST requests, your server will be compliant with non-streaming
-[Streamable HTTP](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#streamable-http) transport
+[Streamable HTTP](https://modelcontextprotocol.io/specification/latest/basic/transports#streamable-http) transport
 requests.
 
 You can use the `Server#handle_json` method to handle requests.
@@ -160,7 +173,7 @@ class ApplicationController < ActionController::Base
   def index
     server = MCP::Server.new(
       name: "my_server",
-      title: "Example Server Display Name", # WARNING: This is a `Draft` and is not supported in the `Version 2025-06-18 (latest)` specification.
+      title: "Example Server Display Name",
       version: "1.0.0",
       instructions: "Use the tools of this server as a last resort",
       tools: [SomeTool, AnotherTool],
@@ -178,7 +191,6 @@ If you want to build a local command-line application, you can use the stdio tra
 
 ```ruby
 require "mcp"
-require "mcp/server/transports/stdio_transport"
 
 # Create a simple tool
 class ExampleTool < MCP::Tool
@@ -337,6 +349,9 @@ configuration = MCP::Configuration.new(protocol_version: "2024-11-05")
 MCP::Server.new(name: "test_server", configuration: configuration)
 ```
 
+If no protocol version is specified, the latest stable version will be applied by default.
+The latest stable version includes new features from the [draft version](https://modelcontextprotocol.io/specification/draft).
+
 This will make all new server instances use the specified protocol version instead of the default version. The protocol version can be reset to the default by setting it to `nil`:
 
 ```ruby
@@ -369,7 +384,7 @@ If no exception reporter is configured, a default no-op reporter is used that si
 
 ### Tools
 
-MCP spec includes [Tools](https://modelcontextprotocol.io/specification/2025-06-18/server/tools) which provide functionality to LLM apps.
+MCP spec includes [Tools](https://modelcontextprotocol.io/specification/latest/server/tools) which provide functionality to LLM apps.
 
 This gem provides a `MCP::Tool` class that can be used to create tools in three ways:
 
@@ -377,7 +392,7 @@ This gem provides a `MCP::Tool` class that can be used to create tools in three
 
 ```ruby
 class MyTool < MCP::Tool
-  title "My Tool" # WARNING: This is a `Draft` and is not supported in the `Version 2025-06-18 (latest)` specification.
+  title "My Tool"
   description "This tool performs specific functionality..."
   input_schema(
     properties: {
@@ -414,21 +429,21 @@ tool = MyTool
 ```ruby
 tool = MCP::Tool.define(
   name: "my_tool",
-  title: "My Tool", # WARNING: This is a `Draft` and is not supported in the `Version 2025-06-18 (latest)` specification.
+  title: "My Tool",
   description: "This tool performs specific functionality...",
   annotations: {
     read_only_hint: true,
     title: "My Tool"
   }
-) do |args, server_context|
+) do |args, server_context:|
   MCP::Tool::Response.new([{ type: "text", text: "OK" }])
 end
 ```
 
-3. By using the `ModelContextProtocol::Server#define_tool` method with a block:
+3. By using the `MCP::Server#define_tool` method with a block:
 
 ```ruby
-server = ModelContextProtocol::Server.new
+server = MCP::Server.new
 server.define_tool(
   name: "my_tool",
   description: "This tool performs specific functionality...",
@@ -436,7 +451,7 @@ server.define_tool(
     title: "My Tool",
     read_only_hint: true
   }
-) do |args, server_context|
+) do |args, server_context:|
   Tool::Response.new([{ type: "text", text: "OK" }])
 end
 ```
@@ -526,7 +541,7 @@ tool = MCP::Tool.define(
     },
     required: ["mean", "median", "count"]
   }
-) do |args, server_context|
+) do |args, server_context:|
   # Calculate statistics and validate against schema
   MCP::Tool::Response.new([{ type: "text", text: "Statistics calculated" }])
 end
@@ -546,7 +561,28 @@ class DataTool < MCP::Tool
 end
 ```
 
-MCP spec for the [Output Schema](https://modelcontextprotocol.io/specification/2025-06-18/server/tools#output-schema) specifies that:
+Output schema may also describe an array of objects:
+
+```ruby
+class WeatherTool < MCP::Tool
+  output_schema(
+    type: "array",
+    items: {
+      properties: {
+        temperature: { type: "number" },
+        condition: { type: "string" },
+        humidity: { type: "integer" }
+      },
+      required: ["temperature", "condition", "humidity"]
+    }
+  )
+end
+```
+
+Please note: in this case, you must provide `type: "array"`. The default type
+for output schemas is `object`.
+
+MCP spec for the [Output Schema](https://modelcontextprotocol.io/specification/latest/server/tools#output-schema) specifies that:
 
 - **Server Validation**: Servers MUST provide structured results that conform to the output schema
 - **Client Validation**: Clients SHOULD validate structured results against the output schema
@@ -555,9 +591,67 @@ MCP spec for the [Output Schema](https://modelcontextprotocol.io/specification/2
 
 The output schema follows standard JSON Schema format and helps ensure consistent data exchange between MCP servers and clients.
 
+### Tool Responses with Structured Content
+
+Tools can return structured data alongside text content using the `structured_content` parameter.
+
+The structured content will be included in the JSON-RPC response as the `structuredContent` field.
+
+```ruby
+class WeatherTool < MCP::Tool
+  description "Get current weather and return structured data"
+
+  def self.call(location:, units: "celsius", server_context:)
+    # Call weather API and structure the response
+    api_response = WeatherAPI.fetch(location, units)
+    weather_data = {
+      temperature: api_response.temp,
+      condition: api_response.description,
+      humidity: api_response.humidity_percent
+    }
+
+    output_schema.validate_result(weather_data)
+
+    MCP::Tool::Response.new(
+      [{
+        type: "text",
+        text: weather_data.to_json
+      }],
+      structured_content: weather_data
+    )
+  end
+end
+```
+
+### Tool Responses with Errors
+
+Tools can return error information alongside text content using the `error` parameter.
+
+The error will be included in the JSON-RPC response as the `isError` field.
+
+```ruby
+class WeatherTool < MCP::Tool
+  description "Get current weather and return structured data"
+
+  def self.call(server_context:)
+    # Do something here
+    content = {}
+
+    MCP::Tool::Response.new(
+      [{
+        type: "text",
+        text: content.to_json
+      }],
+      structured_content: content,
+      error: true
+    )
+  end
+end
+```
+
 ### Prompts
 
-MCP spec includes [Prompts](https://modelcontextprotocol.io/specification/2025-06-18/server/prompts), which enable servers to define reusable prompt templates and workflows that clients can easily surface to users and LLMs.
+MCP spec includes [Prompts](https://modelcontextprotocol.io/specification/latest/server/prompts), which enable servers to define reusable prompt templates and workflows that clients can easily surface to users and LLMs.
 
 The `MCP::Prompt` class provides three ways to create prompts:
 
@@ -566,15 +660,17 @@ The `MCP::Prompt` class provides three ways to create prompts:
 ```ruby
 class MyPrompt < MCP::Prompt
   prompt_name "my_prompt"  # Optional - defaults to underscored class name
-  title "My Prompt" # WARNING: This is a `Draft` and is not supported in the `Version 2025-06-18 (latest)` specification.
+  title "My Prompt"
   description "This prompt performs specific functionality..."
   arguments [
     MCP::Prompt::Argument.new(
       name: "message",
+      title: "Message Title",
       description: "Input message",
       required: true
     )
   ]
+  meta({ version: "1.0", category: "example" })
 
   class << self
     def template(args, server_context:)
@@ -603,15 +699,17 @@ prompt = MyPrompt
 ```ruby
 prompt = MCP::Prompt.define(
   name: "my_prompt",
-  title: "My Prompt", # WARNING: This is a `Draft` and is not supported in the `Version 2025-06-18 (latest)` specification.
+  title: "My Prompt",
   description: "This prompt performs specific functionality...",
   arguments: [
     MCP::Prompt::Argument.new(
       name: "message",
+      title: "Message Title",
       description: "Input message",
       required: true
     )
-  ]
+  ],
+  meta: { version: "1.0", category: "example" }
 ) do |args, server_context:|
   MCP::Prompt::Result.new(
     description: "Response description",
@@ -629,20 +727,22 @@ prompt = MCP::Prompt.define(
 end
 ```
 
-3. Using the `ModelContextProtocol::Server#define_protocol` method:
+3. Using the `MCP::Server#define_prompt` method:
 
 ```ruby
-server = ModelContextProtocol::Server.new
-server.define_protocol(
+server = MCP::Server.new
+server.define_prompt(
   name: "my_prompt",
   description: "This prompt performs specific functionality...",
   arguments: [
     Prompt::Argument.new(
       name: "message",
+      title: "Message Title",
       description: "Input message",
       required: true
     )
-  ]
+  ],
+  meta: { version: "1.0", category: "example" }
 ) do |args, server_context:|
   Prompt::Result.new(
     description: "Response description",
@@ -665,7 +765,7 @@ e.g. around authentication state or user preferences.
 
 ### Key Components
 
-- `MCP::Prompt::Argument` - Defines input parameters for the prompt template
+- `MCP::Prompt::Argument` - Defines input parameters for the prompt template with name, title, description, and required flag
 - `MCP::Prompt::Message` - Represents a message in the conversation with a role and content
 - `MCP::Prompt::Result` - The output of a prompt template containing description and messages
 - `MCP::Content::Text` - Text content for messages
@@ -714,7 +814,7 @@ This is to avoid potential issues with metric cardinality
 
 ### Resources
 
-MCP spec includes [Resources](https://modelcontextprotocol.io/specification/2025-06-18/server/resources).
+MCP spec includes [Resources](https://modelcontextprotocol.io/specification/latest/server/resources).
 
 ### Reading Resources
 
@@ -724,7 +824,7 @@ The `MCP::Resource` class provides a way to register resources with the server.
 resource = MCP::Resource.new(
   uri: "https://example.com/my_resource",
   name: "my-resource",
-  title: "My Resource", # WARNING: This is a `Draft` and is not supported in the `Version 2025-06-18 (latest)` specification.
+  title: "My Resource",
   description: "Lorem ipsum dolor sit amet",
   mime_type: "text/html",
 )
@@ -757,7 +857,7 @@ The `MCP::ResourceTemplate` class provides a way to register resource templates
 resource_template = MCP::ResourceTemplate.new(
   uri_template: "https://example.com/my_resource_template",
   name: "my-resource-template",
-  title: "My Resource Template", # WARNING: This is a `Draft` and is not supported in the `Version 2025-06-18 (latest)` specification.
+  title: "My Resource Template",
   description: "Lorem ipsum dolor sit amet",
   mime_type: "text/html",
 )
@@ -774,8 +874,12 @@ The `MCP::Client` class provides an interface for interacting with MCP servers.
 
 This class supports:
 
-- Tool listing via the `tools/list` method
-- Tool invocation via the `tools/call` method
+- Tool listing via the `tools/list` method (`MCP::Client#tools`)
+- Tool invocation via the `tools/call` method (`MCP::Client#call_tools`)
+- Resource listing via the `resources/list` method (`MCP::Client#resources`)
+- Resource reading via the `resources/read` method (`MCP::Client#read_resources`)
+- Prompt listing via the `prompts/list` method (`MCP::Client#prompts`)
+- Prompt retrieval via the `prompts/get` method (`MCP::Client#get_prompt`)
 - Automatic JSON-RPC 2.0 message formatting
 - UUID request ID generation
 
@@ -864,15 +968,7 @@ The client provides a wrapper class for tools returned by the server:
 
 This class provides easy access to tool properties like name, description, input schema, and output schema.
 
-## Releases
-
-This gem is published to [RubyGems.org](https://rubygems.org/gems/mcp)
-
-Releases are triggered by PRs to the `main` branch updating the version number in `lib/mcp/version.rb`.
-
-1. **Update the version number** in `lib/mcp/version.rb`, following [semver](https://semver.org/)
-1. **Update CHANGELOG.md**, backfilling the changes since the last release if necessary, and adding a new section for the new version, clearing out the Unreleased section
-1. **Create a PR and get approval from a maintainer**
-1. **Merge your PR to the main branch** - This will automatically trigger the release workflow via GitHub Actions
+## Documentation
 
-When changes are merged to the `main` branch, the GitHub Actions workflow (`.github/workflows/release.yml`) is triggered and the gem is published to RubyGems.
+- [SDK API documentation](https://rubydoc.info/gems/mcp)
+- [Model Context Protocol documentation](https://modelcontextprotocol.io)