How to build an MCP client in TypeScript

1mkdir mcp-client && cd mcp-client
2npm init -y
3npm install @modelcontextprotocol/sdk zod
4npm install -D typescript @types/node
5npx tsc --init

1// src/client.ts
2import { Client } from "@modelcontextprotocol/sdk/client/index.js";
3import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
4
5export async function createClient(
6  command: string,
7  args: string[],
8  env?: Record<string, string>
9): Promise<Client> {
10  const transport = new StdioClientTransport({
11    command,
12    args,
13    env: { ...process.env, ...env } as Record<string, string>,
14  });
15
16  const client = new Client(
17    { name: "my-mcp-client", version: "1.0.0" },
18    { capabilities: {} }
19  );
20
21  await client.connect(transport);
22
23  // Get server info
24  const serverInfo = client.getServerVersion();
25  console.error(`Connected to: ${serverInfo?.name} v${serverInfo?.version}`);
26
27  return client;
28}

1// src/discover.ts
2import { Client } from "@modelcontextprotocol/sdk/client/index.js";
3
4export async function discoverTools(client: Client) {
5  const { tools } = await client.listTools();
6
7  console.error(`\nDiscovered ${tools.length} tools:\n`);
8  for (const tool of tools) {
9    console.error(`  ${tool.name}`);
10    console.error(`    ${tool.description}`);
11    if (tool.inputSchema?.properties) {
12      const params = Object.entries(tool.inputSchema.properties)
13        .map(([name, schema]) => {
14          const s = schema as any;
15          const required = tool.inputSchema.required?.includes(name) ? "required" : "optional";
16          return `      - ${name} (${s.type}, ${required}): ${s.description || ""}`;
17        });
18      console.error(params.join("\n"));
19    }
20    console.error();
21  }
22
23  return tools;
24}

1// src/invoke.ts
2import { Client } from "@modelcontextprotocol/sdk/client/index.js";
3
4export interface ToolResult {
5  text: string;
6  isError: boolean;
7}
8
9export async function callTool(
10  client: Client,
11  toolName: string,
12  args: Record<string, unknown>
13): Promise<ToolResult> {
14  try {
15    const result = await client.callTool({
16      name: toolName,
17      arguments: args,
18    });
19
20    const content = result.content as Array<{ type: string; text?: string }>;
21    const text = content
22      .filter(c => c.type === "text" && c.text)
23      .map(c => c.text!)
24      .join("\n");
25
26    return {
27      text: text || "(no text content returned)",
28      isError: (result as any).isError === true,
29    };
30  } catch (error) {
31    return {
32      text: `Client error: ${error instanceof Error ? error.message : String(error)}`,
33      isError: true,
34    };
35  }
36}
37
38// Usage:
39// const result = await callTool(client, "read_file", { filePath: "src/index.ts" });
40// if (result.isError) console.error("Tool failed:", result.text);
41// else console.log(result.text);

1// src/interactive.ts
2import { createInterface } from "readline";
3import { createClient } from "./client.js";
4import { discoverTools } from "./discover.js";
5import { callTool } from "./invoke.js";
6
7async function main() {
8  const command = process.argv[2];
9  const args = process.argv.slice(3);
10  if (!command) {
11    console.error("Usage: node dist/interactive.js <server-command> [args...]");
12    process.exit(1);
13  }
14
15  const client = await createClient(command, args);
16  await discoverTools(client);
17
18  const rl = createInterface({ input: process.stdin, output: process.stderr });
19
20  const promptUser = () => rl.question("\nmcp> ", async (line) => {
21    const trimmed = line.trim();
22    if (trimmed === "quit" || trimmed === "exit") {
23      await client.close();
24      rl.close();
25      return;
26    }
27    if (trimmed === "tools") {
28      await discoverTools(client);
29      promptUser();
30      return;
31    }
32
33    // Parse: toolName key=value key=value
34    const parts = trimmed.split(/\s+/);
35    const toolName = parts[0];
36    const toolArgs: Record<string, unknown> = {};
37    for (const part of parts.slice(1)) {
38      const [key, ...rest] = part.split("=");
39      const value = rest.join("=");
40      toolArgs[key] = isNaN(Number(value)) ? value : Number(value);
41    }
42
43    const result = await callTool(client, toolName, toolArgs);
44    console.error(result.isError ? `ERROR: ${result.text}` : result.text);
45    promptUser();
46  });
47
48  promptUser();
49}
50
51main().catch(e => { console.error(e); process.exit(1); });