# MCPHub Desktop: a local first MCP server manager on Tauri 2 > MCPHub Desktop is a Tauri 2 desktop client for people who want their MCP servers, skills, RAG knowledge base and embedding models managed on their own machine rather than through a hosted hub. It ships Node, uv and Bun runtimes with the app, stores data in local SQLite, and keeps keys in the operating system keyring, with a Rust rewrite of an upstream web project. **skrstop/MCPHub-Desktop** — MCPHub Desktop 是一款基于 Tauri 2 构建的桌面客户端，用于在个人电脑上统一管理 MCP服务器、Skills、RAG 知识库。所有进程、配置、密钥与向量数据都运行/保存在用户自己的机器上，不依赖任何远端服务。 - Repository: https://github.com/skrstop/MCPHub-Desktop - Stars: 1,061 · Forks: 38 - Language: Rust - License: not declared - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/skrstop-mcphub-desktop ## A desktop client where the server side belongs to someone else The repository contains more than one project, and the distinction is stated at the top of the file because it matters legally and technically. The mcphub-origin directory is a source snapshot of the third party open source project samanhappy/mcphub, and the copyright stays with the original author and contributors. It is included for three stated reasons: to make the rewrite traceable, to make it possible to compare the desktop and web versions, and to consult the original documentation offline. The project own code is limited to four directories: frontend, src-tauri, scripts and locales, plus the root configuration files. Changes inside mcphub-origin are forbidden. The positioning difference is then set out in a table. The upstream project is a server side, team facing MCP aggregation web service: a Node.js service on Express with ESM, a React and Vite and Tailwind front end, JSON files or PostgreSQL for storage, JWT plus bcrypt authentication configured through environment variables, and Docker or npm CLI distribution. MCPHub Desktop is a personal desktop client: a Tauri 2 native application with a Rust backend in src-tauri, local SQLite at $APPDATA/mcphub.db through sqlx 0.8, JWT plus bcrypt with keys in the operating system keyring, and platform native installers as dmg, msi or AppImage with automatic updates. The upstream front end is reused, copied into frontend and adapted where the Tauri invoke boundary requires it. ## Servers, runtimes and routing, all local The MCP server management is the part that inherits from the upstream project. You get a local unified view of multiple MCP servers, with start, stop, debug and grouping, and the processes are supervised by Rust rather than by a Node service. Authentication to the servers themselves covers Bearer keys, OAuth and OIDC, and there is an activity log. The part that is new for a desktop build is the runtime handling. Node, UV and Bun runtimes are distributed with the package, and they live under src-tauri/runtimes. The stated point is that it works out of the box with no environment preinstalled, which is the usual objection to asking a non developer to run an MCP server locally. There is a script to fetch those runtimes on first setup. ```bash bash scripts/download-runtimes.sh ``` Grouping and smart routing sit alongside the per server controls. The routing piece matters when you have more than one server exposing similar tools: the client decides which one to call rather than leaving you to remember which server has the search tool and which has the file write tool. Communication between front end and back end uses the Tauri invoke mechanism, with a fetchInterceptor in the front end that forwards calls transparently. The upstream project instead exposes HTTP /api/* endpoints to a browser. Same features, different transport. ## Skills as a shared library across agents The skills feature is aimed at people who work with several AI agents on the same machine and are tired of maintaining the same skill folder in five places. A skill library is imported by scanning the skill directories of installed agents or by pointing at a folder manually, and from there you can view, uninstall and organise the collection. Installation into agents is one click, and the built in catalogue of agent directories lives in src-tauri/runtimes/skill/install.json. The named clients include Claude Code, Cursor, Windsurf, Cline, Roo Code, Continue, Goose, OpenHands and Codex, and custom agent paths are also supported. Two installation modes are offered and the difference is a real one. A symlink means the source library stays authoritative, so a change in the library is reflected in the agent immediately and no space is duplicated. A copy produces an independent copy, which is what you want when the agent needs to keep its own version, for example when distributing a skill to someone else. Because the library is shared, the record of what happened is tracked per skill: which agents it has been installed into and by which method. That is a small detail that makes a shared library auditable rather than mysterious. ## The RAG knowledge base and how it chunks your files The knowledge base is the feature with the most moving parts, and the interesting part is the chunking strategy, which is chosen by strategy pattern rather than by a fixed length. Ordinary text is split on Unicode word and sentence boundaries, Markdown on block and heading boundaries, and source code on tree-sitter AST boundaries, with the dispatch made automatically by file extension. The tree-sitter crate handles the code case. Chunk parameters adapt to the model. chunk_size and chunk_overlap default to Auto, which takes the recommended values from the model's deploy.json and clamps them to the model context window. Turning Auto off lets you set both values by hand. The rest of the feature list is about control and visibility. You can inspect the chunk contents of any document, filter searches by tag, and deleting a document also removes the local file and its vectors. Files are rendered by type in the viewer, with code coloured through highlight.js and search snippets highlighted the same way. What makes this interesting for agent use is the tool exposure. The knowledge base is reachable through MCP tools over tools/call: rag_file_create, rag_file_update, rag_search, rag_get and rag_tag_search among them. The library becomes something an agent calls directly, which is what turns it into long term memory across sessions rather than a document store you have to paste from. ## Embedding models bundled as GGUF with per model deploy settings The embedding models are handled locally, with the GGUF format through the candle backend and automatic format detection. The architectures listed as supported are Gemma3, Qwen3, nomic-bert-moe, LFM2 and modern-bert, with Granite Embedding 97M Multilingual R2 given as an example of the last. Models are either distributed with the package or downloaded on demand, and execution prefers the GPU through Metal or CUDA with a CPU fallback. That fallback matters, because a purely CPU embedded inference path is what determines whether the knowledge base is usable on a laptop without a discrete GPU. Every model ships with a deploy.json that declares the platform, either GPU, CPU or AUTO, a description, whether it is the default, whether the embedding is asymmetric with a prefix, and the recommended chunk size. That last field is what connects the model catalogue to the chunker: the recommended chunk size in the model manifest is what the Auto chunk parameter mode reads, so changing embedding models does not leave you with chunks sized for the previous model. The vector data itself is stored locally, with the comparison table naming lancedb as the vector store. ## Getting it running from source on macOS, Windows or Linux The requirements are macOS, Windows or Linux, Node.js 18 or newer, Rust stable with cargo where the MSRV is stated in src-tauri/Cargo.toml, and the Tauri 2 system prerequisites. Once the runtimes are in place, the shell and front end dependencies are installed with two npm calls. ```bash npm install cd frontend && npm install && cd .. ``` Development mode starts the front end dev server and loads the Rust back end at the same time. ```bash npm run dev ``` That command is equivalent to tauri dev, and the package.json at the root defines three scripts: tauri, dev and build, with dev and build being tauri dev and tauri build. The build produces platform installers into src-tauri/target/release/bundle. ```bash npm run build ``` End users do not need any of this. Installers are published on the Releases page, and Linux users pick a deb, an AppImage or an rpm for their distribution. One macOS wrinkle is documented and worth knowing before you file a bug. If macOS reports that the app is damaged and cannot be opened, that is because the binary is not signed with an Apple developer certificate, and clearing the quarantine attribute fixes it. ```bash xattr -cr "/Applications/MCPHub Desktop.app" ``` ## Ports, crashes on first launch and what the docs leave open Two operational issues are described with their fixes, which tells you what a first run looks like in practice. The HTTP service is how external clients reach the hub, and its port in the dashboard and settings defaults to 23333. If the service fails to start, the application shows an error and writes a log, visible on the logs page inside the app. The usual causes given are the port already being in use, in which case you change the HTTP service port in settings and restart, and the Windows firewall blocking the application from listening or being reached, which is handled in Windows Security Center under the firewall settings. There is also a first launch crash on Windows for a minority of installs, where launching straight from the installer exits immediately and a manual relaunch works. The mitigation listed is that the installer now installs per user with installMode: currentUser and no longer asks for elevation, which removes the elevated start failure. A startup crash log was added, and the locations are the application data directory: on Windows %APPDATA%\app.mcphub.desktop\crash.log, on macOS ~/Library/Application Support/app.mcphub.desktop/crash.log, and on Linux under the local share directory. Two things the project leaves open are worth naming. The licence for the project own code is not stated, even though the vendored upstream snapshot carries an MIT licence, so redistribution terms for the desktop build are not settled by the file. And the current version lives in src-tauri/tauri.conf.json rather than in a tag, with the release list showing v1.1.3010 on 2026-10-12 while the root package.json reads 1.1.3011. ## Conclusion Adopt MCPHub Desktop if you are an individual running several MCP servers on one workstation and want them grouped, routable and inspectable from a single window, together with a skills library and a local vector knowledge base that never leaves the machine. Do not pick it for a shared or server side deployment, since the upstream web project covers that lane and this client is explicitly aimed at one personal machine. Verify first that the bundled runtime download step succeeds on your platform, that your agent directory is one of the supported ones listed in src-tauri/runtimes/skill/install.json, and that the licence situation is settled before you redistribute anything, since the repository does not state one for the project own code while the vendored upstream snapshot carries its own MIT licence. ## FAQ ### Does MCPHub Desktop send my data to a remote server? No. The project describes itself as local first, with all processes, configuration, keys and vector data running and stored on your own machine with no dependence on any remote service. Data is kept in local SQLite at $APPDATA/mcphub.db and authentication keys go into the operating system keyring. ### How do I build MCPHub Desktop from source? Download the bundled runtimes with bash scripts/download-runtimes.sh, install the shell and front end dependencies with npm install and cd frontend && npm install && cd .., then run npm run dev for development or npm run build to produce installers in src-tauri/target/release/bundle. You need Node.js 18 or newer, Rust stable and the Tauri 2 prerequisites. ### Which AI agents can MCPHub Desktop install skills into? The built in agent catalogue lives in src-tauri/runtimes/skill/install.json and covers Claude Code, Cursor, Windsurf, Cline, Roo Code, Continue, Goose, OpenHands and Codex among others. Custom agent paths are supported, and each skill can be installed either as a symlink that stays in sync or as an independent file copy. ### How does MCPHub Desktop let an agent use the RAG knowledge base? The knowledge base is exposed as MCP tools called through tools/call, including rag_file_create, rag_file_update, rag_search, rag_get and rag_tag_search. Documents are chunked by strategy pattern, using Unicode boundaries for plain text, block and heading boundaries for Markdown and tree-sitter AST boundaries for source code. ## Sources - [Issues](https://github.com/skrstop/MCPHub-Desktop/issues) - [README](https://github.com/skrstop/MCPHub-Desktop/blob/main/README.md) - [Releases](https://github.com/skrstop/MCPHub-Desktop/releases) - [skrstop/MCPHub-Desktop on GitHub](https://github.com/skrstop/MCPHub-Desktop) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/skrstop-mcphub-desktop