Universal MCP Development Kit (MCP-UDK)

Provenance: This module has been decoupled from the main repository found at https://github.com/modelcontextprotocol/servers/tree/main/src/everything to function as a self-contained verification server.

This server project serves as a full demonstration suite for the Model Context Protocol (MCP) specifications. It includes dual implementations—TypeScript and Python—intended to act as reference test harnesses for developers building MCP-compliant consumers. Both language versions strive for feature equivalence, showcasing core capabilities such as tool invocation, resource retrieval, prompt templating, data sampling, and system telemetry reporting.

Core Functionality Showcase

Integrated Tools

1. echoService
2. Utility to mirror input payloads back to the caller.
3. Input:
   • content (string): The payload to be reflected.

4. Output: Textual confirmation containing the echoed data.

5. numericSummation

6. Performs the addition of two numerical inputs.
7. Inputs:
   • operand1 (number): The first operand.
   • operand2 (number): The second operand.

8. Output: A string detailing the resulting sum.

9. delayedExecutionMonitor

10. Simulates an extended background task, emitting periodic status updates.
11. Inputs:
    • delaySec (number, default: 10): Target duration in seconds.
    • intervals (number, default: 5): Number of intermediate progress reports.
12. Output: Finalization confirmation upon completion.

13. Mechanism: Transmits real-time progress telemetry.

14. llmSampler

15. Invokes the internal MCP sampling pipeline to generate model output.
16. Inputs:
    • inputQuery (string): The text sequence provided to the underlying model.
    • maxOutputLength (number, default: 100): Token budget constraint.

17. Output: The synthesized response text from the language model.

18. retrieveTestImage

19. Provides a small, standardized raster image asset.
20. Inputs: None.

21. Output: Image data encoded in Base64 PNG format.

22. systemEnvironmentDump

23. Outputs the current configuration variables of the host process.
24. Utility for verifying server startup parameters.
25. Inputs: None.

26. Output: A serialized JSON object representing all active environment variables.

27. metadataEnrichment

28. Illustrates how contextual metadata (annotations) can tag generated content.
29. Inputs:
    • severityLevel (enum: "error" | "success" | "debug" | "info" ): Defines the metadata category.
    • embedAsset (boolean, default: false): Flag to include a sample image asset with annotations.
30. Output: Content structured with varying annotation layers.

Static Artifacts (Resources)

The server hosts a collection of 100 distinct artifact references accessible via the test://static/resource/ scheme, presented in two alternating formats: - Even Indexes: Text-based assets (MIME type implied: text/plain). - URI Format: test://static/resource/{even_id} - Content: Descriptive textual metadata. - Odd Indexes: Binary payload assets (MIME type implied: application/octet-stream). - URI Format: test://static/resource/{odd_id} - Content: Raw binary data serialized via Base64.

Resource features supported: - Iterative retrieval across pages (10 items per page capacity). - Mechanisms for subscribing to asynchronous content modifications. - Demonstration of URI template substitution. - Automated artifact refreshment cycle occurring every 5 seconds for subscribers.

Prompt Templates

1. standard_query
2. Simple template requiring no runtime arguments.

3. Output: A singular exchange message.

4. parameterized_flow

5. Advanced template demonstrating dynamic runtime argument injection.
6. Required Parameters:
   • setting_temp (number): Controls generation stochasticity.
7. Optional Parameters:
   • output_genre (string): Dictates the stylistic constraints of the response.
8. Output: A multi-turn conversational sequence potentially including embedded media.

Telemetry & Diagnostics

The server actively injects diagnostic status reports at regular 15-second intervals, utilizing various severity levels to stress-test the client's MCP logging ingestion pipeline.

TypeScript Runtime Implementation

Source Path: typescript/

Setup Procedures

Local Development Environment

bash

Initial repository checkout (if necessary)

git clone

cd mcp-everything

Change directory into the TS module folder

cd typescript

Install Node dependencies

npm install

Compile source code

npm run build

Execute the server instance

npm start

System-Wide Installation (Global Mode)

bash

Navigate to the module root folder:

cd path/to/mcp-everything/typescript

Install the package globally from the local source tree:

npm install -g .

