Boot MCP

🚀 boot-mcp

[![npm Version][npm-version-src]][npm-version-href] [![npm Downloads][npm-downloads-src]][npm-downloads-href] [![Bundle][bundle-src]][bundle-href] [![JSDocs][jsdocs-src]][jsdocs-href] [![License][license-src]][license-href] [![JavaScript Code Style][code-style-image]][code-style-url]

A comprehensive starter template for building Model Context Protocol (MCP) applications with TypeScript.

🚀 Quick Start

This template includes examples of MCP servers with different transports:

• Stdio transport (for command-line tools and direct integrations)
• HTTP transport with SSE (for remote servers)

Running Example Servers

# Start the basic stdio server
pnpm start:basic

# Start the HTTP server
pnpm start:http

✨ Features

Resources

• Support for text and binary resources
• Dynamic resources with tools
• Standard resource types (e.g., text, JSON)
• Factory functions to create custom resources
• Resource access within the context

Tools

• Command execution tools with context
• Toolchain implementation
• Laboratory environment configuration
• Dynamic tool loading and unloading

Prompts

• Template strings for prompts
• Support for template extensions
• Context variable injection
• Prompt history
• Callback support

Roots

• Context root definition
• Standard context attributes
• Dynamic context extension
• Parent-child context inheritance
• Context sequence management

Transports

• Standard transport implementations (e.g., HTTP)
• Custom transport development
• Transport protocol standardization
• Transport performance optimization
• Transport logging and tracing

Sampling

• LLM request completion
• Sampling with context
• Sampling result processing
• Sampling strategy implementation
• Multilingual support

📦 Installation

# npm
npm install

# pnpm
pnpm install

# yarn
yarn install

📚 Documentation

What is MCP?

Model Context Protocol (MCP) allows you to build servers that provide data and functionality to LLM applications in a secure and standardized way. Imagine it as a Web API, but specifically designed for LLM interactions. An MCP server can:

• Expose data through Resources (similar to GET endpoints; they are used to load information into the LLM's context)
• Provide functionality through Tools (similar to POST endpoints; they are used to execute code or produce side effects)
• Define interaction patterns through Prompts (reusable templates for LLM interactions)
• Define the scope of operation of the server through Roots
• Enable proxy behavior through Sampling (allowing the server to request completions from the LLM)
• Establish a connection through Transports (the communication mechanism between the client and the server)

🔧 Technical Details

Project Structure

boot-mcp/
├── src/
│   ├── index.ts          # Main entry point
│   ├── server/           # MCP server implementation
│   │   ├── basic.ts      # Basic server with common functionality
│   │   └── http.ts       # HTTP transport server with SSE
│   ├── resources/        # Resource implementation
│   │   └── index.ts      # Various standard resource types and tools
│   ├── tools/            # Tool implementation
│   │   └── index.ts      # Various tools organized by category
│   ├── prompts/          # Prompt implementation
│   │   └── index.ts      # Common prompt templates and workflows
│   ├── roots/            # Root management
│   │   └── index.ts      # Root definition and tools
│   ├── transports/       # Transport implementation
│   │   └── index.ts      # Stdio and HTTP/SSE transports
│   └── sampling/         # Sampling utilities (experimental)
│       └── index.ts      # LLM sampling functionality
├── examples/             # Example usage
│   ├── basic-server.ts   # Example of a basic stdio server
│   └── http-server.ts    # Example of an HTTP server
└── test/                 # Tests

📄 License

MIT License