### Set Up Development Environment

Source: https://github.com/samanhappy/mcphub/blob/main/docs/development/contributing.mdx

Follow these bash commands to clone the repository, install dependencies, configure environment variables, and start the development server.

```bash
# 1. Fork and clone the repository
git clone https://github.com/YOUR_USERNAME/mcphub.git
cd mcphub

# 2. Add upstream remote
git remote add upstream https://github.com/samanhappy/mcphub.git

# 3. Install dependencies
pnpm install

# 4. Set up environment
cp .env.example .env.development

# 5. Start development environment
docker-compose -f docker-compose.dev.yml up -d
pnpm run migrate
pnpm run seed

# 6. Start development server
pnpm run dev
```

--------------------------------

### Discovering and installing marketplace servers

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Illustrates browsing the mcphub marketplace for servers, getting detailed information, and installing them into the active hub or a client configuration file.

```bash
# Browse the active profile's hub
mcphub discover --search github --limit 10
```

```bash
mcphub discover info amap-maps
```

```bash
mcphub discover categories
```

```bash
mcphub discover tags
```

```bash
# Install into the active hub (POST /api/servers)
mcphub install amap-maps --env AMAP_MAPS_API_KEY=...
```

```bash
# Install from a different hub into the active one
mcphub install some-server --remote https://hub.example.com --yes
```

```bash
# Dry-run: just print the mcpServers snippet
mcphub install amap-maps --dry-run
```

```bash
# Install into a Claude Desktop / OpenClaw-style config file
mcphub install amap-maps --to file --out ~/Library/Application\ Support/Claude/claude_desktop_config.json
```

--------------------------------

### Manual PostgreSQL Database and User Setup

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/database-configuration.mdx

Install PostgreSQL and create a new database and user for MCPHub using psql commands.

```bash
# Install PostgreSQL (if not already installed)
sudo apt-get install postgresql postgresql-contrib

# Create database and user
sudo -u postgres psql <<EOF
CREATE DATABASE mcphub;
CREATE USER mcphub WITH ENCRYPTED PASSWORD 'your_password';
GRANT ALL PRIVILEGES ON DATABASE mcphub TO mcphub;
EOF
```

--------------------------------

### Start Production Server

Source: https://github.com/samanhappy/mcphub/blob/main/AGENTS.md

Start the production-ready server.

```bash
pnpm start
```

--------------------------------

### Clone and Run MCPHub Locally

Source: https://github.com/samanhappy/mcphub/blob/main/README.md

Clone the repository, install dependencies, and start the development server. For Windows users, backend and frontend may need to be started separately.

```bash
git clone https://github.com/samanhappy/mcphub.git
cd mcphub
pnpm install
pnpm dev
```

```bash
pnpm backend:dev
pnpm frontend:dev
```

--------------------------------

### Set Environment Variables for Manual Setup

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/database-configuration.mdx

Create a .env file to configure MCPHub with database connection details and port for manual installations.

```bash
# Simply set DB_URL to enable database mode (USE_DB is auto-detected)
DB_URL=postgresql://mcphub:your_password@localhost:5432/mcphub
PORT=3000
```

--------------------------------

### Example MCP Settings Configuration

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/mcp-settings.mdx

Provides a concrete example of an mcp_settings.json file with configurations for 'fetch', 'playwright', and 'slack' servers.

```json
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"],
      "env": {
        "USER_AGENT": "MCPHub/1.0"
      }
    },
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest", "--headless"]
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}",
        "SLACK_TEAM_ID": "${SLACK_TEAM_ID}"
      }
    }
  }
}
```

--------------------------------

### Build and Start MCPHub for Production

Source: https://github.com/samanhappy/mcphub/blob/main/docs/installation.mdx

Build the production-ready artifacts for both backend and frontend, then start the production server. This is typically done after development is complete.

```bash
# Build both backend and frontend
pnpm build

# Start production server
pnpm start
```

--------------------------------

### Start the mcphub server (legacy)

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Invoke `mcphub` without any arguments to start the server using its original behavior.

```bash
mcphub
```

--------------------------------

### Start Development Server (Both)

Source: https://github.com/samanhappy/mcphub/blob/main/AGENTS.md

Launch both the backend and frontend development servers.

```bash
pnpm dev
```

