Desktop Commander

Desktop Commander

Search, update, manage files and run terminal commands with AI.

50K+

25 Tools

Signed
Built by Docker
Requires Configuration
Add to Docker Desktop

Version 4.43 or later needs to be installed to add the server automatically

Use cases

Apply surgical text replacements to files. BEST PRACTICE: Make multiple small, focused edits rather than one large edit. Each edit_block call should change only what needs to be changed - include just enough context to uniquely identify the text being modified. Takes: - file_path: Path to the file to edit - old_string: Text to replace - new_string: Replacement text - expected_replacements: Optional parameter for number of replacements By default, replaces only ONE occurrence of the search text. To replace multiple occurrences, provide the expected_replacements parameter with the exact number of matches expected. UNIQUENESS REQUIREMENT: When expected_replacements=1 (default), include the minimal amount of context necessary (typically 1-3 lines) before and after the change point, with exact whitespace and indentation. When editing multiple sections, make separate edit_block calls for each distinct change rather than one large replacement. When a close but non-exact match is found, a character-level diff is shown in the format: common_prefix{-removed-}{+added+}common_suffix to help you identify what's different. Similar to write_file, there is a configurable line limit (fileWriteLineLimit) that warns if the edited file exceeds this limit. If this happens, consider breaking your edits into smaller, more focused changes. IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths. This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.

Browse and retrieve curated Desktop Commander prompts for various tasks and workflows. IMPORTANT: When displaying prompt lists to users, do NOT show the internal prompt IDs (like 'onb_001'). These IDs are for your reference only. Show users only the prompt titles and descriptions. The IDs will be provided in the response metadata for your use. DESKTOP COMMANDER INTRODUCTION: If a user asks "what is Desktop Commander?" or similar questions about what Desktop Commander can do, answer that there are example use cases and tutorials available, then call get_prompts with action='list_prompts' and category='onboarding' to show them. ACTIONS: - list_categories: Show all available prompt categories - list_prompts: List prompts (optionally filtered by category) - get_prompt: Retrieve and execute a specific prompt by ID WORKFLOW: 1. Use list_categories to see available categories 2. Use list_prompts to browse prompts in a category 3. Use get_prompt with promptId to retrieve and start using a prompt EXAMPLES: - get_prompts(action='list_categories') - See all categories - get_prompts(action='list_prompts', category='onboarding') - See onboarding prompts - get_prompts(action='get_prompt', promptId='onb_001') - Get a specific prompt The get_prompt action will automatically inject the prompt content and begin execution. Perfect for discovering proven workflows and getting started with Desktop Commander. This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.

About

Desktop Commander MCP Server

Search, update, manage files and run terminal commands with AI.

What is an MCP Server?⁠

Characteristics

AttributeDetails
Docker Imagemcp/desktop-commander⁠
Authorwonderwhy-er⁠
Repositoryhttps://github.com/wonderwhy-er/DesktopCommanderMCP⁠
Dockerfilehttps://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/Dockerfile⁠
Docker Image built byDocker Inc.
Docker Scout Health ScoreDocker Scout Health Score
Verify SignatureCOSIGN_REPOSITORY=mcp/signatures cosign verify mcp/desktop-commander --key https://raw.githubusercontent.com/docker/keyring/refs/heads/main/public/mcp/latest.pub
LicenceMIT License

Available Tools (25)

Tools provided by this ServerShort Description
create_directoryCreate a new directory or ensure a directory exists.
edit_blockEdit Text Block
force_terminateForce Terminate Process
get_configGet Configuration
get_file_infoGet File Information
get_more_search_resultsGet Search Results
get_promptsBrowse and retrieve curated Desktop Commander prompts for various tasks and workflows.
get_recent_tool_callsGet Recent Tool Calls
get_usage_statsGet Usage Statistics
give_feedback_to_desktop_commanderOpen feedback form in browser to provide feedback about Desktop Commander.
interact_with_processSend Input to Process
kill_processKill Process
list_directoryList Directory Contents
list_processesList Running Processes
list_searchesList Active Searches
list_sessionsList Terminal Sessions
move_fileMove/Rename File
read_fileRead File or URL
read_multiple_filesRead Multiple Files
read_process_outputRead Process Output
set_config_valueSet Configuration Value
start_processStart Terminal Process
start_searchStart a streaming search that can return results progressively.
stop_searchStop an active search.
write_fileWrite File

