Content
# A Simple MCP Server and Client
This is a simple Model Context Protocol (MCP) server and client implementation that demonstrates how to expose and access weather information.
## Server
The server is implemented in `server.js`. It provides the following capabilities:
- **Resources**:
- `city://NewYork`: Basic information about New York City
- `city://London`: Basic information about London
- `city://Tokyo`: Basic information about Tokyo
- **Tools**:
- `get-weather`: Get weather forecast for a city with parameters for city name and number of days
- **Prompts**:
- `weather-advice`: Get travel advice based on weather conditions
## Client
The client is implemented in `client.js`. It demonstrates how to:
- Connect to the MCP server
- List available resources
- Read a specific city resource
- Call the weather forecast tool
- Get a weather advice prompt
## JSON-RPC Communication
This implementation uses JSON-RPC 2.0 as the underlying communication protocol between client and server. Key JSON-RPC concepts used:
- **Methods**: Standard method names like `resources/list`, `resources/read`, `tools/call`, and `prompts/get`
- **Parameters**: Input data sent with method calls
- **Request IDs**: Unique identifiers to match requests with responses
- **Results/Errors**: Structured response data or error information
The MCP SDK abstracts much of this, but understanding the protocol is helpful for debugging and customization. You can see the raw JSON-RPC messages by examining the console output.
## Running the Server and Client
1. Start the client:
```bash
node client.js
```
Starting the client will automatically start the server as a child process. The client will connect to the server and perform all the example operations.
2. To start the server independently:
```bash
node server.js
```
## Transport Mechanism
This example uses stdio (standard input/output) as the transport mechanism between client and server. When the client is started, it spawns the server as a child process and communicates with it through stdin/stdout streams.
A custom logging transport is implemented to show the messages exchanged between the client and server. These messages are logged to the console in a human-readable format, which is helpful for understanding the protocol.
## Troubleshooting
If you encounter issues with resource or prompt requests timing out, check the server implementation. The example includes direct message handling for certain request types to work around limitations in the current SDK version.
Connection Info
You Might Also Like
awesome-mcp-servers
A collection of MCP servers.
git
A Model Context Protocol server for Git automation and interaction.
Appwrite
Build like a team of hundreds
xclaude-plugin
Modular iOS development automation with 8 MCP servers and 24 tools.
awesome-mcp-enterprise
A curated list of MCP tools and services for enterprises to enhance LLM context.
n8n-mcp-cc-buildier
A workflow builder for n8n using n8n-mcp integration.