interactive-mcp

Allows LLMs to pause execution and request specific information from users via a blocking MCP tool call that displays optional predefined choices and timeout support. Implements a request_user_input tool registered with the MCP server that captures user responses through terminal UI components built with React/Ink, returning the selected or typed response back to the LLM context.

Enables LLMs to trigger native operating system notifications via the message_complete_notification MCP tool, using node-notifier for cross-platform support (Windows, macOS, Linux). The tool accepts a message string and dispatches it through the OS notification system, allowing LLMs to alert users asynchronously without blocking execution or requiring terminal focus.

Provides LLMs with the ability to initiate and manage persistent, multi-turn chat sessions via three coordinated MCP tools: start_intensive_chat (creates dedicated terminal interface), ask_intensive_chat (sends messages within active session), and stop_intensive_chat (closes session and cleans resources). Uses React/Ink terminal UI to render a dedicated chat interface that maintains context across multiple LLM-user exchanges within a single session lifecycle.

Implements a full Model Context Protocol (MCP) server that registers and exposes the interactive tools (user input, notifications, chat) as callable MCP tools to LLM clients. Built on the @modelcontextprotocol/sdk, the server initializes with configuration for name, version, and capabilities, then registers tool handlers that map incoming MCP tool calls to the underlying implementation (terminal UI, OS notifications, chat session management).

Renders interactive terminal user interfaces for input prompts, option selection, and chat sessions using React and Ink (React renderer for terminal). The architecture uses React components to define UI structure (prompts with choices, chat message display, input fields) and Ink to render them to the terminal, providing a responsive, component-based approach to terminal UI that updates in real-time as user input is received.

Validates all MCP tool arguments using zod schema definitions before execution, ensuring type safety and preventing invalid tool calls from reaching the implementation layer. Each tool (request_user_input, message_complete_notification, etc.) has a corresponding zod schema that defines required/optional fields, types, and constraints, which is checked at the MCP server level before the tool handler is invoked.

Parses command-line options for the interactive-mcp server using yargs, enabling configuration of server behavior via CLI flags (e.g., port, host, tool enable/disable). The yargs integration provides a structured way to define CLI options, parse process.argv, and pass configuration to the MCP server initialization, supporting both short and long option names with type coercion and validation.

Implements a modular architecture where each interactive capability (user input, notifications, chat) is encapsulated as a separate tool with its own handler, UI component, and schema definition. The MCP server registers each tool independently, allowing tools to be enabled/disabled, tested, and maintained separately while sharing common infrastructure (MCP protocol, terminal rendering, notification dispatch).

Enables true bidirectional communication where LLMs can request user input, receive responses, and incorporate them back into reasoning, rather than one-way LLM-to-user communication. The architecture implements this through blocking MCP tool calls (request_user_input, ask_intensive_chat) that pause LLM execution, wait for user response, and return the response as tool output that the LLM can use in subsequent reasoning steps, creating a synchronous request-response loop.