CtrlK

Community Documentation Log in Get started

tessl/maven-org-springframework-ai--spring-ai-starter-mcp-client-webflux

Spring Boot starter providing auto-configuration for Model Context Protocol (MCP) client with Spring WebFlux, enabling reactive AI applications to connect to MCP servers via SSE and Streamable HTTP transports

Overview

Eval results

Files

Configuration Properties

Name: tessl/maven-org-springframework-ai--spring-ai-starter-mcp-client-webflux
Author: tessl

Complete reference for all configuration properties available in the Spring AI MCP Client WebFlux Starter.

Common MCP Client Properties

Configuration properties shared across all transport types.

Prefix: spring.ai.mcp.client

Properties Class

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Configuration properties for common MCP client settings.
 * Bound from spring.ai.mcp.client.* properties.
 * Immutable after Spring Boot property binding completes.
 * Thread-safe for reads after initialization.
 */
@org.springframework.boot.context.properties.ConfigurationProperties("spring.ai.mcp.client")
public class McpClientCommonProperties {

    /** Enable/disable the MCP client (default: true) */
    private boolean enabled = true;

    /** The name of the MCP client instance (default: "spring-ai-mcp-client") */
    private String name = "spring-ai-mcp-client";

    /** The version of the MCP client instance (default: "1.0.0") */
    private String version = "1.0.0";

    /** Flag to indicate if the MCP client has to be initialized (default: true) */
    private boolean initialized = true;

    /** The timeout duration for MCP client requests (default: 20 seconds) */
    private java.time.Duration requestTimeout = java.time.Duration.ofSeconds(20);

    /** The type of client to use (default: ClientType.SYNC) */
    private ClientType type = ClientType.SYNC;

    /** Enable/disable root change notifications (default: true) */
    private boolean rootChangeNotification = true;

    /** Tool callback configuration */
    private Toolcallback toolcallback = new Toolcallback();

    // Getters and setters...
    public boolean isEnabled() { return enabled; }
    public void setEnabled(boolean enabled) { this.enabled = enabled; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getVersion() { return version; }
    public void setVersion(String version) { this.version = version; }

    public boolean isInitialized() { return initialized; }
    public void setInitialized(boolean initialized) { this.initialized = initialized; }

    public java.time.Duration getRequestTimeout() { return requestTimeout; }
    public void setRequestTimeout(java.time.Duration requestTimeout) { this.requestTimeout = requestTimeout; }

    public ClientType getType() { return type; }
    public void setType(ClientType type) { this.type = type; }

    public boolean isRootChangeNotification() { return rootChangeNotification; }
    public void setRootChangeNotification(boolean rootChangeNotification) { this.rootChangeNotification = rootChangeNotification; }

    public Toolcallback getToolcallback() { return toolcallback; }
    public void setToolcallback(Toolcallback toolcallback) { this.toolcallback = toolcallback; }
}

ClientType Enum

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Client types supported by the MCP client.
 * Determines which beans are created (sync or async).
 * Enum is thread-safe and immutable.
 */
public enum ClientType {
    /** 
     * Synchronous (McpSyncClient) client.
     * Uses blocking I/O operations.
     * Creates McpSyncClient beans and related sync beans.
     */
    SYNC,

    /** 
     * Asynchronous (McpAsyncClient) client.
     * Uses reactive streams (Project Reactor) for non-blocking operations.
     * Creates McpAsyncClient beans and related async beans.
     */
    ASYNC
}

Toolcallback Class

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Callback configuration for tools.
 * Nested configuration class within McpClientCommonProperties.
 * Controls whether MCP tools are automatically converted to Spring AI ToolCallbacks.
 */
public static class Toolcallback {

    /** 
     * Enable/disable tool callbacks (default: true).
     * When true, creates ToolCallbackProvider beans for Spring AI integration.
     * When false, MCP clients are still created but not integrated with Spring AI tools.
     */
    private boolean enabled = true;

