Pocket MCP Manager

Pocket MCP Manager provides a centralized proxy for multiple MCP servers, letting you launch and manage your MCP backends from a single UI and connect through one proxy in your client tools. This simplifies switching between MCP servers and keeps your integration streamlined.

How to use

Set up the server component to run as a local proxy, then connect your MCP-enabled client (such as Claude Desktop or Cursor) to the proxy. You’ll be able to select which MCP servers to run, generate API keys for those servers, and have a single API key to control access from your client.

From the client side, configure the MCP proxy as a single endpoint. Your client will send the API key to authenticate, and the proxy will route requests to the appropriate underlying MCP servers. This approach lets you swap which servers you use by updating the client’s API key without reconfiguring multiple connections.

To connect, place the proxy configuration in your client’s settings so it launches the local node process and points to the built server runtime. The client will provide the API key and the URL to the local API interface.

How to install

Prerequisites: ensure you have Node.js and npm installed on your system.

Clone the Pocket MCP Manager repository, then enter the server directory and install dependencies. The build step runs automatically during installation.

Server installation steps

git clone git@github.com:dailydaniel/pocket-mcp.git
cd pocket-mcp/server

# Install dependencies
npm install

# The build step runs automatically during installation

Connecting to Claude Desktop / Cursor

{
  "mcpServers": {
    "mcp-proxy": {
      "command": "node",
      "args": ["/full/path/to/pocket-mcp/server/build/index.js"],
      "env": {
        "MCP_API_KEY": "api_key_from_client",
        "CLIENT_API_URL": "http://localhost:<port>/api"
      }
    }
  }
}

Client setup and configuration

The client component provides a web-based UI (built with Streamlit) to view configured MCP servers, launch them as a group, generate API keys for launched servers, and manage existing API keys.

Client setup involves creating and activating a Python virtual environment, installing requirements, and running the Streamlit app. You will also prepare a servers_config.json file that lists the MCP servers you want to manage from the client.

Client setup commands

# Navigate to the client directory
cd pocket-mcp/client

# Create and activate a virtual environment
python -m venv .venv --prompt "mcp-venv"
source .venv/bin/activate

# Install requirements
pip install -r requirements.txt

# Copy the example config
cp servers_config_example.json servers_config.json

# Edit the configuration with your MCP servers
vim servers_config.json

# Run the client
streamlit run app.py

Server connection example for the client

Prepare a servers_config.json in the client to declare the MCP servers you want to use. Each server entry specifies how it is started and any environment variables needed.

Example server configuration in the client

{
  "mcpServers": {
    "jetbrains": {
      "command": "npx",
      "args": ["-y", "@jetbrains/mcp-proxy"]
    },
    "logseq": {
      "command": "uvx",
      "args": ["mcp-server-logseq"],
      "env": {
        "LOGSEQ_API_TOKEN": "API_KEY",
        "LOGSEQ_API_URL": "http://127.0.0.1:<port>"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "API_KEY"
      }
    }
  }
}

Example LLM MCP client usage

This project includes an example client for chatting with LLMs via the OpenAI API and MCP servers. It demonstrates connecting to running MCP servers and sending conversations through the unified MCP proxy.

Notes and acknowledgments

The server component is based on an MCP proxy server, and the implementation includes server-sent events (SSE) support for real-time updates.

Troubleshooting and tips

If the proxy fails to start, verify that the Node runtime is installed, the path to the built server is correct, and the MCP_API_KEY you provide from the client matches what the proxy expects.

Available tools

mcp_proxy_server

Core proxy functionality that accepts a client API key, connects to authorized MCP servers, exposes a unified MCP interface, and routes requests to the appropriate backend servers.

unified_interface

Consolidates multiple MCP servers into a single interface for client consumption and routing.

generate_api_key

Generates API keys linked to running MCP servers for client access control.

streamlit_ui

Web-based client UI built with Streamlit for viewing, launching, and configuring MCP servers and API keys.