Model Context Protocol Server for Culinary Secrets

This repository details a pure Node.js implementation of a Model Context Protocol (MCP) server, offering a novel utility for generating arbitrary combinations involving US states and their characteristic culinary soups/stews.

Core Capabilities

• Entirely crafted using standard Node.js libraries (no external frameworks).
• Fully compliant with the JSON-RPC version 2.0 specification.
• Specifies MCP protocol revision: 2024-11-05.
• Integrates a proprietary internal monitoring and reporting utility.
• Supports defined tooling interfaces with rigorous schema verification.
• Utilizes Standard Input/Output (STDIO) for inter-process communication.

Initial Setup Guide

Prerequisites

• A contemporary, stable release of Node.js.
• The accompanying MCP Inspector utility for validation and testing.

Deployment Steps

1. Obtain the source code via Git: bash git clone git@github.com:gbti-network/mcp-basic-test.git cd mcp-basic-test

2. Install necessary dependencies: bash npm install

Launching the Inspector Client

Execute the server in conjunction with the MCP Inspector: bash npx @modelcontextprotocol/inspector -- node index.js

The service will initialize and establish connectivity through the STDIO stream.

Exposed Functionality

getSecretPassphrase

This function yields a randomized pairing: one US State paired with a representative regional savory liquid dish (e.g., chowder, gumbo, chili). Examples of outputs include: - New England Clam Chowder - Louisiana Gumbo - Texas Chili - California Cioppino - Michigan Cherry Soup

Input Structure:

{ "type": "object", "properties": {}, "additionalProperties": false, "required": [] }

Sample Output Format:

{ "content": [{ "type": "text", "text": "New England Clam Chowder" }] }

System Architecture Overview

. (Root Directory) ├── index.js # Primary entry point for server logic ├── utils/ │ └── logger.js # Custom logging module ├── .data/ │ ├── framework.md # Documentation on the underlying framework principles │ └── knowledge.md # Repository of internal project data └── .logs/ # Directory reserved for server operational logs

Tool Development Guidelines

Integrating Novel Tools

