Add a simple module documentation to help LLMs with the pattern

LLMs have issue infering the actual usage pattern from the code
itself. We add a simple module documentation to help with that.

Author: dsp-ant

src/mcp/server/__init__.py

@@ -1,3 +1,62 @@
+"""
+MCP Server Module
+
+This module provides a framework for creating an MCP (Machine Comprehension Protocol) server.
+It allows you to easily define and handle various types of requests and notifications
+in an asynchronous manner.
+
+Usage:
+1. Create a Server instance:
+   server = Server("your_server_name")
+
+2. Define request handlers using decorators:
+   @server.list_prompts()
+   async def handle_list_prompts() -> list[types.Prompt]:
+       # Implementation
+
+   @server.get_prompt()
+   async def handle_get_prompt(name: str, arguments: dict[str, str] | None) -> types.GetPromptResult:
+       # Implementation
+
+   @server.list_tools()
+   async def handle_list_tools() -> list[types.Tool]:
+       # Implementation
+
+   @server.call_tool()
+   async def handle_call_tool(name: str, arguments: dict | None) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+       # Implementation
+
+3. Define notification handlers if needed:
+   @server.progress_notification()
+   async def handle_progress(progress_token: str | int, progress: float, total: float | None) -> None:
+       # Implementation
+
+4. Run the server:
+   async def main():
+       async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+           await server.run(
+               read_stream,
+               write_stream,
+               InitializationOptions(
+                   server_name="your_server_name",
+                   server_version="your_version",
+                   capabilities=server.get_capabilities(
+                       notification_options=NotificationOptions(),
+                       experimental_capabilities={},
+                   ),
+               ),
+           )
+
+   asyncio.run(main())
+
+The Server class provides methods to register handlers for various MCP requests and notifications.
+It automatically manages the request context and handles incoming messages from the client.
+
+For more advanced usage, you can customize the server's capabilities, handle resource requests,
+implement logging, and add completion support for prompts and resources.
+
+Refer to the method docstrings and type hints for detailed information on each handler and its expected inputs and outputs.
+"""
 import contextvars
 import logging
 import warnings

src/mcp/server/session.py

@@ -1,3 +1,39 @@
+"""
+ServerSession Module
+
+This module provides the ServerSession class, which manages communication between the server and client
+in the MCP (Model Context Protocol) framework. It is most commonly used in MCP servers to interact
+with the client.
+
+Common usage pattern:
+```
+    server = Server(name)
+
+    @server.call_tool()
+    async def handle_tool_call(ctx: RequestContext, arguments: dict[str, Any]) -> Any:
+        # Check client capabilities before proceeding
+        if ctx.session.check_client_capability(types.ClientCapabilities(experimental={"advanced_tools": True})):
+            # Perform advanced tool operations
+            result = await perform_advanced_tool_operation(arguments)
+        else:
+            # Fall back to basic tool operations
+            result = await perform_basic_tool_operation(arguments)
+
+        return result
+
+    @server.list_prompts()
+    async def handle_list_prompts(ctx: RequestContext) -> list[types.Prompt]:
+        # Access session for any necessary checks or operations
+        if ctx.session.client_params:
+            # Customize prompts based on client initialization parameters
+            return generate_custom_prompts(ctx.session.client_params)
+        else:
+            return default_prompts
+```
+
+The ServerSession class is typically used internally by the Server class and should not be
+instantiated directly by users of the MCP framework.
+"""
 from enum import Enum
 from typing import Any
 

src/mcp/server/sse.py

@@ -1,3 +1,35 @@
+"""
+SSE Server Transport Module
+
+This module implements a Server-Sent Events (SSE) transport layer for MCP servers.
+
+Example usage:
+```
+    # Create an SSE transport at an endpoint
+    sse = SseServerTransport("/messages")
+
+    # Create Starlette routes for SSE and message handling
+    routes = [
+        Route("/sse", endpoint=handle_sse),
+        Route("/messages", endpoint=handle_messages, methods=["POST"])
+    ]
+
+    # Define handler functions
+    async def handle_sse(request):
+        async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
+            await app.run(streams[0], streams[1], app.create_initialization_options())
+
+    async def handle_messages(request):
+        await sse.handle_post_message(request.scope, request.receive, request._send)
+
+    # Create and run Starlette app
+    starlette_app = Starlette(routes=routes)
+    uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+```
+
+See SseServerTransport class documentation for more details.
+"""
+
 import logging
 from contextlib import asynccontextmanager
 from typing import Any

src/mcp/server/stdio.py

@@ -1,3 +1,22 @@
+"""
+Stdio Server Transport Module
+
+This module provides functionality for creating an stdio-based transport layer
+that can be used to communicate with an MCP client through standard input/output streams.
+
+Example usage:
+```
+    async def run_server():
+        async with stdio_server() as (read_stream, write_stream):
+            # read_stream contains incoming JSONRPCMessages from stdin
+            # write_stream allows sending JSONRPCMessages to stdout
+            server = await create_my_server()
+            await server.run(read_stream, write_stream, init_options)
+
+    anyio.run(run_server)
+```
+"""
+
 import sys
 from contextlib import asynccontextmanager