User Prompt MCP Server

mcp-name: io.github.Jacob-J-Thomas/user-prompt

A Model Context Protocol (MCP) server that gives AI agents the ability to ask users clarifying questions mid-task via a pop-up terminal window. Built with .NET 8 and C#.

The Problem

Long-running AI agents (like Claude Code, IDE copilots, or custom agentic workflows) often encounter situations where they need human input — ambiguous requirements, unexpected errors, or design decisions that could go multiple ways. Without a mechanism to ask, the agent either guesses (often incorrectly) or stops entirely and waits for the user to notice.

The Solution

This MCP server exposes a single tool, user_prompt, that an AI agent can call at any point during execution. When invoked, a new terminal window opens on the user's machine displaying the agent's questions. The user types their answers and the responses are returned directly to the agent, allowing it to continue working with the additional context.

Features

• Pop-up terminal prompt — questions appear in a dedicated window, separate from the agent's own I/O
• Multi-question support — the agent can ask multiple questions in a single call; all are displayed upfront as a numbered list
• Structured responses — answers are returned as clearly formatted Q&A pairs the agent can parse
• Timeout handling — 10-minute response window with graceful fallback messaging
• Window-closed detection — if the user closes the prompt without answering, the agent receives a clear notification
• Stdio transport — communicates over stdin/stdout per the MCP specification, compatible with any MCP client

Prerequisites

• Windows: PowerShell 5.1+ (included with Windows 10/11)
• macOS/Linux (untested): PowerShell Core (pwsh) must be installed

Note: Pre-built releases have no other dependencies. The .NET Global Tool and Build from Source options require the .NET 8.0 SDK or later.

Quick Start

Pick one of the three install options below. Each option walks you through installation, client configuration, and updates end-to-end.

Option A: GitHub Releases

Self-contained executables — no .NET SDK required.

1. Download

Grab the zip for your platform from the latest release:

2. Extract

Unzip to a permanent location, for example:

• Windows: C:\Tools\UserPromptMcpServer\
• macOS / Linux: ~/tools/UserPromptMcpServer/

3. Configure your MCP client

Claude Code (CLI):

claude mcp add user-prompt -- "C:\Tools\UserPromptMcpServer\UserPromptMcpServer.exe"

Other clients — point the command at the executable (see Client Configuration Reference for full examples):

{
  "command": "C:\\Tools\\UserPromptMcpServer\\UserPromptMcpServer.exe"
}

Updating: download the new release and replace the files in the same folder.

Option B: .NET Global Tool

Requires the .NET 8.0 SDK or later. The tool is added to your PATH automatically.

1. Install

dotnet tool install -g UserPrompt

2. Configure your MCP client

Claude Code (CLI):

claude mcp add user-prompt -- user-prompt

Other clients — the command name is user-prompt (see Client Configuration Reference for full examples):

{
  "command": "user-prompt"
}

Updating:

dotnet tool update -g UserPrompt

Option C: Build from Source

Requires the .NET 8.0 SDK or later.

git clone https://github.com/Jacob-J-Thomas/user-context-retrieval-mcp-server.git
cd user-context-retrieval-mcp-server
dotnet publish UserPromptMcpServer -c Release -r win-x64 -o ./publish

Replace win-x64 with your platform's runtime identifier (e.g. osx-arm64, linux-x64).

Then configure your client the same way as Option A, pointing at the executable inside ./publish/.

Client Configuration Reference

This server uses the stdio transport — it does not listen on a port. The MCP client launches the server process and communicates with it over stdin/stdout. Replace the command/path below with the value from whichever install option you chose.

Claude Desktop

Add the following to your claude_desktop_config.json:

{
  "mcpServers": {
    "user-prompt": {
      "command": "/path/to/UserPromptMcpServer.exe"
    }
  }
}

Config file location:

Cursor

Add the following to .cursor/mcp.json (project-level) or ~/.cursor/mcp.json (global):

{
  "mcpServers": {
    "user-prompt": {
      "command": "/path/to/UserPromptMcpServer.exe"
    }
  }
}

OpenAI Codex CLI

Add the following to ~/.codex/config.toml (global) or .codex/config.toml (project-level):

[mcp_servers.user-prompt]
command = "/path/to/UserPromptMcpServer.exe"

Or via the CLI:

codex mcp add user-prompt -- /path/to/UserPromptMcpServer.exe

Other MCP Clients

Any MCP client that supports the stdio transport can launch this server. Point it at the executable (or the user-prompt command name if using the .NET Global Tool).

Usage

Once configured, the user_prompt tool is available to the AI agent automatically. The agent decides when to invoke it based on its own judgment — no manual triggering is required.

Tool Reference

Tool name: user_prompt

Example Tool Call

{
  "name": "user_prompt",
  "arguments": {
    "reason": "The project has no database configuration and I need to set one up.",
    "questions": [
      "Which database engine should I use (PostgreSQL, SQLite, SQL Server)?",
      "Should I include Entity Framework Core as the ORM?"
    ]
  }
}

Example Response

User responded to 2 question(s):

1. Q: Which database engine should I use (PostgreSQL, SQLite, SQL Server)?
   A: PostgreSQL

2. Q: Should I include Entity Framework Core as the ORM?
   A: Yes, use EF Core with code-first migrations

Terminal Window Behavior

When the tool is invoked, a new PowerShell window opens displaying:

1. A header indicating an AI agent needs input
2. The agent's stated reason for asking
3. All questions as a numbered list
4. Numbered input prompts (1>, 2>, etc.) — one Enter per answer
5. A confirmation message before the window auto-closes

If the user does not respond within 10 minutes, or closes the window without answering, the agent receives a descriptive fallback message and can decide how to proceed.

Architecture

UserPromptMcpServer/
├── UserPromptMcpServer.csproj   # Project file (.NET 8)
├── Program.cs                   # MCP server entry point (stdio transport)
└── Tools/
    └── UserPromptTool.cs        # Tool implementation

How It Works Internally

1. The MCP client sends a tools/call JSON-RPC request over stdin
2. The server writes the questions to a temporary JSON file
3. A PowerShell script is generated and launched in a new terminal window
4. The user sees the questions and types answers sequentially
5. Answers are written to a response JSON file; the terminal closes
6. The server reads the response file, formats it, cleans up temp files, and returns the result over stdout

All temporary files are created under %TEMP%/UserPromptMcpServer/<session-guid>/ and are cleaned up after each invocation regardless of outcome.

Contributing

Contributions are welcome! To make sure your change gets merged, please open an issue first to discuss the proposed change and get approval before starting work.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/my-feature)
3. Make your changes and ensure the project builds cleanly (dotnet build)
4. Commit with a clear, descriptive message
5. Open a pull request against develop

Development Setup

git clone https://github.com/Jacob-J-Thomas/user-context-retrieval-mcp-server.git
cd user-context-retrieval-mcp-server
dotnet restore UserPromptMcpServer/UserPromptMcpServer.csproj
dotnet build UserPromptMcpServer/UserPromptMcpServer.csproj

Areas for Contribution