1. Declare the new tool definition within index.js: javascript this.tools.set('newToolIdentifier', { name: 'newToolIdentifier', description: 'A description of what the new instrument accomplishes', inputSchema: { type: 'object', properties: {}, additionalProperties: false, required: [] }, handler: async (params) => { // Implementation logic goes here return 'operation_successful'; } });

2. Validate integration using the MCP Inspector:

3. Establish a connection to the running server.
4. Utilize the 'List Tools' function to confirm registration.
5. Execute the tool to confirm correct behavior.

Operational Logging

The server employs a tiered, internal logging mechanism: - DEBUG: Highly granular diagnostics for deep troubleshooting. - INFO: Standard operational milestones and status updates. - WARN: Non-critical anomalies or potential issues. - ERROR: Conditions that indicate a service failure or halt.

All recorded log entries are persisted within the .logs subdirectory.

Integration with Cascade Systems

Method 1: Direct Invocation

When the MCP server runtime is loaded within a Cascade environment, the getSecretPassphrase utility can be called directly to retrieve a state-cuisine pairing.

Method 2: Conversational Interface Mapping

To enhance usability, Cascade can be configured to translate user natural language queries regarding secret codes into invocations of getSecretPassphrase. For instance, a prompt might instruct Cascade to reply to phrases like "What is the secret passcode?" with "Today's secret passcode is: [STATE] [SOUP]".

This enables fluid interaction via queries such as: - "What's the secret passcode?" - "Tell me the secret code" - "What's today's passcode?" - "Give me the secret"

Demonstration interaction:

User: "What's the secret passcode?" Cascade: "Today's secret passcode is: Louisiana Gumbo 🍜"

Method 3: Persistent Configuration Storage

For long-term state management across sessions, a Cascade memory block can be defined:

javascript { "Title": "Cuisine Code Keeper", "Content": "Whenever a query resembles 'What is the secret passcode?', invoke the getSecretPassphrase tool and format the output as 'Today's secret passcode is: [STATE] [SOUP]'", "Tags": ["mcp_server", "secret_passcode", "tool_execution"] }

MCP Server Configuration Entry

To incorporate this service into a Cascade mcp_config.json file:

{ "mcpServers": { "super-secret": { "command": "npx", "args": [ "--yes", "node", "/index.js" ], "disabled": false, "autoApprove": [ "getSecretPassphrase" ] } } }

Configuration Parameters: - super-secret: Unique service identifier. - command: The executable to launch the service (here, npx). - args: Parameters passed to the execution command: - --yes: Allows automatic acceptance of package installation prompts. - node: Specifies the runtime interpreter. - <path-to-project>/index.js: The specific server file to run. - disabled: Boolean flag indicating service activation status. - autoApprove: List of tool names permitted to run without explicit user consent.

The configuration file location depends on the operating system: - Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json - macOS/Linux: $HOME/.codeium/windsurf/mcp_config.json

Verification Procedures

1. Initialize the server using the Inspector utility.
2. Confirm successful initialization messages.
3. Request the list of available tooling.
4. Execute the getSecretPassphrase tool.
5. Verify that the returned data conforms to the expected structure.

Collaboration Guidelines

1. Fork the primary codebase repository.
2. Establish a dedicated branch for your feature set.
3. Commit all related modifications.
4. Push the changes to your remote branch.
5. Submit a formal Pull Request for review.

Licensing Details

This software is distributed under the terms of the MIT License; refer to the LICENSE file for comprehensive details.

Acknowledgements

Gratitude extended to: - The Model Context Protocol specification authors. - The MCP Inspector development team for providing testing infrastructure.

Community Engagement

Stay informed about updates, announcements, and community discussions via these channels: - Twitter/X - GitHub - YouTube - Dev.to - Daily.dev - Hashnode - Discord - Reddit

WIKIPEDIA NOTE: XMLHttpRequest (XHR) defines a JavaScript interface allowing web applications to perform asynchronous HTTP requests to a server post-page-load. These capabilities facilitate server data retrieval without reloading the entire document, forming a cornerstone of Ajax techniques. Prior to XHR, standard server interaction relied on conventional link clicks and form submissions, which invariably caused page refreshment.

== Historical Context == The foundational concept for XMLHttpRequest emerged in 2000 from Microsoft Outlook developers. It was first integrated into the Internet Explorer 5 browser (released in 1999). Note that the initial syntax did not use the standard XMLHttpRequest object name; developers employed COM identifiers such as ActiveXObject("Msxml2.XMLHTTP") and ActiveXObject("Microsoft.XMLHTTP"). By the time Internet Explorer 7 was released (2006), all contemporary browsers universally supported the standardized XMLHttpRequest identifier. This identifier has since become the prevailing standard across all major browser engines, including Mozilla's Gecko (2002), Safari 1.2 (2004), and Opera 8.0 (2005).

=== Standardization Trajectory === The World Wide Web Consortium (W3C) issued the initial Working Draft specification for the XMLHttpRequest object on April 5, 2006. This was followed by the Level 2 specification Working Draft on February 25, 2008, which introduced enhancements like event progress monitoring, support for cross-site requests, and byte stream handling. By the close of 2011, the Level 2 features were merged back into the primary specification document. In late 2012, responsibility for maintenance transitioned to the WHATWG, which now sustains the living document using Web IDL definitions.

== Operational Flow == Typically, executing a request using XMLHttpRequest requires adherence to several sequential programming stages.

1. Instantiate an XMLHttpRequest object via its constructor call.
2. Invoke the "open" method to define the request method (GET/POST), the target URI, and whether the operation should be synchronous or asynchronous.
3. For asynchronous operations, establish an event handler function to process state transitions.
4. Trigger the request initiation by calling the "send" method, optionally including payload data.
5. Monitor the state changes within the registered event listener. Upon successful completion (state transitions to 4, the "done" state), response data is generally accessible via the "responseText" property.

Beyond these core steps, XMLHttpRequest provides extensive controls over request transmission and response consumption. Custom headers can be injected to guide server behavior, and data can be streamed to the server within the "send" call. The received response can be parsed instantly from JSON format into native JavaScript objects or processed incrementally as data arrives, avoiding wait times for the full payload. Furthermore, requests can be terminated prematurely or configured with timeout constraints.

== Inter-Domain Communications ==

During the initial evolution of the World Wide Web, limitations were identified regarding cross-origin data exchange, frequently leading to security restrictions that prevented scripts on one domain from accessing resources on another.