Class McpServer

constructor

• new McpServer(
      serverInfo: {
          description?: string;
          icons?: {
              mimeType?: string;
              sizes?: string[];
              src: string;
              theme?: "light" | "dark";
          }[];
          name: string;
          title?: string;
          version: string;
          websiteUrl?: string;
      },
      options?: ServerOptions,
  ): McpServer

  Parameters

  • serverInfo: {
        description?: string;
        icons?: {
            mimeType?: string;
            sizes?: string[];
            src: string;
            theme?: "light" | "dark";
        }[];
        name: string;
        title?: string;
        version: string;
        websiteUrl?: string;
    }

    • Optionaldescription?: string

      An optional human-readable description of what this implementation does.

      This can be used by clients or servers to provide context about their purpose and capabilities. For example, a server might describe the types of resources or tools it provides, while a client might describe its intended use case.

    • Optionalicons?: { mimeType?: string; sizes?: string[]; src: string; theme?: "light" | "dark" }[]

      Optional set of sized icons that the client can display in a user interface.

      Clients that support rendering icons MUST support at least the following MIME types:

      • image/png - PNG images (safe, universal compatibility)
      • image/jpeg (and image/jpg) - JPEG images (safe, universal compatibility)

      Clients that support rendering icons SHOULD also support:

      • image/svg+xml - SVG images (scalable but requires security precautions)
      • image/webp - WebP images (modern, efficient format)

    • name: string

      Intended for programmatic or logical use, but used as a display name in past specs or fallback

    • Optionaltitle?: string

      Intended for UI and end-user contexts — optimized to be human-readable and easily understood, even by those unfamiliar with domain-specific terminology.

      If not provided, the name should be used for display (except for Tool, where annotations.title should be given precedence over using name, if present).

    • version: string

    • OptionalwebsiteUrl?: string

      An optional URL of the website for this implementation.

  • Optionaloptions: ServerOptions

  Returns McpServer

Readonlyserver

experimental

• get experimental(): { tasks: ExperimentalMcpServerTasks }
  Experimental

  Access experimental features.

  WARNING: These APIs are experimental and may change without notice.

  Returns { tasks: ExperimentalMcpServerTasks }

close

• close(): Promise<void>

  Closes the connection.

  Returns Promise<void>

connect

• connect(transport: Transport): Promise<void>

  Attaches to the given transport, starts it, and starts listening for messages.

  The server object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.

  Parameters

  • transport: Transport

  Returns Promise<void>

  Example

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

isConnected

• isConnected(): boolean

  Checks if the server is connected to a transport.

  Returns boolean

  true if the server is connected

registerPrompt

• registerPrompt<Args extends AnySchema>(
      name: string,
      config: { argsSchema?: Args; description?: string; title?: string },
      cb: PromptCallback<Args>,
  ): RegisteredPrompt

  Registers a prompt with a config object and callback.

  Type Parameters

  • Args extends AnySchema

  Parameters

  • name: string
  • config: { argsSchema?: Args; description?: string; title?: string }
  • cb: PromptCallback<Args>

  Returns RegisteredPrompt

  Example

  server.registerPrompt(
      'review-code',
      {
          title: 'Code Review',
          description: 'Review code for best practices',
          argsSchema: z.object({ code: z.string() })
      },
      ({ code }) => ({
          messages: [
              {
                  role: 'user' as const,
                  content: {
                      type: 'text' as const,
                      text: `Please review this code:\n\n${code}`
                  }
              }
          ]
      })
  );
  Copy

registerResource

• registerResource(
      name: string,
      uriOrTemplate: string,
      config: ResourceMetadata,
      readCallback: ReadResourceCallback,
  ): RegisteredResource

  Registers a resource with a config object and callback. For static resources, use a URI string. For dynamic resources, use a ResourceTemplate.

  Parameters

  • name: string
  • uriOrTemplate: string
  • config: ResourceMetadata
  • readCallback: ReadResourceCallback

  Returns RegisteredResource

  Example

  server.registerResource(
      'config',
      'config://app',
      {
          title: 'Application Config',
          mimeType: 'text/plain'
      },
      async uri => ({
          contents: [{ uri: uri.href, text: 'App configuration here' }]
      })
  );
  Copy