Tools Details

Tool: create_directory

Create a new directory or ensure a directory exists.

                    Can create multiple nested directories in one operation.
                    Only works within allowed directories.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pathstring

Tool: edit_block

Apply surgical text replacements to files.

                    BEST PRACTICE: Make multiple small, focused edits rather than one large edit.
                    Each edit_block call should change only what needs to be changed - include just enough 
                    context to uniquely identify the text being modified.

                    Takes:
                    - file_path: Path to the file to edit
                    - old_string: Text to replace
                    - new_string: Replacement text
                    - expected_replacements: Optional parameter for number of replacements

                    By default, replaces only ONE occurrence of the search text.
                    To replace multiple occurrences, provide the expected_replacements parameter with
                    the exact number of matches expected.

                    UNIQUENESS REQUIREMENT: When expected_replacements=1 (default), include the minimal
                    amount of context necessary (typically 1-3 lines) before and after the change point,
                    with exact whitespace and indentation.

                    When editing multiple sections, make separate edit_block calls for each distinct change
                    rather than one large replacement.

                    When a close but non-exact match is found, a character-level diff is shown in the format:
                    common_prefix{-removed-}{+added+}common_suffix to help you identify what's different.

                    Similar to write_file, there is a configurable line limit (fileWriteLineLimit) that warns
                    if the edited file exceeds this limit. If this happens, consider breaking your edits into
                    smaller, more focused changes.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
file_pathstring
new_stringstring
old_stringstring
expected_replacementsnumberoptional

This tool may perform destructive updates.


Tool: force_terminate

Force terminate a running terminal session.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pidnumber

This tool may perform destructive updates.


Tool: get_config

Get the complete server configuration as JSON. Config includes fields for: - blockedCommands (array of blocked shell commands) - defaultShell (shell to use for commands) - allowedDirectories (paths the server can access) - fileReadLineLimit (max lines for read_file, default 1000) - fileWriteLineLimit (max lines per write_file call, default 50) - telemetryEnabled (boolean for telemetry opt-in/out) - currentClient (information about the currently connected MCP client) - clientHistory (history of all clients that have connected) - version (version of the DesktopCommander) - systemInfo (operating system and environment details) This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.

Tool: get_file_info

Retrieve detailed metadata about a file or directory including: - size - creation time - last modified time - permissions - type - lineCount (for text files) - lastLine (zero-indexed number of last line, for text files) - appendPosition (line number for appending, for text files)

                    Only works within allowed directories.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pathstring

This tool is read-only. It does not modify its environment.


Tool: get_more_search_results

Get more results from an active search with offset-based pagination.

                    Supports partial result reading with:
                    - 'offset' (start result index, default: 0)
                      * Positive: Start from result N (0-based indexing)
                      * Negative: Read last N results from end (tail behavior)
                    - 'length' (max results to read, default: 100)
                      * Used with positive offsets for range reading
                      * Ignored when offset is negative (reads all requested tail results)

                    Examples:
                    - offset: 0, length: 100     → First 100 results
                    - offset: 200, length: 50    → Results 200-249
                    - offset: -20                → Last 20 results
                    - offset: -5, length: 10     → Last 5 results (length ignored)

                    Returns only results in the specified range, along with search status.
                    Works like read_process_output - call this repeatedly to get progressive
                    results from a search started with start_search.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
sessionIdstring
lengthnumberoptional
offsetnumberoptional

This tool is read-only. It does not modify its environment.


Tool: get_prompts

