diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 553c52d62..51321979f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -25,14 +25,14 @@ repos:
     hooks:
       - id: ruff-format
         name: Ruff Format
-        entry: uv run ruff
+        entry: ruff
         args: [format]
         language: system
         types: [python]
         pass_filenames: false
       - id: ruff
         name: Ruff
-        entry: uv run ruff
+        entry: ruff
         args: ["check", "--fix", "--exit-non-zero-on-fix"]
         types: [python]
         language: system
@@ -40,7 +40,7 @@ repos:
         exclude: ^README\.md$
       - id: pyright
         name: pyright
-        entry: uv run pyright
+        entry: pyright
         language: system
         types: [python]
         pass_filenames: false
@@ -52,7 +52,7 @@ repos:
         pass_filenames: false
       - id: readme-snippets
         name: Check README snippets are up to date
-        entry: uv run scripts/update_readme_snippets.py --check
+        entry: python scripts/update_readme_snippets.py --check
         language: system
         files: ^(README\.md|examples/.*\.py|scripts/update_readme_snippets\.py)$
         pass_filenames: false
diff --git a/README.md b/README.md
index 8142c99ce..99226ef5f 100644
--- a/README.md
+++ b/README.md
@@ -47,6 +47,7 @@
     - [Mounting to an Existing ASGI Server](#mounting-to-an-existing-asgi-server)
   - [Advanced Usage](#advanced-usage)
     - [Low-Level Server](#low-level-server)
+    - [Pagination (Advanced)](#pagination-advanced)
     - [Writing MCP Clients](#writing-mcp-clients)
     - [Client Display Utilities](#client-display-utilities)
     - [OAuth Authentication for Clients](#oauth-authentication-for-clients)
@@ -1727,6 +1728,121 @@ Tools can return data in three ways:
 
 When an `outputSchema` is defined, the server automatically validates the structured output against the schema. This ensures type safety and helps catch errors early.
 
+### Pagination (Advanced)
+
+For servers that need to handle large datasets, the low-level server provides paginated versions of list operations. This is an optional optimization - most servers won't need pagination unless they're dealing with hundreds or thousands of items.
+
+#### Server-side Implementation
+
+<!-- snippet-source examples/snippets/servers/pagination_example.py -->
+```python
+"""
+Example of implementing pagination with MCP server decorators.
+"""
+
+from pydantic import AnyUrl
+
+import mcp.types as types
+from mcp.server.lowlevel import Server
+
+# Initialize the server
+server = Server("paginated-server")
+
+# Sample data to paginate
+ITEMS = [f"Item {i}" for i in range(1, 101)]  # 100 items
+
+
+@server.list_resources_paginated()
+async def list_resources_paginated(cursor: types.Cursor | None) -> types.ListResourcesResult:
+    """List resources with pagination support."""
+    page_size = 10
+
+    # Parse cursor to get offset
+    start = 0 if cursor is None else int(cursor)
+    end = start + page_size
+
+    # Get page of resources
+    page_items = [
+        types.Resource(uri=AnyUrl(f"resource://items/{item}"), name=item, description=f"Description for {item}")
+        for item in ITEMS[start:end]
+    ]
+
+    # Determine next cursor
+    next_cursor = str(end) if end < len(ITEMS) else None
+
+    return types.ListResourcesResult(resources=page_items, nextCursor=next_cursor)
+```
+
+_Full example: [examples/snippets/servers/pagination_example.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/servers/pagination_example.py)_
+<!-- /snippet-source -->
+
+Similar decorators are available for all list operations:
+
+- `@server.list_tools_paginated()` - for paginating tools
+- `@server.list_resources_paginated()` - for paginating resources  
+- `@server.list_prompts_paginated()` - for paginating prompts
+
+#### Client-side Consumption
+
+<!-- snippet-source examples/snippets/clients/pagination_client.py -->
+```python
+"""
+Example of consuming paginated MCP endpoints from a client.
+"""
+
+import asyncio
+
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+from mcp.types import Resource
+
+
+async def list_all_resources() -> None:
+    """Fetch all resources using pagination."""
+    async with stdio_client(StdioServerParameters(command="uv", args=["run", "mcp-simple-pagination"])) as (
+        read,
+        write,
+    ):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            all_resources: list[Resource] = []
+            cursor = None
+
+            while True:
+                # Fetch a page of resources
+                result = await session.list_resources(cursor=cursor)
+                all_resources.extend(result.resources)
+
+                print(f"Fetched {len(result.resources)} resources")
+
+                # Check if there are more pages
+                if result.nextCursor:
+                    cursor = result.nextCursor
+                else:
+                    break
+
+            print(f"Total resources: {len(all_resources)}")
+
+
+if __name__ == "__main__":
+    asyncio.run(list_all_resources())
+```
+
+_Full example: [examples/snippets/clients/pagination_client.py](https://github.com/modelcontextprotocol/python-sdk/blob/main/examples/snippets/clients/pagination_client.py)_
+<!-- /snippet-source -->
+
+#### Key Points
+
+- **Cursors are opaque strings** - the server defines the format (numeric offsets, timestamps, etc.)
+- **Return `nextCursor=None`** when there are no more pages
+- **Backward compatible** - clients that don't support pagination will still work (they'll just get the first page)
+- **Flexible page sizes** - Each endpoint can define its own page size based on data characteristics
+
+> **NOTE**: The paginated decorators (`list_tools_paginated()`, `list_resources_paginated()`, `list_prompts_paginated()`) are mutually exclusive with their non-paginated counterparts and cannot be used together on the same server instance.
+
+See the [simple-pagination example](examples/servers/simple-pagination) for a complete implementation.
+
 ### Writing MCP Clients
 
 The SDK provides a high-level client interface for connecting to MCP servers using various [transports](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports):
diff --git a/examples/servers/simple-pagination/README.md b/examples/servers/simple-pagination/README.md
new file mode 100644
index 000000000..e732b8efb
--- /dev/null
+++ b/examples/servers/simple-pagination/README.md
@@ -0,0 +1,77 @@
+# MCP Simple Pagination
+
+A simple MCP server demonstrating pagination for tools, resources, and prompts using cursor-based pagination.
+
+## Usage
+
+Start the server using either stdio (default) or SSE transport:
+
+```bash
+# Using stdio transport (default)
+uv run mcp-simple-pagination
+
+# Using SSE transport on custom port
+uv run mcp-simple-pagination --transport sse --port 8000
+```
+
+The server exposes:
+
+- 25 tools (paginated, 5 per page)
+- 30 resources (paginated, 10 per page)
+- 20 prompts (paginated, 7 per page)
+
+Each paginated list returns a `nextCursor` when more pages are available. Use this cursor in subsequent requests to retrieve the next page.
+
+## Example
+
+Using the MCP client, you can retrieve paginated items like this using the STDIO transport:
+
+```python
+import asyncio
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+
+
+async def main():
+    async with stdio_client(
+        StdioServerParameters(command="uv", args=["run", "mcp-simple-pagination"])
+    ) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            # Get first page of tools
+            tools_page1 = await session.list_tools()
+            print(f"First page: {len(tools_page1.tools)} tools")
+            print(f"Next cursor: {tools_page1.nextCursor}")
+
+            # Get second page using cursor
+            if tools_page1.nextCursor:
+                tools_page2 = await session.list_tools(cursor=tools_page1.nextCursor)
+                print(f"Second page: {len(tools_page2.tools)} tools")
+
+            # Similarly for resources
+            resources_page1 = await session.list_resources()
+            print(f"First page: {len(resources_page1.resources)} resources")
+
+            # And for prompts
+            prompts_page1 = await session.list_prompts()
+            print(f"First page: {len(prompts_page1.prompts)} prompts")
+
+
+asyncio.run(main())
+```
+
+## Pagination Details
+
+The server uses simple numeric indices as cursors for demonstration purposes. In production scenarios, you might use:
+
+- Database offsets or row IDs
+- Timestamps for time-based pagination
+- Opaque tokens encoding pagination state
+
+The pagination implementation demonstrates:
+
+- Handling `None` cursor for the first page
+- Returning `nextCursor` when more data exists
+- Gracefully handling invalid cursors
+- Different page sizes for different resource types
diff --git a/examples/servers/simple-pagination/mcp_simple_pagination/__init__.py b/examples/servers/simple-pagination/mcp_simple_pagination/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/examples/servers/simple-pagination/mcp_simple_pagination/__main__.py b/examples/servers/simple-pagination/mcp_simple_pagination/__main__.py
new file mode 100644
index 000000000..e7ef16530
--- /dev/null
+++ b/examples/servers/simple-pagination/mcp_simple_pagination/__main__.py
@@ -0,0 +1,5 @@
+import sys
+
+from .server import main
+
+sys.exit(main())  # type: ignore[call-arg]
diff --git a/examples/servers/simple-pagination/mcp_simple_pagination/server.py b/examples/servers/simple-pagination/mcp_simple_pagination/server.py
new file mode 100644
index 000000000..8a7ebdb9c
--- /dev/null
+++ b/examples/servers/simple-pagination/mcp_simple_pagination/server.py
@@ -0,0 +1,225 @@
+"""
+Simple MCP server demonstrating pagination for tools, resources, and prompts.
+
+This example shows how to use the paginated decorators to handle large lists
+of items that need to be split across multiple pages.
+"""
+
+from typing import Any
+
+import anyio
+import click
+import mcp.types as types
+from mcp.server.lowlevel import Server
+from pydantic import AnyUrl
+from starlette.requests import Request
+
+# Sample data - in real scenarios, this might come from a database
+SAMPLE_TOOLS = [
+    types.Tool(
+        name=f"tool_{i}",
+        title=f"Tool {i}",
+        description=f"This is sample tool number {i}",
+        inputSchema={"type": "object", "properties": {"input": {"type": "string"}}},
+    )
+    for i in range(1, 26)  # 25 tools total
+]
+
+SAMPLE_RESOURCES = [
+    types.Resource(
+        uri=AnyUrl(f"file:///path/to/resource_{i}.txt"),
+        name=f"resource_{i}",
+        description=f"This is sample resource number {i}",
+    )
+    for i in range(1, 31)  # 30 resources total
+]
+
+SAMPLE_PROMPTS = [
+    types.Prompt(
+        name=f"prompt_{i}",
+        description=f"This is sample prompt number {i}",
+        arguments=[
+            types.PromptArgument(name="arg1", description="First argument", required=True),
+        ],
+    )
+    for i in range(1, 21)  # 20 prompts total
+]
+
+
+@click.command()
+@click.option("--port", default=8000, help="Port to listen on for SSE")
+@click.option(
+    "--transport",
+    type=click.Choice(["stdio", "sse"]),
+    default="stdio",
+    help="Transport type",
+)
+def main(port: int, transport: str) -> int:
+    app = Server("mcp-simple-pagination")
+
+    # Paginated list_tools - returns 5 tools per page
+    @app.list_tools_paginated()
+    async def list_tools_paginated(cursor: types.Cursor | None) -> types.ListToolsResult:
+        page_size = 5
+
+        if cursor is None:
+            # First page
+            start_idx = 0
+        else:
+            # Parse cursor to get the start index
+            try:
+                start_idx = int(cursor)
+            except (ValueError, TypeError):
+                # Invalid cursor, return empty
+                return types.ListToolsResult(tools=[], nextCursor=None)
+
+        # Get the page of tools
+        page_tools = SAMPLE_TOOLS[start_idx : start_idx + page_size]
+
+        # Determine if there are more pages
+        next_cursor = None
+        if start_idx + page_size < len(SAMPLE_TOOLS):
+            next_cursor = str(start_idx + page_size)
+
+        return types.ListToolsResult(tools=page_tools, nextCursor=next_cursor)
+
+    # Paginated list_resources - returns 10 resources per page
+    @app.list_resources_paginated()
+    async def list_resources_paginated(
+        cursor: types.Cursor | None,
+    ) -> types.ListResourcesResult:
+        page_size = 10
+
+        if cursor is None:
+            # First page
+            start_idx = 0
+        else:
+            # Parse cursor to get the start index
+            try:
+                start_idx = int(cursor)
+            except (ValueError, TypeError):
+                # Invalid cursor, return empty
+                return types.ListResourcesResult(resources=[], nextCursor=None)
+
+        # Get the page of resources
+        page_resources = SAMPLE_RESOURCES[start_idx : start_idx + page_size]
+
+        # Determine if there are more pages
+        next_cursor = None
+        if start_idx + page_size < len(SAMPLE_RESOURCES):
+            next_cursor = str(start_idx + page_size)
+
+        return types.ListResourcesResult(resources=page_resources, nextCursor=next_cursor)
+
+    # Paginated list_prompts - returns 7 prompts per page
+    @app.list_prompts_paginated()
+    async def list_prompts_paginated(
+        cursor: types.Cursor | None,
+    ) -> types.ListPromptsResult:
+        page_size = 7
+
+        if cursor is None:
+            # First page
+            start_idx = 0
+        else:
+            # Parse cursor to get the start index
+            try:
+                start_idx = int(cursor)
+            except (ValueError, TypeError):
+                # Invalid cursor, return empty
+                return types.ListPromptsResult(prompts=[], nextCursor=None)
+
+        # Get the page of prompts
+        page_prompts = SAMPLE_PROMPTS[start_idx : start_idx + page_size]
+
+        # Determine if there are more pages
+        next_cursor = None
+        if start_idx + page_size < len(SAMPLE_PROMPTS):
+            next_cursor = str(start_idx + page_size)
+
+        return types.ListPromptsResult(prompts=page_prompts, nextCursor=next_cursor)
+
+    # Implement call_tool handler
+    @app.call_tool()
+    async def call_tool(name: str, arguments: dict[str, Any]) -> list[types.ContentBlock]:
+        # Find the tool in our sample data
+        tool = next((t for t in SAMPLE_TOOLS if t.name == name), None)
+        if not tool:
+            raise ValueError(f"Unknown tool: {name}")
+
+        # Simple mock response
+        return [
+            types.TextContent(
+                type="text",
+                text=f"Called tool '{name}' with arguments: {arguments}",
+            )
+        ]
+
+    # Implement read_resource handler
+    @app.read_resource()
+    async def read_resource(uri: AnyUrl) -> str:
+        # Find the resource in our sample data
+        resource = next((r for r in SAMPLE_RESOURCES if r.uri == uri), None)
+        if not resource:
+            raise ValueError(f"Unknown resource: {uri}")
+
+        # Return a simple string - the decorator will convert it to TextResourceContents
+        return f"Content of {resource.name}: This is sample content for the resource."
+
+    # Implement get_prompt handler
+    @app.get_prompt()
+    async def get_prompt(name: str, arguments: dict[str, str] | None) -> types.GetPromptResult:
+        # Find the prompt in our sample data
+        prompt = next((p for p in SAMPLE_PROMPTS if p.name == name), None)
+        if not prompt:
+            raise ValueError(f"Unknown prompt: {name}")
+
+        # Simple mock response
+        message_text = f"This is the prompt '{name}'"
+        if arguments:
+            message_text += f" with arguments: {arguments}"
+
+        return types.GetPromptResult(
+            description=prompt.description,
+            messages=[
+                types.PromptMessage(
+                    role="user",
+                    content=types.TextContent(type="text", text=message_text),
+                )
+            ],
+        )
+
+    if transport == "sse":
+        from mcp.server.sse import SseServerTransport
+        from starlette.applications import Starlette
+        from starlette.responses import Response
+        from starlette.routing import Mount, Route
+
+        sse = SseServerTransport("/messages/")
+
+        async def handle_sse(request: Request):
+            async with sse.connect_sse(request.scope, request.receive, request._send) as streams:  # type: ignore[reportPrivateUsage]
+                await app.run(streams[0], streams[1], app.create_initialization_options())
+            return Response()
+
+        starlette_app = Starlette(
+            debug=True,
+            routes=[
+                Route("/sse", endpoint=handle_sse, methods=["GET"]),
+                Mount("/messages/", app=sse.handle_post_message),
+            ],
+        )
+
+        import uvicorn
+
+        uvicorn.run(starlette_app, host="127.0.0.1", port=port)
+    else:
+        from mcp.server.stdio import stdio_server
+
+        async def arun():
+            async with stdio_server() as streams:
+                await app.run(streams[0], streams[1], app.create_initialization_options())
+
+        anyio.run(arun)
+
+    return 0
diff --git a/examples/servers/simple-pagination/pyproject.toml b/examples/servers/simple-pagination/pyproject.toml
new file mode 100644
index 000000000..0c60cf73c
--- /dev/null
+++ b/examples/servers/simple-pagination/pyproject.toml
@@ -0,0 +1,47 @@
+[project]
+name = "mcp-simple-pagination"
+version = "0.1.0"
+description = "A simple MCP server demonstrating pagination for tools, resources, and prompts"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Anthropic, PBC." }]
+maintainers = [
+    { name = "David Soria Parra", email = "davidsp@anthropic.com" },
+    { name = "Justin Spahr-Summers", email = "justin@anthropic.com" },
+]
+keywords = ["mcp", "llm", "automation", "pagination", "cursor"]
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+]
+dependencies = ["anyio>=4.5", "click>=8.2.0", "httpx>=0.27", "mcp"]
+
+[project.scripts]
+mcp-simple-pagination = "mcp_simple_pagination.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["mcp_simple_pagination"]
+
+[tool.pyright]
+include = ["mcp_simple_pagination"]
+venvPath = "."
+venv = ".venv"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = []
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.uv]
+dev-dependencies = ["pyright>=1.1.378", "pytest>=8.3.3", "ruff>=0.6.9"]
\ No newline at end of file
diff --git a/examples/snippets/clients/pagination_client.py b/examples/snippets/clients/pagination_client.py
new file mode 100644
index 000000000..4df1aec60
--- /dev/null
+++ b/examples/snippets/clients/pagination_client.py
@@ -0,0 +1,41 @@
+"""
+Example of consuming paginated MCP endpoints from a client.
+"""
+
+import asyncio
+
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+from mcp.types import Resource
+
+
+async def list_all_resources() -> None:
+    """Fetch all resources using pagination."""
+    async with stdio_client(StdioServerParameters(command="uv", args=["run", "mcp-simple-pagination"])) as (
+        read,
+        write,
+    ):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            all_resources: list[Resource] = []
+            cursor = None
+
+            while True:
+                # Fetch a page of resources
+                result = await session.list_resources(cursor=cursor)
+                all_resources.extend(result.resources)
+
+                print(f"Fetched {len(result.resources)} resources")
+
+                # Check if there are more pages
+                if result.nextCursor:
+                    cursor = result.nextCursor
+                else:
+                    break
+
+            print(f"Total resources: {len(all_resources)}")
+
+
+if __name__ == "__main__":
+    asyncio.run(list_all_resources())
diff --git a/examples/snippets/servers/pagination_example.py b/examples/snippets/servers/pagination_example.py
new file mode 100644
index 000000000..3852a209c
--- /dev/null
+++ b/examples/snippets/servers/pagination_example.py
@@ -0,0 +1,35 @@
+"""
+Example of implementing pagination with MCP server decorators.
+"""
+
+from pydantic import AnyUrl
+
+import mcp.types as types
+from mcp.server.lowlevel import Server
+
+# Initialize the server
+server = Server("paginated-server")
+
+# Sample data to paginate
+ITEMS = [f"Item {i}" for i in range(1, 101)]  # 100 items
+
+
+@server.list_resources_paginated()
+async def list_resources_paginated(cursor: types.Cursor | None) -> types.ListResourcesResult:
+    """List resources with pagination support."""
+    page_size = 10
+
+    # Parse cursor to get offset
+    start = 0 if cursor is None else int(cursor)
+    end = start + page_size
+
+    # Get page of resources
+    page_items = [
+        types.Resource(uri=AnyUrl(f"resource://items/{item}"), name=item, description=f"Description for {item}")
+        for item in ITEMS[start:end]
+    ]
+
+    # Determine next cursor
+    next_cursor = str(end) if end < len(ITEMS) else None
+
+    return types.ListResourcesResult(resources=page_items, nextCursor=next_cursor)
diff --git a/src/mcp/server/lowlevel/server.py b/src/mcp/server/lowlevel/server.py
index 8c459383c..f17aa1ac0 100644
--- a/src/mcp/server/lowlevel/server.py
+++ b/src/mcp/server/lowlevel/server.py
@@ -242,6 +242,19 @@ async def handler(_: Any):
 
         return decorator
 
+    def list_prompts_paginated(self):
+        def decorator(func: Callable[[types.Cursor | None], Awaitable[types.ListPromptsResult]]):
+            logger.debug("Registering handler for PromptListRequest with pagination")
+
+            async def handler(req: types.ListPromptsRequest):
+                result = await func(req.params.cursor if req.params else None)
+                return types.ServerResult(result)
+
+            self.request_handlers[types.ListPromptsRequest] = handler
+            return func
+
+        return decorator
+
     def get_prompt(self):
         def decorator(
             func: Callable[[str, dict[str, str] | None], Awaitable[types.GetPromptResult]],
@@ -270,6 +283,19 @@ async def handler(_: Any):
 
         return decorator
 
+    def list_resources_paginated(self):
+        def decorator(func: Callable[[types.Cursor | None], Awaitable[types.ListResourcesResult]]):
+            logger.debug("Registering handler for ListResourcesRequest with pagination")
+
+            async def handler(req: types.ListResourcesRequest):
+                result = await func(req.params.cursor if req.params else None)
+                return types.ServerResult(result)
+
+            self.request_handlers[types.ListResourcesRequest] = handler
+            return func
+
+        return decorator
+
     def list_resource_templates(self):
         def decorator(func: Callable[[], Awaitable[list[types.ResourceTemplate]]]):
             logger.debug("Registering handler for ListResourceTemplatesRequest")
@@ -397,6 +423,23 @@ async def handler(_: Any):
 
         return decorator
 
+    def list_tools_paginated(self):
+        def decorator(func: Callable[[types.Cursor | None], Awaitable[types.ListToolsResult]]):
+            logger.debug("Registering paginated handler for ListToolsRequest")
+
+            async def handler(request: types.ListToolsRequest):
+                cursor = request.params.cursor if request.params else None
+                result = await func(cursor)
+                # Refresh the tool cache with returned tools
+                for tool in result.tools:
+                    self._tool_cache[tool.name] = tool
+                return types.ServerResult(result)
+
+            self.request_handlers[types.ListToolsRequest] = handler
+            return func
+
+        return decorator
+
     def _make_error_result(self, error_message: str) -> types.ServerResult:
         """Create a ServerResult with an error CallToolResult."""
         return types.ServerResult(
diff --git a/tests/server/lowlevel/__init__.py b/tests/server/lowlevel/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/server/lowlevel/test_server_pagination.py b/tests/server/lowlevel/test_server_pagination.py
new file mode 100644
index 000000000..f2c786e45
--- /dev/null
+++ b/tests/server/lowlevel/test_server_pagination.py
@@ -0,0 +1,103 @@
+import pytest
+
+from mcp.server import Server
+from mcp.types import (
+    Cursor,
+    ListPromptsRequest,
+    ListPromptsResult,
+    ListResourcesRequest,
+    ListResourcesResult,
+    ListToolsRequest,
+    ListToolsResult,
+    PaginatedRequestParams,
+    ServerResult,
+)
+
+
+@pytest.mark.anyio
+async def test_list_prompts_pagination() -> None:
+    server = Server("test")
+    test_cursor = "test-cursor-123"
+
+    # Track what cursor was received
+    received_cursor: Cursor | None = None
+
+    @server.list_prompts_paginated()
+    async def handle_list_prompts(cursor: Cursor | None) -> ListPromptsResult:
+        nonlocal received_cursor
+        received_cursor = cursor
+        return ListPromptsResult(prompts=[], nextCursor="next")
+
+    handler = server.request_handlers[ListPromptsRequest]
+
+    # Test: No cursor provided -> handler receives None
+    request = ListPromptsRequest(method="prompts/list", params=None)
+    result = await handler(request)
+    assert received_cursor is None
+    assert isinstance(result, ServerResult)
+
+    # Test: Cursor provided -> handler receives exact cursor value
+    request_with_cursor = ListPromptsRequest(method="prompts/list", params=PaginatedRequestParams(cursor=test_cursor))
+    result2 = await handler(request_with_cursor)
+    assert received_cursor == test_cursor
+    assert isinstance(result2, ServerResult)
+
+
+@pytest.mark.anyio
+async def test_list_resources_pagination() -> None:
+    server = Server("test")
+    test_cursor = "resource-cursor-456"
+
+    # Track what cursor was received
+    received_cursor: Cursor | None = None
+
+    @server.list_resources_paginated()
+    async def handle_list_resources(cursor: Cursor | None) -> ListResourcesResult:
+        nonlocal received_cursor
+        received_cursor = cursor
+        return ListResourcesResult(resources=[], nextCursor="next")
+
+    handler = server.request_handlers[ListResourcesRequest]
+
+    # Test: No cursor provided -> handler receives None
+    request = ListResourcesRequest(method="resources/list", params=None)
+    result = await handler(request)
+    assert received_cursor is None
+    assert isinstance(result, ServerResult)
+
+    # Test: Cursor provided -> handler receives exact cursor value
+    request_with_cursor = ListResourcesRequest(
+        method="resources/list", params=PaginatedRequestParams(cursor=test_cursor)
+    )
+    result2 = await handler(request_with_cursor)
+    assert received_cursor == test_cursor
+    assert isinstance(result2, ServerResult)
+
+
+@pytest.mark.anyio
+async def test_list_tools_pagination() -> None:
+    server = Server("test")
+    test_cursor = "tools-cursor-789"
+
+    # Track what cursor was received
+    received_cursor: Cursor | None = None
+
+    @server.list_tools_paginated()
+    async def handle_list_tools(cursor: Cursor | None) -> ListToolsResult:
+        nonlocal received_cursor
+        received_cursor = cursor
+        return ListToolsResult(tools=[], nextCursor="next")
+
+    handler = server.request_handlers[ListToolsRequest]
+
+    # Test: No cursor provided -> handler receives None
+    request = ListToolsRequest(method="tools/list", params=None)
+    result = await handler(request)
+    assert received_cursor is None
+    assert isinstance(result, ServerResult)
+
+    # Test: Cursor provided -> handler receives exact cursor value
+    request_with_cursor = ListToolsRequest(method="tools/list", params=PaginatedRequestParams(cursor=test_cursor))
+    result2 = await handler(request_with_cursor)
+    assert received_cursor == test_cursor
+    assert isinstance(result2, ServerResult)
diff --git a/uv.lock b/uv.lock
index 59192bee0..eedc19757 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,11 +1,12 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.10"
 
 [manifest]
 members = [
     "mcp",
     "mcp-simple-auth",
+    "mcp-simple-pagination",
     "mcp-simple-prompt",
     "mcp-simple-resource",
     "mcp-simple-streamablehttp",
@@ -705,6 +706,39 @@ dev = [
     { name = "ruff", specifier = ">=0.8.5" },
 ]
 
+[[package]]
+name = "mcp-simple-pagination"
+version = "0.1.0"
+source = { editable = "examples/servers/simple-pagination" }
+dependencies = [
+    { name = "anyio" },
+    { name = "click" },
+    { name = "httpx" },
+    { name = "mcp" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pyright" },
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "anyio", specifier = ">=4.5" },
+    { name = "click", specifier = ">=8.2.0" },
+    { name = "httpx", specifier = ">=0.27" },
+    { name = "mcp", editable = "." },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pyright", specifier = ">=1.1.378" },
+    { name = "pytest", specifier = ">=8.3.3" },
+    { name = "ruff", specifier = ">=0.6.9" },
+]
+
 [[package]]
 name = "mcp-simple-prompt"
 version = "0.1.0"