Launch the executable (The actual command name is defined in typescript/package.json's 'bin' section)

Example command structure:

mcp-server-ts-executable

Global execution command fidelity relies entirely on the configuration specified in typescript/package.json.

Containerized Deployment (Docker)

bash

Build the image, specifying the source directory context at the root level:

docker build -t mcp-server-ts -f Dockerfile . --build-arg APP_DIR=typescript

Initiate the container

docker run -it mcp-server-ts

Client Configuration Integration (e.g., Desktop Clients)

Integrate the following block into your MCP client's configuration file. Path variables must be adjusted to point correctly.

If utilizing a published NPM package via npx:

{ "mcpGateways": { "universal-ts-runner": { "executor": "npx", "arguments": [ "-y", "mcp-server-ts-executable" // Substitute with the actual globally installed package name ] } } }

If executing from a locally compiled instance (ensure execution context cwd aligns with the typescript folder):

{ "mcpGateways": { "universal-ts-local": { "executor": "npm", "arguments": [ "start" ], "workingDirectory": "/absolute/path/to/mcp-everything/typescript" } } }

Ensure /absolute/path/to/mcp-everything/typescript is replaced with the actual path location.

---

Python Runtime Implementation

Source Path: python/

Initialization & Environment Setup

1. From the project root, change directory to the Python module folder: bash cd python

2. (Recommended Practice) Provision and activate a sandboxed Python environment: bash python -m venv .venv source .venv/bin/activate # For Windows users: .venv\Scripts\activate

3. Install required dependencies listed in the manifest: bash pip install -r requirements.txt

Server Execution

Execute the primary server script while inside the python directory (ensure the virtual environment is active if one was created): bash python core_service.py

This server instance communicates with MCP consumers primarily via standard input/output streams (stdio).

Client Configuration Snippet (Python Endpoint)

Configuration example for standard MCP clients:

{ "mcpGateways": { "universal-py-stdio": { "executor": "python", // Or full path to the interpreter in the virtual environment "arguments": ["core_service.py"], "workingDirectory": "/path/to/mcp-everything/python" // Must point correctly } } }

Update the workingDirectory field to match the physical location of the Python source files.

Automated Verification (CI/CD)

• Status: Under active development.

• Verification Run Alpha

• Verification Run Beta

WIKIPEDIA CONTEXT: The XMLHttpRequest (XHR) is a standardized JavaScript interface allowing web applications to dispatch HTTP requests asynchronously from the active document context back to a target web server. This capability is central to the implementation of Asynchronous JavaScript and XML (Ajax), enabling dynamic content updates without full page reloads, which was the prevalent method before XHR.

== Historical Context == The foundational concept originated around 2000 within Microsoft's development team for Outlook. It was first integrated into Internet Explorer 5 (1999), though it initially employed proprietary object instantiation syntax (e.g., ActiveXObject("Msxml2.XMLHTTP")). By the release of Internet Explorer 7 (2006), the standardized XMLHttpRequest identifier became universally supported across major browser engines, including Mozilla's Gecko (2002), Safari 1.2 (2004), and Opera 8.0 (2005).

=== Standardization Path === The World Wide Web Consortium (W3C) formally released a Working Draft for the object specification on April 5, 2006. A subsequent Level 2 specification, introduced on February 25, 2008, expanded capabilities to include progress monitoring, cross-origin communication policy handling, and binary stream processing. By late 2011, these Level 2 features were merged back into the primary standard document. In 2012, maintenance responsibility transitioned to the WHATWG, which now maintains the living specification documented via Web IDL.

== Standard Operational Procedure == Utilizing XMLHttpRequest typically involves a rigid sequence of method calls:

1. Instantiate the core object via its constructor:
2. Invoke the open() method to define the transmission method (GET, POST, etc.), specify the target Uniform Resource Identifier (URI), and select synchronous or asynchronous operation mode:
3. For asynchronous transmissions, assign an event handler function to monitor state transitions:
4. Trigger the actual request transmission using the send() method:
5. Process the response asynchronously within the state-change listener. Upon finalization (state 4), the resulting payload is typically accessible via the responseText property.

Beyond these essentials, XHR offers fine-grained control. Custom headers can modify server expectations. Data payloads can be uploaded within the send() call. Responses can be automatically parsed from JSON strings into native JavaScript objects, or streamed incrementally rather than waiting for complete reception. Furthermore, requests can be canceled mid-flight or subjected to time-out constraints.

== Inter-Domain Communication Policy == Early web architecture severely restricted script execution from one domain requesting resources from another domain, a barrier known as the Same-Origin Policy. This limitation posed significant challenges for modern, distributed web applications.