--------------------------------

### Manual Setup: Set Environment Variables

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Set the necessary environment variables for database connection, OpenAI API key, and enabling smart routing for manual setup.

```bash
export DB_URL="postgresql://mcphub:your_password@localhost:5432/mcphub"
export OPENAI_API_KEY="your_openai_api_key"
export SMART_ROUTING_ENABLED="true"
```

--------------------------------

### Install Mintlify CLI

Source: https://github.com/samanhappy/mcphub/blob/main/docs/README.md

Install the Mintlify CLI globally to preview documentation changes locally. This command is run using npm.

```bash
npm i -g mintlify
```

--------------------------------

### Install Dependencies

Source: https://github.com/samanhappy/mcphub/blob/main/AGENTS.md

Install project dependencies using pnpm.

```bash
pnpm install
```

--------------------------------

### Install Dependencies for Local Development

Source: https://github.com/samanhappy/mcphub/blob/main/docs/installation.mdx

Install project dependencies using pnpm, npm, or yarn after cloning the repository. pnpm is recommended for optimal performance.

```bash
# Install dependencies with pnpm (recommended)
pnpm install

# Or with npm
npm install

# Or with yarn
yarn install
```

--------------------------------

### Create and Configure Environment File

Source: https://github.com/samanhappy/mcphub/blob/main/docs/development/getting-started.mdx

Copy the example environment file and configure essential variables for database, JWT, and OpenAI.

```bash
cp .env.example .env
```

```env
# Server Configuration
PORT=3000
NODE_ENV=development

# Database Configuration
DB_URL=postgresql://username:password@localhost:5432/mcphub

# JWT Configuration
JWT_SECRET=your-secret-key
JWT_EXPIRES_IN=24h

# OpenAI Configuration (for smart routing)
OPENAI_API_KEY=your-openai-api-key
```

--------------------------------

### Get Database Performance Statistics

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Example of fetching database performance statistics using a GET request to the /api/smart-routing/db-stats endpoint.

```bash
curl http://localhost:3000/api/smart-routing/db-stats \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"
```

--------------------------------

### Start Development Server (Frontend Only)

Source: https://github.com/samanhappy/mcphub/blob/main/AGENTS.md

Launch only the frontend development server.

```bash
pnpm frontend:dev
```

--------------------------------

### Start Local Development Server

Source: https://github.com/samanhappy/mcphub/blob/main/docs/README.md

Run the Mintlify development server from the root of your documentation directory. Ensure docs.json is present.

```bash
mintlify dev
```

--------------------------------

### Start Development Server (Backend Only)

Source: https://github.com/samanhappy/mcphub/blob/main/AGENTS.md

Launch only the backend development server.

```bash
pnpm backend:dev
```

--------------------------------

### Start MCPHub in Development Mode

Source: https://github.com/samanhappy/mcphub/blob/main/docs/installation.mdx

Launch both the backend and frontend of MCPHub in development mode using pnpm. This command starts the backend on port 3000 and the frontend on port 5173.

```bash
# Start both backend and frontend in development mode
pnpm dev
```

--------------------------------

### Action-Oriented Query Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Illustrates an action-oriented query to find tools for creating files and uploading them to a GitHub repository.

```bash
curl -X POST http://localhost:3000/mcp/$smart \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/search",
    "params": {
      "query": "create file upload to github repository"
    }
  }'
```

--------------------------------

### Context-Aware Query Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Demonstrates a context-aware query, including project details, technologies, and environment, for more relevant results.

```bash
curl -X POST http://localhost:3000/mcp/$smart \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/search",
    "params": {
      "query": "automated testing web application",
      "context": {
        "project": "e-commerce website",
        "technologies": ["React", "Node.js"],
        "environment": "staging"
      }
    }
  }'
```

--------------------------------

### Execute a Found Tool

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Example of executing a tool named 'fetch_html' with specified arguments, such as a URL.

```bash
curl -X POST http://localhost:3000/mcp/$smart \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "fetch_html",
      "arguments": {
        "url": "https://example.com"
      }
    }
  }'
```

--------------------------------

### Start Production Environment with Docker Compose

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/docker-setup.mdx

Command to start the production environment in detached mode. Use `logs -f` to follow the logs and `down` to stop the environment.