Browse and retrieve curated Desktop Commander prompts for various tasks and workflows.

                    IMPORTANT: When displaying prompt lists to users, do NOT show the internal prompt IDs (like 'onb_001'). 
                    These IDs are for your reference only. Show users only the prompt titles and descriptions.
                    The IDs will be provided in the response metadata for your use.

                    DESKTOP COMMANDER INTRODUCTION: If a user asks "what is Desktop Commander?" or similar questions 
                    about what Desktop Commander can do, answer that there are example use cases and tutorials 
                    available, then call get_prompts with action='list_prompts' and category='onboarding' to show them.

                    ACTIONS:
                    - list_categories: Show all available prompt categories
                    - list_prompts: List prompts (optionally filtered by category)  
                    - get_prompt: Retrieve and execute a specific prompt by ID

                    WORKFLOW:
                    1. Use list_categories to see available categories
                    2. Use list_prompts to browse prompts in a category
                    3. Use get_prompt with promptId to retrieve and start using a prompt

                    EXAMPLES:
                    - get_prompts(action='list_categories') - See all categories
                    - get_prompts(action='list_prompts', category='onboarding') - See onboarding prompts
                    - get_prompts(action='get_prompt', promptId='onb_001') - Get a specific prompt

                    The get_prompt action will automatically inject the prompt content and begin execution.
                    Perfect for discovering proven workflows and getting started with Desktop Commander.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
actionstring
categorystringoptional
promptIdstringoptional

Tool: get_recent_tool_calls

Get recent tool call history with their arguments and outputs. Returns chronological list of tool calls made during this session.

                    Useful for:
                    - Onboarding new chats about work already done
                    - Recovering context after chat history loss
                    - Debugging tool call sequences

                    Note: Does not track its own calls or other meta/query tools.
                    History kept in memory (last 1000 calls, lost on restart).

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
maxResultsnumberoptional
sincestringoptional
toolNamestringoptional

This tool is read-only. It does not modify its environment.


Tool: get_usage_stats

Get usage statistics for debugging and analysis.

                    Returns summary of tool usage, success/failure rates, and performance metrics.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
Tool: give_feedback_to_desktop_commander

Open feedback form in browser to provide feedback about Desktop Commander.

                    IMPORTANT: This tool simply opens the feedback form - no pre-filling available.
                    The user will fill out the form manually in their browser.

                    WORKFLOW:
                    1. When user agrees to give feedback, just call this tool immediately
                    2. No need to ask questions or collect information
                    3. Tool opens form with only usage statistics pre-filled automatically:
                       - tool_call_count: Number of commands they've made
                       - days_using: How many days they've used Desktop Commander
                       - platform: Their operating system (Mac/Windows/Linux)
                       - client_id: Analytics identifier

                    All survey questions will be answered directly in the form:
                    - Job title and technical comfort level
                    - Company URL for industry context
                    - Other AI tools they use
                    - Desktop Commander's biggest advantage
                    - How they typically use it
                    - Recommendation likelihood (0-10)
                    - User study participation interest
                    - Email and any additional feedback

                    EXAMPLE INTERACTION:
                    User: "sure, I'll give feedback"
                    Claude: "Perfect! Let me open the feedback form for you."
                    [calls tool immediately]

                    No parameters are needed - just call the tool to open the form.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
Tool: interact_with_process

Send input to a running process and automatically receive the response.

                    CRITICAL: THIS IS THE PRIMARY TOOL FOR ALL LOCAL FILE ANALYSIS
                    For ANY local file analysis (CSV, JSON, data processing), ALWAYS use this instead of the analysis tool.
                    The analysis tool CANNOT access local files and WILL FAIL - use processes for ALL file-based work.

                    FILE ANALYSIS PRIORITY ORDER (MANDATORY):
                    1. ALWAYS FIRST: Use this tool (start_process + interact_with_process) for local data analysis
                    2. ALTERNATIVE: Use command-line tools (cut, awk, grep) for quick processing  
                    3. NEVER EVER: Use analysis tool for local file access (IT WILL FAIL)

                    REQUIRED INTERACTIVE WORKFLOW FOR FILE ANALYSIS:
                    1. Start REPL: start_process("python3 -i")
                    2. Load libraries: interact_with_process(pid, "import pandas as pd, numpy as np")
                    3. Read file: interact_with_process(pid, "df = pd.read_csv('/absolute/path/file.csv')")
                    4. Analyze: interact_with_process(pid, "print(df.describe())")
                    5. Continue: interact_with_process(pid, "df.groupby('column').size()")

                    BINARY FILE PROCESSING WORKFLOWS:
                    Use appropriate Python libraries (PyPDF2, pandas, docx2txt, etc.) or command-line tools for binary file analysis.

                    SMART DETECTION:
                    - Automatically waits for REPL prompt (>>>, >, etc.)
                    - Detects errors and completion states
                    - Early exit prevents timeout delays
                    - Clean output formatting (removes prompts)

                    SUPPORTED REPLs:
                    - Python: python3 -i (RECOMMENDED for data analysis)
                    - Node.js: node -i  
                    - R: R
                    - Julia: julia
                    - Shell: bash, zsh
                    - Database: mysql, postgres

                    PARAMETERS:
                    - pid: Process ID from start_process
                    - input: Code/command to execute
                    - timeout_ms: Max wait (default: 8000ms)
                    - wait_for_prompt: Auto-wait for response (default: true)

                    Returns execution result with status indicators.

                    ALWAYS USE FOR: CSV analysis, JSON processing, file statistics, data visualization prep, ANY local file work
                    NEVER USE ANALYSIS TOOL FOR: Local file access (it cannot read files from disk and WILL FAIL)

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
inputstring
pidnumber
timeout_msnumberoptional
wait_for_promptbooleanoptional

