modelcontextprotocol/docs
Watch
1
0
Fork
You've already forked docs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #118 from modelcontextprotocol/revert-115-justin/simplified-ts-sdk

Browse source 
Revert "Update TypeScript examples to use simplified API"
This commit is contained in:
Justin Spahr-Summers 2025-01-23 14:01:33 +00:00 • committed by GitHub
commit 3684fe2ddd
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 251 additions and 141 deletions
Download patch file Download diff file Expand all files Collapse all files

53
docs/concepts/architecture.mdx
View file

@ -210,30 +210,35 @@ Here's a basic example of implementing an MCP server:
<Tabs> <Tabs>
<Tab title="TypeScript"> <Tab title="TypeScript">
```typescript ```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
const server = new McpServer({
name: "example-server", const server = new Server({
version: "1.0.0" name: "example-server",
}); version: "1.0.0"
}, {
// Register a resource capabilities: {
server.resource( resources: {}
"example", }
"example://resource", });
async (uri) => ({
contents: [{ // Handle requests
uri: uri.href, server.setRequestHandler(ListResourcesRequestSchema, async () => {
text: "Example resource content" return {
}] resources: [
}) {
); uri: "example://resource",
name: "Example Resource"
// Connect transport }
const transport = new StdioServerTransport(); ]
await server.connect(transport); };
``` });
// Connect transport
const transport = new StdioServerTransport();
await server.connect(transport);
```
</Tab> </Tab>
<Tab title="Python"> <Tab title="Python">
```python ```python

138
docs/concepts/prompts.mdx
View file

@ -197,52 +197,98 @@ Here's a complete example of implementing prompts in an MCP server:
<Tabs> <Tabs>
<Tab title="TypeScript"> <Tab title="TypeScript">
```typescript ```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; import { Server } from "@modelcontextprotocol/sdk/server";
import { z } from "zod"; import {
ListPromptsRequestSchema,
const server = new McpServer({ GetPromptRequestSchema
name: "example-prompts-server", } from "@modelcontextprotocol/sdk/types";
version: "1.0.0"
}); const PROMPTS = {
"git-commit": {
// Register git commit prompt name: "git-commit",
server.prompt( description: "Generate a Git commit message",
"git-commit", arguments: [
"Generate a Git commit message", {
{ name: "changes",
changes: z.string().describe("Git diff or description of changes") description: "Git diff or description of changes",
}, required: true
({ changes }) => ({ }
messages: [{ ]
role: "user", },
content: { "explain-code": {
type: "text", name: "explain-code",
text: `Generate a concise but descriptive commit message for these changes:\n\n${changes}` description: "Explain how code works",
} arguments: [
}] {
}) name: "code",
); description: "Code to explain",
required: true
// Register code explanation prompt },
server.prompt( {
"explain-code", name: "language",
"Explain how code works", description: "Programming language",
{ required: false
code: z.string().describe("Code to explain"), }
language: z.string().optional().describe("Programming language") ]
}, }
({ code, language }) => ({ };
messages: [{
role: "user", const server = new Server({
content: { name: "example-prompts-server",
type: "text", version: "1.0.0"
text: `Explain how this ${language || "Unknown"} code works:\n\n${code}` }, {
} capabilities: {
}] prompts: {}
}) }
); });
```
// List available prompts
server.setRequestHandler(ListPromptsRequestSchema, async () => {
return {
prompts: Object.values(PROMPTS)
};
});
// Get specific prompt
server.setRequestHandler(GetPromptRequestSchema, async (request) => {
const prompt = PROMPTS[request.params.name];
if (!prompt) {
throw new Error(`Prompt not found: ${request.params.name}`);
}
if (request.params.name === "git-commit") {
return {
messages: [
{
role: "user",
content: {
type: "text",
text: `Generate a concise but descriptive commit message for these changes:\n\n${request.params.arguments?.changes}`
}
}
]
};
}
if (request.params.name === "explain-code") {
const language = request.params.arguments?.language || "Unknown";
return {
messages: [
{
role: "user",
content: {
type: "text",
text: `Explain how this ${language} code works:\n\n${request.params.arguments?.code}`
}
}
]
};
}
throw new Error("Prompt implementation not found");
});
```
</Tab> </Tab>
<Tab title="Python"> <Tab title="Python">
```python ```python

51
docs/concepts/resources.mdx
View file

@ -145,32 +145,47 @@ Here's a simple example of implementing resource support in an MCP server:
<Tabs> <Tabs>
<Tab title="TypeScript"> <Tab title="TypeScript">
```typescript ```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; const server = new Server({
const server = new McpServer({
name: "example-server", name: "example-server",
version: "1.0.0" version: "1.0.0"
}, {
capabilities: {
resources: {}
}
}); });
// Add static resource // List available resources
server.resource( server.setRequestHandler(ListResourcesRequestSchema, async () => {
"logs", return {
"file:///logs/app.log", resources: [
{ {
mimeType: "text/plain", uri: "file:///logs/app.log",
description: "Application log file" name: "Application Logs",
}, mimeType: "text/plain"
async (uri) => { }
]
};
});
// Read resource contents
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
const uri = request.params.uri;
if (uri === "file:///logs/app.log") {
const logContents = await readLogFile(); const logContents = await readLogFile();
return { return {
contents: [{ contents: [
uri: uri.href, {
mimeType: "text/plain", uri,
text: logContents mimeType: "text/plain",
}] text: logContents
}
]
}; };
} }
);
throw new Error("Resource not found");
});
``` ```
</Tab> </Tab>
<Tab title="Python"> <Tab title="Python">

69
docs/concepts/tools.mdx
View file

@ -40,31 +40,50 @@ Here's an example of implementing a basic tool in an MCP server:
<Tabs> <Tabs>
<Tab title="TypeScript"> <Tab title="TypeScript">
```typescript ```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; const server = new Server({
import { z } from "zod"; name: "example-server",
version: "1.0.0"
const server = new McpServer({ }, {
name: "example-server", capabilities: {
version: "1.0.0" tools: {}
}); }
});
// Register a tool
server.tool( // Define available tools
"calculate_sum", server.setRequestHandler(ListToolsRequestSchema, async () => {
"Add two numbers together", return {
{ tools: [{
a: z.number(), name: "calculate_sum",
b: z.number() description: "Add two numbers together",
}, inputSchema: {
async ({ a, b }) => ({ type: "object",
content: [{ properties: {
type: "text", a: { type: "number" },
text: String(a + b) b: { type: "number" }
}] },
}) required: ["a", "b"]
); }
``` }]
};
});
// Handle tool execution
server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (request.params.name === "calculate_sum") {
const { a, b } = request.params.arguments;
return {
content: [
{
type: "text",
text: String(a + b)
}
]
};
}
throw new Error("Tool not found");
});
```
</Tab> </Tab>
<Tab title="Python"> <Tab title="Python">
```python ```python

87
quickstart/server.mdx
View file

@ -450,39 +450,64 @@ const ForecastArgumentsSchema = z.object({
longitude: z.number().min(-180).max(180), longitude: z.number().min(-180).max(180),
}); });
// Create server instance
const server = new Server(
{
name: "weather",
version: "1.0.0",
},
{
capabilities: {
tools: {},
},
}
);
```
### Implementing tool listing
We need to tell clients what tools are available. This `server.setRequestHandler` call will register this list for us:
```typescript ```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; // List available tools
import { z } from "zod"; server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
const server = new McpServer({ tools: [
name: "weather", {
version: "1.0.0" name: "get-alerts",
description: "Get weather alerts for a state",
inputSchema: {
type: "object",
properties: {
state: {
type: "string",
description: "Two-letter state code (e.g. CA, NY)",
},
},
required: ["state"],
},
},
{
name: "get-forecast",
description: "Get weather forecast for a location",
inputSchema: {
type: "object",
properties: {
latitude: {
type: "number",
description: "Latitude of the location",
},
longitude: {
type: "number",
description: "Longitude of the location",
},
},
required: ["latitude", "longitude"],
},
},
],
};
}); });
// Register weather alert tool
server.tool(
"get-alerts",
"Get weather alerts for a state",
{
state: z.string().length(2).describe("Two-letter state code (e.g. CA, NY)")
},
async ({ state }) => {
// Tool implementation
}
);
// Register forecast tool
server.tool(
"get-forecast",
"Get weather forecast for a location",
{
latitude: z.number().min(-90).max(90).describe("Latitude of the location"),
longitude: z.number().min(-180).max(180).describe("Longitude of the location")
},
async ({ latitude, longitude }) => {
// Tool implementation
}
);
``` ```
This defines our two tools: `get-alerts` and `get-forecast`. This defines our two tools: `get-alerts` and `get-forecast`.