# user-prompt

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/Jacob-J-Thomas/user-context-retrieval-mcp-server  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/user-prompt

## Description
An MCP server that enables AI agents to ask users clarifying questions via pop-up terminal windows.

## Claude Desktop Quick Installation
Heuristic fallback — verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low):

```json
"mcpServers": {
  "user-prompt": {
    "command": "npx",
    "args": ["-y","user-prompt"]
  }
}
```

## Documentation & README

# User Prompt MCP Server

![.NET](https://img.shields.io/badge/.NET-8.0-purple)
![License](https://img.shields.io/badge/license-Apache%202.0-blue)

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

A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 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](https://docs.anthropic.com/en/docs/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.

![Terminal prompt demo](./demo.png)

## 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`)](https://github.com/PowerShell/PowerShell#get-powershell) must be installed

> **Note:** [Pre-built releases](#option-a-github-releases-recommended) have no other dependencies. The [.NET Global Tool](#option-b-net-global-tool) and [Build from Source](#option-c-build-from-source) options require the [.NET 8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0) 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](https://github.com/Jacob-J-Thomas/user-context-retrieval-mcp-server/releases/latest):

| Platform              | Asset                                    |
|-----------------------|------------------------------------------|
| Windows (x64)         | `UserPromptMcpServer-win-x64.zip`        |
| macOS (Intel)         | `UserPromptMcpServer-osx-x64.zip`        |
| macOS (Apple Silicon) | `UserPromptMcpServer-osx-arm64.zip`      |
| Linux (x64)           | `UserPromptMcpServer-linux-x64.zip`      |

**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):**

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

**Other clients** — point the command at the executable (see [Client Configuration Reference](#client-configuration-reference) for full examples):

```json
{
  "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](https://dotnet.microsoft.com/download/dotnet/8.0) or later. The tool is added to your PATH automatically.

**1. Install**

```bash
dotnet tool install -g UserPrompt
```

**2. Configure your MCP client**

**Claude Code (CLI):**

```bash
claude mcp add user-prompt -- user-prompt
```

**Other clients** — the command name is `user-prompt` (see [Client Configuration Reference](#client-configuration-reference) for full examples):

```json
{
  "command": "user-prompt"
}
```

**Updating:**

```bash
dotnet tool update -g UserPrompt
```

---

### Option C: Build from Source

Requires the [.NET 8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0) or later.

```bash
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](https://learn.microsoft.com/en-us/dotnet/core/rid-catalog) (e.g. `osx-arm64`, `linux-x64`).

Then configure your client the same way as [Option A](#option-a-github-releases-recommended), 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`:

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

**Config file location:**

| Platform | Path |
|----------|------|
| Windows  | `%APPDATA%\Claude\claude_desktop_config.json` |
| macOS    | `~/Library/Application Support/Claude/claude_desktop_config.json` |

### Cursor

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

```json
{
  "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):

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

Or via the CLI:

```bash
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`

| Parameter   | Type       | Required | Description |
|-------------|------------|----------|-------------|
| `reason`    | `string`   | Yes      | A clear explanation of why the agent needs user input. Displayed prominently in the terminal window. |
| `questions` | `string[]` | Yes      | A list of specific questions. Displayed as a numbered list; the user answers each in sequence. |

### Example Tool Call

```json
{
  "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

```bash
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

- **Cross-platform support** — the macOS and Linux terminal launching is currently stubbed out and untested
- **Test coverage** — no test project exists yet
- **Additional MCP tools** — if the project scope expands beyond a single tool

## License

This project is licensed under the **[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0)**. See [LICENSE](LICENSE) for details.

## Author

**Jacob Thomas** — [@Jacob-J-Thomas](https://github.com/Jacob-J-Thomas)