    public boolean isEnabled() { return enabled; }
    public void setEnabled(boolean enabled) { this.enabled = enabled; }
}

Configuration Example

spring.ai.mcp.client:
  enabled: true                          # Enable MCP client
  name: my-ai-application-client         # Client name
  version: 2.0.0                         # Client version
  initialized: true                      # Initialize on startup
  request-timeout: 30s                   # 30 second timeout
  type: SYNC                             # Use synchronous client
  root-change-notification: true         # Enable root change notifications
  toolcallback:
    enabled: true                        # Enable tool callbacks

Properties format:

spring.ai.mcp.client.enabled=true
spring.ai.mcp.client.name=my-ai-application-client
spring.ai.mcp.client.version=2.0.0
spring.ai.mcp.client.initialized=true
spring.ai.mcp.client.request-timeout=30s
spring.ai.mcp.client.type=SYNC
spring.ai.mcp.client.root-change-notification=true
spring.ai.mcp.client.toolcallback.enabled=true

Property Details

`enabled` (boolean, default: `true`)

Purpose: Master switch to enable/disable all MCP client functionality
Effect when false: No MCP beans are created, all auto-configuration is skipped
Use case: Disable MCP in test environments or specific profiles

`name` (String, default: `"spring-ai-mcp-client"`)

Purpose: Identifier for the MCP client instance
Format: Free text, should be descriptive
Sent to server: Yes, as part of client identification during MCP handshake
Pattern: Client names follow {configured-name} - {connection-name} for each connection

`version` (String, default: `"1.0.0"`)

Purpose: Version identifier for the MCP client
Format: Semantic versioning recommended (major.minor.patch)
Sent to server: Yes, as part of client identification

`initialized` (boolean, default: `true`)

Purpose: Whether to automatically initialize clients on creation
Effect when false: Clients are created but not initialized; must call client.initialize() manually
Use case: Delayed initialization for conditional or lazy startup scenarios

`request-timeout` (Duration, default: `20s`)

Purpose: Maximum time to wait for MCP requests to complete
Format: Spring Boot Duration format (e.g., 20s, 5m, PT30S)
Applies to: All MCP operations (listTools, callTool, readResource, etc.)
On timeout: Throws TimeoutException
Considerations: Set higher for slow operations, lower for fast-fail behavior

`type` (ClientType, default: `SYNC`)

Purpose: Determines whether to create synchronous or asynchronous clients
Values: SYNC or ASYNC
Mutually exclusive: Only one type of client is created per application
Performance: SYNC for simplicity, ASYNC for high concurrency

`root-change-notification` (boolean, default: `true`)

Purpose: Enable clients to receive root change notifications from servers
MCP Protocol: Part of client capabilities negotiation
Effect when false: Server won't send root change notifications

`toolcallback.enabled` (boolean, default: `true`)

Purpose: Enable automatic conversion of MCP tools to Spring AI ToolCallbacks
Effect when false: MCP clients created but not integrated with Spring AI
Use case: Disable if using MCP clients directly without Spring AI chat framework

SSE Client Properties

Configuration properties for Server-Sent Events (SSE) based MCP client connections.

Prefix: spring.ai.mcp.client.sse

Properties Class

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Configuration properties for SSE client connections.
 * Bound from spring.ai.mcp.client.sse.* properties.
 * Thread-safe for reads after initialization.
 */
@org.springframework.boot.context.properties.ConfigurationProperties("spring.ai.mcp.client.sse")
public class McpSseClientProperties {

    /**
     * Map of named SSE connection configurations.
     * Key: connection name (used to identify the transport)
     * Value: SSE parameters for that connection
     * Mutable during property binding, then effectively immutable.
     */
    private final java.util.Map<String, SseParameters> connections = new java.util.HashMap<>();

