Echo MCP Server by aadversteeg - MCP Server

Echo MCP Server

A simple echo server implementing the Model Context Protocol (MCP). This server provides a basic echo functionality through the MCP interface.

Overview

The Echo MCP server is built with .NET Core using the Model Context Protocol C# SDK (github.com/modelcontextprotocol/csharp-sdk). It provides a tool for echoing messages back to the client. The server is designed to be lightweight and demonstrates how to create a custom MCP server with a simple functionality. It can be deployed either directly on a machine or as a Docker container.

Features

Echo any message back to the client
Customizable message format through configuration
Built on the Model Context Protocol standard

Getting Started

Prerequisites

.NET 10.0 (for local development/deployment)
Docker (for container deployment)

Build Instructions (for development)

If you want to build the project from source:

Clone this repository:

git clone https://github.com/yourusername/echo-mcp-server.git

Navigate to the project root directory:
```
cd echo-mcp-server
```
Build the project using:
```
dotnet build src/echo.sln
```
Run the tests:
```
dotnet test src/echo.sln
```

.NET Tool

The Echo MCP Server is available as a .NET global tool on NuGet.

Installation

dotnet tool install --global Ave.McpServer.Echo

Running

ave-mcpserver-echo

One-shot execution (without permanent installation)

With .NET 10 SDK, you can run the tool without installing it globally using dotnet tool exec:

dotnet tool exec -y ave.mcpserver.echo

The -y flag accepts prompts automatically. The tool is cached locally but not added to your PATH.

Docker Support

Manual Docker Build

To build the Docker image yourself:

# Navigate to the repository root
cd echo-mcp-server

# Build the Docker image
docker build -f src/Core.Infrastructure.McpServer/Dockerfile -t echo-mcp-server:latest src/

# Run the locally built image
docker run -d --name echo-mcp echo-mcp-server:latest

MCP Protocol Usage

Client Integration

To connect to the Echo MCP Server from your applications:

Use the Model Context Protocol C# SDK or any MCP-compatible client
Configure your client to connect to the server's endpoint
Call the available tools described below

Available Tools

echo

Echoes the message back to the client.

Parameters:

message (required): The message to echo back.

Example request:

{
  "name": "echo",
  "parameters": {
    "message": "Hello, world!"
  }
}

Example response:

Echo: Hello, world!

Configuration

MessageFormat

The MessageFormat setting determines how the echoed message is formatted. It uses a template string with the {message} placeholder that gets replaced with the input message.

You can set the MessageFormat in two ways:

appsettings.json file (for local deployment):

{
  "MessageFormat": "Server says: {message}"
}

Environment Variables (for containerized deployments):

When using MCP server with Claude, environment variables are passed through the Claude Desktop configuration as shown in the "Configuring Claude Desktop" section below.

If not specified, the server defaults to "Echo: {message}".

Configuring Claude Desktop / Claude Code

Add the server configuration to the mcpServers section in your configuration file.

Using .NET Tool

Requires .NET 10 SDK. This approach automatically downloads the tool on first use and updates to the latest version on subsequent runs.

"echo": {
  "command": "dotnet",
  "args": [
    "tool",
    "exec",
    "-y",
    "ave.mcpserver.echo"
  ],
  "env": {
    "MessageFormat": "Claude says: {message}"
  }
}

Using Global Installation

Requires .NET 10 SDK. Install the tool once, then use it directly.

dotnet tool install --global Ave.McpServer.Echo

"echo": {
  "command": "ave-mcpserver-echo",
  "env": {
    "MessageFormat": "Claude says: {message}"
  }
}

To update: dotnet tool update --global Ave.McpServer.Echo

Using Docker

Does not require .NET 10 SDK.

"echo": {
  "command": "docker",
  "args": [
    "run",
    "--rm",
    "-i",
    "-e", "MessageFormat=Claude says: {message}",
    "aadversteeg/echo-mcp-server:latest"
  ]
}

Using Docker with Custom Configuration File

To use a custom configuration file from your host system:

Create a custom configuration file on your host machine (e.g., echo-appsettings.json):

{
  "MessageFormat": "My Custom Format: {message}",
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    }
  }
}

Update the configuration to mount this file:

"echo": {
  "command": "docker",
  "args": [
    "run",
    "--rm",
    "-i",
    "-v", "C:/path/to/echo-appsettings.json:/app/appsettings.json",
    "aadversteeg/echo-mcp-server:latest"
  ]
}

Important Notes:

The configuration file must exist on your host system before starting the container
You can use any filename on the host (e.g., echo-appsettings.json), but it must be mounted to /app/appsettings.json inside the container
Make sure the path is correct for your operating system (Windows uses backslashes or forward slashes, Linux/macOS use forward slashes)
After changing the configuration file, restart Claude Desktop to apply the changes