```bash
# Start production environment
docker-compose up -d

# View logs
docker-compose logs -f mcphub

# Stop production environment
docker-compose down

```

--------------------------------

### Set Up MCPHub for Local Development

Source: https://github.com/samanhappy/mcphub/blob/main/docs/quickstart.mdx

Clone the MCPHub repository and install dependencies to set up a local development environment. This is recommended for customization and development.

```bash
# Clone the repository
git clone https://github.com/samanhappy/mcphub.git
cd mcphub

# Install dependencies
pnpm install

# Start development servers
pnpm dev
```

--------------------------------

### Get Settings

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/servers.mdx

Retrieves all server settings and configurations.

```APIDOC
## GET /api/settings

### Description
Retrieves all server settings and configurations.

### Method
GET

### Endpoint
/api/settings

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful.
- **data** (object) - Contains the server settings and configurations.
  - **data.servers** (array) - List of servers.
  - **data.groups** (array) - List of groups.
  - **data.systemConfig** (object) - System-wide configuration.

#### Response Example
```json
{
  "success": true,
  "data": {
    "servers": [...],
    "groups": [...],
    "systemConfig": {}
  }
}
```
```

--------------------------------

### Install and Run MCPHub as an npm Package

Source: https://github.com/samanhappy/mcphub/blob/main/docs/quickstart.mdx

Install MCPHub globally using npm to run it as a command-line application. This is a convenient option for users who prefer managing packages with npm.

```bash
# Install globally
npm install -g @samanhappy/mcphub

# Run MCPHub
mcphub
```

--------------------------------

### Start Development Environment with Docker Compose

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/docker-setup.mdx

Command to start the development environment in detached mode. Use `logs -f` to follow the logs and `down` to stop the environment.

```bash
# Start development environment
docker-compose -f docker-compose.dev.yml up -d

# View logs
docker-compose -f docker-compose.dev.yml logs -f mcphub-dev

# Stop development environment
docker-compose -f docker-compose.dev.yml down

```

--------------------------------

### Environment Variable Substitution Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/mcp-settings.mdx

Demonstrates how to use environment variable substitution for API keys and URLs in server configurations.

```json
{
  "mcpServers": {
    "api-server": {
      "command": "python",
      "args": ["-m", "api_server"],
      "env": {
        "API_KEY": "${API_KEY}",
        "API_URL": "${API_BASE_URL}/v1"
      }
    }
  }
}
```

--------------------------------

### Check tool schema using mcphub tools get and jq

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Demonstrates checking the input schema of a tool after finding it, using `mcphub tools get` and `jq`.

```bash
mcphub tools get fetch_url --json | jq '.inputSchema'
```

--------------------------------

### List all mcphub tools

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Get a flat list of all available tools across all connected servers.

```bash
mcphub tools list
```

--------------------------------

### Run MCPHub with Docker

Source: https://github.com/samanhappy/mcphub/blob/main/docs/index.mdx

Use this command to quickly start MCPHub using Docker. Access the dashboard at http://localhost:3000.

```bash
docker run -p 3000:3000 samanhappy/mcphub
```

--------------------------------

### Install and Reload Nginx Configuration

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/nginx.mdx

Steps to copy, update, enable, test, and reload Nginx configuration files for production deployment.

```bash
# Copy the example configuration
cp nginx.conf.example /etc/nginx/sites-available/mcphub

# Update the configuration with your domain and paths
sudo nano /etc/nginx/sites-available/mcphub

# Enable the site
sudo ln -s /etc/nginx/sites-available/mcphub /etc/nginx/sites-enabled/

# Test and reload
sudo nginx -t && sudo systemctl reload nginx
```

--------------------------------

### Task-Based Query Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Demonstrates a task-based query to find tools for sending a message to a Slack channel.

```bash
curl -X POST http://localhost:3000/mcp/$smart \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/search",
    "params": {
      "query": "send a message to a slack channel"
    }
  }'
```

--------------------------------

### List mcphub tools with schemas in JSON

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Get a machine-readable list of tools including their input schemas.

```bash
mcphub tools list --schema --json
```

--------------------------------

### Get Current User Response Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/auth.mdx

A successful GET request to /api/auth/user returns the authenticated user's details.

```json
{
  "success": true,
  "user": {
    "username": "admin",
    "isAdmin": true,
    "permissions": { ... }
  }
}
```