    public java.util.Map<String, SseParameters> getConnections() {
        return connections;
    }
}

SseParameters Record

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Parameters for configuring an SSE connection to an MCP server.
 * Immutable record type - thread-safe.
 * Bound from spring.ai.mcp.client.sse.connections.{name}.* properties.
 *
 * @param url The base URL for SSE communication with the MCP server (required, must be valid HTTP/HTTPS URL)
 * @param sseEndpoint The SSE endpoint path (optional, defaults to "/sse" if null)
 */
public record SseParameters(String url, String sseEndpoint) {}

Configuration Examples

Simple configuration with default SSE endpoint (/sse):

spring.ai.mcp.client.sse:
  connections:
    server1:
      url: http://localhost:8080
    server2:
      url: http://api.example.com

Custom SSE endpoints:

spring.ai.mcp.client.sse:
  connections:
    mcp-hub:
      url: http://localhost:3000
      sse-endpoint: /mcp-hub/sse/cf9ec4527e3c4a2cbb149a85ea45ab01
    custom-server:
      url: http://api.example.com
      sse-endpoint: /v1/mcp/events?token=abc123

Properties format:

# Server 1 with default endpoint
spring.ai.mcp.client.sse.connections.server1.url=http://localhost:8080

# Server 2 with custom endpoint
spring.ai.mcp.client.sse.connections.mcp-hub.url=http://localhost:3000
spring.ai.mcp.client.sse.connections.mcp-hub.sse-endpoint=/mcp-hub/sse/cf9ec4527e3c4a2cbb149a85ea45ab01

URL Splitting Guidelines

When you have a full URL like http://localhost:3000/mcp-hub/sse/token123, split it as:

url: http://localhost:3000 (protocol + host + port)
sse-endpoint: /mcp-hub/sse/token123 (path including any query parameters)

More examples:

Full URL	url	sse-endpoint
`http://localhost:8080/sse`	`http://localhost:8080`	`/sse` (default, can omit)
`http://localhost:3000/api/v1/sse`	`http://localhost:3000`	`/api/v1/sse`
`http://api.example.com/mcp/events?key=xyz`	`http://api.example.com`	`/mcp/events?key=xyz`

SSE Connection Details

Protocol: Uses Server-Sent Events (text/event-stream)
Direction: Unidirectional (server to client streaming)
Persistence: Long-lived connection maintained by WebClient
Reconnection: Automatic reconnection on connection loss (handled by WebFlux SSE transport)
Buffering: Respects WebClient codec buffer settings (default 256KB, configurable)
Backpressure: Handled by reactive streams

Streamable HTTP Client Properties

Configuration properties for Streamable HTTP client connections to MCP servers.

Prefix: spring.ai.mcp.client.streamable-http

Properties Class

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Configuration properties for Streamable HTTP client connections.
 * Bound from spring.ai.mcp.client.streamable-http.* properties.
 * Thread-safe for reads after initialization.
 */
@org.springframework.boot.context.properties.ConfigurationProperties("spring.ai.mcp.client.streamable-http")
public class McpStreamableHttpClientProperties {

    /**
     * Map of named Streamable HTTP connection configurations.
     * Key: connection name (used to identify the transport)
     * Value: Connection parameters for that connection
     * Mutable during property binding, then effectively immutable.
     */
    private final java.util.Map<String, ConnectionParameters> connections = new java.util.HashMap<>();

    public java.util.Map<String, ConnectionParameters> getConnections() {
        return connections;
    }
}

ConnectionParameters Record

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Parameters for configuring a Streamable HTTP connection to an MCP server.
 * Immutable record type - thread-safe.
 * Bound from spring.ai.mcp.client.streamable-http.connections.{name}.* properties.
 *
 * @param url The base URL for Streamable HTTP communication with the MCP server (required, must be valid HTTP/HTTPS URL)
 * @param endpoint The endpoint path (optional, defaults to "/mcp" if null)
 */
public record ConnectionParameters(String url, String endpoint) {}

Configuration Examples

Simple configuration with default endpoint (/mcp):

spring.ai.mcp.client.streamable-http:
  connections:
    server1:
      url: http://localhost:8080
    server2:
      url: http://api.example.com

Custom endpoints:

spring.ai.mcp.client.streamable-http:
  connections:
    primary:
      url: http://localhost:9000
      endpoint: /custom/mcp/endpoint
    secondary:
      url: http://api.example.com
      endpoint: /v2/mcp

Properties format:

# Server 1 with default endpoint
spring.ai.mcp.client.streamable-http.connections.server1.url=http://localhost:8080

# Server 2 with custom endpoint
spring.ai.mcp.client.streamable-http.connections.primary.url=http://localhost:9000
spring.ai.mcp.client.streamable-http.connections.primary.endpoint=/custom/mcp/endpoint

Streamable HTTP Connection Details

Protocol: HTTP with streaming (typically chunked transfer encoding)
Direction: Bidirectional (client and server can both stream)
Connection Model: Per-request connections (can use keep-alive)
Reconnection: Not applicable (new connection per request)
Buffering: Respects WebClient codec buffer settings
Backpressure: Handled by reactive streams

Stdio Client Properties

Configuration properties for standard input/output (stdio) based MCP client connections.

Prefix: spring.ai.mcp.client.stdio

Properties Class

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Configuration properties for stdio client connections.
 * Bound from spring.ai.mcp.client.stdio.* properties.
 * Thread-safe for reads after initialization.
 * Part of common MCP client autoconfiguration, not WebFlux-specific.
 */
@org.springframework.boot.context.properties.ConfigurationProperties("spring.ai.mcp.client.stdio")
public class McpStdioClientProperties {

