bioruby-mcp-server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9af8854132608c26884e31bb79bfa446eec6847f198757afddca808daf879aa8
+  data.tar.gz: 0a7dc98c744e4007cb6b9e785fa592932005480beee802d03fd9cbc0f01d4432
+SHA512:
+  metadata.gz: 81e2e6489387e4cbb564b7881cbc7fddad3742831acc1ba609b54d41205c2d4978062aa02c8eafad90e2ffcc6b8d67eb289ae2ef0979ed3c56d3e70ab6781380
+  data.tar.gz: 6ed869a261b186ec7743d2d1edbda88daf452ccd2a8061af66c040680ae7e9261549811389875bbee05aac771f5e2ddd0ee6a41fbd1ece00d4a1b3c3cd52e200

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-09-19
+
+### Added
+- Initial release of bioruby-mcp-server
+- Model Context Protocol (MCP) server implementation using official MCP Ruby SDK
+- Integration with BioRuby KEGG module
+- KEGG pathway information retrieval (`kegg_pathway_info`)
+- KEGG compound information retrieval (`kegg_compound_info`)
+- KEGG enzyme information retrieval (`kegg_enzyme_info`)
+- KEGG compound search functionality (`kegg_search_compounds`)
+- Pathway discovery by compound (`kegg_find_pathways_by_compound`)
+- KEGG organism listing (`kegg_list_organisms`)
+- Comprehensive test suite
+- Command-line executable (`bioruby-mcp-server`)
+- Full documentation and examples
+
+### Technical Details
+- Built on Ruby 3.0+ with BioRuby and official MCP Ruby SDK
+- Uses KEGG REST API for data access
+- Follows MCP protocol specification via official SDK
+- Each KEGG operation implemented as MCP::Tool subclass
+- Includes proper error handling and logging
+- Supports filtering and search capabilities
+- Full MCP protocol compliance through SDK