--------------------------------

### Get Tool Usage Analytics

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Example of retrieving tool usage analytics data using a GET request to the /api/smart-routing/analytics endpoint.

```bash
curl http://localhost:3000/api/smart-routing/analytics \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"
```

--------------------------------

### Inspect a specific mcphub tool

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Get detailed information about a tool, including its description, parameters, schema, and a sample command.

```bash
mcphub tools get fetch_url
```

--------------------------------

### Get Smart Routing Statistics

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Example of fetching Smart Routing performance statistics using a GET request to the /api/smart-routing/stats endpoint.

```bash
curl http://localhost:3000/api/smart-routing/stats \
  -H "Authorization: Bearer YOUR_JWT_TOKEN"
```

--------------------------------

### Verify MCP Server Setup

Source: https://github.com/samanhappy/mcphub/blob/main/docs/quickstart.mdx

Test your MCP server configuration by sending a POST request to list available tools.

```bash
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'
```

--------------------------------

### Domain-Specific Query Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/smart-routing.mdx

Shows a domain-specific query to find tools related to database operations and SQL queries.

```bash
curl -X POST http://localhost:3000/mcp/$smart \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/search",
    "params": {
      "query": "database operations SQL queries"
    }
  }'
```

--------------------------------

### Get All Groups Response Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/groups.mdx

This JSON shows the structure of a successful response when retrieving a list of all server groups.

```json
{
  "success": true,
  "data": [
    {
      "id": "group-1",
      "name": "My Group",
      "description": "A collection of servers.",
      "servers": ["server1", "server2"],
      "owner": "admin"
    }
  ]
}
```

--------------------------------

### Get All Server Settings

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/servers.mdx

Retrieves all server settings, configurations, groups, and system configuration. The response includes a 'data' object containing these details.

```json
{
  "success": true,
  "data": {
    "servers": [...],
    "groups": [...],
    "systemConfig": {...}
  }
}
```

--------------------------------

### Get All Logs Response

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/logs.mdx

This is an example of a successful response when retrieving all stored logs. It includes a list of log entries, each with a timestamp, level, message, and service.

```json
{
  "success": true,
  "data": [
    {
      "timestamp": "2023-10-27T10:00:00.000Z",
      "level": "info",
      "message": "Server started successfully.",
      "service": "system"
    }
  ]
}
```

--------------------------------

### Web Fetch Server Configuration

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/server-management.mdx

Configure the web fetch server for web scraping and HTTP requests. This setup enables tools for making HTTP requests, scraping web pages, and getting JSON data from APIs.

```json
{
  "fetch": {
    "command": "uvx",
    "args": ["mcp-server-fetch"]
  }
}
```

--------------------------------

### Start Docker Compose

Source: https://github.com/samanhappy/mcphub/blob/main/docs/installation.mdx

Command to start the services defined in your docker-compose.yml file in detached mode.

```bash
docker-compose up -d
```

--------------------------------

### Add mcphub server from file

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Add a new server configuration by loading it from a JSON file.

```bash
mcphub servers add fetch --from-file ./fetch.json
```

--------------------------------

### Execute Tool via GET

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/openapi.mdx

Executes an MCP tool using a GET request. Parameters are passed as query parameters.

```bash
curl "http://localhost:3000/api/tools/amap/amap-maps_weather?city=Beijing"
```

--------------------------------

### Build All Projects

Source: https://github.com/samanhappy/mcphub/blob/main/AGENTS.md

Compile and build all parts of the project, including backend and frontend.

```bash
pnpm build
```

--------------------------------

### Get mcphub tool schema

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Retrieve the input schema for a specific tool. This is an alias for `mcphub tools get --json`.

```bash
mcphub tools schema fetch_url
```

--------------------------------

### Run Backend and Frontend Separately on Windows

Source: https://github.com/samanhappy/mcphub/blob/main/docs/installation.mdx

Instructions for running the backend and frontend development servers separately on Windows. This is necessary due to potential issues with concurrent process management.

```bash
# Terminal 1: Backend
pnpm backend:dev

# Terminal 2: Frontend
pnpm frontend:dev
```

--------------------------------

### Development Dockerfile

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/docker-setup.mdx

