Fix CI for MDX files

Most `*.md` files were converted to `*.mdx` in modelcontextprotocol#283, but `package.json`
scripts and CI config were not updated to match.  This commit makes the
necessary updates.

Unfortunately, Prettier currently only supports MDX v1 (see
[prettier#15221][] and [prettier#12209][]), which causes it to treat
content inside JSX tags as JSX instead of Markdown unless the content is
surrounded by blank lines (see [prettier#16589][]).  Therefore, this
commit also adds blank lines inside JSX elements where necessary.

This commit also removes the 89-character line wrap rule for `.md` files
rather than update it for `.mdx` files.  It's not clear that the rule
was helpful, and we already have many files that do not abide by it:

  ```console
  $ grep -l '.{90}' docs/**/*.mdx | wc -l
  59
  ```

For ease of rebasing, this commit _does not_ actually format the files
using Prettier.  That will be done in the next commit.

[prettier#15221]: prettier/prettier#15221
[prettier#12209]: prettier/prettier#12209
[prettier#16589]: prettier/prettier#16589

Author: jonathanhefner

.github/workflows/markdown-format.yml

@@ -4,23 +4,25 @@ on:
   push:
     paths:
       - '**/*.md'
+      - '**/*.mdx'
   pull_request:
     paths:
       - '**/*.md'
+      - '**/*.mdx'
 
 jobs:
   format:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      
+
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
           node-version: '20'
-          
+
       - name: Install dependencies
         run: npm ci
-        
+
       - name: Check markdown formatting
-        run: npm run format:check
+        run: npm run format:check

docs/development/roadmap.mdx

@@ -7,7 +7,11 @@ description: Our plans for evolving Model Context Protocol
 
 The Model Context Protocol is rapidly evolving. This page outlines our current thinking on key priorities and direction for approximately **the next six months**, though these may change significantly as the project develops. To see what's changed recently, check out the **[specification changelog](/specification/2025-03-26/changelog/)**.
 
-<Note>The ideas presented here are not commitments—we may solve these challenges differently than described, or some may not materialize at all. This is also not an _exhaustive_ list; we may incorporate work that isn't mentioned here.</Note>
+<Note>
+
+The ideas presented here are not commitments—we may solve these challenges differently than described, or some may not materialize at all. This is also not an _exhaustive_ list; we may incorporate work that isn't mentioned here.
+
+</Note>
 
 We value community participation! Each section links to relevant discussions where you can learn more and contribute your thoughts.
 

docs/docs/concepts/architecture.mdx

@@ -38,6 +38,7 @@ The protocol layer handles message framing, request/response linking, and high-l
 
 <Tabs>
   <Tab title="TypeScript">
+
     ```typescript
     class Protocol<Request, Notification, Result> {
         // Handle incoming requests
@@ -53,8 +54,10 @@ The protocol layer handles message framing, request/response linking, and high-l
         notification(notification: Notification): Promise<void>
     }
     ```
+
   </Tab>
   <Tab title="Python">
+
     ```python
     class Session(BaseSession[RequestT, NotificationT, ResultT]):
         async def send_request(
@@ -86,6 +89,7 @@ The protocol layer handles message framing, request/response linking, and high-l
             """Handle incoming notification from other side."""
             # Notification handling implementation
     ```
+
   </Tab>
 </Tabs>
 
@@ -208,6 +212,7 @@ Here's a basic example of implementing an MCP server:
 
 <Tabs>
   <Tab title="TypeScript">
+
     ```typescript
     import { Server } from "@modelcontextprotocol/sdk/server/index.js";
     import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -237,8 +242,10 @@ Here's a basic example of implementing an MCP server:
     const transport = new StdioServerTransport();
     await server.connect(transport);
     ```
+
   </Tab>
   <Tab title="Python">
+
     ```python
     import asyncio
     import mcp.types as types
@@ -267,6 +274,7 @@ Here's a basic example of implementing an MCP server:
     if __name__ == "__main__":
         asyncio.run(main())
     ```
+
   </Tab>
 </Tabs>
 

docs/docs/concepts/prompts.mdx

@@ -6,7 +6,9 @@ description: "Create reusable prompt templates and workflows"
 Prompts enable servers to define reusable prompt templates and workflows that clients can easily surface to users and LLMs. They provide a powerful way to standardize and share common LLM interactions.
 
 <Note>
+
   Prompts are designed to be **user-controlled**, meaning they are exposed from servers to clients with the intention of the user being able to explicitly select them for use.
+
 </Note>
 
 ## Overview
@@ -197,6 +199,7 @@ Here's a complete example of implementing prompts in an MCP server:
 
 <Tabs>
   <Tab title="TypeScript">
+
     ```typescript
     import { Server } from "@modelcontextprotocol/sdk/server";
     import {
@@ -289,8 +292,10 @@ Here's a complete example of implementing prompts in an MCP server:
       throw new Error("Prompt implementation not found");
     });
     ```
+
   </Tab>
   <Tab title="Python">
+
     ```python
     from mcp.server import Server
     import mcp.types as types
@@ -372,6 +377,7 @@ Here's a complete example of implementing prompts in an MCP server:
 
         raise ValueError("Prompt implementation not found")
     ```
+
   </Tab>
 </Tabs>
 

docs/docs/concepts/resources.mdx

@@ -6,13 +6,15 @@ description: "Expose data and content from your servers to LLMs"
 Resources are a core primitive in the Model Context Protocol (MCP) that allow servers to expose data and content that can be read by clients and used as context for LLM interactions.
 
 <Note>
+
   Resources are designed to be **application-controlled**, meaning that the client application can decide how and when they should be used.
   Different MCP clients may handle resources differently. For example:
   - Claude Desktop currently requires users to explicitly select resources before they can be used
   - Other clients might automatically select resources based on heuristics
   - Some implementations may even allow the AI model itself to determine which resources to use
 
   Server authors should be prepared to handle any of these interaction patterns when implementing resource support. In order to expose data to models automatically, server authors should use a **model-controlled** primitive such as [Tools](./tools).
+
 </Note>
 
 ## Overview
@@ -119,7 +121,9 @@ The server responds with a list of resource contents:
 ```
 
 <Tip>
+
   Servers may return multiple resources in response to one `resources/read` request. This could be used, for example, to return a list of files inside a directory when the directory is read.
+
 </Tip>
 
 ## Resource updates
@@ -145,6 +149,7 @@ Here's a simple example of implementing resource support in an MCP server:
 
 <Tabs>
   <Tab title="TypeScript">
+
     ```typescript
     const server = new Server({
       name: "example-server",
@@ -188,8 +193,10 @@ Here's a simple example of implementing resource support in an MCP server:
       throw new Error("Resource not found");
     });
     ```
+
   </Tab>
   <Tab title="Python">
+
     ```python
     app = Server("example-server")
 
@@ -219,6 +226,7 @@ Here's a simple example of implementing resource support in an MCP server:
             app.create_initialization_options()
         )
     ```
+
   </Tab>
 </Tabs>
 

docs/docs/concepts/sampling.mdx

@@ -6,7 +6,9 @@ description: "Let your servers request completions from LLMs"
 Sampling is a powerful MCP feature that allows servers to request LLM completions through the client, enabling sophisticated agentic behaviors while maintaining security and privacy.
 
 <Info>
+
   This feature of MCP is not yet supported in the Claude Desktop client.
+
 </Info>
 
 ## How sampling works

docs/docs/concepts/tools.mdx

@@ -6,7 +6,9 @@ description: "Enable LLMs to perform actions through your server"
 Tools are a powerful primitive in the Model Context Protocol (MCP) that enable servers to expose executable functionality to clients. Through tools, LLMs can interact with external systems, perform computations, and take actions in the real world.
 
 <Note>
+
   Tools are designed to be **model-controlled**, meaning that tools are exposed from servers to clients with the intention of the AI model being able to automatically invoke them (with a human in the loop to grant approval).
+
 </Note>
 
 ## Overview
@@ -47,6 +49,7 @@ Here's an example of implementing a basic tool in an MCP server:
 
 <Tabs>
   <Tab title="TypeScript">
+
     ```typescript
     const server = new Server({
       name: "example-server",
@@ -91,8 +94,10 @@ Here's an example of implementing a basic tool in an MCP server:
       throw new Error("Tool not found");
     });
     ```
+
   </Tab>
   <Tab title="Python">
+
     ```python
     app = Server("example-server")
 
@@ -125,6 +130,7 @@ Here's an example of implementing a basic tool in an MCP server:
             return [types.TextContent(type="text", text=str(result))]
         raise ValueError(f"Tool not found: {name}")
     ```
+
   </Tab>
 </Tabs>
 
@@ -255,6 +261,7 @@ Here's an example of proper error handling for tools:
 
 <Tabs>
   <Tab title="TypeScript">
+
     ```typescript
     try {
       // Tool operation
@@ -279,8 +286,10 @@ Here's an example of proper error handling for tools:
       };
     }
     ```
+
   </Tab>
   <Tab title="Python">
+
     ```python
     try:
         # Tool operation
@@ -304,6 +313,7 @@ Here's an example of proper error handling for tools:
             ]
         )
     ```
+
   </Tab>
 </Tabs>
 
@@ -403,6 +413,7 @@ Here's how to define tools with annotations for different scenarios:
 
 <Tabs>
   <Tab title="TypeScript">
+
     ```typescript
     server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
@@ -426,13 +437,15 @@ Here's how to define tools with annotations for different scenarios:
       };
     });
     ```
+
   </Tab>
   <Tab title="Python">
+
     ```python
     from mcp.server.fastmcp import FastMCP
-    
+
     mcp = FastMCP("example-server")
-    
+
     @mcp.tool(
         annotations={
             "title": "Calculate Sum",
@@ -442,14 +455,15 @@ Here's how to define tools with annotations for different scenarios:
     )
     async def calculate_sum(a: float, b: float) -> str:
         """Add two numbers together.
-        
+
         Args:
             a: First number to add
             b: Second number to add
         """
         result = a + b
         return str(result)
     ```
+
   </Tab>
 </Tabs>