data/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2025, Kozo Nishida
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,293 @@
+# bioruby-mcp-server
+
+A Model Context Protocol (MCP) server that provides access to BioRuby KEGG functionality. This server allows AI assistants to query KEGG databases for biological pathways, compounds, enzymes, and other molecular information through the standardized MCP protocol.
+
+Built using the official [MCP Ruby SDK](https://github.com/modelcontextprotocol/ruby-sdk).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bioruby-mcp-server'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install bioruby-mcp-server
+```
+
+## Usage
+
+### Starting the Server
+
+To start the MCP server:
+
+```bash
+$ bioruby-mcp-server
+```
+
+The server will start and listen for MCP protocol messages on stdin/stdout.
+
+### Available Tools
+
+The server provides the following tools for interacting with KEGG databases:
+
+#### 1. `kegg_pathway_info`
+Get detailed information about a KEGG pathway.
+
+**Parameters:**
+- `pathway_id` (string): KEGG pathway ID (e.g., 'map00010', 'hsa00010')
+
+**Example:**
+```json
+{
+  "name": "kegg_pathway_info",
+  "arguments": {
+    "pathway_id": "map00010"
+  }
+}
+```
+
+#### 2. `kegg_compound_info`
+Get detailed information about a KEGG compound.
+
+**Parameters:**
+- `compound_id` (string): KEGG compound ID (e.g., 'C00002', 'cpd:C00002')
+
+**Example:**
+```json
+{
+  "name": "kegg_compound_info",
+  "arguments": {
+    "compound_id": "C00002"
+  }
+}
+```
+
+#### 3. `kegg_enzyme_info`
+Get detailed information about a KEGG enzyme.
+
+**Parameters:**
+- `enzyme_id` (string): KEGG enzyme ID (e.g., 'ec:1.1.1.1')
+
+**Example:**
+```json
+{
+  "name": "kegg_enzyme_info",
+  "arguments": {
+    "enzyme_id": "ec:1.1.1.1"
+  }
+}
+```
+
+#### 4. `kegg_search_compounds`
+Search for KEGG compounds by name or formula.
+
+**Parameters:**
+- `query` (string): Search query (compound name, formula, etc.)
+- `database` (string, optional): Database to search (default: 'compound')
+
+**Example:**
+```json
+{
+  "name": "kegg_search_compounds",
+  "arguments": {
+    "query": "glucose",
+    "database": "compound"
+  }
+}
+```
+
+#### 5. `kegg_find_pathways_by_compound`
+Find pathways containing a specific compound.
+
+**Parameters:**
+- `compound_id` (string): KEGG compound ID (e.g., 'C00002')
+
+**Example:**
+```json
+{
+  "name": "kegg_find_pathways_by_compound",
+  "arguments": {
+    "compound_id": "C00002"
+  }
+}
+```
+
+#### 6. `kegg_list_organisms`
+List available organisms in KEGG.
+
+**Parameters:**
+- `filter` (string, optional): Optional filter for organism names
+
+**Example:**
+```json
+{
+  "name": "kegg_list_organisms",
+  "arguments": {
+    "filter": "human"
+  }
+}
+```
+
+### Integration with AI Assistants
+
+This MCP server can be used with any AI assistant that supports the Model Context Protocol. Configure your AI assistant to connect to this server to enable KEGG database queries.
+
+#### Claude Desktop Integration
+
+To connect this server to Claude Desktop, you'll need to configure it in Claude's MCP settings:
+
+##### 1. Install the Server
+
+First, install the bioruby-mcp-server gem:
+
+```bash
+gem install bioruby-mcp-server
+```
+
+##### 2. Configure Claude Desktop
+
+Add the server configuration to Claude Desktop's configuration file:
+
+**On macOS:**
+Edit or create `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+**On Windows:**
+Edit or create `%APPDATA%\Claude\claude_desktop_config.json`
+
+**On Linux:**
+Edit or create `~/.config/Claude/claude_desktop_config.json`
+
+Add the following configuration:
+
+```json
+{
+  "mcpServers": {
+    "bioruby-kegg": {
+      "command": "bioruby-mcp-server",
+      "args": []
+    }
+  }
+}
+```
+
+If you are Windows WSL user:
+
+```json
+{
+  "mcpServers": {
+    "bioruby-kegg": {
+			"command": "wsl.exe",
+			"args": [
+				"bioruby-mcp-server"
+			]
+    }
+  }
+}
+```
+
+##### 3. Restart Claude Desktop
+
+After saving the configuration file, restart Claude Desktop to load the new MCP server.
+
+##### 4. Verify Connection
+
+Once connected, you can test the integration by asking Claude to query KEGG databases. For example:
+
+- "Get information about KEGG pathway map00010"
+- "Search for glucose compounds in KEGG"
+- "Find pathways containing compound C00002"
+
+##### Troubleshooting
+
+If the connection fails:
+
+1. **Check gem installation**: Ensure `bioruby-mcp-server` is installed and accessible in your PATH
+   ```bash
+   which bioruby-mcp-server
+   gem list bioruby-mcp-server
+   ```
+
+2. **Verify configuration**: Check that the JSON configuration file is valid and in the correct location
+
+3. **Check permissions**: Ensure Claude Desktop has permission to execute the bioruby-mcp-server command
+
+4. **Review logs**: Check Claude Desktop's logs for any error messages related to MCP server connections
+
+#### General MCP Configuration
+
+For other AI assistants that support MCP, use this general configuration format:
+
+```json
+{
+  "mcpServers": {
+    "bioruby-kegg": {
+      "command": "bioruby-mcp-server",
+      "args": []
+    }
+  }
+}
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` 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).
+
+## Testing
+
+Run the test suite:
+
+```bash
+$ bundle exec rake test
+```
+
+Run RuboCop for code style checking:
+
+```bash
+$ bundle exec rubocop
+```
+
+## Requirements
+
+- Ruby 3.0 or higher
+- Internet connectivity for accessing KEGG REST API
+
+## Dependencies
+
+- [bio](https://github.com/bioruby/bioruby) - BioRuby library for biological data processing
+- [mcp](https://github.com/modelcontextprotocol/ruby-sdk) - Official MCP Ruby SDK
+
+## Technical Implementation
+
+This server is built using the official [MCP Ruby SDK](https://github.com/modelcontextprotocol/ruby-sdk), ensuring full compliance with the Model Context Protocol specification. Each KEGG tool is implemented as an `MCP::Tool` subclass, providing proper input schema validation and structured responses.
+
+### Architecture
+
+- **KEGG REST API Integration**: Direct integration with KEGG's REST API for real-time data access
+- **BioRuby Parser Integration**: Uses BioRuby's KEGG parsers for proper data structure handling  
+- **MCP Protocol Compliance**: Built on the official MCP Ruby SDK for standardized protocol handling
+- **Tool-based Architecture**: Each KEGG operation is implemented as a separate MCP tool
+- **Robust Error Handling**: Comprehensive error handling for network issues, invalid IDs, and API failures
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kozo2/bioruby-mcp-server. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/kozo2/bioruby-mcp-server/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [BSD 2-Clause License](https://opensource.org/licenses/BSD-2-Clause).
+
+## Code of Conduct
+
+Everyone interacting in the bioruby-mcp-server project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/kozo2/bioruby-mcp-server/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'minitest/test_task'
+
+Minitest::TestTask.create
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/bioruby-mcp-server.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'lib/bioruby/mcp/server/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'bioruby-mcp-server'
+  spec.version = BioRuby::MCP::Server::VERSION
+  spec.authors = ['Kozo Nishida']
+  spec.email = ['kozo2@gmail.com']
+
+  spec.summary = 'Model Context Protocol server for BioRuby KEGG module'
+  spec.description = 'An MCP server that provides access to BioRuby KEGG functionality, ' \
+                     'allowing AI assistants to query KEGG databases for biological pathways, ' \
+                     'compounds, and other molecular information.'
+  spec.homepage = 'https://github.com/kozo2/bioruby-mcp-server'
+  spec.license = 'BSD-2-Clause'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/kozo2/bioruby-mcp-server'
+  spec.metadata['changelog_uri'] = 'https://github.com/kozo2/bioruby-mcp-server/blob/main/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Dependencies
+  spec.add_dependency 'bio', '~> 2.0'
+  spec.add_dependency 'mcp', '~> 0.1'
+
+  # Development dependencies
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rubocop', '~> 1.21'
+end

data/exe/bioruby-mcp-server

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/bioruby'
+
+# Start the BioRuby MCP Server using the SDK
+BioRuby::MCP::Server::Core.start_stdio_server

data/lib/bioruby/mcp/server/core.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'mcp'
+require 'mcp/server/transports/stdio_transport'
+require_relative 'kegg_tools'
+
+module BioRuby
+  module MCP
+    module Server
+      # BioRuby MCP Server using the official MCP Ruby SDK
+      class Core
+        def self.create_server
+          # Create MCP server with all KEGG tools
+          ::MCP::Server.new(
+            name: 'bioruby-mcp-server',
+            version: VERSION,
+            tools: [
+              KEGGPathwayTool,
+              KEGGCompoundTool,
+              KEGGEnzymeTool,
+              KEGGSearchTool,
+              KEGGPathwayFinderTool,
+              KEGGOrganismTool
+            ]
+          )
+        end
+
+        def self.start_stdio_server
+          server = create_server
+          transport = ::MCP::Server::Transports::StdioTransport.new(server)
+          transport.open
+        end
+      end
+    end
+  end
+end

data/lib/bioruby/mcp/server/kegg_tools.rb

@@ -0,0 +1,417 @@
+# frozen_string_literal: true
+
+require 'mcp'
+require 'bio'
+require 'open-uri'
+require 'uri'
+
+module BioRuby
+  module MCP
+    module Server
+      # KEGG pathway information tool
+      class KEGGPathwayTool < ::MCP::Tool
+        tool_name 'kegg_pathway_info'
+        description 'Get information about a KEGG pathway'
+        input_schema(
+          properties: {
+            pathway_id: {
+              type: 'string',
+              description: 'KEGG pathway ID (e.g., "map00010", "hsa00010")'
+            }
+          },
+          required: ['pathway_id']
+        )
+
+        KEGG_REST_BASE = 'http://rest.kegg.jp'
+
+        class << self
+          def call(pathway_id:, server_context: nil)
+            # Clean up pathway ID if needed
+            pathway_id = pathway_id.gsub(/^(pathway:|path:|map:)/, '')
+            
+            # Get pathway entry from KEGG REST API
+            pathway_data = kegg_get_entry(pathway_id)
+            
+            if pathway_data.nil? || pathway_data.empty?
+              return ::MCP::Tool::Response.new([{
+                type: 'text',
+                text: "Pathway not found: #{pathway_id}"
+              }])
+            end
+
+            # Parse the pathway data using BioRuby
+            pathway = Bio::KEGG::PATHWAY.new(pathway_data)
+            
+            result = []
+            result << {
+              type: 'text',
+              text: "KEGG Pathway: #{pathway_id}\n" \
+                    "Name: #{pathway.name}\n" \
+                    "Description: #{pathway.description}\n" \
+                    "Class: #{pathway.pathway_class}\n" \
+                    "Genes: #{pathway.genes&.length || 0} genes\n" \
+                    "Compounds: #{pathway.compounds&.length || 0} compounds"
+            }
+            
+            if pathway.genes && !pathway.genes.empty?
+              gene_list = pathway.genes.first(10).map { |gene_id, name| "#{gene_id}: #{name}" }
+              result << {
+                type: 'text',
+                text: "Sample genes (first 10):\n#{gene_list.join("\n")}"
+              }
+            end
+
+            ::MCP::Tool::Response.new(result)
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "Error retrieving pathway info: #{e.message}"
+            }])
+          end
+
+          private
+
+          def kegg_get_entry(entry_id)
+            uri = URI("#{KEGG_REST_BASE}/get/#{entry_id}")
+            begin
+              uri.open.read
+            rescue OpenURI::HTTPError
+              nil
+            end
+          end
+        end
+      end
+
+      # KEGG compound information tool
+      class KEGGCompoundTool < ::MCP::Tool
+        tool_name 'kegg_compound_info'
+        description 'Get information about a KEGG compound'
+        input_schema(
+          properties: {
+            compound_id: {
+              type: 'string',
+              description: 'KEGG compound ID (e.g., "C00002", "cpd:C00002")'
+            }
+          },
+          required: ['compound_id']
+        )
+
+        KEGG_REST_BASE = 'http://rest.kegg.jp'
+
+        class << self
+          def call(compound_id:, server_context: nil)
+            # Clean up compound ID if needed
+            compound_id = compound_id.gsub(/^(cpd:|compound:)/, '')
+            
+            # Get compound entry from KEGG REST API
+            compound_data = kegg_get_entry(compound_id)
+            
+            if compound_data.nil? || compound_data.empty?
+              return ::MCP::Tool::Response.new([{
+                type: 'text',
+                text: "Compound not found: #{compound_id}"
+              }])
+            end
+
+            # Parse the compound data using BioRuby
+            compound = Bio::KEGG::COMPOUND.new(compound_data)
+            
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "KEGG Compound: #{compound_id}\n" \
+                    "Name: #{compound.name}\n" \
+                    "Formula: #{compound.formula}\n" \
+                    "Mass: #{compound.mass}\n" \
+                    "Comment: #{compound.comment}\n" \
+                    "Pathways: #{compound.pathways&.length || 0} pathways\n" \
+                    "Enzymes: #{compound.enzymes&.length || 0} enzymes"
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "Error retrieving compound info: #{e.message}"
+            }])
+          end
+
+          private
+
+          def kegg_get_entry(entry_id)
+            uri = URI("#{KEGG_REST_BASE}/get/#{entry_id}")
+            begin
+              uri.open.read
+            rescue OpenURI::HTTPError
+              nil
+            end
+          end
+        end
+      end
+
+      # KEGG enzyme information tool
+      class KEGGEnzymeTool < ::MCP::Tool
+        tool_name 'kegg_enzyme_info'
+        description 'Get information about a KEGG enzyme'
+        input_schema(
+          properties: {
+            enzyme_id: {
+              type: 'string',
+              description: 'KEGG enzyme ID (e.g., "ec:1.1.1.1")'
+            }
+          },
+          required: ['enzyme_id']
+        )
+
+        KEGG_REST_BASE = 'http://rest.kegg.jp'
+
+        class << self
+          def call(enzyme_id:, server_context: nil)
+            # Clean up enzyme ID if needed  
+            enzyme_id = enzyme_id.gsub(/^(ec:|enzyme:)/, '')
+            
+            # Get enzyme entry from KEGG REST API
+            enzyme_data = kegg_get_entry(enzyme_id)
+            
+            if enzyme_data.nil? || enzyme_data.empty?
+              return ::MCP::Tool::Response.new([{
+                type: 'text',
+                text: "Enzyme not found: #{enzyme_id}"
+              }])
+            end
+
+            # Parse the enzyme data using BioRuby
+            enzyme = Bio::KEGG::ENZYME.new(enzyme_data)
+            
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "KEGG Enzyme: #{enzyme_id}\n" \
+                    "Name: #{enzyme.name}\n" \
+                    "Class: #{enzyme.enzyme_class}\n" \
+                    "Reaction: #{enzyme.reaction}\n" \
+                    "Substrate: #{enzyme.substrate}\n" \
+                    "Product: #{enzyme.product}\n" \
+                    "Comment: #{enzyme.comment}"
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "Error retrieving enzyme info: #{e.message}"
+            }])
+          end
+
+          private
+
+          def kegg_get_entry(entry_id)
+            uri = URI("#{KEGG_REST_BASE}/get/#{entry_id}")
+            begin
+              uri.open.read
+            rescue OpenURI::HTTPError
+              nil
+            end
+          end
+        end
+      end
+
+      # KEGG compound search tool
+      class KEGGSearchTool < ::MCP::Tool
+        tool_name 'kegg_search_compounds'
+        description 'Search for KEGG compounds by name or formula'
+        input_schema(
+          properties: {
+            query: {
+              type: 'string',
+              description: 'Search query (compound name, formula, etc.)'
+            },
+            database: {
+              type: 'string',
+              description: 'Database to search (default: "compound")',
+              default: 'compound'
+            }
+          },
+          required: ['query']
+        )
+
+        KEGG_REST_BASE = 'http://rest.kegg.jp'
+
+        class << self
+          def call(query:, database: 'compound', server_context: nil)
+            # Use KEGG REST API to search for compounds
+            results = kegg_find_entries(database, query)
+            
+            if results.nil? || results.empty?
+              return ::MCP::Tool::Response.new([{
+                type: 'text',
+                text: "No compounds found for query: #{query}"
+              }])
+            end
+
+            # Parse and format results
+            formatted_results = results.split("\n").first(20).map do |line|
+              parts = line.split("\t")
+              "#{parts[0]}: #{parts[1]}" if parts.length >= 2
+            end.compact
+
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "Search results for '#{query}' (first 20):\n#{formatted_results.join("\n")}"
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "Error searching compounds: #{e.message}"
+            }])
+          end
+
+          private
+
+          def kegg_find_entries(database, query)
+            uri = URI("#{KEGG_REST_BASE}/find/#{database}/#{query}")
+            begin
+              uri.open.read
+            rescue OpenURI::HTTPError
+              nil
+            end
+          end
+        end
+      end
+
+      # KEGG pathway finder tool
+      class KEGGPathwayFinderTool < ::MCP::Tool
+        tool_name 'kegg_find_pathways_by_compound'
+        description 'Find pathways containing a specific compound'
+        input_schema(
+          properties: {
+            compound_id: {
+              type: 'string',
+              description: 'KEGG compound ID (e.g., "C00002")'
+            }
+          },
+          required: ['compound_id']
+        )
+
+        KEGG_REST_BASE = 'http://rest.kegg.jp'
+
+        class << self
+          def call(compound_id:, server_context: nil)
+            # Clean up compound ID
+            compound_id = compound_id.gsub(/^(cpd:|compound:)/, '')
+            
+            # Get compound info first to find associated pathways
+            compound_data = kegg_get_entry(compound_id)
+            
+            if compound_data.nil? || compound_data.empty?
+              return ::MCP::Tool::Response.new([{
+                type: 'text',
+                text: "Compound not found: #{compound_id}"
+              }])
+            end
+
+            compound = Bio::KEGG::COMPOUND.new(compound_data)
+            
+            if compound.pathways.nil? || compound.pathways.empty?
+              return ::MCP::Tool::Response.new([{
+                type: 'text',
+                text: "No pathways found for compound: #{compound_id}"
+              }])
+            end
+
+            pathway_list = compound.pathways.map do |pathway_id, pathway_name|
+              "#{pathway_id}: #{pathway_name}"
+            end
+
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "Pathways containing compound #{compound_id}:\n#{pathway_list.join("\n")}"
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "Error finding pathways: #{e.message}"
+            }])
+          end
+
+          private
+
+          def kegg_get_entry(entry_id)
+            uri = URI("#{KEGG_REST_BASE}/get/#{entry_id}")
+            begin
+              uri.open.read
+            rescue OpenURI::HTTPError
+              nil
+            end
+          end
+        end
+      end
+
+      # KEGG organism list tool
+      class KEGGOrganismTool < ::MCP::Tool
+        tool_name 'kegg_list_organisms'
+        description 'List available organisms in KEGG'
+        input_schema(
+          properties: {
+            filter: {
+              type: 'string',
+              description: 'Optional filter for organism names'
+            }
+          }
+        )
+
+        KEGG_REST_BASE = 'http://rest.kegg.jp'
+
+        class << self
+          def call(filter: nil, server_context: nil)
+            # Get list of organisms from KEGG REST API
+            organism_data = kegg_list_entries('organism')
+            
+            if organism_data.nil? || organism_data.empty?
+              return ::MCP::Tool::Response.new([{
+                type: 'text',
+                text: 'No organisms found'
+              }])
+            end
+
+            organisms = organism_data.split("\n").map do |line|
+              parts = line.split("\t")
+              if parts.length >= 2
+                org_code = parts[0]
+                org_name = parts[1]
+                { code: org_code, name: org_name }
+              end
+            end.compact
+
+            # Apply filter if provided
+            if filter
+              organisms = organisms.select do |org|
+                org[:name].downcase.include?(filter.downcase) ||
+                org[:code].downcase.include?(filter.downcase)
+              end
+            end
+
+            # Limit results and format
+            organisms = organisms.first(50)
+            formatted_list = organisms.map { |org| "#{org[:code]}: #{org[:name]}" }
+
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "KEGG Organisms#{filter ? " (filtered by '#{filter}')" : ''} (first 50):\n#{formatted_list.join("\n")}"
+            }])
+          rescue => e
+            ::MCP::Tool::Response.new([{
+              type: 'text',
+              text: "Error listing organisms: #{e.message}"
+            }])
+          end
+
+          private
+
+          def kegg_list_entries(database)
+            uri = URI("#{KEGG_REST_BASE}/list/#{database}")
+            begin
+              uri.open.read
+            rescue OpenURI::HTTPError
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioruby/mcp/server/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BioRuby
+  module MCP
+    module Server
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/bioruby.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'bioruby/mcp/server/version'
+require_relative 'bioruby/mcp/server/kegg_tools'
+require_relative 'bioruby/mcp/server/core'
+
+module BioRuby
+  module MCP
+    module Server
+      class Error < StandardError; end
+    end
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: bioruby-mcp-server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kozo Nishida
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+description: An MCP server that provides access to BioRuby KEGG functionality, allowing
+  AI assistants to query KEGG databases for biological pathways, compounds, and other
+  molecular information.
+email:
+- kozo2@gmail.com
+executables:
+- bioruby-mcp-server
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- bioruby-mcp-server.gemspec
+- exe/bioruby-mcp-server
+- lib/bioruby.rb
+- lib/bioruby/mcp/server/core.rb
+- lib/bioruby/mcp/server/kegg_tools.rb
+- lib/bioruby/mcp/server/version.rb
+homepage: https://github.com/kozo2/bioruby-mcp-server
+licenses:
+- BSD-2-Clause
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/kozo2/bioruby-mcp-server
+  source_code_uri: https://github.com/kozo2/bioruby-mcp-server
+  changelog_uri: https://github.com/kozo2/bioruby-mcp-server/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Model Context Protocol server for BioRuby KEGG module
+test_files: []