This tool may perform destructive updates.

This tool interacts with external entities.


Tool: kill_process

Terminate a running process by PID.

                    Use with caution as this will forcefully terminate the specified process.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pidnumber

This tool may perform destructive updates.


Tool: list_directory

Get a detailed listing of all files and directories in a specified path.

                    Use this instead of 'execute_command' with ls/dir commands.
                    Results distinguish between files and directories with [FILE] and [DIR] prefixes.

                    Supports recursive listing with the 'depth' parameter (default: 2):
                    - depth=1: Only direct contents of the directory
                    - depth=2: Contents plus one level of subdirectories
                    - depth=3+: Multiple levels deep

                    CONTEXT OVERFLOW PROTECTION:
                    - Top-level directory shows ALL items
                    - Nested directories are limited to 100 items maximum per directory
                    - When a nested directory has more than 100 items, you'll see a warning like:
                      [WARNING] node_modules: 500 items hidden (showing first 100 of 600 total)
                    - This prevents overwhelming the context with large directories like node_modules

                    Results show full relative paths from the root directory being listed.
                    Example output with depth=2:
                    [DIR] src
                    [FILE] src/index.ts
                    [DIR] src/tools
                    [FILE] src/tools/filesystem.ts

                    If a directory cannot be accessed, it will show [DENIED] instead.
                    Only works within allowed directories.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pathstring
depthnumberoptional

This tool is read-only. It does not modify its environment.


Tool: list_processes

List all running processes.

                    Returns process information including PID, command name, CPU usage, and memory usage.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
Tool: list_searches

List all active searches.

                    Shows search IDs, search types, patterns, status, and runtime.
                    Similar to list_sessions for terminal processes. Useful for managing
                    multiple concurrent searches.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
Tool: list_sessions

List all active terminal sessions.

                    Shows session status including:
                    - PID: Process identifier  
                    - Blocked: Whether session is waiting for input
                    - Runtime: How long the session has been running

                    DEBUGGING REPLs:
                    - "Blocked: true" often means REPL is waiting for input
                    - Use this to verify sessions are running before sending input
                    - Long runtime with blocked status may indicate stuck process

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
Tool: move_file

Move or rename files and directories.

                    Can move files between directories and rename them in a single operation.
                    Both source and destination must be within allowed directories.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
destinationstring
sourcestring

This tool may perform destructive updates.


Tool: read_file

