Struct ProxyBuilder 

pub struct ProxyBuilder { /* private fields */ }

Fluent builder for constructing an MCP proxy without TOML config files.

Call build() to connect backends and produce a ready-to-serve Proxy.

Implementations

impl ProxyBuilder

pub fn new(name: impl Into<String>) -> Self

Create a new proxy builder with the given name.

Defaults: version “0.1.0”, separator “/”, listen 127.0.0.1:8080.

pub fn version(self, version: impl Into<String>) -> Self

Set the proxy version (default: “0.1.0”).

pub fn separator(self, separator: impl Into<String>) -> Self

Set the namespace separator (default: “/”).

pub fn listen(self, host: impl Into<String>, port: u16) -> Self

Set the listen address and port (default: 127.0.0.1:8080).

pub fn instructions(self, instructions: impl Into<String>) -> Self

Set instructions text sent to MCP clients.

pub fn shutdown_timeout(self, timeout: Duration) -> Self

Set the graceful shutdown timeout (default: 30s).

pub fn hot_reload(self, enabled: bool) -> Self

Enable hot reload for watching config file changes.

pub fn global_rate_limit(self, requests: usize, period: Duration) -> Self

Set a global rate limit across all backends.

pub fn stdio_backend( self, name: impl Into<String>, command: impl Into<String>, args: &[&str], ) -> Self

Add a stdio backend (subprocess).

pub fn stdio_backend_with_env( self, name: impl Into<String>, command: impl Into<String>, args: &[&str], env: HashMap<String, String>, ) -> Self

Add a stdio backend with environment variables.

pub fn http_backend( self, name: impl Into<String>, url: impl Into<String>, ) -> Self

Add an HTTP backend.

pub fn http_backend_with_token( self, name: impl Into<String>, url: impl Into<String>, token: impl Into<String>, ) -> Self

Add an HTTP backend with a bearer token.

pub fn configure_backend(self, f: impl FnOnce(&mut BackendConfig)) -> Self

Configure the last added backend with a per-backend modifier.

Panics

Panics if no backends have been added.

pub fn bearer_auth(self, tokens: Vec<String>) -> Self

Enable bearer token authentication. Enable bearer token authentication.

All tokens in this list have unrestricted access to all tools. For per-token tool scoping, use scoped_bearer_auth.

pub fn scoped_bearer_auth(self, scoped_tokens: Vec<BearerTokenConfig>) -> Self

Enable bearer token authentication with per-token tool scoping.

Each BearerTokenConfig can specify allow_tools or deny_tools to restrict which tools that token can access.

pub fn coalesce_requests(self, enabled: bool) -> Self

Enable request coalescing.

pub fn max_argument_size(self, max_bytes: usize) -> Self

Set the maximum argument size for validation.

pub fn audit_logging(self, enabled: bool) -> Self

Enable audit logging.

pub fn access_logging(self, enabled: bool) -> Self

Enable access logging.

pub fn log_level(self, level: impl Into<String>) -> Self

Set the log level (default: “info”).

pub fn json_logs(self, enabled: bool) -> Self

Enable structured JSON logging.

pub fn metrics(self, enabled: bool) -> Self

Enable Prometheus metrics.

pub fn timeout(self, seconds: u64) -> Self

Set the timeout for the last added backend.

Panics

Panics if no backends have been added.

Example

use mcp_proxy::builder::ProxyBuilder;

let config = ProxyBuilder::new("my-proxy")
    .http_backend("api", "http://api:8080")
    .timeout(30)
    .into_config();

assert_eq!(config.backends[0].timeout.as_ref().unwrap().seconds, 30);

pub fn rate_limit(self, requests: usize, period_seconds: u64) -> Self

Set the rate limit for the last added backend.

Panics

Panics if no backends have been added.

Example

use mcp_proxy::builder::ProxyBuilder;

let config = ProxyBuilder::new("my-proxy")
    .http_backend("api", "http://api:8080")
    .rate_limit(100, 1)
    .into_config();

let rl = config.backends[0].rate_limit.as_ref().unwrap();
assert_eq!(rl.requests, 100);
assert_eq!(rl.period_seconds, 1);

pub fn circuit_breaker(self, failure_rate: f64) -> Self

Set the circuit breaker for the last added backend.

Uses sensible defaults for other fields: minimum 5 calls, 30-second wait duration, and 3 half-open calls.

Panics

Panics if no backends have been added.

Example

use mcp_proxy::builder::ProxyBuilder;

let config = ProxyBuilder::new("my-proxy")
    .http_backend("api", "http://api:8080")
    .circuit_breaker(0.5)
    .into_config();

let cb = config.backends[0].circuit_breaker.as_ref().unwrap();
assert!((cb.failure_rate_threshold - 0.5).abs() < f64::EPSILON);

pub fn expose_tools(self, tools: &[&str]) -> Self

Set the tool allowlist for the last added backend.

Only the listed tools will be exposed through the proxy.

Panics

Panics if no backends have been added.

Example

use mcp_proxy::builder::ProxyBuilder;

let config = ProxyBuilder::new("my-proxy")
    .http_backend("api", "http://api:8080")
    .expose_tools(&["read_file", "list_dir"])
    .into_config();

assert_eq!(config.backends[0].expose_tools, vec!["read_file", "list_dir"]);

pub fn hide_tools(self, tools: &[&str]) -> Self

Set the tool denylist for the last added backend.

The listed tools will be hidden from clients.

Panics

Panics if no backends have been added.

Example

use mcp_proxy::builder::ProxyBuilder;

let config = ProxyBuilder::new("my-proxy")
    .http_backend("api", "http://api:8080")
    .hide_tools(&["dangerous_op"])
    .into_config();

assert_eq!(config.backends[0].hide_tools, vec!["dangerous_op"]);

pub fn retry(self, max_retries: u32) -> Self

Set the retry policy for the last added backend.

Uses sensible defaults: 100ms initial backoff, 5000ms max backoff, no budget limit.

Panics

Panics if no backends have been added.

Example

use mcp_proxy::builder::ProxyBuilder;

let config = ProxyBuilder::new("my-proxy")
    .http_backend("api", "http://api:8080")
    .retry(3)
    .into_config();

let retry = config.backends[0].retry.as_ref().unwrap();
assert_eq!(retry.max_retries, 3);

pub fn into_config(self) -> ProxyConfig

Extract the built ProxyConfig without connecting to backends.

Useful for inspection, serialization, or passing to Proxy::from_config() manually.

pub async fn build(self) -> Result<Proxy>

Build the proxy: validate config, connect to all backends, and construct the middleware stack.