feat: support setting title and description for server

Author: XInke YI

src/mcp/server/fastmcp/server.py

@@ -150,6 +150,8 @@ def __init__(  # noqa: PLR0913
         instructions: str | None = None,
         website_url: str | None = None,
         icons: list[Icon] | None = None,
+        title: str | None = None,
+        description: str | None = None,
         auth_server_provider: (OAuthAuthorizationServerProvider[Any, Any, Any] | None) = None,
         token_verifier: TokenVerifier | None = None,
         event_store: EventStore | None = None,
@@ -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

@@ -142,6 +142,8 @@ def __init__(
         instructions: str | None = None,
         website_url: str | None = None,
         icons: list[types.Icon] | None = None,
+        title: str | None = None,
+        description: str | None = None,
         lifespan: Callable[
             [Server[LifespanResultT, RequestT]],
             AbstractAsyncContextManager[LifespanResultT],
@@ -152,6 +154,8 @@ def __init__(
         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

@@ -265,6 +265,15 @@ class Implementation(BaseMetadata):
 
     version: str
 
+    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.
+    """
+
     websiteUrl: str | None = None
     """An optional URL of the website for this implementation."""
 

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

@@ -83,6 +83,62 @@ async def run_server():
     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):  # pragma: no cover
+            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:  # pragma: no branch
+                if isinstance(message, Exception):  # pragma: no cover
+                    raise message
+
+                if isinstance(message, ClientNotification) and isinstance(
+                    message.root, InitializedNotification
+                ):  # pragma: no branch
+                    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:  # pragma: no cover
+        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")