trackmcp
Back to directory
s2005

mcp-everything

View on GitHub

MCP server that exercises all the features of the MCP protocol

0 stars PythonOthers Updated May 23, 2025

Documentation

MCP Everything

Note: This project was extracted from https://github.com/modelcontextprotocol/servers/tree/main/src/everything to create a standalone implementation.

This MCP server project demonstrates various features of the Model Context Protocol (MCP). It includes server implementations in TypeScript and Python, serving as test servers for MCP client builders. Both implementations aim for functional parity, showcasing capabilities like prompts, tools, resources, sampling, logging, and more.

Common Features

Tools

1. `echo`

    2. `add`

      3. `longRunningOperation`

        4. `sampleLLM`

          5. `getTinyImage`

            6. `printEnv`

              7. `annotatedMessage`

                Resources

                The server provides 100 test resources in two formats:

                • Even numbered resources:
                  • Plaintext format
                  • URI pattern: `test://static/resource/{even_number}`
                  • Content: Simple text description
                • Odd numbered resources:
                  • Binary blob format
                  • URI pattern: `test://static/resource/{odd_number}`
                  • Content: Base64 encoded binary data

                Resource features:

                • Supports pagination (10 items per page)
                • Allows subscribing to resource updates
                • Demonstrates resource templates
                • Auto-updates subscribed resources every 5 seconds

                Prompts

                1. `simple_prompt`

                  2. `complex_prompt`

                    Logging

                    The server sends random-leveled log messages every 15 seconds to demonstrate the logging capabilities of MCP.

                    TypeScript Implementation

                    Location: `typescript/`

                    Installation

                    Local Development

                    bash
                    # Clone the repository (if not already done)
                    # git clone https://github.com/modelcontextprotocol/mcp-everything.git
                    # cd mcp-everything
                    
                    # Navigate to the TypeScript directory from the repository root
                    cd typescript
                    
                    # Install dependencies
                    npm install
                    
                    # Build the project
                    npm run build
                    
                    # Start the server
                    npm start

                    Global Installation

                    bash
                    # Navigate to the TypeScript directory:
                    # cd path/to/mcp-everything/typescript
                    # Then install globally from the local package:
                    npm install -g .
                    
                    # Run the server 
                    # (The command name will depend on the 'bin' field in typescript/package.json, 
                    #  e.g., 'mcp-everything-ts' or 'mcp-everything' if modified)
                    # Example:
                    # mcp-everything-ts

                    *Note: Global installation functionality and the exact command depend on the `bin` configuration within `typescript/package.json`.*

                    Docker

                    bash
                    # Build the Docker image from the repository root
                    # (Assumes Dockerfile is updated to handle APP_DIR build argument or typescript context)
                    docker build -t mcp-everything-ts -f Dockerfile . --build-arg APP_DIR=typescript
                    
                    # Run the container
                    docker run -it mcp-everything-ts

                    Usage with MCP Clients (e.g., Claude Desktop)

                    Add to your client's MCP server configuration. Paths might need adjustment.

                    If using `npx` with a published package (e.g., `mcp-everything-ts`):

                    json
                    {
                      "mcpServers": {
                        "everything-ts-npx": {
                          "command": "npx",
                          "args": [
                            "-y",
                            "mcp-everything-ts" 
                            // Replace 'mcp-everything-ts' with the actual package name if different
                          ]
                        }
                      }
                    }

                    If running from a local build (ensure `cwd` is the `typescript` directory):

                    json
                    {
                      "mcpServers": {
                        "everything-ts-local": {
                          "command": "npm",
                          "args": [
                            "start"
                          ],
                          // Ensure 'cwd' points to the 'typescript' directory of this project.
                          "cwd": "path/to/mcp-everything/typescript" 
                        }
                      }
                    }

                    Replace `"path/to/mcp-everything/typescript"` with the correct path.


                    Python Implementation

                    Location: `python/`

                    Installation & Setup

                    1. From the repository root, navigate to the Python directory:

                    bash
                    cd python

                    2. (Recommended) Create and activate a virtual environment:

                    bash
                    python -m venv venv
                        source venv/bin/activate  # On Windows: venv\Scripts\activate

                    3. Install dependencies:

                    bash
                    pip install -r requirements.txt

                    Running the Server

                    From within the `python` directory (and with the virtual environment activated if used):

                    bash
                    python mcp_server.py

                    The server listens for MCP messages over stdio.

                    Usage with MCP Clients (e.g., Claude Desktop)

                    Example configuration:

                    json
                    {
                      "mcpServers": {
                        "everything-py": {
                          "command": "python", // Or "path/to/python/venv/bin/python"
                          "args": ["mcp_server.py"],
                          "cwd": "path/to/mcp-everything/python" // Ensure this is the correct path
                        }
                      }
                    }

                    Replace `"path/to/mcp-everything/python"` with the correct path.

                    Testing the Server via GitHub Actions

                    >Note: Implementation is in progress. The server is not yet fully functional.

                    • Test 1
                    • Test 2

                    Frequently asked questions

                    What is mcp-everything?

                    mcp-everything is MCP server that exercises all the features of the MCP protocol

                    How do I install mcp-everything?

                    Open the GitHub repository and follow its README. Most MCP servers are added to your client's MCP config, then called by your agent.

                    Is mcp-everything open source?

                    Yes — it is hosted on GitHub at https://github.com/s2005/mcp-everything.

                    Related MCP tools

                    Run your own MCP server? See who uses it and what to fix.

                    Measure it with TrackMCP