• registerResource(
      name: string,
      uriOrTemplate: ResourceTemplate,
      config: ResourceMetadata,
      readCallback: ReadResourceTemplateCallback,
  ): RegisteredResourceTemplate

  Registers a resource with a config object and callback. For static resources, use a URI string. For dynamic resources, use a ResourceTemplate.

  Parameters

  • name: string
  • uriOrTemplate: ResourceTemplate
  • config: ResourceMetadata
  • readCallback: ReadResourceTemplateCallback

  Returns RegisteredResourceTemplate

  Example

  server.registerResource(
      'config',
      'config://app',
      {
          title: 'Application Config',
          mimeType: 'text/plain'
      },
      async uri => ({
          contents: [{ uri: uri.href, text: 'App configuration here' }]
      })
  );
  Copy

registerTool

• registerTool<
      OutputArgs extends AnySchema,
      InputArgs extends AnySchema | undefined = undefined,
  >(
      name: string,
      config: {
          _meta?: Record<string, unknown>;
          annotations?: {
              destructiveHint?: boolean;
              idempotentHint?: boolean;
              openWorldHint?: boolean;
              readOnlyHint?: boolean;
              title?: string;
          };
          description?: string;
          inputSchema?: InputArgs;
          outputSchema?: OutputArgs;
          title?: string;
      },
      cb: BaseToolCallback<
          {
              _meta?: {
                  "io.modelcontextprotocol/related-task"?: { taskId: string };
                  progressToken?: string | number;
                  [key: string]: unknown;
              };
              content: (
                  | {
                      _meta?: { [key: string]: unknown };
                      annotations?: {
                          audience?: ("user" | "assistant")[];
                          lastModified?: string;
                          priority?: number;
                      };
                      text: string;
                      type: "text";
                  }
                  | {
                      _meta?: { [key: string]: unknown };
                      annotations?: {
                          audience?: ("user" | "assistant")[];
                          lastModified?: string;
                          priority?: number;
                      };
                      data: string;
                      mimeType: string;
                      type: "image";
                  }
                  | {
                      _meta?: { [key: string]: unknown };
                      annotations?: {
                          audience?: ("user" | "assistant")[];
                          lastModified?: string;
                          priority?: number;
                      };
                      data: string;
                      mimeType: string;
                      type: "audio";
                  }
                  | {
                      _meta?: { [key: string]: unknown };
                      annotations?: {
                          audience?: ("user" | "assistant")[];
                          lastModified?: string;
                          priority?: number;
                      };
                      resource: | {
                          _meta?: { [key: string]: unknown };
                          mimeType?: string;
                          text: string;
                          uri: string;
                      }
                      | {
                          _meta?: { [key: string]: unknown };
                          blob: string;
                          mimeType?: string;
                          uri: string;
                      };
                      type: "resource";
                  }
                  | {
                      _meta?: { [key: string]: unknown };
                      annotations?: {
                          audience?: ("user" | "assistant")[];
                          lastModified?: string;
                          priority?: number;
                      };
                      description?: string;
                      icons?: {
                          mimeType?: string;
                          sizes?: string[];
                          src: string;
                          theme?: "light"
                          | "dark";
                      }[];
                      mimeType?: string;
                      name: string;
                      title?: string;
                      type: "resource_link";
                      uri: string;
                  }
              )[];
              isError?: boolean;
              structuredContent?: { [key: string]: unknown };
              [key: string]: unknown;
          },
      >,
  ): RegisteredTool

  Registers a tool with a config object and callback.

  Type Parameters

  • OutputArgs extends AnySchema
  • InputArgs extends AnySchema | undefined = undefined

  Parameters

  • name: string
  • config: {
        _meta?: Record<string, unknown>;
        annotations?: {
            destructiveHint?: boolean;
            idempotentHint?: boolean;
            openWorldHint?: boolean;
            readOnlyHint?: boolean;
            title?: string;
        };
        description?: string;
        inputSchema?: InputArgs;
        outputSchema?: OutputArgs;
        title?: string;
    }
  • cb: BaseToolCallback<
        {
            _meta?: {
                "io.modelcontextprotocol/related-task"?: { taskId: string };
                progressToken?: string | number;
                [key: string]: unknown;
            };
            content: (
                | {
                    _meta?: { [key: string]: unknown };
                    annotations?: {
                        audience?: ("user" | "assistant")[];
                        lastModified?: string;
                        priority?: number;
                    };
                    text: string;
                    type: "text";
                }
                | {
                    _meta?: { [key: string]: unknown };
                    annotations?: {
                        audience?: ("user" | "assistant")[];
                        lastModified?: string;
                        priority?: number;
                    };
                    data: string;
                    mimeType: string;
                    type: "image";
                }
                | {
                    _meta?: { [key: string]: unknown };
                    annotations?: {
                        audience?: ("user" | "assistant")[];
                        lastModified?: string;
                        priority?: number;
                    };
                    data: string;
                    mimeType: string;
                    type: "audio";
                }
                | {
                    _meta?: { [key: string]: unknown };
                    annotations?: {
                        audience?: ("user" | "assistant")[];
                        lastModified?: string;
                        priority?: number;
                    };
                    resource: | {
                        _meta?: { [key: string]: unknown };
                        mimeType?: string;
                        text: string;
                        uri: string;
                    }
                    | {
                        _meta?: { [key: string]: unknown };
                        blob: string;
                        mimeType?: string;
                        uri: string;
                    };
                    type: "resource";
                }
                | {
                    _meta?: { [key: string]: unknown };
                    annotations?: {
                        audience?: ("user" | "assistant")[];
                        lastModified?: string;
                        priority?: number;
                    };
                    description?: string;
                    icons?: {
                        mimeType?: string;
                        sizes?: string[];
                        src: string;
                        theme?: "light"
                        | "dark";
                    }[];
                    mimeType?: string;
                    name: string;
                    title?: string;
                    type: "resource_link";
                    uri: string;
                }
            )[];
            isError?: boolean;
            structuredContent?: { [key: string]: unknown };
            [key: string]: unknown;
        },
    >

  Returns RegisteredTool

  Example

  server.registerTool(
      'calculate-bmi',
      {
          title: 'BMI Calculator',
          description: 'Calculate Body Mass Index',
          inputSchema: z.object({
              weightKg: z.number(),
              heightM: z.number()
          }),
          outputSchema: z.object({ bmi: z.number() })
      },
      async ({ weightKg, heightM }) => {
          const output = { bmi: weightKg / (heightM * heightM) };
          return {
              content: [{ type: 'text', text: JSON.stringify(output) }],
              structuredContent: output
          };
      }
  );
  Copy