    /**
     * External JSON file containing server configurations.
     * Can be used instead of or in addition to inline connections.
     * Spring Resource format (classpath:, file:, http:, etc.).
     * Optional - if not provided, only inline connections are used.
     */
    private org.springframework.core.io.Resource serversConfiguration;

    /**
     * Map of named stdio connection configurations.
     * Key: connection name (used to identify the transport)
     * Value: Stdio parameters for that connection
     * Mutable during property binding, then effectively immutable.
     * Can be combined with serversConfiguration file.
     */
    private final java.util.Map<String, Parameters> connections = new java.util.HashMap<>();

    public org.springframework.core.io.Resource getServersConfiguration() { return serversConfiguration; }
    public void setServersConfiguration(org.springframework.core.io.Resource serversConfiguration) {
        this.serversConfiguration = serversConfiguration;
    }

    public java.util.Map<String, Parameters> getConnections() { return connections; }

    /**
     * Converts all configured connections to ServerParameters map for the MCP SDK.
     * Merges inline connections and serversConfiguration file.
     * Thread-safe - called during bean creation only.
     *
     * @return Map of connection names to ServerParameters (never null, may be empty)
     * @throws IOException if serversConfiguration file cannot be read
     * @throws com.fasterxml.jackson.core.JsonProcessingException if JSON parsing fails
     */
    public java.util.Map<String, io.modelcontextprotocol.spec.ServerParameters> toServerParameters();
}

Parameters Record

package org.springframework.ai.mcp.client.common.autoconfigure.properties;

/**
 * Parameters for configuring a stdio connection to an MCP server.
 * Immutable record type - thread-safe.
 * Bound from spring.ai.mcp.client.stdio.connections.{name}.* properties.
 *
 * @param command The command to execute (e.g., "node", "python", "/usr/bin/mcp-server")
 * @param args Command arguments as a list (optional, can be null or empty)
 * @param env Environment variables for the process (optional, can be null or empty)
 */
public record Parameters(
    String command,
    java.util.List<String> args,
    java.util.Map<String, String> env
) {
    /**
     * Converts this Parameters object to ServerParameters for the MCP SDK.
     * Creates immutable ServerParameters instance.
     *
     * @return ServerParameters instance (never null)
     */
    public io.modelcontextprotocol.spec.ServerParameters toServerParameters();
}

Configuration Examples

Basic stdio configuration:

spring.ai.mcp.client.stdio:
  connections:
    local-node-server:
      command: node
      args:
        - /path/to/mcp-server.js
    python-server:
      command: python
      args:
        - /path/to/mcp_server.py
        - --verbose
      env:
        PYTHONPATH: /custom/path
        DEBUG: "true"

Using external JSON configuration file:

spring.ai.mcp.client.stdio:
  servers-configuration: classpath:mcp-servers.json

The JSON file format:

{
  "mcpServers": {
    "server1": {
      "command": "node",
      "args": ["/path/to/server.js"]
    },
    "server2": {
      "command": "python",
      "args": ["/path/to/server.py"],
      "env": {
        "KEY": "value"
      }
    }
  }
}

Properties format:

spring.ai.mcp.client.stdio.connections.local-server.command=node
spring.ai.mcp.client.stdio.connections.local-server.args[0]=/path/to/mcp-server.js
spring.ai.mcp.client.stdio.connections.python-server.command=python
spring.ai.mcp.client.stdio.connections.python-server.args[0]=/path/to/server.py
spring.ai.mcp.client.stdio.connections.python-server.env.DEBUG=true

Stdio Connection Details

Process Management: Each connection spawns a separate child process
Communication: Via standard input (stdin) and standard output (stdout)
Error Stream: stderr is captured separately for logging (not used for MCP messages)
Working Directory: Inherited from parent process (configurable via shell wrapper)
Process Lifecycle: Started on bean creation, terminated on application context close
Stdin Buffering: Line-buffered or unbuffered (depends on process implementation)
Stdout Buffering: Process must flush after each message for reliable communication
Process Termination: Graceful shutdown with SIGTERM, forced with SIGKILL after timeout

Command Resolution

PATH Lookup: Commands without full path are resolved via system PATH
Absolute Paths: Recommended for production to avoid PATH dependencies
Shell Execution: Not used by default - provide explicit command and args
Platform Differences: Commands may differ between OS (e.g., python vs python3, node vs node.exe)

Annotation Scanner Properties

Configuration properties for the MCP client annotation scanner feature.

Prefix: spring.ai.mcp.client.annotation-scanner

Properties Class

package org.springframework.ai.mcp.client.common.autoconfigure.annotations;

/**
 * Configuration properties for MCP client annotation scanner.
 * Bound from spring.ai.mcp.client.annotation-scanner.* properties.
 * Thread-safe for reads after initialization.
 * Controls whether annotated handler methods are scanned and registered.
 */
@org.springframework.boot.context.properties.ConfigurationProperties("spring.ai.mcp.client.annotation-scanner")
public class McpClientAnnotationScannerProperties {

