Test MCP Server

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!