Merge pull request modelcontextprotocol#624 from jonathanhefner/fix-ci-for-mdx-files

Fix CI for MDX files

Author: dsp-ant

.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/clients.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/development/roadmap.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,20 +89,22 @@ The protocol layer handles message framing, request/response linking, and high-l
             """Handle incoming notification from other side."""
             # Notification handling implementation
     ```
+
   </Tab>
 </Tabs>
 
 Key classes include:
 
-* `Protocol`
-* `Client`
-* `Server`
+- `Protocol`
+- `Client`
+- `Server`
 
 ### Transport layer
 
 The transport layer handles the actual communication between clients and servers. MCP supports multiple transport mechanisms:
 
 1. **Stdio transport**
+
    - Uses standard input/output for communication
    - Ideal for local processes
 
@@ -114,36 +119,39 @@ All transports use [JSON-RPC](https://www.jsonrpc.org/) 2.0 to exchange messages
 MCP has these main types of messages:
 
 1. **Requests** expect a response from the other side:
-    ```typescript
-    interface Request {
-      method: string;
-      params?: { ... };
-    }
-    ```
+
+   ```typescript
+   interface Request {
+     method: string;
+     params?: { ... };
+   }
+   ```
 
 2. **Results** are successful responses to requests:
-    ```typescript
-    interface Result {
-      [key: string]: unknown;
-    }
-    ```
+
+   ```typescript
+   interface Result {
+     [key: string]: unknown;
+   }
+   ```
 
 3. **Errors** indicate that a request failed:
-    ```typescript
-    interface Error {
-      code: number;
-      message: string;
-      data?: unknown;
-    }
-    ```
+
+   ```typescript
+   interface Error {
+     code: number;
+     message: string;
+     data?: unknown;
+   }
+   ```
 
 4. **Notifications** are one-way messages that don't expect a response:
-    ```typescript
-    interface Notification {
-      method: string;
-      params?: { ... };
-    }
-    ```
+   ```typescript
+   interface Notification {
+     method: string;
+     params?: { ... };
+   }
+   ```
 
 ## Connection lifecycle
 
@@ -176,6 +184,7 @@ After initialization, the following patterns are supported:
 ### 3. Termination
 
 Either party can terminate the connection:
+
 - Clean shutdown via `close()`
 - Transport disconnection
 - Error conditions
@@ -191,13 +200,14 @@ enum ErrorCode {
   InvalidRequest = -32600,
   MethodNotFound = -32601,
   InvalidParams = -32602,
-  InternalError = -32603
+  InternalError = -32603,
 }
 ```
 
 SDKs and applications can define their own error codes above -32000.
 
 Errors are propagated through:
+
 - Error responses to requests
 - Error events on transports
 - Protocol-level error handlers
@@ -208,6 +218,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 +248,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 +280,7 @@ Here's a basic example of implementing an MCP server:
     if __name__ == "__main__":
         asyncio.run(main())
     ```
+
   </Tab>
 </Tabs>
 
@@ -275,6 +289,7 @@ Here's a basic example of implementing an MCP server:
 ### Transport selection
 
 1. **Local communication**
+
    - Use stdio transport for local processes
    - Efficient for same-machine communication
    - Simple process management
@@ -286,12 +301,14 @@ Here's a basic example of implementing an MCP server:
 ### Message handling
 
 1. **Request processing**
+
    - Validate inputs thoroughly
    - Use type-safe schemas
    - Handle errors gracefully
    - Implement timeouts
 
 2. **Progress reporting**
+
    - Use progress tokens for long operations
    - Report progress incrementally
    - Include total progress when known
@@ -304,17 +321,20 @@ Here's a basic example of implementing an MCP server:
 ## Security considerations
 
 1. **Transport security**
+
    - Use TLS for remote connections
    - Validate connection origins
    - Implement authentication when needed
 
 2. **Message validation**
+
    - Validate all incoming messages
    - Sanitize inputs
    - Check message size limits
    - Verify JSON-RPC format
 
 3. **Resource protection**
+
    - Implement access controls
    - Validate resource paths
    - Monitor resource usage
@@ -329,12 +349,14 @@ Here's a basic example of implementing an MCP server:
 ## Debugging and monitoring
 
 1. **Logging**
+
    - Log protocol events
    - Track message flow
    - Monitor performance
    - Record errors
 
 2. **Diagnostics**
+
    - Implement health checks
    - Monitor connection state
    - Track resource usage

docs/docs/concepts/architecture.mdx

@@ -6,12 +6,15 @@ 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.
+
+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
 
 Prompts in MCP are predefined templates that can:
+
 - Accept dynamic arguments
 - Include context from resources
 - Chain multiple interactions
@@ -43,7 +46,7 @@ Clients can discover available prompts through the `prompts/list` endpoint:
 ```typescript
 // Request
 {
-  method: "prompts/list"
+  method: "prompts/list";
 }
 
 // Response
@@ -56,19 +59,19 @@ Clients can discover available prompts through the `prompts/list` endpoint:
         {
           name: "language",
           description: "Programming language",
-          required: true
-        }
-      ]
-    }
-  ]
+          required: true,
+        },
+      ],
+    },
+  ];
 }
 ```
 
 ## Using prompts
 
 To use a prompt, clients make a `prompts/get` request:
 
-```typescript
+````typescript
 // Request
 {
   method: "prompts/get",
@@ -93,7 +96,7 @@ To use a prompt, clients make a `prompts/get` request:
     }
   ]
 }
-```
+````
 
 ## Dynamic prompts
 
@@ -169,25 +172,25 @@ const debugWorkflow = {
         role: "user",
         content: {
           type: "text",
-          text: `Here's an error I'm seeing: ${error}`
-        }
+          text: `Here's an error I'm seeing: ${error}`,
+        },
       },
       {
         role: "assistant",
         content: {
           type: "text",
-          text: "I'll help analyze this error. What have you tried so far?"
-        }
+          text: "I'll help analyze this error. What have you tried so far?",
+        },
       },
       {
         role: "user",
         content: {
           type: "text",
-          text: "I've tried restarting the service, but the error persists."
-        }
-      }
+          text: "I've tried restarting the service, but the error persists.",
+        },
+      },
     ];
-  }
+  },
 };
 ```
 
@@ -197,6 +200,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 +293,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 +378,7 @@ Here's a complete example of implementing prompts in an MCP server:
 
         raise ValueError("Prompt implementation not found")
     ```
+
   </Tab>
 </Tabs>