Builds the Docker image for the development environment, installing pnpm, copying project files, and setting up the application to run with the development server.

```dockerfile
FROM node:20-alpine

# Install pnpm
RUN npm install -g pnpm

# Set working directory
WORKDIR /app

# Copy package files
COPY package.json pnpm-lock.yaml ./ 
COPY frontend/package.json ./frontend/ 

# Install dependencies
RUN pnpm install

# Copy source code
COPY . .

# Expose ports
EXPOSE 3000 5173 9229

# Start development server
CMD ["pnpm", "dev"]

```

--------------------------------

### Example Generated OpenAPI Operation

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/openapi.mdx

This YAML snippet shows an example of a generated OpenAPI operation for a weather tool. It details the endpoint, HTTP method, parameters, and responses.

```yaml
/tools/amap/amap-maps_weather:
  get:
    summary: "根据城市名称或者标准adcode查询指定城市的天气"
    operationId: "amap_amap-maps_weather"
    tags: ["amap"]
    parameters:
      - name: city
        in: query
        required: true
        description: "城市名称或者adcode"
        schema:
          type: string
    responses:
      '200':
        description: "Successful tool execution"
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ToolResponse'
```

--------------------------------

### Calling mcphub tools with arguments

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Demonstrates various ways to call mcphub tools, including passing simple key-value arguments, using JSON for nested parameters, and specifying routing preferences like server or group.

```bash
mcphub call fetch_url url=https://example.com timeout=30
```

```bash
mcphub call fetch_url url=https://example.com --server fetch        # pin to a specific server
```

```bash
mcphub call my_tool --group dev nested='{"a":1}'
```

```bash
mcphub call my_tool --params-json '{"deep":{"v":1}}'
```

--------------------------------

### List all mcphub CLI subcommands

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Run `mcphub --help` to see a list of all available subcommands and their usage.

```bash
mcphub --help
```

--------------------------------

### List all profiles

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Display all configured mcphub profiles.

```bash
mcphub config list
```

--------------------------------

### Conventional Commits Examples

Source: https://github.com/samanhappy/mcphub/blob/main/docs/development/contributing.mdx

Examples of commit messages following the Conventional Commits specification. Use specific types like 'feat', 'fix', 'docs', etc., with optional scopes.

```bash
# Format: <type>[optional scope]: <description>

# Features
git commit -m "feat(auth): add JWT token refresh functionality"
git commit -m "feat(ui): implement server status dashboard"

# Bug fixes
git commit -m "fix(api): resolve memory leak in server manager"
git commit -m "fix(db): handle connection timeout gracefully"

# Documentation
git commit -m "docs(api): add examples for server endpoints"
git commit -m "docs(readme): update installation instructions"

# Refactoring
git commit -m "refactor(services): extract auth logic into separate module"

# Tests
git commit -m "test(api): add integration tests for server management"

# Chores
git commit -m "chore(deps): update dependencies to latest versions"

```

--------------------------------

### Stream Logs Example Event

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/logs.mdx

This is an example of a log entry received when streaming logs in real-time via Server-Sent Events (SSE). Each 'log' event contains a single new log entry.

```text
data: {"type":"log","log":{"timestamp":"2023-10-27T10:00:05.000Z","level":"debug","message":"Processing request for /api/some-endpoint","service":"mcp-server"}}

```

--------------------------------

### Run MCPHub with Default Docker Configuration

Source: https://github.com/samanhappy/mcphub/blob/main/docs/quickstart.mdx

Use this command to quickly start MCPHub with its default settings using Docker. Ensure port 3000 is available on your host machine.

```bash
# Run with default configuration
docker run -p 3000:3000 samanhappy/mcphub
```

--------------------------------

### GET /api/logs

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/logs.mdx

Retrieves all stored logs.

```APIDOC
## GET /api/logs

### Description
Retrieves all stored logs.

### Method
GET

### Endpoint
/api/logs

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **data** (array) - An array of log objects.
  - **timestamp** (string) - The time the log was generated.
  - **level** (string) - The severity level of the log (e.g., info, warn, error).
  - **message** (string) - The log message.
  - **service** (string) - The service that generated the log.

### Response Example
```json
{
  "success": true,
  "data": [
    {
      "timestamp": "2023-10-27T10:00:00.000Z",
      "level": "info",
      "message": "Server started successfully.",
      "service": "system"
    }
  ]
}
```
```

