0
# Transport Layer
1

2
The SDK supports multiple transport mechanisms. All transports implement the same `Transport` interface.
3

4
## Stdio Transport
5

6
For local integrations where server is spawned as a child process.
7

8
### Server Side
9

10
```typescript { .api }
11
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
12

13
class StdioServerTransport implements Transport {
14
  constructor(stdin?: Readable, stdout?: Writable);
15
}
16
```
17

18
### Client Side
19

20
```typescript { .api }
21
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
22

23
class StdioClientTransport implements Transport {
24
  constructor(options: {
25
    command: string;
26
    args?: string[];
27
    env?: Record<string, string>;
28
    stderr?: 'inherit' | 'ignore' | 'pipe' | Stream | number;
29
    cwd?: string;
30
  });
31
}
32
```
33

34
### Examples
35

36
```typescript
37
// Server
38
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
39
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
40

41
const server = new McpServer({ name: 'my-server', version: '1.0.0' });
42
const transport = new StdioServerTransport();
43
await server.connect(transport);
44

45
// Client
46
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
47
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
48

49
const client = new Client({ name: 'my-client', version: '1.0.0' });
50
const transport = new StdioClientTransport({
51
  command: 'node',
52
  args: ['server.js'],
53
  env: { ...process.env, DEBUG: 'true' },
54
  cwd: '/path/to/server'
55
});
56
await client.connect(transport);
57
```
58

59
## StreamableHTTP Transport
60

61
Modern HTTP-based transport for remote servers with session management, reconnection support, and event replay.
62

63
### Server Side
64

65
```typescript { .api }
66
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
67

68
class StreamableHTTPServerTransport implements Transport {
69
  constructor(options: {
70
    sessionIdGenerator?: () => string;                // undefined for stateless mode
71
    onsessioninitialized?: (sessionId: string) => void | Promise<void>;
72
    onsessionclosed?: (sessionId: string) => void | Promise<void>;
73
    enableJsonResponse?: boolean;                     // JSON responses instead of newline-delimited JSON
74
    eventStore?: EventStore;                          // Event store for session resumption
75
    allowedHosts?: string[];                          // DNS rebinding protection
76
    allowedOrigins?: string[];                        // DNS rebinding protection
77
    enableDnsRebindingProtection?: boolean;           // Default: false
78
  });
79

80
  async handleRequest(req: IncomingMessage, res: ServerResponse, body?: JSONRPCMessage): Promise<void>;
81
}
82

83
interface EventStore {
84
  storeEvent(sessionId: string, event: { sequence: number; data: JSONRPCMessage }): Promise<void>;
85
  replayEventsAfter(sessionId: string, afterSequence: number): Promise<Array<{ sequence: number; data: JSONRPCMessage }>>;
86
}
87
```
88

89
### Client Side
90

91
```typescript { .api }
92
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
93

94
class StreamableHTTPClientTransport implements Transport {
95
  constructor(
96
    url: URL,
97
    options?: {
98
      reconnectionOptions?: {
99
        maxReconnectionDelay: number;
100
        initialReconnectionDelay: number;
101
        reconnectionDelayGrowFactor: number;
102
        maxRetries: number;
103
      };
104
      authProvider?: OAuthClientProvider;
105
      fetch?: FetchLike;
106
    }
107
  );
108

109
  async finishAuth(authorizationCode: string): Promise<void>;
110
}
111
```
112

113
### Examples
114

115
```typescript
116
// Server - Stateless mode (recommended)
117
import express from 'express';
118
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
119
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
120

121
const app = express();
122
app.use(express.json());
123

124
const server = new McpServer({ name: 'http-server', version: '1.0.0' });
125

126
app.post('/mcp', async (req, res) => {
127
  const transport = new StreamableHTTPServerTransport({
128
    sessionIdGenerator: undefined,  // Stateless
129
    enableJsonResponse: true
130
  });
131

132
  res.on('close', () => transport.close());
133
  await server.connect(transport);
134
  await transport.handleRequest(req, res, req.body);
135
});
136

137
app.listen(3000);
138

139
// Server - Stateful mode with session management
140
const transports = {};
141

142
app.post('/mcp', async (req, res) => {
143
  const sessionId = req.headers['mcp-session-id'];
144
  let transport;
145

146
  if (sessionId && transports[sessionId]) {
147
    transport = transports[sessionId];
148
  } else {
149
    transport = new StreamableHTTPServerTransport({
150
      sessionIdGenerator: () => crypto.randomUUID(),
151
      onsessioninitialized: (id) => { transports[id] = transport; },
152
      onsessionclosed: (id) => { delete transports[id]; },
153
      enableDnsRebindingProtection: true,
154
      allowedHosts: ['127.0.0.1', 'localhost']
155
    });
156
    await server.connect(transport);
157
  }
158

159
  await transport.handleRequest(req, res, req.body);
160
});
161

162
// Client
163
const client = new Client({ name: 'http-client', version: '1.0.0' });
164
const transport = new StreamableHTTPClientTransport(
165
  new URL('http://localhost:3000/mcp'),
166
  {
167
    reconnectionOptions: {
168
      maxReconnectionDelay: 30000,
169
      initialReconnectionDelay: 1000,
170
      reconnectionDelayGrowFactor: 2,
171
      maxRetries: 10
172
    }
173
  }
174
);
175
await client.connect(transport);
176
```
177

178
## WebSocket Transport
179

180
WebSocket-based communication (client-side only).
181

182
```typescript { .api }
183
import { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
184

185
class WebSocketClientTransport implements Transport {
186
  constructor(url: URL);
187
}
188
```
189

190
### Example
191

192
```typescript
193
const client = new Client({ name: 'ws-client', version: '1.0.0' });
194
const transport = new WebSocketClientTransport(new URL('ws://localhost:3000/mcp'));
195
await client.connect(transport);
196
```
197

198
## InMemory Transport
199

200
For testing and development.
201

202
```typescript { .api }
203
import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
204

205
class InMemoryTransport implements Transport {
206
  static createLinkedPair(): [InMemoryTransport, InMemoryTransport];
207
}
208
```
209

210
### Example
211

212
```typescript
213
import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
214
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
215
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
216

217
const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
218

219
const client = new Client({ name: 'test-client', version: '1.0.0' });
220
const server = new Server({ name: 'test-server', version: '1.0.0' });
221

222
await Promise.all([
223
  client.connect(clientTransport),
224
  server.connect(serverTransport)
225
]);
226
```
227

228
## Transport Interface
229

230
```typescript { .api }
231
interface Transport {
232
  sessionId?: string;
233
  onclose?: () => void;
234
  onerror?: (error: Error) => void;
235
  onmessage?: (message: JSONRPCMessage) => void;
236
  start(): Promise<void>;
237
  send(message: JSONRPCMessage): Promise<void>;
238
  close(): Promise<void>;
239
  setProtocolVersion?: (version: string) => void;  // HTTP transports only
240
}
241
```
242

243
## Choosing a Transport
244

245
| Transport | Use Case | Characteristics |
246
|-----------|----------|----------------|
247
| **Stdio** | Local integrations, CLI tools, IDE extensions | Simple, fast |
248
| **StreamableHTTP** | Remote servers, web services, distributed systems | Stateless, scalable |
249
| **WebSocket** | Real-time bidirectional communication | Low latency |
250
| **InMemory** | Unit tests, integration tests | Isolated |
251
252
**Note:** SSE transport is deprecated - use StreamableHTTP for new implementations.
253