@@ -537,6 +537,68 @@ The same `addToolFilter(...)` method is available on the stateless builders.
 - With STDIO there is no per-request metadata, so the filter receives `McpTransportContext.EMPTY` and has nothing to key
   on.
 
+### Caching Hints for Listings
+
+A server can tell clients how long they may reuse a listing before asking for it again, so that a
+client polling `tools/list` on a stable catalog stops paying for a round trip each time. The hint
+travels on the response as a time to live (TTL) in milliseconds and a cache scope; a client that
+honors it serves the cached listing until the TTL lapses or a `*_changed` notification arrives.
+
+Listings carry no TTL by default. Set one with `listCache(...)`, which applies to `tools/list`,
+`prompts/list`, `resources/list`, and `resources/templates/list`:
+
+=== "Sync"
+
+    ```java
+    McpServer.sync(transportProvider)
+        .tools(calculatorTool, weatherTool)
+        .listCache(Duration.ofMinutes(5), CacheScope.PRIVATE)
+        .build();
+    ```
+
+=== "Async"
+
+    ```java
+    McpServer.async(transportProvider)
+        .tools(calculatorTool, weatherTool)
+        .listCache(Duration.ofMinutes(5), CacheScope.PRIVATE)
+        .build();
+    ```
+
+The same `listCache(...)` method is available on the stateless builders.
+
+!!! warning "`PUBLIC` means any caller may be served the response"
+
+    `CacheScope.PUBLIC` tells a shared cache, such as an MCP gateway, that it may serve one
+    principal the response it stored for another. Use it only for a listing that is identical for
+    every caller. Any registered [tool filter](#filtering-the-tool-listing-per-request) makes the
+    listing caller-specific, so keep the scope `PRIVATE` whenever you filter.
+
+**How a client uses the hint**
+
+- The TTL is a ceiling, not a promise. A client may re-fetch sooner, and it drops the entry as
+  soon as it receives the matching `notifications/tools/list_changed`,
+  `notifications/prompts/list_changed`, or `notifications/resources/list_changed`.
+- Set a TTL only on listings the server can invalidate. With `listChanged` disabled, a client has
+  no way to learn about a change before the TTL lapses.
+- A listing that spans several pages isn't cached: pairing a cached first page with a later page
+  fetched fresh would mix two different views of the catalog.
+
+**Caching a resource read**
+
+`resources/read` carries its own hint, because how long a resource stays valid is a property of
+that resource rather than of the server. Set it on the result the read handler returns:
+
+```java
+ReadResourceResult.builder(contents)
+    .ttlMs(Duration.ofMinutes(1).toMillis())
+    .cacheScope(CacheScope.PRIVATE)
+    .build();
+```
+
+A client drops the entry when it receives `notifications/resources/updated` for that URI. Results
+that set neither field default to a TTL of `0` with a `private` scope, which means no caching.
+
 ### Resource Specification
 
 Specification of a resource with its handler function.
 
@@ -120,6 +120,11 @@ public class McpAsyncServer {
 
 	private final McpAsyncListFilter<McpSchema.Tool> toolFilter;
 
+	/**
+	 * The caching hint attached to every listing response (SEP-2549).
+	 */
+	private final McpListCacheOptions listCacheOptions;
+
 	private List<String> protocolVersions;
 
 	private McpUriTemplateManagerFactory uriTemplateManagerFactory = new DefaultMcpUriTemplateManagerFactory();
@@ -134,7 +139,7 @@ public class McpAsyncServer {
 	McpAsyncServer(McpServerTransportProvider mcpTransportProvider, McpJsonMapper jsonMapper,
 			McpServerFeatures.Async features, Duration requestTimeout,
 			McpUriTemplateManagerFactory uriTemplateManagerFactory, JsonSchemaValidator jsonSchemaValidator,
-			boolean validateToolInputs) {
+			boolean validateToolInputs, McpListCacheOptions listCacheOptions) {
 		this.mcpTransportProvider = mcpTransportProvider;
 		this.jsonMapper = jsonMapper;
 		this.serverInfo = features.serverInfo();
@@ -149,6 +154,7 @@ public class McpAsyncServer {
 		this.jsonSchemaValidator = jsonSchemaValidator;
 		this.validateToolInputs = validateToolInputs;
 		this.toolFilter = McpAsyncListFilter.and(features.toolFilters());
+		this.listCacheOptions = listCacheOptions != null ? listCacheOptions : McpListCacheOptions.NONE;
 
 		Map<String, McpRequestHandler<?>> requestHandlers = prepareRequestHandlers();
 		Map<String, McpNotificationHandler> notificationHandlers = prepareNotificationHandlers(features);
@@ -166,7 +172,7 @@ public class McpAsyncServer {
 	McpAsyncServer(McpStreamableServerTransportProvider mcpTransportProvider, McpJsonMapper jsonMapper,
 			McpServerFeatures.Async features, Duration requestTimeout,
 			McpUriTemplateManagerFactory uriTemplateManagerFactory, JsonSchemaValidator jsonSchemaValidator,
-			boolean validateToolInputs) {
+			boolean validateToolInputs, McpListCacheOptions listCacheOptions) {
 		this.mcpTransportProvider = mcpTransportProvider;
 		this.jsonMapper = jsonMapper;
 		this.serverInfo = features.serverInfo();
@@ -181,6 +187,7 @@ public class McpAsyncServer {
 		this.jsonSchemaValidator = jsonSchemaValidator;
 		this.validateToolInputs = validateToolInputs;
 		this.toolFilter = McpAsyncListFilter.and(features.toolFilters());
+		this.listCacheOptions = listCacheOptions != null ? listCacheOptions : McpListCacheOptions.NONE;
 
 		Map<String, McpRequestHandler<?>> requestHandlers = prepareRequestHandlers();
 		Map<String, McpNotificationHandler> notificationHandlers = prepareNotificationHandlers(features);
@@ -548,9 +555,11 @@ private McpRequestHandler<McpSchema.ListToolsResult> toolsListRequestHandler() {
 				.filterWhen(tool -> this.toolFilter.isVisible(exchange.transportContext(), tool)
 					.onErrorResume(error -> opaqueListFilterError(tool, error)))
 				.collectList()
+				// PRIVATE, not PUBLIC: the listing is filtered per caller, so a shared
+				// cache must never serve one principal's response to another.
 				.map(tools -> McpSchema.ListToolsResult.builder(tools)
-					.ttlMs(0L)
-					.cacheScope(McpSchema.CacheScope.PUBLIC)
+					.ttlMs(this.listCacheOptions.ttlMs())
+					.cacheScope(this.listCacheOptions.cacheScope())
 					.build());
 		};
 	}
@@ -819,8 +828,8 @@ private McpRequestHandler<McpSchema.ListResourcesResult> resourcesListRequestHan
 				.map(McpServerFeatures.AsyncResourceSpecification::resource)
 				.toList();
 			return Mono.just(McpSchema.ListResourcesResult.builder(resourceList)
-				.ttlMs(0L)
-				.cacheScope(McpSchema.CacheScope.PUBLIC)
+				.ttlMs(this.listCacheOptions.ttlMs())
+				.cacheScope(this.listCacheOptions.cacheScope())
 				.build());
 		};
 	}
@@ -832,8 +841,8 @@ private McpRequestHandler<McpSchema.ListResourceTemplatesResult> resourceTemplat
 				.map(McpServerFeatures.AsyncResourceTemplateSpecification::resourceTemplate)
 				.toList();
 			return Mono.just(McpSchema.ListResourceTemplatesResult.builder(resourceList)
-				.ttlMs(0L)
-				.cacheScope(McpSchema.CacheScope.PUBLIC)
+				.ttlMs(this.listCacheOptions.ttlMs())
+				.cacheScope(this.listCacheOptions.cacheScope())
 				.build());
 		};
 	}
@@ -998,8 +1007,8 @@ private McpRequestHandler<McpSchema.ListPromptsResult> promptsListRequestHandler
 				.toList();
 
 			return Mono.just(McpSchema.ListPromptsResult.builder(promptList)
-				.ttlMs(0L)
-				.cacheScope(McpSchema.CacheScope.PUBLIC)
+				.ttlMs(this.listCacheOptions.ttlMs())
+				.cacheScope(this.listCacheOptions.cacheScope())
 				.build());
 		};
 	}
 
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2026-2026 the original author or authors.
+ */
+
+package io.modelcontextprotocol.server;
+
+import java.time.Duration;
+
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.util.Assert;
+
+/**
+ * The caching hint a server attaches to its listing responses — {@code tools/list},
+ * {@code prompts/list}, {@code resources/list} and {@code resources/templates/list}
+ * (SEP-2549).
+ * <p>
+ * A {@code resources/read} handler carries its own hint on the
+ * {@link McpSchema.ReadResourceResult} it builds and is not covered here.
+ *
+ * @param ttlMs how long a client may reuse a listing before re-fetching it. Zero disables
+ * caching.
+ * @param cacheScope whether a shared cache may serve the listing to another principal.
+ * @author Sylwester Lachiewicz
+ * @see <a href=
+ * "https://spec.modelcontextprotocol.io/specification/draft/server/utilities/caching/">Specification:
+ * Caching</a>
+ */
+public record McpListCacheOptions(long ttlMs, McpSchema.CacheScope cacheScope) {
+
+	/**
+	 * The default: listings are not cached. Scoped {@code private} so that a gateway
+	 * cannot share a listing across principals should a server later attach a TTL without
+	 * revisiting the scope.
+	 */
+	public static final McpListCacheOptions NONE = new McpListCacheOptions(0L, McpSchema.CacheScope.PRIVATE);
+
+	public McpListCacheOptions {
+		Assert.isTrue(ttlMs >= 0, "ttlMs must not be negative");
+		Assert.notNull(cacheScope, "cacheScope must not be null");
+	}
+
+	/**
+	 * @param ttl how long a client may reuse a listing. MUST NOT be null or negative.
+	 * @param cacheScope whether a shared cache may serve the listing to another
+	 * principal. Use {@link McpSchema.CacheScope#PUBLIC} only for a listing that is
+	 * identical for every caller: a per-request tool filter makes the listing
+	 * caller-specific, and {@code public} would let a gateway hand one principal's
+	 * filtered listing to another.
+	 */
+	public static McpListCacheOptions of(Duration ttl, McpSchema.CacheScope cacheScope) {
+		Assert.notNull(ttl, "ttl must not be null");
+		return new McpListCacheOptions(ttl.toMillis(), cacheScope);
+	}
+
+}