--------------------------------

### Add Slack Integration Server

Source: https://github.com/samanhappy/mcphub/blob/main/docs/quickstart.mdx

Set up the Slack integration server, including the command, arguments, and required environment variables for authentication.

```json
{
  "name": "slack",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-slack"],
  "env": {
    "SLACK_BOT_TOKEN": "your-bot-token",
    "SLACK_TEAM_ID": "your-team-id"
  }
}
```

--------------------------------

### GET /api/groups

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/groups.mdx

Retrieves a list of all server groups.

```APIDOC
## GET /api/groups

### Description
Retrieves a list of all server groups.

### Method
GET

### Endpoint
/api/groups

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful.
- **data** (array) - An array of group objects.
  - **id** (string) - The unique identifier for the group.
  - **name** (string) - The name of the group.
  - **description** (string) - A description of the group.
  - **servers** (array) - A list of server names in the group.
  - **owner** (string) - The owner of the group.

#### Response Example
```json
{
  "success": true,
  "data": [
    {
      "id": "group-1",
      "name": "My Group",
      "description": "A collection of servers.",
      "servers": ["server1", "server2"],
      "owner": "admin"
    }
  ]
}
```
```

--------------------------------

### Get a Server

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/servers.mdx

Reads a single server's configuration.

```APIDOC
## GET /api/servers/:name

### Description
Returns the configuration of a single server, including upstream tools/prompts/resources when connected.

### Method
GET

### Endpoint
/api/servers/:name

### Parameters
#### Path Parameters
- **name** (string) - Required - The name of the server to retrieve.

### Response
Returns `404` if the server is not configured.
```

--------------------------------

### Toggle mcphub server

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Enable or disable a server. Use `--on` to enable.

```bash
mcphub servers toggle fetch --on
```

--------------------------------

### GET /api/auth/user

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/auth.mdx

Retrieves the profile of the currently authenticated user.

```APIDOC
## GET /api/auth/user

### Description
Retrieves the profile of the currently authenticated user.

### Method
GET

### Endpoint
/api/auth/user

### Parameters
#### Header Parameters
- **Authorization** (string, required): Bearer Token required.

### Response
#### Success Response (200)
- **success** (boolean)
- **user** (object)

#### Response Example
{
  "success": true,
  "user": {
    "username": "admin",
    "isAdmin": true,
    "permissions": { ... }
  }
}
```

--------------------------------

### Server Configuration with Environment Variables

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/server-management.mdx

Define server commands and environment variables for configuration. Supports variable expansion for dynamic values.

```json
{
  "server-name": {
    "command": "python",
    "args": ["server.py"],
    "env": {
      "API_KEY": "${YOUR_API_KEY}",
      "DEBUG": "true",
      "MAX_CONNECTIONS": "10"
    }
  }
}
```

--------------------------------

### Run Docker with Custom Configuration File

Source: https://github.com/samanhappy/mcphub/blob/main/docs/installation.mdx

Deploy MCPHub using a custom JSON configuration file mounted into the container. Create the 'mcp_settings.json' file before running the command.

```bash
# Create your configuration file
cat > mcp_settings.json << 'EOF'
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    },
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest", "--headless"]
    }
  }
}
EOF

# Run with mounted config
docker run -d \
  --name mcphub \
  -p 3000:3000 \
  -v $(pwd)/mcp_settings.json:/app/mcp_settings.json \
  samanhappy/mcphub:latest
```

--------------------------------

### Get All Servers

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/servers.mdx

Retrieves a list of all configured MCP servers and their status.

```APIDOC
## GET /api/servers

### Description
Retrieves a list of all configured MCP servers, including their status and available tools.

### Method
GET

### Endpoint
/api/servers

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful.
- **data** (array) - An array of server objects.
  - **name** (string) - The name of the server.
  - **status** (string) - The current status of the server (e.g., "connected").
  - **tools** (array) - A list of tools available on the server.
    - **name** (string) - The name of the tool.
    - **description** (string) - The description of the tool.
  - **config** (object) - The server configuration.
    - **type** (string) - The type of server configuration (e.g., "stdio").
    - **command** (string) - The command to execute for `stdio` type.
    - **args** (array of strings) - Arguments for the command.

### Response Example
{
  "success": true,
  "data": [
    {
      "name": "example-server",
      "status": "connected",
      "tools": [
        {
          "name": "tool1",
          "description": "Description of tool 1"
        }
      ],
      "config": {
        "type": "stdio",
        "command": "node",
        "args": ["server.js"]
      }
    }
  ]
}
```

