Test MCP Server

A simple MCP (Model Context Protocol) server for learning purposes. This server demonstrates basic MCP functionality including tools and resources with Zod validation.

What is MCP?

MCP (Model Context Protocol) is a protocol that allows AI models to interact with external tools and resources. It provides a standardized way for AI assistants to:

• Call tools (functions) to perform actions

• Read resources (files, data sources) to get information

• Provide structured responses with proper error handling

How MCP Works

1. AI Model (like Cursor) wants to use a tool

2. AI Model sends a JSON-RPC request to the MCP Server via stdio

3. MCP Server processes the request and returns a response

4. AI Model uses the response to help the user

The communication happens through JSON-RPC 2.0 over stdio - no web servers needed!

Features

This test server includes:

Tools (with Zod Validation)

• echo: Echo back input text with validation

• add_numbers: Add two numbers together with type checking

• get_system_info: Get basic system information (Node.js platform details)

• validate_email: Validate email addresses using Zod's built-in email validation

Resources

• file://example.txt: A sample text file with timestamp

• file://example.json: A sample JSON file with server metadata

Key Features

• ✅ Zod Validation: Runtime type checking for all tool inputs

• ✅ Error Handling: Clear error messages for invalid inputs

• ✅ JSON-RPC 2.0: Standard protocol communication

• ✅ Type Safety: TypeScript/JavaScript with proper schemas

• ✅ Resource Management: Both text and JSON resource examples

Setup

1. Install dependencies:

2. Make the server executable:

Usage

Running the Server

The server can be run directly:

Testing with the Client

Run the test client to see the server in action:

Using with Cursor

1. Copy the configuration from mcp_config.json to your Cursor settings

2. Update the path to point to your local copy of this repository

Option 1: Using absolute path

Option 2: Using working directory (recommended)

The mcp_config.json file in this repository serves as a template - copy it to your ~/.cursor/mcp.json and update the paths as needed.

How It Works

Server Architecture

1. Server Initialization: Creates MCP server with capabilities

2. Tool Registration: Tools are registered with Zod schemas for validation

3. Resource Registration: Resources are registered with URIs and metadata

4. Request Handling: Server processes JSON-RPC requests via stdio

5. Response Generation: Responses are formatted according to MCP protocol

Communication Flow

Example JSON-RPC Communication

Request:

Response:

Extending the Server

Adding New Tools

1. Define Zod Schema:

   const MyToolInputSchema = z.object({ param1: z.string().describe('Description'), param2: z.number().optional() });

2. Add Tool Definition:

   { name: 'my_tool', description: 'My new tool', inputSchema: { /* JSON schema */ } }

3. Implement Handler:

   case 'my_tool': { const validatedArgs = MyToolInputSchema.parse(args); // Tool logic here return { content: [{ type: 'text', text: 'Result' }] }; }

Adding New Resources

1. Add Resource Definition:

   { uri: 'file://my-resource', name: 'My Resource', description: 'Description', mimeType: 'text/plain' }

2. Implement Handler:

   case 'file://my-resource': { return { contents: [{ type: 'text', text: 'Resource content', uri: 'file://my-resource' }] }; }

Troubleshooting

MCP Tools Not Appearing in Cursor

1. Check configuration: Ensure ~/.cursor/mcp.json has the correct path

2. Restart Cursor: MCP configuration changes require a restart

3. Test server: Run node server.js to verify it starts without errors

4. Check logs: Look for error messages in Cursor's developer console

Common Issues

• Path issues: Use absolute paths in MCP configuration

• Permission errors: Ensure the server file is executable (chmod +x server.js)

• Dependency issues: Run npm install to ensure all packages are installed

• Port conflicts: MCP uses stdio, so no port conflicts possible

Testing Your Server

Project Structure

Contributing

1. Fork the repository

2. Create a feature branch

3. Add your tools/resources

4. Test thoroughly

5. Submit a pull request

License

MIT License - feel free to use this as a starting point for your own MCP servers!