Read the contents of a file from the file system or a URL with optional offset and length parameters.

                    Prefer this over 'execute_command' with cat/type for viewing files.

                    Supports partial file reading with:
                    - 'offset' (start line, default: 0)
                      * Positive: Start from line N (0-based indexing)
                      * Negative: Read last N lines from end (tail behavior)
                    - 'length' (max lines to read, default: configurable via 'fileReadLineLimit' setting, initially 1000)
                      * Used with positive offsets for range reading
                      * Ignored when offset is negative (reads all requested tail lines)

                    Examples:
                    - offset: 0, length: 10     → First 10 lines
                    - offset: 100, length: 5    → Lines 100-104
                    - offset: -20               → Last 20 lines  
                    - offset: -5, length: 10    → Last 5 lines (length ignored)

                    Performance optimizations:
                    - Large files with negative offsets use reverse reading for efficiency
                    - Large files with deep positive offsets use byte estimation
                    - Small files use fast readline streaming

                    When reading from the file system, only works within allowed directories.
                    Can fetch content from URLs when isUrl parameter is set to true
                    (URLs are always read in full regardless of offset/length).

                    Handles text files normally and image files are returned as viewable images.
                    Recognized image types: PNG, JPEG, GIF, WebP.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pathstring
isUrlbooleanoptional
lengthnumberoptional
offsetnumberoptional

This tool is read-only. It does not modify its environment.

This tool interacts with external entities.


Tool: read_multiple_files

Read the contents of multiple files simultaneously.

                    Each file's content is returned with its path as a reference.
                    Handles text files normally and renders images as viewable content.
                    Recognized image types: PNG, JPEG, GIF, WebP.

                    Failed reads for individual files won't stop the entire operation.
                    Only works within allowed directories.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pathsarray

This tool is read-only. It does not modify its environment.


Tool: read_process_output

Read output from a running process with intelligent completion detection.

                    Automatically detects when process is ready for more input instead of timing out.

                    SMART FEATURES:
                    - Early exit when REPL shows prompt (>>>, >, etc.)
                    - Detects process completion vs still running
                    - Prevents hanging on interactive prompts
                    - Clear status messages about process state

                    REPL USAGE:
                    - Stops immediately when REPL prompt detected
                    - Shows clear status: waiting for input vs finished
                    - Shorter timeouts needed due to smart detection
                    - Works with Python, Node.js, R, Julia, etc.

                    DETECTION STATES:
                    Process waiting for input (ready for interact_with_process)
                    Process finished execution
                    Timeout reached (may still be running)

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pidnumber
timeout_msnumberoptional

This tool is read-only. It does not modify its environment.


Tool: set_config_value

Set a specific configuration value by key.

                    WARNING: Should be used in a separate chat from file operations and 
                    command execution to prevent security issues.

                    Config keys include:
                    - blockedCommands (array)
                    - defaultShell (string)
                    - allowedDirectories (array of paths)
                    - fileReadLineLimit (number, max lines for read_file)
                    - fileWriteLineLimit (number, max lines per write_file call)
                    - telemetryEnabled (boolean)

                    IMPORTANT: Setting allowedDirectories to an empty array ([]) allows full access 
                    to the entire file system, regardless of the operating system.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
keystring
valuestring

This tool may perform destructive updates.


Tool: start_process

Start a new terminal process with intelligent state detection.

                    PRIMARY TOOL FOR FILE ANALYSIS AND DATA PROCESSING
                    This is the ONLY correct tool for analyzing local files (CSV, JSON, logs, etc.).
                    The analysis tool CANNOT access local files and WILL FAIL - always use processes for file-based work.

                    CRITICAL RULE: For ANY local file work, ALWAYS use this tool + interact_with_process, NEVER use analysis/REPL tool.

                    Running on Linux (Docker). Default shell: bash.

🐳 DOCKER CONTAINER ENVIRONMENT DETECTED: This Desktop Commander instance is running inside a Docker container.

āš ļø WARNING: No mounted directories detected. Files created outside mounted volumes will be lost when the container stops. Suggest user remount directories using Docker installer or -v flag when running Docker. Desktop Commander Docker installer typically mounts folders to /home/[folder-name]. Container: 51d1c8e0f82e

