Fastmcp

🚀 FastMCP Quick Start Guide

FastMCP is a TypeScript framework for rapidly developing MCP (Model Context Protocol) servers. It simplifies the integration with various LLMs and supports multiple advanced features.

📦 Installation

To start using FastMCP, follow these installation steps:

1. First, install FastMCP via npm:

npm install fastmcp --save

2. Create a new file named server.ts and add the following code:

import { createServer } from 'fastmcp';

const server = createServer();

// Add custom routes
server.get('/ping', (req, res) => {
  res.send('pong');
});

server.start(3000);

3. Run the server:

ts-node server.ts

✨ Features

• Easy to Use: Quickly build custom MCP services through an intuitive API and middleware system.
• High Performance: Built - in efficient request handling mechanism ensures low latency and high throughput.
• Scalability: Supports a plugin system, allowing easy addition of custom features.
• Cross - platform Compatibility: Supports multiple operating systems and environments.

💻 Usage Examples

Basic Usage

The following is a simple example showing how to create a basic MCP server:

import { createServer } from 'fastmcp';

const server = createServer();

// Handle root path requests
server.get('/', (req, res) => {
  res.send('Welcome to FastMCP Server!');
});

// Start the server
server.start(3000);

Advanced Usage

Configuration Options

FastMCP provides a rich set of configuration options to meet different needs:

• Port Configuration:

server.start({
  port: 3001,
});

• Logging:

server.configure({
  loggingLevel: 'debug',
});

Middleware Example

import { createServer, Middleware } from 'fastmcp';

const server = createServer();

// Create a simple middleware
const loggerMiddleware: Middleware = (req, res, next) => {
  console.log('Request started:', req.url);
  next();
};

// Apply the middleware to all requests
server.use(loggerMiddleware);

server.get('/', (req, res) => {
  res.send('Hello World!');
});

server.start(3000);

Routing Example

import { createServer } from 'fastmcp';

const server = createServer();

// Define routes to handle different request types
server.get('/api/data', (req, res) => {
  // Return JSON data
  res.json({ message: 'Data fetched successfully!' });
});

server.post('/api/upload', async (req, res) => {
  // Handle file upload
  const uploadedFile = await req.file();
  res.send(`File ${uploadedFile.name} uploaded successfully!`);
});

server.start(3001);

📚 Documentation

API Reference

Server Class

• start(port: number)
  • Start the server and specify the port to listen on.
• get(path: string, handler: (req, res) => void)
  • Add a new GET route.
• post(path: string, handler: (req, res) => void)
  • Add a new POST route.

Middleware

• Type Definition:

type Middleware = (
  req: Request,
  res: Response,
  next: () => void
) => void;

Development Guide

Creating Custom Middleware

FastMCP allows you to create custom middleware to extend server functionality:

import { createServer, Middleware } from 'fastmcp';

const server = createServer();

// Custom logging middleware
const logger: Middleware = (req, res, next) => {
  console.log(`Received request: ${req.method} ${req.url}`);
  next();
};

server.use(logger);

server.get('/', (req, res) => {
  res.send('Hello World!');
});

server.start(3002);

Using Plugins

FastMCP's plugin system allows you to quickly extend server functionality. For example, add authentication, logging, etc.:

import { createServer } from 'fastmcp';
import { cors } from 'fastmcp/plugins/cors';

const server = createServer();

// Enable the CORS plugin
server.use(cors());

server.get('/api/test', (req, res) => {
  res.send('CORS is enabled!');
});

server.start(3003);

Common Issues

How to Handle Errors?

You can use middleware to catch and handle errors:

import { createServer, Middleware } from 'fastmcp';

const server = createServer();

// Error handling middleware
const errorHandler: Middleware = (req, res, next) => {
  try {
    next();
  } catch (err) {
    console.error('An error occurred:', err);
    res.status(500).send('Internal Server Error');
  }
};

server.use(errorHandler);

server.get('/test/error', () => {
  throw new Error('Test error handling');
});

server.start(3004);

Quick Start

Install Dependencies

npm install fastmcp --save

Create Project Structure

your-project/
├── package.json
├── tsconfig.json
└── src/
    └── server.ts

Initialize Configuration

Add the following content to tsconfig.json to enable TypeScript support:

{
  "compilerOptions": {
    "target": "ES6",
    "module": "CommonJS"
  }
}

Run the Server

ts-node src/server.ts

Other Resources

• GitHub Repository: fastmcp/fastmcp
• Discord Community: Join the FastMCP Discussion Group for support and communication.
• Developer Blog: Read the FastMCP Development Log to stay updated.

With FastMCP, you can quickly build efficient, reliable, and easily extensible MCP servers. Start your project now!