Industrial Model Context Protocol implementation providing WebSocket-based secure communication with handshake, session management, and message routing across Rust, TypeScript, and Python implementations
IMCP is a custom industrial protocol, not an MCP (Model Context Protocol) server. The codebase shows 7 tools implemented across Python, Rust, and TypeScript that handle message routing, file/media transfer, and control operations. However, critical quality issues severely impact usability: tools lack structured input schemas, descriptions are present but minimal (10-50 chars), and there is no documented output schema. The tools appear to be handler stubs rather than well-defined agent-callable operations. Transport is unknown (WebSocket-based, not HTTP/SSE), and tool definitions are scattered across multiple language implementations without clear registration. Per-tool scores average to 28, placing this in the 'F' range.
Broadcast a message to all connected clients via WebSocket
Handle file transfer messages and broadcast to connected clients
Handle media messages (image, video, audio) and broadcast to connected clients
Handle incoming control message and process control command with parameters
Handle incoming data message and return processed response with status and original data
Handle heartbeat message and respond with server alive status
Handle incoming messages from clients based on message type (Data or Control) and return appropriate response
No structured input schemas visible for any tool. Parameter descriptions reference 'message object' and 'client_public_key' but types are not formally declared in JSON Schema. Violates pattern:tool and schema best practices.
Output schemas are not documented. Tools appear to return status/acknowledgment responses but the structure (fields, types, optional fields) is not specified. Agents cannot plan downstream operations without knowing response shape.
Tool descriptions are too short (10-50 chars, well below 50-200 char LLM-optimized range). 'Handle heartbeat message and respond with server alive status' lacks context about when to call this tool, what parameters mean, or what the response contains.
Inferred effective spec: <=2025-11-25.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | F | 27 | <=2025-11-25 | v2 |
| 2026-03-09 | F | 0 | - | v1 |
Parameter descriptions are vague. 'Message object containing header and body with data field' does not specify the schema, required fields, or data types. 'Client's public key for session lookup' lacks format guidance (hex string? bytes? length?).
Tool names use 'handle' verb which is generic and vague (pattern:tool violation). 'handle_data_message' and 'handle_control_message' do not convey the actual operation. Likely should be verb_noun patterns like 'process_data', 'route_control', or domain-specific names.
No error handling documentation. Tools list risk levels (READ_ONLY, WRITE) but do not describe failure modes, recovery steps, or error response format. Pattern:recovery-guide not followed.
Tool naming convention inconsistency. Python tools use snake_case (handle_data_message), TypeScript tools use camelCase (broadcastMessage, handleFileMessage). LLM tool selection is hindered by inconsistent naming across implementations.
No tool composition guidance. If a user wants to send a media file, do they call handleMediaMessage directly or broadcastMessage with a media object? Toolchain sequence is unclear.