    /**
     * Enable/disable annotation-based MCP handler scanning (default: true).
     * When enabled, scans for @McpLogging, @McpSampling, @McpProgress, etc.
     * Scanning happens at startup during bean initialization.
     * When disabled, no annotation scanning occurs and handler registry is not created.
     */
    private boolean enabled = true;

    public boolean isEnabled() { return enabled; }
    public void setEnabled(boolean enabled) { this.enabled = enabled; }
}

Configuration Example

spring.ai.mcp.client:
  annotation-scanner:
    enabled: true  # default, can be disabled

To disable annotation scanning:

spring.ai.mcp.client:
  annotation-scanner:
    enabled: false

Annotation Scanner Details

Scan Timing: During Spring context refresh, after bean creation
Scan Scope: All Spring-managed beans (components, services, configurations)
Supported Annotations: @McpLogging, @McpSampling, @McpElicitation, @McpProgress, @McpToolListChanged, @McpResourceListChanged, @McpPromptListChanged
Handler Registration: Handlers registered with appropriate registry (sync or async based on client type)
Method Requirements: Annotated methods must have correct signatures matching annotation type
Error Handling: Invalid handler methods log warnings and are skipped

Complete Configuration Example

Example showing all property types together:

spring.ai.mcp.client:
  # Common properties
  enabled: true
  name: my-mcp-client
  version: 1.0.0
  initialized: true
  request-timeout: 25s
  type: SYNC
  root-change-notification: true
  toolcallback:
    enabled: true
  annotation-scanner:
    enabled: true

  # Stdio connections (local processes)
  stdio:
    connections:
      local-node-server:
        command: node
        args:
          - ./mcp-servers/filesystem.js
      local-python-server:
        command: python
        args:
          - ./mcp-servers/database.py
        env:
          DATABASE_URL: jdbc:postgresql://localhost:5432/mydb

  # SSE connections (remote servers)
  sse:
    connections:
      weather-service:
        url: http://localhost:8080
        sse-endpoint: /weather/sse
      data-service:
        url: http://localhost:9000

