> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mcphub.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Group Management

> Organize servers into logical groups for streamlined access control

## Overview

Group Management in MCPHub allows you to organize your MCP servers into logical collections based on functionality, use case, or access requirements. This enables fine-grained control over which tools are available to different AI clients and users.

## Core Concepts

### What are Groups?

Groups are named collections of MCP servers that can be accessed through dedicated endpoints. Instead of connecting to all servers at once, AI clients can connect to specific groups to access only relevant tools.

### Benefits of Groups

* **Focused Tool Access**: AI clients see only relevant tools for their use case
* **Better Performance**: Reduced tool discovery overhead
* **Enhanced Security**: Limit access to sensitive tools
* **Improved Organization**: Logical separation of functionality
* **Simplified Management**: Easier to manage related servers together

## Creating Groups

### Via Dashboard

1. **Navigate to Groups Section**: Click "Groups" in the main navigation

2. **Click "Create Group"**: Start the group creation process

3. **Fill Group Details**:

   * **Name**: Unique identifier for the group

4. **Add Servers**: Select servers to include in the group

### Via API

Create groups programmatically:

```bash theme={null}
curl -X POST http://localhost:3000/api/groups \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -d '{
    "name": "web-automation",
    "servers": ["playwright", "fetch"]
  }'
```

## Group Types and Use Cases

<AccordionGroup>
  <Accordion title="Web Automation Group">
    **Purpose**: Browser automation and web scraping

    **Servers**:

    * `playwright`: Browser automation
    * `fetch`: HTTP requests and web scraping
    * `selenium`: Alternative browser automation

    **Use Cases**:

    * Automated testing
    * Data collection
    * Web monitoring
    * Content analysis

    **Endpoint**: `http://localhost:3000/mcp/web-automation`
  </Accordion>

  <Accordion title="Data Processing Group">
    **Purpose**: Data manipulation and analysis

    **Servers**:

    * `sqlite`: Database operations
    * `filesystem`: File operations
    * `spreadsheet`: Excel/CSV processing

    **Use Cases**:

    * Data analysis
    * Report generation
    * File processing
    * Database queries

    **Endpoint**: `http://localhost:3000/mcp/data-processing`
  </Accordion>

  <Accordion title="Communication Group">
    **Purpose**: Messaging and collaboration

    **Servers**:

    * `slack`: Slack integration
    * `discord`: Discord bot
    * `email`: Email sending
    * `sms`: SMS notifications

    **Use Cases**:

    * Team notifications
    * Customer communication
    * Alert systems
    * Social media management

    **Endpoint**: `http://localhost:3000/mcp/communication`
  </Accordion>

  <Accordion title="Development Group">
    **Purpose**: Software development tools

    **Servers**:

    * `github`: GitHub operations
    * `gitlab`: GitLab integration
    * `docker`: Container management
    * `kubernetes`: K8s operations

    **Use Cases**:

    * Code deployment
    * Repository management
    * CI/CD operations
    * Infrastructure management

    **Endpoint**: `http://localhost:3000/mcp/development`
  </Accordion>

  <Accordion title="AI/ML Group">
    **Purpose**: Machine learning and AI tools

    **Servers**:

    * `openai`: OpenAI API integration
    * `huggingface`: Hugging Face models
    * `vector-db`: Vector database operations

    **Use Cases**:

    * Model inference
    * Data embeddings
    * Natural language processing
    * Computer vision

    **Endpoint**: `http://localhost:3000/mcp/ai-ml`
  </Accordion>
</AccordionGroup>

## Group Endpoints

### Accessing Groups

Each group gets its own MCP endpoint:

<Tabs>
  <Tab title="HTTP MCP">
    ```
    http://localhost:3000/mcp/{group-name}
    ```

    Examples:

    * `http://localhost:3000/mcp/web-tools`
    * `http://localhost:3000/mcp/data-processing`
    * `http://localhost:3000/mcp/communication`
  </Tab>

  <Tab title="SSE (Legacy)">
    ```
    http://localhost:3000/sse/{group-name}
    ```

    Examples:

    * `http://localhost:3000/sse/web-tools`
    * `http://localhost:3000/sse/data-processing`
    * `http://localhost:3000/sse/communication`
  </Tab>
