feat: support setting title and description for server

Author: XInke YI

src/mcp/server/fastmcp/server.py

@@ -173,6 +173,8 @@ def __init__(  # noqa: PLR0913
         lifespan: (Callable[[FastMCP[LifespanResultT]], AbstractAsyncContextManager[LifespanResultT]] | None) = None,
         auth: AuthSettings | None = None,
         transport_security: TransportSecuritySettings | None = None,
+        title: str | None = None,
+        description: str | None = None,
     ):
         # Auto-enable DNS rebinding protection for localhost (IPv4 and IPv6)
         if transport_security is None and host in ("127.0.0.1", "localhost", "::1"):
@@ -207,6 +209,8 @@ def __init__(  # noqa: PLR0913
             instructions=instructions,
             website_url=website_url,
             icons=icons,
+            title=title,
+            description=description,
             # TODO(Marcelo): It seems there's a type mismatch between the lifespan type from an FastMCP and Server.
             # We need to create a Lifespan type that is a generic on the server type, like Starlette does.
             lifespan=(lifespan_wrapper(self, self.settings.lifespan) if self.settings.lifespan else default_lifespan),  # type: ignore
@@ -249,6 +253,14 @@ def name(self) -> str:
     def instructions(self) -> str | None:
         return self._mcp_server.instructions
 
+    @property
+    def title(self) -> str | None:
+        return self._mcp_server.title
+
+    @property
+    def description(self) -> str | None:
+        return self._mcp_server.description
+
     @property
     def website_url(self) -> str | None:
         return self._mcp_server.website_url

src/mcp/server/lowlevel/server.py

@@ -146,12 +146,16 @@ def __init__(
             [Server[LifespanResultT, RequestT]],
             AbstractAsyncContextManager[LifespanResultT],
         ] = lifespan,
+        title: str | None = None,
+        description: str | None = None,
     ):
         self.name = name
         self.version = version
         self.instructions = instructions
         self.website_url = website_url
         self.icons = icons
+        self.title = title
+        self.description = description
         self.lifespan = lifespan
         self.request_handlers: dict[type, Callable[..., Awaitable[types.ServerResult]]] = {
             types.PingRequest: _ping_handler,
@@ -186,6 +190,8 @@ def pkg_version(package: str) -> str:
                 experimental_capabilities or {},
             ),
             instructions=self.instructions,
+            title=self.title,
+            description=self.description,
             website_url=self.website_url,
             icons=self.icons,
         )

src/mcp/server/models.py

@@ -16,5 +16,7 @@ class InitializationOptions(BaseModel):
     server_version: str
     capabilities: ServerCapabilities
     instructions: str | None = None
+    title: str | None = None
+    description: str | None = None
     website_url: str | None = None
     icons: list[Icon] | None = None

src/mcp/server/session.py