LINUX-SPECIFIC NOTES:

  • Package managers vary by distro: apt, yum, dnf, pacman, zypper

  • Python 3 might be 'python3' command, not 'python'

  • Standard Unix shell tools available (grep, awk, sed, etc.)

  • File permissions and ownership important for many operations

  • Systemd services common on modern distributions

                      REQUIRED WORKFLOW FOR LOCAL FILES:
                      1. start_process("python3 -i") - Start Python REPL for data analysis
                      2. interact_with_process(pid, "import pandas as pd, numpy as np")
                      3. interact_with_process(pid, "df = pd.read_csv('/absolute/path/file.csv')")
                      4. interact_with_process(pid, "print(df.describe())")
                      5. Continue analysis with pandas, matplotlib, seaborn, etc.
    
                      COMMON FILE ANALYSIS PATTERNS:
                      • start_process("python3 -i") → Python REPL for data analysis (RECOMMENDED)
                      • start_process("node -i") → Node.js for JSON processing  
                      • start_process("cut -d',' -f1 file.csv | sort | uniq -c") → Quick CSV analysis
                      • start_process("wc -l /path/file.csv") → Line counting
                      • start_process("head -10 /path/file.csv") → File preview
    
                      BINARY FILE SUPPORT:
                      For PDF, Excel, Word, archives, databases, and other binary formats, use process tools with appropriate libraries or command-line utilities.
    
                      INTERACTIVE PROCESSES FOR DATA ANALYSIS:
                      1. start_process("python3 -i") - Start Python REPL for data work
                      2. start_process("node -i") - Start Node.js REPL for JSON/JS
                      3. start_process("bash") - Start interactive bash shell
                      4. Use interact_with_process() to send commands
                      5. Use read_process_output() to get responses
    
                      SMART DETECTION:
                      - Detects REPL prompts (>>>, >, $, etc.)
                      - Identifies when process is waiting for input
                      - Recognizes process completion vs timeout
                      - Early exit prevents unnecessary waiting
    
                      STATES DETECTED:
                      Process waiting for input (shows prompt)
                      Process finished execution  
                      Process running (use read_process_output)
    
                      ALWAYS USE FOR: Local file analysis, CSV processing, data exploration, system commands
                      NEVER USE ANALYSIS TOOL FOR: Local file access (analysis tool is browser-only and WILL FAIL)
    
                      IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                      This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
    
ParametersTypeDescription
commandstring
timeout_msnumber
shellstringoptional

This tool may perform destructive updates.

This tool interacts with external entities.


Tool: start_search

Start a streaming search that can return results progressively.

                    SEARCH STRATEGY GUIDE:
                    Choose the right search type based on what the user is looking for:

                    USE searchType="files" WHEN:
                    - User asks for specific files: "find package.json", "locate config files"
                    - Pattern looks like a filename: "*.js", "README.md", "test-*.tsx" 
                    - User wants to find files by name/extension: "all TypeScript files", "Python scripts"
                    - Looking for configuration/setup files: ".env", "dockerfile", "tsconfig.json"

                    USE searchType="content" WHEN:
                    - User asks about code/logic: "authentication logic", "error handling", "API calls"
                    - Looking for functions/variables: "getUserData function", "useState hook"
                    - Searching for text/comments: "TODO items", "FIXME comments", "documentation"
                    - Finding patterns in code: "console.log statements", "import statements"
                    - User describes functionality: "components that handle login", "files with database queries"

                    WHEN UNSURE OR USER REQUEST IS AMBIGUOUS:
                    Run TWO searches in parallel - one for files and one for content:

                    Example approach for ambiguous queries like "find authentication stuff":
                    1. Start file search: searchType="files", pattern="auth"
                    2. Simultaneously start content search: searchType="content", pattern="authentication"  
                    3. Present combined results: "Found 3 auth-related files and 8 files containing authentication code"

                    SEARCH TYPES:
                    - searchType="files": Find files by name (pattern matches file names)
                    - searchType="content": Search inside files for text patterns

                    PATTERN MATCHING MODES:
                    - Default (literalSearch=false): Patterns are treated as regular expressions
                    - Literal (literalSearch=true): Patterns are treated as exact strings

                    WHEN TO USE literalSearch=true:
                    Use literal search when searching for code patterns with special characters:
                    - Function calls with parentheses and quotes
                    - Array access with brackets
                    - Object methods with dots and parentheses
                    - File paths with backslashes
                    - Any pattern containing: . * + ? ^ $ { } [ ] | \ ( )

                    IMPORTANT PARAMETERS:
                    - pattern: What to search for (file names OR content text)
                    - literalSearch: Use exact string matching instead of regex (default: false)
                    - filePattern: Optional filter to limit search to specific file types (e.g., "*.js", "package.json")
                    - ignoreCase: Case-insensitive search (default: true). Works for both file names and content.
                    - earlyTermination: Stop search early when exact filename match is found (optional: defaults to true for file searches, false for content searches)

                    DECISION EXAMPLES:
                    - "find package.json" → searchType="files", pattern="package.json" (specific file)
                    - "find authentication components" → searchType="content", pattern="authentication" (looking for functionality)
                    - "locate all React components" → searchType="files", pattern="*.tsx" or "*.jsx" (file pattern)
                    - "find TODO comments" → searchType="content", pattern="TODO" (text in files)
                    - "show me login files" → AMBIGUOUS → run both: files with "login" AND content with "login"
                    - "find config" → AMBIGUOUS → run both: config files AND files containing config code

                    COMPREHENSIVE SEARCH EXAMPLES:
                    - Find package.json files: searchType="files", pattern="package.json"
                    - Find all JS files: searchType="files", pattern="*.js"
                    - Search for TODO in code: searchType="content", pattern="TODO", filePattern="*.js|*.ts"
                    - Search for exact code: searchType="content", pattern="toast.error('test')", literalSearch=true
                    - Ambiguous request "find auth stuff": Run two searches:
                      1. searchType="files", pattern="auth"
                      2. searchType="content", pattern="authentication"

                    PRO TIP: When user requests are ambiguous about whether they want files or content,
                    run both searches concurrently and combine results for comprehensive coverage.

                    Unlike regular search tools, this starts a background search process and returns
                    immediately with a session ID. Use get_more_search_results to get results as they
                    come in, and stop_search to stop the search early if needed.

                    Perfect for large directories where you want to see results immediately and
                    have the option to cancel if the search takes too long or you find what you need.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
