Supercharge Your LLMs with the MCP TypeScript SDK: A Comprehensive Guide

npm install @modelcontextprotocol/sdk

import { McpServer, ResourceTemplate} from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js";
import { z} from "zod";

// Create an MCP server
const server = new McpServer({
 name: "Demo",
 version: "1.0.0"
});

// Add an addition tool
server.tool("add",
 { a: z.number(), b: z.number()},
 async ({ a, b}) => ({
 content: [{ type: "text", text: String(a + b)}]
})
);

// Add a dynamic greeting resource
server.resource(
 "greeting",
 new ResourceTemplate("greeting://{name}", { list: undefined}),
 async (uri, { name}) => ({
 contents: [{
 uri: uri.href,
 text: `Hello, ${name}!`
}]
})
);

// Start receiving messages on stdin and sending messages on stdout
const transport = new StdioServerTransport();
await server.connect(transport);

const server = new McpServer({
 name: "My App",
 version: "1.0.0"
});

// Static resource
server.resource(
 "config",
 "config://app",
 async (uri) => ({
 contents: [{
 uri: uri.href,
 text: "App configuration here"
}]
})
);

// Dynamic resource with parameters
server.resource(
 "user-profile",
 new ResourceTemplate("users://{userId}/profile", { list: undefined}),
 async (uri, { userId}) => ({
 contents: [{
 uri: uri.href,
 text: `Profile data for user ${userId}`
}]
})
);

// Simple tool with parameters
server.tool(
 "calculate-bmi",
 {
 weightKg: z.number(),
 heightM: z.number()
},
 async ({ weightKg, heightM}) => ({
 content: [{
 type: "text",
 text: String(weightKg / (heightM * heightM))
}]
})
);

// Async tool with external API call
server.tool(
 "fetch-weather",
 { city: z.string()},
 async ({ city}) => {
 const response = await fetch(`https://api.weather.com/${city}`);
 const data = await response.text();
 return {
 content: [{ type: "text", text: data}]
};
}
);

server.prompt(
 "review-code",
 { code: z.string()},
 ({ code}) => ({
 messages: [{
 role: "user",
 content: {
 type: "text",
 text: `Please review this code:\n\n${code}`
}
}]
})
);

import { McpServer} from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new McpServer({
 name: "example-server",
 version: "1.0.0"
});

//... set up server resources, tools, and prompts...

const transport = new StdioServerTransport();
await server.connect(transport);

import express from "express";
import { McpServer} from "@modelcontextprotocol/sdk/server/mcp.js";
import { SSEServerTransport} from "@modelcontextprotocol/sdk/server/sse.js";

const server = new McpServer({
 name: "example-server",
 version: "1.0.0"
});

//... set up server resources, tools, and prompts...

const app = express();

app.get("/sse", async (req, res) => {
 const transport = new SSEServerTransport("/messages", res);
 await server.connect(transport);
});

app.post("/messages", async (req, res) => {
 // Note: to support multiple simultaneous connections, these messages will
 // need to be routed to a specific matching transport. (This logic isn't
 // implemented here, for simplicity.)
 await transport.handlePostMessage(req, res);
});

app.listen(3001);

import { McpServer, ResourceTemplate} from "@modelcontextprotocol/sdk/server/mcp.js";
import { z} from "zod";

const server = new McpServer({
 name: "Echo",
 version: "1.0.0"
});

server.resource(
 "echo",
 new ResourceTemplate("echo://{message}", { list: undefined}),
 async (uri, { message}) => ({
 contents: [{
 uri: uri.href,
 text: `Resource echo: ${message}`
}]
})
);

server.tool(
 "echo",
 { message: z.string()},
 async ({ message}) => ({
 content: [{ type: "text", text: `Tool echo: ${message}`}]
})
);

server.prompt(
 "echo",
 { message: z.string()},
 ({ message}) => ({
 messages: [{
 role: "user",
 content: {
 type: "text",
 text: `Please process this message: ${message}`
}
}]
})
);

import { McpServer} from "@modelcontextprotocol/sdk/server/mcp.js";
import sqlite3 from "sqlite3";
import { promisify} from "util";
import { z} from "zod";

const server = new McpServer({
 name: "SQLite Explorer",
 version: "1.0.0"
});

// Helper to create DB connection
const getDb = () => {
 const db = new sqlite3.Database("database.db");
 return {
 all: promisify (db.all.bind(db)),
 close: promisify(db.close.bind(db))
};
};

server.resource(
 "schema",
 "schema://main",
 async (uri) => {
 const db = getDb();
 try {
 const tables = await db.all(
 "SELECT sql FROM sqlite_master WHERE type='table'"
);
 return {
 contents: [{
 uri: uri.href,
 text: tables.map((t: {sql: string}) => t.sql).join("\n")
}]
};
} finally {
 await db.close();
}
}
);

server.tool(
 "query",
 { sql: z.string()},
 async ({ sql}) => {
 const db = getDb();
 try {
 const results = await db.all(sql);
 return {
 content: [{
 type: "text",
 text: JSON.stringify(results, null, 2)
}]
};
} catch (err: unknown) {
 const error = err as Error;
 return {
 content: [{
 type: "text",
 text: `Error: ${error.message}`
}],
 isError: true
};
} finally {
 await db.close();
}
}
);

import { Server} from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js";
import {
 ListPromptsRequestSchema,
 GetPromptRequestSchema
} from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
 {
 name: "example-server",
 version: "1.0.0"
},
 {
 capabilities: {
 prompts: {}
}
}
);

server.setRequestHandler(ListPromptsRequestSchema, async () => {
 return {
 prompts: [{
 name: "example-prompt",
 description: "An example prompt template",
 arguments: [{
 name: "arg1",
 description: "Example argument",
 required: true
}]
}]
};
});

server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 if (request.params.name!== "example-prompt") {
 throw new Error("Unknown prompt");
}
 return {
 description: "Example prompt",
 messages: [{
 role: "user",
 content: {
 type: "text",
 text: "Example prompt text"
}
}]
};
});

const transport = new StdioServerTransport();
await server.connect(transport);

import { Client} from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport} from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
 command: "node",
 args: ["server.js"]
});

const client = new Client(
 {
 name: "example-client",
 version: "1.0.0"
},
 {
 capabilities: {
 prompts: {},
 resources: {},
 tools: {}
}
}
);

await client.connect(transport);

// List prompts
const prompts = await client.listPrompts();

// Get a prompt
const prompt = await client.getPrompt("example-prompt", {
 arg1: "value"
});

// List resources
const resources = await client.listResources();

// Read a resource
const resource = await client.readResource("file:///example.txt");

// Call a tool
const result = await client.callTool({
 name: "example-tool",
 arguments: {
 arg1: "value"
}
});