  # Streamable HTTP connections (remote servers)
  streamable-http:
    connections:
      analysis-service:
        url: http://localhost:7000
        endpoint: /analyze/mcp
      report-service:
        url: http://localhost:6000

Property Binding

All properties are automatically bound by Spring Boot's configuration property mechanism. You can use:

application.yml or application.properties files: Standard Spring Boot configuration files
Environment variables: Uppercase with underscores (e.g., SPRING_AI_MCP_CLIENT_ENABLED=true)
Command-line arguments: Pass as arguments (e.g., --spring.ai.mcp.client.enabled=true)
Spring Cloud Config Server: External configuration service
System properties: Java system properties (e.g., -Dspring.ai.mcp.client.enabled=true)
Profile-specific files: application-{profile}.yml for environment-specific configuration
@ConfigurationProperties binding: Custom beans can bind MCP properties

Property Precedence (highest to lowest)

Command-line arguments
System properties
OS environment variables
Profile-specific application files (application-{profile}.yml)
Application configuration files (application.yml)
Default values in @ConfigurationProperties classes

Validation

The starter performs these validations:

Required Fields

SSE connections: url is required
Streamable HTTP connections: url is required
Stdio connections: command is required

Format Validation

URLs: Must be valid HTTP/HTTPS URLs
requestTimeout: Must be valid Duration string (e.g., 20s, 5m, PT30S)
type: Must be either SYNC or ASYNC
Connection names: Must be unique within their transport type

Runtime Validation

URL accessibility: Not validated at startup - errors occur on first connection attempt
Command existence: Not validated at startup - errors occur when spawning process
Endpoint paths: Not validated - errors occur on first request

Validation Failures

Invalid property format: Application fails to start with BindException
Missing required fields: Application fails to start with BindException
Invalid enum values: Application fails to start with BindException
Runtime connection failures: Handled by transport layer, logged as errors

Disabling Auto-Configuration

To completely disable MCP client auto-configuration:

spring.ai.mcp.client:
  enabled: false

Or exclude the auto-configuration classes:

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.SpringApplication;

@SpringBootApplication(exclude = {
    org.springframework.ai.mcp.client.webflux.autoconfigure.SseWebFluxTransportAutoConfiguration.class,
    org.springframework.ai.mcp.client.webflux.autoconfigure.StreamableHttpWebFluxTransportAutoConfiguration.class,
    org.springframework.ai.mcp.client.common.autoconfigure.StdioTransportAutoConfiguration.class,
    org.springframework.ai.mcp.client.common.autoconfigure.McpClientAutoConfiguration.class,
    org.springframework.ai.mcp.client.common.autoconfigure.McpToolCallbackAutoConfiguration.class,
    org.springframework.ai.mcp.client.common.autoconfigure.annotations.McpClientAnnotationScannerAutoConfiguration.class
})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Selective Disabling

Disable specific features while keeping others:

spring.ai.mcp.client:
  enabled: true
  toolcallback:
    enabled: false          # Disable Spring AI integration
  annotation-scanner:
    enabled: false          # Disable annotation scanning

Environment-Specific Configuration

Use Spring profiles for environment-specific settings:

# application-dev.yml
spring.ai.mcp.client:
  request-timeout: 60s      # Longer timeout for debugging
  sse:
    connections:
      test-server:
        url: http://localhost:8080

# application-prod.yml
spring.ai.mcp.client:
  request-timeout: 10s      # Shorter timeout for production
  sse:
    connections:
      prod-server:
        url: https://api.production.com
        sse-endpoint: /mcp/v1/sse

External Configuration

Load configuration from external sources:

spring.config.import: optional:file:./config/mcp-config.yml

Or use Spring Cloud Config:

spring.cloud.config:
  uri: http://config-server:8888
  name: mcp-client

Configuration Best Practices

Use Descriptive Names: Choose meaningful connection names that indicate purpose
Set Appropriate Timeouts: Balance between responsiveness and reliability
Environment Variables for Secrets: Don't hardcode passwords or tokens in configuration files
Profile-Specific Configuration: Separate dev, test, and prod settings
Validate Early: Test configuration at startup, not on first use
Document Custom Properties: Add comments to configuration files
Version Control: Commit application.yml template with placeholders, not actual values
Externalize URLs: Use environment-specific property files or external configuration
Monitor Configuration: Log active configuration at startup for debugging
Fail Fast: Use enabled: false to explicitly disable features rather than removing configuration

tessl i tessl/maven-org-springframework-ai--spring-ai-starter-mcp-client-webflux@1.1.0

docs

examples

guides

reference

annotation-scanner.md

configuration-properties.md

streamable-http-transport.md

tool-callbacks.md

index.md

tile.json

tessl/maven-org-springframework-ai--spring-ai-starter-mcp-client-webflux