</Tabs>

### Group Tool Discovery

When connecting to a group endpoint, AI clients will only see tools from servers within that group:

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

Response will only include tools from `fetch` and `playwright` servers.

## Dynamic Group Management

### Adding Servers to Groups

<Tabs>
  <Tab title="Dashboard">
    1. Navigate to the group in the dashboard
    2. Click "Manage Servers"
    3. Select additional servers to add
    4. Click "Save Changes"
  </Tab>

  <Tab title="API">
    ```bash theme={null}
    curl -X POST http://localhost:3000/api/groups/web-tools/servers \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer YOUR_JWT_TOKEN" \
      -d '{"serverId": "new-server"}'
    ```
  </Tab>
</Tabs>

### Removing Servers from Groups

<Tabs>
  <Tab title="Dashboard">
    1. Navigate to the group in the dashboard
    2. Click "Manage Servers"
    3. Unselect servers to remove
    4. Click "Save Changes"
  </Tab>

  <Tab title="API">
    ```bash theme={null}
    curl -X DELETE http://localhost:3000/api/groups/web-tools/servers/server-name \
      -H "Authorization: Bearer YOUR_JWT_TOKEN"
    ```
  </Tab>
</Tabs>

{/* ## Group Monitoring

### Group Status

Monitor group health and activity:

```bash
# Get group status
curl http://localhost:3000/api/groups/web-tools/status \
-H "Authorization: Bearer YOUR_JWT_TOKEN"
```

Response includes:

- Number of active servers
- Tool count
- Active connections
- Recent activity

### Group Analytics

Track group usage:

```bash
# Get group analytics
curl http://localhost:3000/api/groups/web-tools/analytics \
-H "Authorization: Bearer YOUR_JWT_TOKEN"
```

Metrics include:

- Request count by tool
- Response times
- Error rates
- User activity */}

## Best Practices

### Group Organization

<Tip>
  **Organize by Use Case**: Group servers based on what users want to accomplish, not just technical
  similarity.
</Tip>

<Tip>
  **Keep Groups Focused**: Avoid creating groups with too many diverse tools. Smaller, focused
  groups are more useful.
</Tip>

<Tip>
  **Use Descriptive Names**: Choose names that clearly indicate the group's purpose and contents.
</Tip>

### Performance Optimization

<Info>
  **Balance Group Size**: Very large groups may have slower tool discovery. Consider splitting into
  smaller groups.
</Info>

<Info>
  **Monitor Usage**: Use analytics to identify which groups are heavily used and optimize
  accordingly.
</Info>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Group Not Accessible">
    **Check:**

    * User has proper permissions
    * Group exists and is active
    * Servers in group are running
    * Network connectivity

    **Solutions:**

    1. Verify user group membership
    2. Check group configuration
    3. Test individual server connections
    4. Review access logs
  </Accordion>

  <Accordion title="Tools Missing from Group">
    **Possible causes:**

    * Server not properly added to group
    * Server is not running
    * Tool discovery failed
    * Caching issues

    **Debug steps:**

    1. Verify server is in group configuration
    2. Check server status
    3. Force refresh tool discovery
    4. Clear group cache
  </Accordion>

  <Accordion title="Group Performance Issues">
    **Common issues:**

    * Too many servers in group
    * Slow server responses
    * Network latency
    * Resource constraints

    **Optimizations:**

    1. Split large groups
    2. Monitor server performance
    3. Implement request caching
    4. Use connection pooling
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Smart Routing" icon="route" href="/features/smart-routing">
    AI-powered tool discovery across groups
  </Card>

  <Card title="Authentication" icon="shield" href="/features/authentication">
    User management and access control
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/groups">
    Complete group management API
  </Card>

  <Card title="Configuration" icon="cog" href="/configuration/mcp-settings">
    Advanced group configuration options
  </Card>
</CardGroup>