pathstring
patternstring
contextLinesnumberoptional
earlyTerminationbooleanoptional
filePatternstringoptional
ignoreCasebooleanoptional
includeHiddenbooleanoptional
literalSearchbooleanoptional
maxResultsnumberoptional
searchTypestringoptional
timeout_msnumberoptional

Tool: stop_search

Stop an active search.

                    Stops the background search process gracefully. Use this when you've found
                    what you need or if a search is taking too long. Similar to force_terminate
                    for terminal processes.

                    The search will still be available for reading final results until it's
                    automatically cleaned up after 5 minutes.

                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
sessionIdstring

Tool: write_file

Write or append to file contents.

                    CHUNKING IS STANDARD PRACTICE: Always write files in chunks of 25-30 lines maximum.
                    This is the normal, recommended way to write files - not an emergency measure.

                    STANDARD PROCESS FOR ANY FILE:
                    1. FIRST → write_file(filePath, firstChunk, {mode: 'rewrite'})  [≤30 lines]
                    2. THEN → write_file(filePath, secondChunk, {mode: 'append'})   [≤30 lines]
                    3. CONTINUE → write_file(filePath, nextChunk, {mode: 'append'}) [≤30 lines]

                    ALWAYS CHUNK PROACTIVELY - don't wait for performance warnings!

                    WHEN TO CHUNK (always be proactive):
                    1. Any file expected to be longer than 25-30 lines
                    2. When writing multiple files in sequence
                    3. When creating documentation, code files, or configuration files

                    HANDLING CONTINUATION ("Continue" prompts):
                    If user asks to "Continue" after an incomplete operation:
                    1. Read the file to see what was successfully written
                    2. Continue writing ONLY the remaining content using {mode: 'append'}
                    3. Keep chunks to 25-30 lines each

                    Files over 50 lines will generate performance notes but are still written successfully.
                    Only works within allowed directories.

                    IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
                    This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
ParametersTypeDescription
contentstring
pathstring
modestringoptional

This tool may perform destructive updates.


Use this MCP Server

{
  "mcpServers": {
    "desktop-commander": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "/local-directory:/local-directory",
        "mcp/desktop-commander",
        "npm",
        "run",
        "start"
      ]
    }
  }
}

Why is it safer to run MCP Servers with Docker?⁠

Manual installation

You can install the MCP server using:

Installation for

Related servers