What is Mcp Serverless

mcp-serverless is a serverless implementation of the Model Context Protocol (MCP) architecture that facilitates tool management through a clean and efficient interface.

Use cases

Use cases include creating custom tools for arithmetic operations, managing tool requests in a serverless environment, and integrating with other services that require secure API key validation.

How to use

To use mcp-serverless, install it via npm with ‘npm install @tilfin/mcp-serverless’. Then, create a ToolManager to register tools and use the createService function to set up an in-memory client-server connection for handling tool requests.

Key features

Key features include tool registration and management, handling tool-related requests, creating in-memory client-server connections, and extending requests with context for credential transmission.

Where to use

mcp-serverless can be used in various domains such as software development, automation tools, and any application requiring dynamic tool management and execution.

MCP Serverless

A serverless implementation for the Model Context Protocol (MCP) architecture that enables tool management through a clean interface.

Overview

This package provides a serverless implementation of the MCP server that allows you to:

• Register and manage tools
• Handle tool-related requests
• Create in-memory client-server connections
• Extend request with context to enable credential transmission from clients

Installation

npm install @tilfin/mcp-serverless

Usage

Tool Registration and create a client for service implements

import { createService, ToolManager } from '@tilfin/mcp-serverless';

// Create a tool manager
const toolManager = new ToolManager();

// Register tools
toolManager.registerTools([
  {
    name: 'calculator',
    description: 'Performs basic arithmetic operations',
    inputSchema: {
      type: 'object',
      properties: {
        operation: { type: 'string' },
        numbers: { type: 'array', items: { type: 'number' } }
      },
      required: ['operation', 'numbers']
    },
    toolFunction: async (params, ctx) => {
      if (ctx.apiKey !== 'xyz') throw new Error('Invalid API Key');

      let result;
      if (params.operation === 'add') {
        result = params.numbers.reduce((sum, n) => sum + n, 0);
      }
      return { result };
    }
  }
]);

// Create a serverless client
const client = createService(toolManager);

// List available tools
const toolsList = await client.listTools();

// Call a tool
try {
  const result = await client.callTool({
    name: 'calculator',
    arguments: {
      operation: 'add',
      numbers: [1, 2, 3]
    }
  });
} catch (err) {
  // raise Invalid API Key error
}

// Call a tool with context
const result = await client.callTool({
  name: 'calculator',
  arguments: {
    operation: 'add',
    numbers: [1, 2, 3]
  },
  ctx: { apiKey: 'xyz' }
});

API Reference

ToolManager class

Manages the registration and handling of tools.

Tool Interface

Tools must implement the following interface:

interface Tool {
  name: string;
  description: string;
  inputSchema: ToolInput;
  toolFunction: (args: CallToolRequestArguments, ctx: CallToolRequestContext) => Promise<CallToolResultContent>;
}

createServer(serverInfo, toolManager)

Creates an MCP server with the given tool manager.

createService(toolManager)

Creates an in-memory client-server setup for serverless operation.

Examples

Standard I/O Transport

The package includes examples for using the stdio transports for both client and server communication:

• StdioClientTransport: Allows clients to communicate with servers over standard input/output
• StdioServerTransport: Enables servers to handle requests through standard input/output

Check out the example implementation:

• Client: stdio_client.mjs
• Server: stdio_server.mjs