bc59932176I added an example for how rate limiting should be implemented using middleware. Fixes #22 ## Motivation and Context <!-- Why is this change needed? What problem does it solve? --> Rate limiting can be enabled using middleware. This adds an example on how to do that. ## How Has This Been Tested? <!-- Have you tested this in a real application? Which scenarios were tested? --> N/A ## Breaking Changes <!-- Will users need to update their code or configurations? --> No ## Types of changes <!-- What types of changes does your code introduce? Put an `x` in all the boxes that apply: --> - [ ] Bug fix (non-breaking change which fixes an issue) - [ ] New feature (non-breaking change which adds functionality) - [ ] Breaking change (fix or feature that would cause existing functionality to change) - [x] Documentation update ## Checklist <!-- Go over all the following points, and put an `x` in all the boxes that apply. --> - [x] I have read the [MCP Documentation](https://modelcontextprotocol.io) - [x] My code follows the repository's style guidelines - [x] New and existing tests pass locally - [x] I have added appropriate error handling - [x] I have added or updated documentation as needed ## Additional context <!-- Add any other context, implementation notes, or design decisions -->
54 lines
2.1 KiB
Go
54 lines
2.1 KiB
Go
// Copyright 2025 The Go MCP SDK Authors. All rights reserved.
|
|
// Use of this source code is governed by an MIT-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"github.com/modelcontextprotocol/go-sdk/mcp"
|
|
"golang.org/x/time/rate"
|
|
)
|
|
|
|
// GlobalRateLimiterMiddleware creates a middleware that applies a global rate limit.
|
|
// Every request attempting to pass through will try to acquire a token.
|
|
// If a token cannot be acquired immediately, the request will be rejected.
|
|
func GlobalRateLimiterMiddleware[S mcp.Session](limiter *rate.Limiter) mcp.Middleware[S] {
|
|
return func(next mcp.MethodHandler[S]) mcp.MethodHandler[S] {
|
|
return func(ctx context.Context, session S, method string, params mcp.Params) (mcp.Result, error) {
|
|
if !limiter.Allow() {
|
|
return nil, errors.New("JSON RPC overloaded")
|
|
}
|
|
return next(ctx, session, method, params)
|
|
}
|
|
}
|
|
}
|
|
|
|
// PerMethodRateLimiterMiddleware creates a middleware that applies rate limiting
|
|
// on a per-method basis.
|
|
// Methods not specified in limiters will not be rate limited by this middleware.
|
|
func PerMethodRateLimiterMiddleware[S mcp.Session](limiters map[string]*rate.Limiter) mcp.Middleware[S] {
|
|
return func(next mcp.MethodHandler[S]) mcp.MethodHandler[S] {
|
|
return func(ctx context.Context, session S, method string, params mcp.Params) (mcp.Result, error) {
|
|
if limiter, ok := limiters[method]; ok {
|
|
if !limiter.Allow() {
|
|
return nil, errors.New("JSON RPC overloaded")
|
|
}
|
|
}
|
|
return next(ctx, session, method, params)
|
|
}
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
server := mcp.NewServer("greeter1", "v0.0.1", nil)
|
|
server.AddReceivingMiddleware(GlobalRateLimiterMiddleware[*mcp.ServerSession](rate.NewLimiter(rate.Every(time.Second/5), 10)))
|
|
server.AddReceivingMiddleware(PerMethodRateLimiterMiddleware[*mcp.ServerSession](map[string]*rate.Limiter{
|
|
"callTool": rate.NewLimiter(rate.Every(time.Second), 5), // once a second with a burst up to 5
|
|
"listTools": rate.NewLimiter(rate.Every(time.Minute), 20), // once a minute with a burst up to 20
|
|
}))
|
|
// Run Server logic.
|
|
}
|