Winform MCP Server

🚀 WinForm MCP Server

A fully functional MCP (Model Context Protocol) application demo based on Windows Forms, integrating features such as MCP Server, Mcp Client, embedded web services, LLM API calls, chat interfaces, and tool management. It can serve as reference code integrating specific technologies for enterprise-level desktop application development.

🚀 Quick Start

1. Build and Run

Using Visual Studio:

• Open the solution src\WinFormMcpServer.sln.
• Select the build configuration (Debug/Release), and directly start debugging (F5) or running (Ctrl+F5).

Using .NET CLI:

# Navigate to the project directory
cd src/WinFormMcpServer

# Build the project
dotnet build

# Start the application
dotnet run

2. Application Configuration

Start the server:

1. Enter the port (default is 3000) in the main form.
2. Click the "Start Server" button.
3. If the status bar shows "Running", it means the service has started.

Configure the LLM API:

1. Click "Configuration" → "LLM API Configuration" in the menu bar.
2. Select to use the Mock API or the real API.
3. If using the real API, fill in the corresponding configuration information:
   • API base URL (e.g., https://api.openai.com/v1).
   • API key.
   • Model name (e.g., gpt-3.5-turbo).
   • Other parameters (timeout, maximum tokens, temperature, etc.).
4. Click "Test Connection" to verify the configuration.
5. Save the configuration.

3. Use the Chat Interface

Access http://localhost:3000 to open the modern Web chat interface:

• Supports real-time message sending and receiving.
• Responsive design, suitable for various devices.
• Supports MCP tool calls and result display.

✨ Features

🤖 LLM API Integration

• Configurable LLM Services: Supports seamless switching between Mock API and real API.
• OpenAI Compatible Interfaces: Supports all OpenAI-compatible API endpoints.
• Intelligent Configuration Management: Configurations are automatically saved to JSON files and support hot updates.
• Connection Testing: Built-in API connection testing function to ensure correct configuration.

💬 Modern Chat Interface

• Web Chat Interface: A responsive chat interface based on modern Web technologies.
• Real-time Message Processing: Supports real-time message sending and receiving.
• Aesthetic UI Design: Adopts a modern design style with blue-grey tones.
• Mobile Adaptation: Fully responsive design, supporting various screen sizes.

🔧 MCP Tool System

• Tool Management: A complete MCP tool registration and management system.
• Remote Tool Invocation: Supports invoking MCP tools through HTTP endpoints.
• Tool Testing: Built-in tool testing interface for easy debugging and verification.
• Scalability: Supports custom tool development and integration.

⚙️ Configuration Management

• MCP Server Configuration: Supports the configuration and management of multiple MCP servers.
• JSON Configuration Editing: A visual JSON configuration editor.
• Configuration Persistence: All configurations are automatically saved and retained after the application restarts.

🛠 Technology Stack

• Target Framework: .NET 8 (net8.0-windows)
• UI Framework: Windows Forms + modern Web interface
• Web Service: ASP.NET Core Minimal API + Kestrel
• Protocol Support: ModelContextProtocol 0.3.0-preview.4
• Logging System: Serilog (rolling file logging)
• Front-end Technologies: HTML5 + CSS3 + JavaScript
• HTTP Client: HttpClient with OpenAI compatible interfaces

📋 Prerequisites

• .NET SDK 8.0+
• Optional: Visual Studio 2022 (Community edition recommended)

🔌 API Endpoints

MCP Protocol Endpoints

• Base Address: http://localhost:{port}/mcp
• SSE Connection: http://localhost:{port}/sse
• Chat API: http://localhost:{port}/api/chat

Static Resources

• Chat Interface: http://localhost:{port}/index
• Static Files: http://localhost:{port}/wwwroot/

📁 Project Structure

src/WinFormMcpServer/
├── Controllers/           # API controllers
│   └── ChatController.cs  # Chat API controller
├── McpServer/            # MCP server core
│   ├── HttpMcpServer.cs  # HTTP MCP server
│   ├── McpServerHost.cs  # MCP server host
│   └── Tools/            # MCP tool collection
├── Models/               # Data models
│   ├── ChatModels.cs     # Chat-related models
│   ├── LlmApiConfig.cs   # LLM API configuration model
│   └── McpClientConfig.cs # MCP client configuration model
├── Services/             # Business services
│   ├── ChatService.cs    # Chat service
│   ├── ConfigurableLlmService.cs # Configurable LLM service
│   ├── LlmApiConfigService.cs    # LLM API configuration service
│   ├── LlmApiServiceFactory.cs   # LLM API service factory
│   ├── RealLlmApiService.cs      # Real LLM API service
│   ├── MockLlmApiService.cs      # Mock LLM API service
│   └── McpClientService.cs       # MCP client service
├── wwwroot/              # Web static resources
│   ├── index.html        # Chat interface
│   ├── chat.js          # Chat script
│   └── styles.css       # Style file
├── MainForm.cs          # Main form
├── LlmApiConfigForm.cs  # LLM API configuration form
├── McpConfigForm.cs     # MCP configuration form
└── Program.cs           # Program entry

🔧 Configuration Files

LLM API Configuration (llm-api-config.json)

{
  "UseMockApi": false,
  "BaseUrl": "https://api.openai.com/v1",
  "ApiKey": "your-api-key-here",
  "ModelName": "gpt-3.5-turbo",
  "TimeoutSeconds": 30,
  "MaxTokens": 1000,
  "Temperature": 0.7
}

MCP Server Configuration (mcp-servers.json)

{
  "mcpServers": {
    "example-server": {
      "type": "sse",
      "url": "http://localhost:3001/sse",
      "name": "Example Server"
    }
  }
}

📊 Logging System

• Logging Framework: Serilog
• Log Location: logs/WinFormMcpServer_.log
• Rolling Policy: Daily rolling
• Log Level: Verbose (development environment)

🧪 Testing

End-to-End Testing

The test scripts are located in the test/ directory:

• Uses Playwright for front-end automated testing.
• Supports API endpoint testing.
• Includes integration testing for chat functions.

MCP Inspector Testing

# Install MCP Inspector
npx @modelcontextprotocol/inspector

# Access the test interface
http://localhost:6247/

📦 Deployment

Framework-Dependent Deployment

dotnet publish src/WinFormMcpServer -c Release -r win-x64 --self-contained false

Self-Contained Deployment

dotnet publish src/WinFormMcpServer -c Release -r win-x64 --self-contained true

The published artifacts are located at: bin/Release/net8.0-windows/win-x64/publish/

🔗 MCP Client Integration

Add the following to your MCP client configuration:

{
  "mcpServers": {
    "winform-mcp-server": {
      "type": "sse",
      "url": "http://localhost:3000/sse",
      "name": "WinForm MCP Server"
    }
  }
}

🤝 Contribution Guidelines

1. Fork this repository.
2. Create a feature branch (git checkout -b feature/AmazingFeature).
3. Commit your changes (git commit -m 'Add some AmazingFeature').
4. Push to the branch (git push origin feature/AmazingFeature).
5. Open a Pull Request.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🆘 Support

If you encounter problems or have questions, please:

1. Check the Issues page.
2. Create a new Issue to describe the problem.
3. Provide detailed error information and reproduction steps.

⚠️ Important Note

This project is an enterprise-level MCP server implementation, integrating complete LLM API calls, a modern chat interface, and tool management functions. It is suitable for production environment deployment.