Tauri Plugin: Model Context Protocol (MCP)

A Tauri plugin and MCP server that allow AI Agents such as Cursor and Claude Code to debug within your tauri application.

Features

The Tauri MCP Plugin provides a comprehensive set of tools that allow AI models and external applications to interact with Tauri applications:

Window Interaction

• Take Screenshot: Capture images of any Tauri window with configurable quality and size
• Window Management: Control window position, size, focus, minimize/maximize state
• DOM Access: Retrieve the HTML DOM content from webviews windows

User Input Simulation

• Mouse Movement: Simulate mouse clicks, movements, and scrolling
• Text Input: Programmatically input text into focused elements
• Execute JavaScript: Run arbitrary JavaScript code in the application context

Data & Storage

• Local Storage Management: Get, set, remove, and clear localStorage entries
• Ping: Simple connectivity testing to verify the plugin is responsive

How to build

pnpm i 
pnpm run build && pnpm run build-plugin

Follow instructions at https://v2.tauri.app/start/create-project/

in src-tauri/cargo.toml add

tauri-plugin-mcp = { path = "../../tauri-plugin-mcp" }

In package.json

    "tauri-plugin-mcp": "file:../tauri-mcp",

Then, register the plugin in your Tauri application:

Only include the MCP plugin in development builds

Take care to set the Application name correctly, this is how it identifies the window to screenshot

    #[cfg(debug_assertions)]
    {
        info!("Development build detected, enabling MCP plugin");
        tauri::Builder::default()
        .plugin(tauri_mcp::init_with_config(
         tauri_mcp::PluginConfig::new("APPLICATION_NAME".to_string())
                .start_socket_server(true)
                // For IPC socket (default)
                .socket_path("/tmp/tauri-mcp.sock")
                // Or for TCP socket
                // .tcp("127.0.0.1", 9999)
                // For multi-webview architectures where the window label differs
                // from the webview label (e.g., window "main" contains webview "preview")
                // .default_webview_label("preview".to_string())
        ));
    }

Setting up MCP Server

First, build the MCP server:

cd mcp-server-ts
pnpm i
pnpm build

Configuration Examples

IPC Mode (Default)

This is the default mode using platform-specific local sockets:

{
  "mcpServers": {
    "tauri-mcp": {
      "command": "node",
      "args": ["C:\\Users\\Pegleg\\workspace\\tauri-plugin-mcp\\mcp-server-ts\\build\\index.js"]
    }
  }
}

Or with a custom socket path:

{
  "mcpServers": {
    "tauri-mcp": {
      "command": "node",
      "args": ["C:\\Users\\Pegleg\\workspace\\tauri-plugin-mcp\\mcp-server-ts\\build\\index.js"],
      "env": {
        "TAURI_MCP_IPC_PATH": "/custom/path/to/socket"
      }
    }
  }
}

TCP Mode

For TCP connections (useful for Docker, remote debugging, or when IPC doesn't work):

{
  "mcpServers": {
    "tauri-mcp": {
      "command": "node",
      "args": ["C:\\Users\\Pegleg\\workspace\\tauri-plugin-mcp\\mcp-server-ts\\build\\index.js"],
      "env": {
        "TAURI_MCP_CONNECTION_TYPE": "tcp",
        "TAURI_MCP_TCP_HOST": "127.0.0.1",
        "TAURI_MCP_TCP_PORT": "4000"
      }
    }
  }
}

Important: Make sure your Tauri app is configured to use the same connection mode and settings:

// For TCP mode in your Tauri app
.plugin(tauri_mcp::init_with_config(
    PluginConfig::new("MyApp".to_string())
        .tcp("127.0.0.1".to_string(), 4000)
))

Communication Between Tauri Plugin MCP Components

The Tauri MCP plugin supports both IPC and TCP socket communication to expose Tauri application functionality to external clients:

Socket Server (Rust)

The socket_server.rs component:

• Creates either an IPC socket (Unix socket on macOS/Linux, named pipe on Windows) or TCP socket
• Listens for client connections on the configured socket
• Processes incoming JSON commands
• Executes Tauri API calls based on the commands
• Returns results as JSON responses

Socket Client (TypeScript)

The client.ts component:

• Connects to either IPC or TCP socket based on environment configuration
• Provides a Promise-based API for sending commands
• Handles reconnection logic and error management
• Parses JSON responses from the server

Troubleshooting

Common Issues

1. "Connection refused" error
2. Ensure your Tauri app is running and the socket server started successfully
3. Check that both sides are using the same connection mode (IPC or TCP)

4. For TCP, verify the port number matches on both sides

5. "Socket file not found" (IPC mode)

6. Check the socket path exists (look in /tmp on macOS/Linux)
7. Ensure proper permissions to create/access the socket file

8. Try using TCP mode as an alternative

9. "Permission denied" errors

10. On Windows, ensure the named pipe path is correct
11. On Unix systems, check file permissions for the socket

12. Consider using TCP mode which avoids file permission issues

13. Connection drops after each request

14. Update to the latest version which includes persistent connection support
15. Check for any errors in the Tauri app console

Testing Your Setup

You can test your MCP server configuration using the MCP Inspector:

# For IPC mode (default)
cd mcp-server-ts
npx @modelcontextprotocol/inspector node build/index.js

# For TCP mode
cd mcp-server-ts
set TAURI_MCP_CONNECTION_TYPE=tcp&& set TAURI_MCP_TCP_HOST=127.0.0.1&& set TAURI_MCP_TCP_PORT=4000&& npx @modelcontextprotocol/inspector node build\index.js