@@ -177,6 +177,8 @@ async def _received_request(self, responder: RequestResponder[types.ClientReques
                                 serverInfo=types.Implementation(
                                     name=self._init_options.server_name,
                                     version=self._init_options.server_version,
+                                    title=self._init_options.title,
+                                    description=self._init_options.description,
                                     websiteUrl=self._init_options.website_url,
                                     icons=self._init_options.icons,
                                 ),

src/mcp/types.py

@@ -244,6 +244,15 @@ class BaseMetadata(BaseModel):
     if present).
     """
 
+    description: str | None = None
+    """
+    An optional human-readable description of what this implementation does.
+
+    This can be used by clients or servers to provide context about their purpose
+    and capabilities. For example, a server might describe the types of resources
+    or tools it provides, while a client might describe its intended use case.
+    """
+
 
 class Icon(BaseModel):
     """An icon for display in user interfaces."""

tests/server/fastmcp/test_server.py

@@ -23,6 +23,7 @@
     ContentBlock,
     EmbeddedResource,
     ImageContent,
+    InitializeResult,
     TextContent,
     TextResourceContents,
 )
@@ -38,6 +39,39 @@ async def test_create_server(self):
         assert mcp.name == "FastMCP"
         assert mcp.instructions == "Server instructions"
 
+    @pytest.mark.anyio
+    async def test_server_with_title_and_description(self):
+        """Test that FastMCP server title and description are passed through to serverInfo."""
+        mcp = FastMCP(
+            name="test-fastmcp-server",
+            title="Test FastMCP Server Title",
+            description="A test server that demonstrates title and description support.",
+        )
+
+        assert mcp.title == "Test FastMCP Server Title"
+        assert mcp.description == "A test server that demonstrates title and description support."
+
+        async with client_session(mcp._mcp_server) as client_session_instance:
+            result = await client_session_instance.initialize()
+
+            assert isinstance(result, InitializeResult)
+            assert result.serverInfo.name == "test-fastmcp-server"
+            assert result.serverInfo.title == "Test FastMCP Server Title"
+            assert result.serverInfo.description == "A test server that demonstrates title and description support."
+
+    @pytest.mark.anyio
+    async def test_server_without_title_and_description(self):
+        """Test that FastMCP server works correctly when title and description are not provided."""
+        mcp = FastMCP(name="test-fastmcp-server")
+
+        async with client_session(mcp._mcp_server) as client_session_instance:
+            result = await client_session_instance.initialize()
+
+            assert isinstance(result, InitializeResult)
+            assert result.serverInfo.name == "test-fastmcp-server"
+            assert result.serverInfo.title is None
+            assert result.serverInfo.description is None
+
     @pytest.mark.anyio
     async def test_normalize_path(self):
         """Test path normalization for mount paths."""

tests/server/test_session.py

@@ -35,7 +35,7 @@ async def test_server_session_initialize():
     client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[SessionMessage](1)
 
     # Create a message handler to catch exceptions
-    async def message_handler(  # pragma: no cover
+    async def message_handler(
         message: RequestResponder[types.ServerRequest, types.ClientResult] | types.ServerNotification | Exception,
     ) -> None:
         if isinstance(message, Exception):
@@ -55,15 +55,15 @@ async def run_server():
                 capabilities=ServerCapabilities(),
             ),
         ) as server_session:
-            async for message in server_session.incoming_messages:  # pragma: no branch
-                if isinstance(message, Exception):  # pragma: no cover
+            async for message in server_session.incoming_messages:
+                assert message is not None, "Expected to receive messages"
+                if isinstance(message, Exception):
                     raise message
 
-                if isinstance(message, ClientNotification) and isinstance(
-                    message.root, InitializedNotification
-                ):  # pragma: no branch
-                    received_initialized = True
-                    return
+                assert isinstance(message, ClientNotification), "Expected ClientNotification"
+                assert isinstance(message.root, InitializedNotification), "Expected InitializedNotification"
+                received_initialized = True
+                return
 
     try:
         async with (
@@ -77,12 +77,70 @@ async def run_server():
             tg.start_soon(run_server)
 
             await client_session.initialize()
-    except anyio.ClosedResourceError:  # pragma: no cover
+    except anyio.ClosedResourceError:
+        # This can happen if the server closes before the client finishes
         pass
 
     assert received_initialized
 
 
+@pytest.mark.anyio
+async def test_server_session_initialize_with_title_and_description():
+    """Test that server_title and server_description are passed through to serverInfo."""
+    server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[SessionMessage](1)
+    client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[SessionMessage](1)
+
+    async def message_handler(
+        message: RequestResponder[types.ServerRequest, types.ClientResult] | types.ServerNotification | Exception,
+    ) -> None:
+        if isinstance(message, Exception):
+            raise message
+
+    async def run_server():
+        async with ServerSession(
+            client_to_server_receive,
+            server_to_client_send,
+            InitializationOptions(
+                server_name="test-server",
+                server_version="1.0.0",
+                title="Test Server Title",
+                description="A description of what this server does.",
+                capabilities=ServerCapabilities(),
+            ),
+        ) as server_session:
+            async for message in server_session.incoming_messages:
+                assert message is not None, "Expected to receive messages"
+                if isinstance(message, Exception):
+                    raise message
+
+                assert isinstance(message, ClientNotification), "Expected ClientNotification"
+                assert isinstance(message.root, InitializedNotification), "Expected InitializedNotification"
+                return
+
+    result: types.InitializeResult | None = None
+    try:
+        async with (
+            ClientSession(
+                server_to_client_receive,
+                client_to_server_send,
+                message_handler=message_handler,
+            ) as client_session,
+            anyio.create_task_group() as tg,
+        ):
+            tg.start_soon(run_server)
+
+            result = await client_session.initialize()
+    except anyio.ClosedResourceError:
+        # This can happen if the server closes before the client finishes
+        pass
+
+    assert result is not None
+    assert result.serverInfo.name == "test-server"
+    assert result.serverInfo.title == "Test Server Title"
+    assert result.serverInfo.version == "1.0.0"
+    assert result.serverInfo.description == "A description of what this server does."
+
+
 @pytest.mark.anyio
 async def test_server_capabilities():
     server = Server("test")
@@ -97,7 +155,7 @@ async def test_server_capabilities():
 
     # Add a prompts handler
     @server.list_prompts()
-    async def list_prompts() -> list[Prompt]:  # pragma: no cover
+    async def list_prompts() -> list[Prompt]:
         return []
 
     caps = server.get_capabilities(notification_options, experimental_capabilities)
@@ -107,7 +165,7 @@ async def list_prompts() -> list[Prompt]:  # pragma: no cover
 
     # Add a resources handler
     @server.list_resources()
-    async def list_resources() -> list[Resource]:  # pragma: no cover
+    async def list_resources() -> list[Resource]:
         return []
 
     caps = server.get_capabilities(notification_options, experimental_capabilities)
@@ -117,7 +175,7 @@ async def list_resources() -> list[Resource]:  # pragma: no cover
 
     # Add a complete handler
     @server.completion()
-    async def complete(  # pragma: no cover
+    async def complete(
         ref: PromptReference | ResourceTemplateReference,
         argument: CompletionArgument,
         context: CompletionContext | None,
@@ -153,15 +211,15 @@ async def run_server():
                 capabilities=ServerCapabilities(),
             ),
         ) as server_session:
-            async for message in server_session.incoming_messages:  # pragma: no branch
-                if isinstance(message, Exception):  # pragma: no cover
+            async for message in server_session.incoming_messages:
+                assert message is not None, "Expected to receive messages"
+                if isinstance(message, Exception):
                     raise message
 
-                if isinstance(message, types.ClientNotification) and isinstance(
-                    message.root, InitializedNotification
-                ):  # pragma: no branch
-                    received_initialized = True
-                    return
+                assert isinstance(message, types.ClientNotification), "Expected ClientNotification"
+                assert isinstance(message.root, InitializedNotification), "Expected InitializedNotification"
+                received_initialized = True
+                return
 
     async def mock_client():
         nonlocal received_protocol_version
@@ -239,18 +297,18 @@ async def run_server():
                 capabilities=ServerCapabilities(),
             ),
         ) as server_session:
-            async for message in server_session.incoming_messages:  # pragma: no branch
-                if isinstance(message, Exception):  # pragma: no cover
+            async for message in server_session.incoming_messages:
+                assert message is not None, "Expected to receive messages"
+                if isinstance(message, Exception):
                     raise message
 
                 # We should receive a ping request before initialization
-                if isinstance(message, RequestResponder) and isinstance(
-                    message.request.root, types.PingRequest
-                ):  # pragma: no branch
-                    # Respond to the ping
-                    with message:
-                        await message.respond(types.ServerResult(types.EmptyResult()))
-                    return
+                assert isinstance(message, RequestResponder), "Expected RequestResponder"
+                assert isinstance(message.request.root, types.PingRequest), "Expected PingRequest"
+                # Respond to the ping
+                with message:
+                    await message.respond(types.ServerResult(types.EmptyResult()))
+                return
 
     async def mock_client():
         nonlocal ping_response_received, ping_response_id
@@ -508,9 +566,9 @@ async def mock_client():
 
         # Wait for the error response
         error_message = await server_to_client_receive.receive()
-        if isinstance(error_message.message.root, types.JSONRPCError):  # pragma: no branch
-            error_response_received = True
-            error_code = error_message.message.root.error.code
+        assert isinstance(error_message.message.root, types.JSONRPCError), "Expected JSONRPCError response"
+        error_response_received = True
+        error_code = error_message.message.root.error.code
 
     async with (
         client_to_server_send,