A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
class McpController < ApplicationController
skip_before_action :check_xhr,
:preload_json,
:verify_authenticity_token,
:redirect_to_login_if_required
before_action :ensure_mcp_enabled
before_action :validate_origin
def create
if !request.media_type.to_s.casecmp?("application/json")
return(
render json: jsonrpc_error(nil, -32_600, "Content-Type must be application/json"),
status: :unsupported_media_type
)
end
accept = request.headers["Accept"].to_s
if !accept.include?("application/json") || !accept.include?("text/event-stream")
return(
render json:
jsonrpc_error(
nil,
-32_600,
"Accept must include application/json and text/event-stream",
),
status: :not_acceptable
)
end
request_context = DiscourseMcp::Authenticator.new(request).authenticate!
enforce_rate_limits!(request_context)
raw_payload = request.body.read(SiteSetting.mcp_max_request_bytes + 1) || ""
if raw_payload.bytesize > SiteSetting.mcp_max_request_bytes
return(
render json: jsonrpc_error(nil, -32_600, "Request too large"), status: :payload_too_large
)
end
payload = JSON.parse(raw_payload)
mcp_response =
DiscourseMcp::Server.new(request: request, request_context: request_context).call(payload)
mcp_response.headers.each { |name, value| response.set_header(name, value) }
return head mcp_response.http_status if mcp_response.body.nil?
encoded_response = JSON.generate(mcp_response.body)
if encoded_response.bytesize > SiteSetting.mcp_max_response_bytes
return(
render json: jsonrpc_error(payload["id"], -32_603, "Response too large"),
status: :internal_server_error
)
end
render json: encoded_response, status: mcp_response.http_status
rescue RateLimiter::LimitExceeded => error
record_rate_limited_audit(request_context)
response.set_header("Retry-After", error.available_in.to_s)
render json: jsonrpc_error(nil, -32_000, "Rate limit exceeded"), status: :too_many_requests
rescue JSON::ParserError
render json: jsonrpc_error(nil, -32_700, "Parse error"), status: :bad_request
rescue DiscourseMcp::AuthenticationError => error
response.set_header(
"WWW-Authenticate",
DiscourseMcp::Authenticator.challenge(error: error.oauth_error),
)
render json: jsonrpc_error(nil, -32_001, "Authorization required"), status: :unauthorized
end
def method_not_allowed
head :method_not_allowed, allow: "POST"
end
private
def enforce_rate_limits!(request_context)
limit = SiteSetting.mcp_global_rate_limit_per_minute
RateLimiter.new(
request_context.user,
"mcp-client-#{request_context.oauth_client_id}",
limit,
1.minute,
apply_limit_to_staff: true,
).performed!
RateLimiter.new(
nil,
"mcp-ip-#{request.remote_ip}",
limit,
1.minute,
apply_limit_to_staff: true,
).performed!
end
def record_rate_limited_audit(request_context)
bucket_at = Time.zone.now.beginning_of_minute
audit_key =
"mcp-rate-limit-audit:#{request_context&.user_id}:#{request_context&.oauth_client_id}:#{bucket_at.to_i}"
return if !Discourse.redis.set(audit_key, "1", nx: true, ex: 2.minutes.to_i)
McpAuditLog.create!(
occurred_at: Time.zone.now,
bucket_at:,
user_id: request_context&.user_id,
mcp_oauth_client_id: request_context&.oauth_client_id,
outcome: "rate_limited",
http_status: 429,
)
rescue StandardError => error
Discourse.warn_exception(error, message: "MCP audit record failed")
end
def ensure_mcp_enabled
raise Discourse::NotFound if !SiteSetting.mcp_server_enabled
end
def validate_origin
origin = request.headers["Origin"]
return if origin.blank?
actual = URI.parse(origin)
expected = URI.parse(DiscourseMcp.issuer)
if actual.path.blank? && actual.userinfo.blank? &&
[actual.scheme, actual.host, actual.port] ==
[expected.scheme, expected.host, expected.port]
return
end
render json: jsonrpc_error(nil, -32_001, "Invalid Origin"), status: :forbidden
rescue URI::InvalidURIError
render json: jsonrpc_error(nil, -32_001, "Invalid Origin"), status: :forbidden
end
def jsonrpc_error(id, code, message)
{ jsonrpc: "2.0", id: id, error: { code: code, message: message } }
end
end