📌Overview

Purpose: LiteMCP is designed to simplify the process of building Model Context Protocol (MCP) servers using TypeScript.

Overview: LiteMCP provides an elegant framework for developers to create and manage MCP servers efficiently. It supports a variety of features including tools, resources, and logging, ensuring robust server functionalities tailored for integration with Large Language Models (LLMs).

Key Features:

Simple Tool, Resource, Prompt Definition: Easily define interactive tools and resources that clients can invoke, allowing for straightforward integration of complex functionalities.
Full TypeScript Support: Built with TypeScript, ensuring type safety and enhancing the development experience with better IDE support and error checking.
Built-in Logging: Incorporates a robust logging mechanism to track server activities, helping in debugging and monitoring the server's behavior.
Error Handling: Features built-in error handling, ensuring that server failures are managed gracefully without disrupting user experience.
Built-in CLI for Testing and Debugging: Provides a command-line interface (CLI) for rapid testing of the server, facilitating the development workflow.
SSE Transport Support: Allows servers to communicate over Server-Sent Events (SSE), enabling real-time updates to clients in an efficient manner.

LiteMCP

A TypeScript framework for building MCP (Model Context Protocol) servers elegantly.

Features

Simple Tool, Resource, Prompt definition
Full TypeScript support
Built-in logging
Built-in error handling
Built-in CLI for testing and debugging
Built-in support for SSE transport

Installation

npm install litemcp zod

Quickstart

import { LiteMCP } from "litemcp";
import { z } from "zod";

const server = new LiteMCP("demo", "1.0.0");

server.addTool({
  name: "add",
  description: "Add two numbers",
  parameters: z.object({
    a: z.number(),
    b: z.number(),
  }),
  execute: async (args) => {
    return args.a + args.b;
  },
});

server.addResource({
  uri: "file:///logs/app.log",
  name: "Application Logs",
  mimeType: "text/plain",
  async load() {
    return {
      text: "Example log content",
    };
  },
});

server.start();

You can test the server in terminal with:

npx litemcp dev server.js

Core Concepts

Tools

Tools in MCP allow servers to expose executable functions that clients and LLMs can invoke to perform actions.

server.addTool({
  name: "fetch",
  description: "Fetch the content of a url",
  parameters: z.object({
    url: z.string(),
  }),
  execute: async (args) => {
    const content = await fetchWebpageContent(args.url);
    return content;
  },
});

Resources

Resources represent any kind of data that an MCP server wants to make available to clients, such as file contents, screenshots, images, log files, and more.

Each resource is identified by a unique URI and can contain either text or binary data.

server.addResource({
  uri: "file:///logs/app.log",
  name: "Application Logs",
  mimeType: "text/plain",
  async load() {
    return {
      text: await readLogFile(),
    };
  },
});

Binary content can also be returned in load:

async load() {
  return {
    blob: 'base64-encoded-data'
  }
}

Prompts

Prompts allow servers to define reusable prompt templates and workflows that clients can easily surface to users and LLMs, standardizing common LLM interactions.

server.addPrompt({
  name: "git-commit",
  description: "Generate a Git commit message",
  arguments: [
    {
      name: "changes",
      description: "Git diff or description of changes",
      required: true,
    },
  ],
  load: async (args) => {
    return `Generate a concise but descriptive commit message for these changes:\n\n${args.changes}`;
  },
});

Logging

You can send log messages to the client with server.logger.

Example:

server.addTool({
  name: "download",
  description: "Download a file from a url",
  parameters: z.object({
    url: z.string(),
  }),
  execute: async (args) => {
    server.logger.info("Downloading file", { url: args.url });
    // ...
    server.logger.info("Downloaded file", { url: args.url });
    return response;
  },
});

The logger object supports these methods:

debug(message: string, context?: JsonValue)
info(message: string, context?: JsonValue)
warn(message: string, context?: JsonValue)
error(message: string, context?: JsonValue)

Running Your Server

Debugging with mcp-cli

The fastest way to test and debug your server is with mcp-cli:

npx litemcp dev server.js
npx litemcp dev server.ts

This runs your server with mcp-cli for terminal testing and debugging.

Inspect with MCP Inspector

You can also use the official MCP Inspector to inspect your server with a Web UI:

npx litemcp inspect server.js

SSE Transport

Servers run with stdio transport by default. You can run the server with SSE mode:

server.start({
  transportType: "sse",
  sse: {
    endpoint: "/sse",
    port: 8080,
  },
});

This starts the server listening for SSE connections on http://localhost:8080/sse.

You can connect to the server with SSE transport in the client.

Showcase

If you've developed a server using LiteMCP, please submit a PR to showcase it here!

Roadmap

Add support for Resource Templates

mcp-cli - A CLI for testing and debugging MCP servers
mcpservers.org - A curated list of MCP servers
FastMCP - A Python library for MCP server development, inspiration for this project

litemcp