--------------------------------

### Troubleshoot Docker Container Startup Issues

Source: https://github.com/samanhappy/mcphub/blob/main/docs/installation.mdx

If a Docker container fails to start, check its logs using 'docker logs' or run it interactively for debugging purposes.

```bash
# Check container logs
docker logs mcphub

# Run interactively for debugging
docker run -it --rm samanhappy/mcphub /bin/bash
```

--------------------------------

### Find a tool using mcphub tools list and jq

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Demonstrates a common agent workflow: first list tools, then filter them using `jq` to find a specific tool.

```bash
mcphub tools list --json | jq '.[] | select(.name | contains("fetch"))'
```

--------------------------------

### Development Environment Variables

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/environment-variables.mdx

Basic environment variables for a development setup.

```env
NODE_ENV=development
PORT=3000
JWT_SECRET=dev-secret-key
```

--------------------------------

### Get a specific mcphub server

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Retrieve details for a specific server by its name.

```bash
mcphub servers get <name>
```

--------------------------------

### Add Web Fetch Server

Source: https://github.com/samanhappy/mcphub/blob/main/docs/quickstart.mdx

Configure the web fetch server by specifying its name, command, and arguments.

```json
{
  "name": "fetch",
  "command": "uvx",
  "args": ["mcp-server-fetch"]
}
```

--------------------------------

### Build MCPHub with Extended Features

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/docker-setup.mdx

Build a Docker image with additional tools like Docker Engine and browsers for Playwright by setting the INSTALL_EXT=true build argument. This image is larger but offers extended capabilities.

```bash
docker build --build-arg INSTALL_EXT=true -t mcphub:extended .
```

--------------------------------

### Get Available Servers

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/openapi.mdx

Retrieves a list of connected MCP server names.

```bash
curl "http://localhost:3000/api/openapi/servers"
```

--------------------------------

### GET /api/groups/:id

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/groups.mdx

Retrieves details for a specific group by its ID or name.

```APIDOC
## GET /api/groups/:id

### Description
Retrieves details for a specific group by its ID or name.

### Method
GET

### Endpoint
/api/groups/:id

### Parameters
#### Path Parameters
- **:id** (string) - Required - The ID or name of the group.
```

--------------------------------

### Autonomous agent recipe for mcphub

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Shows how an agent can drive the discover-call loop using mcphub commands with JSON output, including setting environment variables for URL and token.

```bash
export MCPHUB_URL=http://localhost:3000
export MCPHUB_TOKEN=$JWT

# 1. enumerate tools
mcphub tools list --json > tools.json

# 2. pick one and read its schema
mcphub tools get fetch_url --json > schema.json

# 3. build a payload from the schema and invoke
mcphub call fetch_url --params-json "$(jq -n '{url:"https://example.com"}')" --json
```

--------------------------------

### GET /api/logs/stream

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/logs.mdx

Streams logs in real-time using Server-Sent Events (SSE).

```APIDOC
## GET /api/logs/stream

### Description
Streams logs in real-time using Server-Sent Events (SSE). The connection will remain open, and new log entries will be sent as they occur.

### Method
GET

### Endpoint
/api/logs/stream

### Response Format
The stream sends events with a `data` field containing a JSON object. The first event has `type: 'initial'` and contains all historical logs. Subsequent events have `type: 'log'` and contain a single new log entry.

### Example Event
```
data: {"type":"log","log":{"timestamp":"2023-10-27T10:00:05.000Z","level":"debug","message":"Processing request for /api/some-endpoint","service":"mcp-server"}}
```
```

--------------------------------

### GET /api/users

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/users.mdx

Lists all users. The 'password' field is stripped from every record in the response.

```APIDOC
## GET /api/users

### Description
Lists all users. The `password` field is stripped from every record.

### Method
GET

### Endpoint
/api/users

### Response
#### Success Response (200)
- **data** (array) - An array of user objects, each containing `username` and `isAdmin`.

### Response Example
```json
{
  "success": true,
  "data": [
    { "username": "admin", "isAdmin": true },
    { "username": "alice", "isAdmin": false }
  ]
}
```
```