sendLoggingMessage

• sendLoggingMessage(
      params: {
          _meta?: {
              "io.modelcontextprotocol/related-task"?: { taskId: string };
              progressToken?: string | number;
              [key: string]: unknown;
          };
          data: unknown;
          level: | "debug"
          | "error"
          | "info"
          | "notice"
          | "warning"
          | "critical"
          | "alert"
          | "emergency";
          logger?: string;
      },
      sessionId?: string,
  ): Promise<void>

  Sends a logging message to the client, if connected. Note: You only need to send the parameters object, not the entire JSON-RPC message.

  Parameters

  • params: {
        _meta?: {
            "io.modelcontextprotocol/related-task"?: { taskId: string };
            progressToken?: string | number;
            [key: string]: unknown;
        };
        data: unknown;
        level: | "debug"
        | "error"
        | "info"
        | "notice"
        | "warning"
        | "critical"
        | "alert"
        | "emergency";
        logger?: string;
    }

    • Optional_meta?: {
          "io.modelcontextprotocol/related-task"?: { taskId: string };
          progressToken?: string | number;
          [key: string]: unknown;
      }

      See MCP specification for notes on _meta usage.

      • Optionalio.modelcontextprotocol/related-task?: { taskId: string }

        If specified, this request is related to the provided task.

      • OptionalprogressToken?: string | number

        If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.

    • data: unknown

      The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.

    • level:
          | "debug"
          | "error"
          | "info"
          | "notice"
          | "warning"
          | "critical"
          | "alert"
          | "emergency"

      The severity of this log message.

    • Optionallogger?: string

      An optional name of the logger issuing this message.

  • OptionalsessionId: string

    Optional for stateless transports and backward compatibility.

  Returns Promise<void>

  See

  LoggingMessageNotification

  Example

  await server.sendLoggingMessage({
      level: 'info',
      data: 'Processing complete'
  });
  Copy

sendPromptListChanged

• sendPromptListChanged(): void

  Sends a prompt list changed event to the client, if connected.

  Returns void

sendResourceListChanged

• sendResourceListChanged(): void

  Sends a resource list changed event to the client, if connected.

  Returns void

sendToolListChanged

• sendToolListChanged(): void

  Sends a tool list changed event to the client, if connected.

  Returns void