yjacquin/fast-mcp
61.1
Adequate · 6 November 2026
3.5k
lines of production code
Ruby
primary language
4
measurements over time
What this system is
This system is a Ruby gem that implements the Model Context Protocol (MCP) for server-side applications, enabling the creation of MCP servers with tools and resources. It provides middleware for integrating these servers into Rack-based frameworks like Rails, supporting both standard and authenticated transports via Server-Sent Events. The library includes generators for scaffolding, schema validation, and comprehensive testing utilities to ensure compliance and security.
Features
Add FastMcp Rails generator for scaffolding MCP integration
Introduces a new \fast\_mcp:install\ generator that scaffolds a Rails application for Model Context Protocol (MCP) support. Running the generator creates a \config/initializers/fast\_mcp.rb\ file with middleware configuration (including default routes for SSE and messages, and security settings like \localhost\_only\), along with base classes \ApplicationTool\ and \ApplicationResource\ for inheritance, and sample implementations to demonstrate usage.
lib/generators · high confidence
Initial Rails 8.0 demo application scaffold
The \examples/rails-demo-app\ directory now contains a complete, production-ready Rails 8.0 application scaffold. This includes a Dockerfile for containerized deployment, Kamal configuration files for orchestration, and a GitHub Actions CI workflow that runs security scans (Brakeman, Importmap audit) and tests. The application is configured with SQLite for development and production, Solid Cache, Solid Cable, and Solid Queue for background jobs, and uses Thruster as the HTTP server. It also features a basic MCP (Model Context Protocol) integration via a \User\ model hook and a \SampleResource\.
examples/rails-demo-app · high confidence
Initial project scaffolding and configuration
Establishes the foundational structure for the Fast MCP Ruby gem, including the initial release (v0.1.0) and core library code. This change introduces essential development and quality tools: a \.rubocop.yml\ configuration for code style enforcement (targeting Ruby 3.0), an \.rspec\ file for test formatting, and a \.gitignore\ to exclude build artifacts. It also adds standard documentation files such as \CONTRIBUTING.md\, \CHANGELOG.md\, and an updated \README.md\ that describes the library's features, including tool and resource APIs, multiple transport options, and Rails integration.
(repo-wide) · high confidence
Initial release of FastMcp library with Rails integration and MCP compliance
This change introduces the FastMcp library (v1.6.0), providing a Ruby implementation of the Model Context Protocol (MCP). It includes a \Server\ class for handling JSON-RPC requests, support for registering and filtering tools and resources, and a dedicated \Railtie\ for automatic discovery of tools and resources in Rails applications. The library also features a custom \Logger\ for transport-aware logging and extends Dry::Schema to support schema metadata like descriptions and hidden properties.
lib/mcp · high confidence
Initial release of the FastMcp Ruby library
This change introduces the FastMcp library, a Ruby implementation of the Model Context Protocol (MCP) for server-side applications. It provides a core module for managing MCP servers, tools, and resources, along with convenience methods to integrate the server into Rack-based applications (including Rails) via middleware. The library supports configurable routes for SSE and messages, authentication options, and DNS rebinding protection.
lib · high confidence
Introduces Rack-based MCP transport with optional authentication
The library now includes a new \RackTransport\ class that allows the MCP server to be mounted as middleware in any Rack-compatible web framework, supporting configurable routes for Server-Sent Events (SSE) and message handling, along with security features like DNS rebinding protection and localhost-only binding by default. Additionally, an \AuthenticatedRackTransport\ subclass is provided to enforce token-based authentication on incoming requests, allowing administrators to specify custom auth headers and exempt specific paths from authentication checks.
lib/mcp/transports · high confidence
New example applications for MCP server integration
Added several Ruby example scripts demonstrating how to use the FastMcp library. These include a basic Rack middleware setup, an authenticated Rack middleware variant, a server using stdio transport with file-backed resources and tools, and a comprehensive tool definition guide. The examples also introduce dynamic tool and resource filtering based on user roles (public, user, admin) and demonstrate advanced argument validation using Dry::Schema, including nested objects, arrays, and optional fields.
examples · high confidence
Behavioural changes
Added gemspec verification script and bundle configuration
A new script, script/verify\_gemspec.rb, has been added to verify that the gemspec loads correctly, aiding CI processes in catching issues early. Additionally, a .bundle/config file was introduced to configure Bundler to include the 'examples' directory during dependency resolution.
.bundle, script · high confidence
Test coverage
Initial test suite for MCP server components
Added comprehensive RSpec tests covering the FastMcp server, tools, resources, and Rack-based transports. The new test suite validates core server behaviors such as handling ping, initialize, and notification requests, as well as tool registration, execution, and filtering. It also verifies resource management including templated resources and dynamic content, and ensures transport layers correctly handle authentication, SSE client management, and request filtering.
spec · high confidence
Dependencies
Initial release of fast-mcp gem and Rails 8 demo app
This change introduces the initial version of the fast-mcp Ruby gem (v1.6.0) and a new Rails 8.0.2 demo application. The gem provides a Model Context Protocol implementation with runtime dependencies on addressable, dry-schema, json, mime-types, and rack (relaxed to support versions 2.0 through 3.x). The accompanying Rails demo app showcases integration with the gem and utilizes modern Rails tooling including Propshaft, Solid Cache/Queue/Cable, and Kamal for deployment.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 55 → 61 (+6.4)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 66 → 66 (+0.0)
- Architecture 96 → 96 (+0.0)
- Maturity 33 → 48 (+14.8)
- Readiness 78 → 78 (+0.0)
- Security 73 → 70 (-3.2)
- Domain Modelling 100 → 100 (+0.0)
Resolved (4)
- Ambiguous getter/setter pattern. Resource exposes uri(value) as a method, implying it can be used as both a getter (no args) and setter (with args). While this is a common Ruby idiom, it is inconsistent with other properties like description(value) and description() which are listed separately. More importantly, Resource.uri() is also listed as a method, creating redundancy with the getter behavior of uri(value). This suggests a lack of clarity on whether uri is a property or a method.
- Duplicate notification API surface. Both FastMcp and Server expose notify_resource_updated. This mirrors the registration issue, offering two ways to trigger the same internal event, potentially leading to redundant notifications or race conditions.
- Duplicate registration API surface. Both the top-level FastMcp class and the internal Server class expose identical register_tool and register_tools methods. This creates confusion about whether the user should interact with the facade (FastMcp) or the underlying component (Server), and risks double-registration or inconsistent state if both are used.
- Inconsistent server startup/middleware patterns. FastMcp offers two distinct methods for Rack middleware (rack_middleware vs authenticated_rack_middleware), while Server offers start_rack. It is unclear if Server.start_rack is equivalent to one of the FastMcp methods or a lower-level primitive. The naming convention (middleware vs start) suggests different abstraction levels that are not clearly documented or separated in the public surface.
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
yjacquin/fast-mcp was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 6 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 7ec08b91b7fbacd8bb4cea48a29de66b21697633 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.2+preprod-5c4e66d9318b.