--------------------------------

### Add mcphub server inline

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Add a new server configuration by providing its details directly as arguments.

```bash
mcphub servers add fetch \
  --type stdio --command uvx \
  --arg mcp-server-fetch \
  --env USER_AGENT=mcphub
```

--------------------------------

### Build and Run MCPHub from Source

Source: https://github.com/samanhappy/mcphub/blob/main/docs/configuration/docker-setup.mdx

Clone the MCPHub repository, build a local Docker image, and run the container. This method is suitable for development when you need to modify the source code.

```bash
git clone https://github.com/your-username/mcphub.git
cd mcphub

docker build -t mcphub:local .

docker run -d \
  --name mcphub \
  -p 3000:3000 \
  -v $(pwd)/mcp_settings.json:/app/mcp_settings.json \
  mcphub:local
```

--------------------------------

### Register User Request Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/auth.mdx

Send a POST request to the /api/auth/register endpoint with username, password, and optional isAdmin flag to create a new user.

```json
{
  "username": "newuser",
  "password": "password123",
  "isAdmin": false
}
```

--------------------------------

### Define Private Group

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/group-management.mdx

Example JSON configuration for a private group, visible only to specified members.

```json
{
  "name": "internal-tools",
  "accessLevel": "private",
  "members": ["user1", "user2"],
  "servers": ["internal-api", "database"]
}
```

--------------------------------

### Define Public Group

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/group-management.mdx

Example JSON configuration for a public group, accessible to all authenticated users.

```json
{
  "name": "public-tools",
  "accessLevel": "public",
  "servers": ["fetch", "calculator"]
}
```

--------------------------------

### Configure Server with Manual Client Provisioning

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/oauth.mdx

Configure servers that do not support dynamic registration, such as GitHub's MCP endpoint. You must manually create an OAuth App with the provider and supply the client ID and secret.

```json
{
  "mcpServers": {
    "github": {
      "type": "sse",
      "url": "https://api.githubcopilot.com/mcp/",
      "oauth": {
        "clientId": "${GITHUB_OAUTH_APP_ID}",
        "clientSecret": "${GITHUB_OAUTH_APP_SECRET}",
        "scopes": ["replace-with-provider-scope"],
        "resource": "https://api.githubcopilot.com"
      }
    }
  }
}
```

--------------------------------

### Login Request Example

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/auth.mdx

Send a POST request to the /api/auth/login endpoint with username and password to authenticate.

```json
{
  "username": "admin",
  "password": "your-admin-password"
}
```

--------------------------------

### Scripting and CI with mcphub JSON output

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Demonstrates using mcphub commands with the --json flag and environment variables for seamless integration into scripting and CI/CD pipelines.

```bash
export MCPHUB_URL=https://hub.example.com
export MCPHUB_TOKEN=$CI_HUB_TOKEN

mcphub servers list --json | jq '.[] | select(.status != "connected") | .name'
```

--------------------------------

### List mcphub tools in JSON format

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Retrieve a machine-readable list of tools without schemas.

```bash
mcphub tools list --json
```

--------------------------------

### GET /api/users/:username

Source: https://github.com/samanhappy/mcphub/blob/main/docs/api-reference/users.mdx

Retrieves a single user by their username. Returns a 404 if the user does not exist.

```APIDOC
## GET /api/users/:username

### Description
Gets a single user by their username. Returns `404` if the user does not exist.

### Method
GET

### Endpoint
/api/users/:username

### Parameters
#### Path Parameters
- **username** (string) - Required - The username of the user to retrieve.

### Response
#### Success Response (200)
- **data** (object) - The user object, containing `username` and `isAdmin`.

### Response Example
```json
{
  "success": true,
  "data": { "username": "alice", "isAdmin": false }
}
```
```

--------------------------------

### Exporting mcphub settings

Source: https://github.com/samanhappy/mcphub/blob/main/docs/features/cli.mdx

Shows how to export the mcphub configuration, either to a specified output file or by redirecting standard output.

```bash
mcphub export --out backup.json
```

```bash
mcphub export > backup.json
```