### Individual Server Setup Workflow with MCPM

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

A common workflow for setting up individual servers using MCPM. This involves searching for, installing, and testing a server, followed by integrating it with a client application like Claude Desktop.

```bash
# 1. Find and install a server
mcpm search filesystem
mcpm install filesystem

# 2. Test the server
mcpm run filesystem --http

# 3. Integrate with Claude Desktop
mcpm client edit claude-desktop
# Select 'filesystem' in the checkbox interface
```

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

### Get MCPM Server Information

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Retrieves detailed information about a specific MCPM server before installation. This includes the server's description, installation method, and configuration prerequisites.

```bash
mcpm info <server-name>
```

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

### Profile-Based Server Setup Workflow with MCPM

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

A workflow for setting up multiple servers using MCPM profiles. This involves installing several servers, creating and configuring a profile with selected servers, and then enabling that profile in a client application.

```bash
# 1. Install multiple servers
mcpm install filesystem github-tools slack-connector

# 2. Create a development profile
mcpm profile create development
mcpm profile edit development
# Select desired servers for the profile

# 3. Enable profile in client
mcpm client edit cursor
# Select 'development' profile in the checkbox interface
```

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

### Install MCPM Servers

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Installs MCPM servers to the global configuration, typically located at `~/.config/mcpm/servers.json`. This command can install single or multiple servers at once.

```bash
# Install a server from the registry
mcpm install filesystem

# Install multiple servers
mcpm install github-tools slack-connector
```

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

### MCP Server Installation Configuration Examples

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/2

Provides examples of different installation configurations for an MCP server, specifically the GitHub server. It demonstrates 'http' and 'docker' installation types, including their respective parameters and commands. This allows MCPM to install and run servers in various environments.

```json
{
  "installations": {
    "http": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "description": "Run github mcp directly with OAuth",
      "recommended": true
    },
    "docker": {
      "type": "docker",
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "${GITHUB_PERSONAL_ACCESS_TOKEN}", "ghcr.io/github/github-mcp-server"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}"
      }
    }
  }
}
```

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

### Install MCPM via Curl

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Installs MCPM using a curl command to download and execute the installation script. This is the recommended installation method. It requires curl to be installed on the system.

```bash
curl -sSL https://mcpm.sh/install | bash
```

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

### List Installed MCPM Servers

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Displays a list of all servers currently installed in the global MCPM configuration. It shows server names, their associated profiles, and current status.

```bash
mcpm ls
```

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

### Run and Inspect MCPM Servers

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Executes installed MCPM servers for testing or debugging. Supports standard input/output mode, HTTP mode for testing, and launching an MCP Inspector for detailed debugging.

```bash
# Run server over stdio (standard MCP mode)
mcpm run filesystem

# Run server over HTTP for testing
mcpm run filesystem --http

# Launch MCP Inspector for debugging
mcpm inspect filesystem
```

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

### Manage MCPM Client Integration

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Provides commands to manage the integration of MCPM servers with supported MCP clients. Includes listing detected clients and interactively configuring server selections for specific clients.

```bash
# View Supported Clients
mcpm client ls

# Configure Client Integration (interactive)
mcpm client edit claude-desktop
mcpm client edit cursor

# Open client config in external editor
mcpm client edit cursor -e
```

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

### Import Existing Configuration with MCPM

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Workflow to import servers from an existing client configuration into MCPM management. This process creates a new profile and potentially replaces the current configuration with MCPM's management, guiding the user through organization.

```bash
# Import servers from existing client config
mcpm client import claude-desktop

# Creates profile and replaces config with MCPM management
# Follow prompts to organize imported servers
```

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

### Verify MCPM Installation

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Checks if the MCPM command-line tool is installed and accessible by printing its version. This command is used after installation to confirm success.

```bash
mcpm --version
```

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

### MCPM System Health and Diagnostics Commands

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Commands used to verify the MCPM setup and monitor system health. These include checking overall system health, viewing current configuration settings, and monitoring server usage.

```bash
# Check system health
mcpm doctor

# View configuration settings
mcpm config

# Monitor server usage
mcpm usage
```

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

### Installation Types

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

The system supports multiple installation methods defined in the `installations` object, including `uvx`, `npm`, `docker`, `python`, and `custom`.

```APIDOC
### Installation Types

The system supports multiple installation methods defined in the `installations` object:

| Installation Type | Command Examples        | Description                |
|-------------------|-------------------------|----------------------------|
| `uvx`             | `uvx`, `uvx run`        | Python package execution via uvx |
| `npm`             | `npx`, `npm install`    | Node.js package management |
| `docker`          | `docker run`            | Container-based deployment |
| `python`          | `python`, `pip install` | Direct Python execution    |
| `custom`          | Various                 | Custom installation commands |

The `filter_and_sort_installations` method prioritizes these types in order of preference.
```

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

### Use MCPM Profiles with Clients

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Enables the use of defined profiles within client configurations. This allows for the selection of entire groups of servers for specific applications, simplifying client setup. The client edit command facilitates this integration.

```bash
# The client edit command includes profile selection
mcpm client edit claude-desktop
# Select profiles alongside individual servers
```

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

### Search for MCPM Servers

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Discovers available MCP servers from the MCP Registry API. It can search for all available servers or filter by specific functionality keywords like 'filesystem' or 'github'.

```bash
# Search all servers
mcpm search

# Search for specific functionality
mcpm search filesystem
mcpm search github
```

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

### MCP Server Installation Types

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/2

Details the various installation types supported by MCPM for MCP servers, including configuration examples.

```APIDOC
## Installation Types and Execution

MCPM supports multiple installation types for MCP servers, each with specific execution patterns.

### Installation Configuration Examples

The `github` server demonstrates multiple installation methods:

```json
{
  "installations": {
    "http": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "description": "Run github mcp directly with OAuth",
      "recommended": true
    },
    "docker": {
      "type": "docker",
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "${GITHUB_PERSONAL_ACCESS_TOKEN}", "ghcr.io/github/github-mcp-server"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}"
      }
    }
  }
}
```
```

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

### Installation Methods - MCPM Shell Scripts

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7.1-mcpm

The installation section on the landing page offers multiple methods for installing MCPM, including a shell script. Users can easily copy and paste commands for installation via shell, Homebrew, pipx, or pip.

```shell
curl -sSL https://mcpm.sh/install | bash
```

```shell
brew install mcpm
```

```shell
pipx install mcpm
```

```shell
pip install mcpm
```

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

### Create and Manage MCPM Profiles

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/1

Commands for creating, editing, and listing MCPM profiles. Profiles help organize servers into logical groups for different workflows. This functionality is managed via the 'mcpm profile' subcommand.

```bash
# Create a new profile
mcpm profile create development

# Edit profile server assignments
mcpm profile edit development

# List all profiles
mcpm profile ls
```

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

### Installation Validation Utilities (Python)

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

Provides utility functions for validating installations, including standardizing variable placeholders and handling Docker-specific flags. It also includes functions to inspect Docker Hub repositories and verify repository existence via HTTP GET requests.

```python
import re
import requests

DOCKER_HUB_REPO_URL = "https://registry.hub.docker.com/v2/repositories/"

def validate_arguments_in_installation(arguments: list[str]) -> list[str]:
    validated_arguments = []
    for arg in arguments:
        if arg.startswith("-e") or arg.startswith("--env"):  # Docker-specific handling
            match = re.match(r"^(-\w+|-+\w+)=(\w+)=(.*)$

```

```python
def inspect_docker_repo(repo_name: str) -> bool:
    url = f"{DOCKER_HUB_REPO_URL}{repo_name}"
    response = requests.get(url)
    return response.status_code == 200

def validate_docker_url(url: str) -> bool:
    try:
        response = requests.get(url)
        return response.status_code == 200
    except requests.exceptions.RequestException:
        return False

```

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

### JavaScript for Interactive Installation and Terminal Demo

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

This JavaScript code handles interactive elements on the mcpm.sh landing page, including tabbed installation instructions with copy-to-clipboard functionality and an animated terminal demo showcasing MCPM CLI commands. It utilizes the navigator.clipboard API for copying and a custom typeCommand function for the animation.

```javascript
const installTabs = document.getElementById('install-tabs');
const tabButtons = installTabs.querySelectorAll('.tab-button');
const tabContents = installTabs.querySelectorAll('.tab-content');

function copyToClipboard(text, button) {
    navigator.clipboard.writeText(text).then(() => {
        const originalText = button.innerText;
        button.innerText = 'Copied!';
        setTimeout(() => {
            button.innerText = originalText;
        }, 2000);
    }).catch(err => {
        console.error('Failed to copy text: ', err);
    });
}

tabButtons.forEach(button => {
    button.addEventListener('click', () => {
        const targetTab = button.dataset.tab;
        tabButtons.forEach(btn => btn.classList.remove('active'));
        tabContents.forEach(content => content.classList.remove('active'));
        button.classList.add('active');
        document.getElementById(targetTab).classList.add('active');
    });
});

installTabs.addEventListener('click', (event) => {
    if (event.target.classList.contains('copy-button')) {
        const commandToCopy = event.target.dataset.command;
        copyToClipboard(commandToCopy, event.target);
    }
});

function typeCommand(element, commands, typingSpeed = 100) {
    let commandIndex = 0;
    let charIndex = 0;
    let currentCommand = '';

    function type() {
        if (commandIndex < commands.length) {
            const command = commands[commandIndex];
            if (charIndex < command.length) {
                currentCommand += command.charAt(charIndex);
                element.innerText = currentCommand;
                charIndex++;
                setTimeout(type, typingSpeed);
            } else {
                charIndex = 0;
                commandIndex++;
                currentCommand = '';
                setTimeout(() => {
                    element.innerText = '';
                    type();
                }, 1500);
            }
        }
    }
    type();
}

const terminalDemo = document.querySelector('.terminal-demo');
if (terminalDemo) {
    const demoCommands = [
        'mcpm profile add work server',
        'mcpm client edit cursor',
        'mcpm run server-name',
        'mcpm share server-name'
    ];
    typeCommand(terminalDemo, demoCommands);
}
```

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

### Model Context Protocol (MCP) Overview

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/2

Explains the Model Context Protocol (MCP) and how MCPM manages MCP servers through standardized manifests, installation methods, and capability definitions.

```APIDOC
## Overview

This document explains the Model Context Protocol (MCP) and how MCPM manages MCP servers through standardized manifests, installation methods, and capability definitions. For information about MCPM's global configuration model, see Global Configuration Model. For server registry and discovery mechanisms, see Server Registry.

### What is MCP?

The Model Context Protocol (MCP) is a standardized protocol that enables AI applications to securely connect to external data sources and tools. MCP servers expose capabilities through three primary interfaces: **tools** (for function calls), **resources** (for data access), and **prompts** (for templated interactions).

MCPM acts as a management layer for MCP servers, providing discovery, installation, configuration, and execution capabilities through a centralized registry and standardized manifest system.

### MCP Server Architecture in MCPM

MCPM manages MCP servers using a standardized JSON schema for server manifests. This schema describes server metadata, installation methods, and capabilities. The core manifest structure includes:

#### Core Manifest Properties

| Property        | Type   | Description                                    |
|-----------------|--------|------------------------------------------------|
| `name`          | string | Server identifier in kebab-case                |
| `display_name`  | string | Human-readable name                            |
| `description`   | string | Server functionality description               |
| `installations` | object | Available installation methods                 |
| `tools`         | array  | Function call capabilities                     |
| `resources`     | array  | Data access capabilities                       |
| `prompts`       | array  | Template capabilities                          |
| `arguments`     | object | Required configuration parameters              |
```

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

### Manifest Structure

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

Server manifests are JSON files containing structured data about each server, including basic metadata, repository information, installation methods, configuration, capabilities, and categorization.

```APIDOC
### Manifest Structure

Server manifests follow a standardized JSON schema containing:

*   **Basic Metadata**: `name`, `display_name`, `description`, `author`, `license`
*   **Repository Information**: `repository.url`, `homepage`
*   **Installation Methods**: `installations` object with different deployment options
*   **Configuration**: `arguments` object defining required environment variables
*   **Capabilities**: `tools`, `prompts`, `resources` arrays describing server functionality
*   **Categorization**: `categories` and `tags` arrays for discovery
```

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

### Package Entry Point Definition (TOML)

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/9

Defines the command-line entry point for the 'mcpm' package. This TOML snippet in pyproject.toml specifies that the 'mcpm' command should execute the 'main' function located in the 'mcpm.cli' module when the package is installed.

```toml
[project.scripts]
mcpm = "mcpm.cli:main"

```

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

### MCP Server Tool Capability Example

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/2

Illustrates the 'tools' capability for an MCP server, specifically for the GitHub server. It defines available tools like `list_repositories`, `create_issue`, and `search_code`, along with their descriptions and required parameters. This enables AI clients to perform specific actions via the MCP server.

```markdown
| Tool Name          | Description                       | Required Parameters       |
|--------------------|-----------------------------------|---------------------------|
| `list_repositories`| List repositories for user/org    | `owner`                   |
| `create_issue`     | Create a new issue                | `owner`, `repo`, `title`  |
| `search_code`      | Search for code on GitHub         | `query`                   |
```

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

### API Integration Example (JavaScript)

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7.1-mcpm

Handles loading server manifest data and GitHub star counts from separate API endpoints. It includes error handling for failed requests and data transformation for UI consumption. This snippet demonstrates fetching and processing data from external sources.

```javascript
/* pages/registry/index.html (logic within script tags or linked JS file) */

async function loadServerData() {
  try {
    const [serversResponse, starsResponse] = await Promise.all([
      fetch('/api/servers.json'),
      fetch('/api/stars.json')
    ]);

    if (!serversResponse.ok) throw new Error('Failed to load servers');
    if (!starsResponse.ok) throw new Error('Failed to load stars');

    const servers = await serversResponse.json();
    const stars = await starsResponse.json();

    // Process and combine server and star data
    const combinedData = processApiData(servers, stars);
    updateUI(combinedData);

  } catch (error) {
    console.error('API integration error:', error);
    // Display error message to user
  }
}

function processApiData(servers, stars) {
  // ... logic to merge and transform data ...
  return servers.map(server => {
    const starData = stars.find(s => s.id === server.id);
    return {
      ...server,
      stars: starData ? starData.stars : 0
    };
  });
}

loadServerData();

```

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

### Utility Functions - Python

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

Python utility functions for the registry system, including filtering and sorting installation types.

```python
def filter_and_sort_installations(installations):
    """Filters and sorts installation methods based on a predefined preference order."""
    preference_order = ['uvx', 'npm', 'docker', 'python', 'custom']
    
    # Create a list of (preference_index, type, details) tuples
    sorted_installations = []
    for inst_type, details in installations.items():
        try:
            preference_index = preference_order.index(inst_type)
            sorted_installations.append((preference_index, inst_type, details))
        except ValueError:
            # Handle unknown installation types if necessary, or ignore them
            pass
            
    # Sort based on the preference index
    sorted_installations.sort(key=lambda x: x[0])
    
    # Return just the sorted installation details
    return [inst[2] for inst in sorted_installations]

# Example usage:
# sample_installations = {
#     "npm": {"type": "npm", "command": "npx", "args": ["package-name"]},
#     "uvx": {"type": "uvx", "command": "uvx", "args": ["package-name"]},
#     "docker": {"type": "docker", "command": "docker run", "args": ["image-name"]}
# }
# sorted_inst = filter_and_sort_installations(sample_installations)
# print(sorted_inst)

```

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

### Determine Server Configuration Model (Python)

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/5-server-management

This Python code snippet demonstrates how to select the appropriate Pydantic model (RemoteServerConfig or STDIOServerConfig) for server configuration based on the installation type. It handles the instantiation of these models with relevant parameters like name, URL, command, arguments, and environment variables.

```python
# Installation type determines configuration model:
if installation_type == "http":
    return RemoteServerConfig(name=name, url=url, headers=headers)
else:
    return STDIOServerConfig(name=name, command=command, args=args, env=env)
```

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

### Registry API Response Structure - JSON

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

Defines the structure of the JSON response for the `/api/servers.json` endpoint, detailing server metadata and installation information.

```json
{
  "name": "server-name",
  "display_name": "Human Readable Name",
  "description": "Server description",
  "author": {"name": "author-name"},
  "categories": ["Category Name"],
  "tags": ["tag1", "tag2"],
  "installations": {
    "uvx": {
      "type": "uvx",
      "command": "uvx",
      "args": ["package-name"],
      "env": {"VAR": "${VAR}"}
    },
    "npm": {
      "type": "npm",
      "command": "npm install",
      "args": ["package-name"]
    }
  },
  "is_official": true,
  "repository": {"type": "git", "url": "https://github.com/..."}
}
```

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

### Server Registry System - Python

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

Python script for managing server manifests and metadata. It handles fetching manifest data and categorizing servers.

```python
import os
import json

def get_server_manifest(server_path):
    """Reads and parses a server manifest JSON file."""
    try:
        with open(server_path, 'r', encoding='utf-8') as f:
            return json.load(f)
    except FileNotFoundError:
        print(f"Error: Manifest file not found at {server_path}")
        return None
    except json.JSONDecodeError:
        print(f"Error: Could not decode JSON from {server_path}")
        return None

def categorize_server(manifest):
    """Determines categories and tags for a server based on its manifest."""
    categories = manifest.get('categories', [])
    tags = manifest.get('tags', [])
    # Add more sophisticated categorization logic here if needed
    return categories, tags

def process_registry(registry_dir):
    """Processes all server manifests in the registry directory."""
    all_servers_data = []
    for filename in os.listdir(registry_dir):
        if filename.endswith(".json"):
            server_path = os.path.join(registry_dir, filename)
            manifest = get_server_manifest(server_path)
            if manifest:
                categories, tags = categorize_server(manifest)
                server_data = {
                    "name": manifest.get('name'),
                    "display_name": manifest.get('display_name'),
                    "description": manifest.get('description'),
                    "categories": categories,
                    "tags": tags,
                    "installations": manifest.get('installations'),
                    "repository": manifest.get('repository')
                }
                all_servers_data.append(server_data)
    return all_servers_data

if __name__ == "__main__":
    REGISTRY_DIRECTORY = "mcp-registry/servers/"
    servers_data = process_registry(REGISTRY_DIRECTORY)
    # Further processing or API serving of servers_data can be done here
    print(f"Processed {len(servers_data)} servers.")

```

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

### AMap Server API Key Configuration

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/2

Configuration schema for the AMap server, specifying the required AMAP_MAPS_API_KEY. This argument is essential for authenticating and accessing the AMap service, with an example placeholder provided.

```json
{
  "arguments": {
    "AMAP_MAPS_API_KEY": {
      "description": "The API key to access the AMap service.",
      "required": true,
      "example": "YOUR_API_KEY_HERE"
    }
  }
}
```

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

### Get FRPC Directory for Cross-Platform Path Management

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/8-advanced-features

The get_frpc_directory() function automatically determines the correct directory for the FRPC client based on the operating system (macOS, Linux, or Windows). This ensures that the application can locate and use the FRPC executable regardless of the platform it's running on.

```python
def get_frpc_directory():
    if sys.platform == "darwin":
        return os.path.expanduser("~/Library/Application Support/mcpm/frpc")
    elif sys.platform.startswith("linux"):
        xdg_data_home = os.environ.get("XDG_DATA_HOME", os.path.expanduser("~/.local/share"))
        return os.path.join(xdg_data_home, "mcpm/frpc")
    elif sys.platform == "win32":
        local_app_data = os.environ.get("LOCALAPPDATA")
        if local_app_data:
            return os.path.join(local_app_data, "mcpm/frpc")
        else:
            # Fallback for systems where LOCALAPPDATA might not be set
            return os.path.expanduser("%LOCALAPPDATA%/mcpm/frpc")
    else:
        raise OSError("Unsupported platform for FRPC directory.")
```

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

### Capability Extraction using McpClient (Python)

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

Demonstrates how the McpClient class is used to connect to MCP servers and discover their capabilities like tools, prompts, and resources. It manages asynchronous resource cleanup and includes error handling for failed queries, returning empty result objects when necessary.

```python
from async_exit_stack import AsyncExitStack
from datetime import timedelta
from typing import Any

from idpy.mcpm.mcpm_error import McpError
from idpy.mcpm.mcpm_server_parameters import StdioServerParameters
from idpy.mcpm.stdio_client import stdio_client


class McpClient:
    def __init__(self) -> None:
        self.exit_stack = AsyncExitStack()

    async def connect_to_server(self, command: list[str], args: list[str] = [], env: dict[str, str] = {}) -> Any:
        parameters = StdioServerParameters(command=command, args=args, env={**env, **{"MCPM_SERVER_REGISTRY_ONLY": "true"}})
        transport = await self.exit_stack.enter_async_context(stdio_client(parameters=parameters, timeout=timedelta(seconds=60)))
        return transport

    async def list_tools(self, transport: Any) -> Any:
        try:
            return await transport.list_tools()
        except McpError:
            return ListToolsResult(tools=[])

    async def list_prompts(self, transport: Any) -> Any:
        try:
            return await transport.list_prompts()
        except McpError:
            return ListPromptsResult(prompts=[])

    async def list_resources(self, transport: Any) -> Any:
        try:
            return await transport.list_resources()
        except McpError:
            return ListResourcesResult(resources=[])


class ListToolsResult:
    def __init__(self, tools: list[Any]) -> None:
        self.tools = tools

class ListPromptsResult:
    def __init__(self, prompts: list[Any]) -> None:
        self.prompts = prompts

class ListResourcesResult:
    def __init__(self, resources: list[Any]) -> None:
        self.resources = resources

```

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

### Automated Manifest Generation

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

Server manifests are automatically generated using GitHub Actions, LLM-powered analysis, and a Python script (`scripts/get_manifest.py`), orchestrated by `.github/workflows/generate-manifest.yml`.

```APIDOC
## Automated Manifest Generation

### Description
The system uses GitHub Actions workflow automation combined with LLM-powered analysis to generate server manifests from repository submissions. The process is orchestrated by `.github/workflows/generate-manifest.yml` and executed by `scripts/get_manifest.py`.

### GitHub Actions Workflow and Manifest Generation Pipeline

The manifest generation pipeline is triggered via GitHub Actions, utilizing an LLM to analyze repository content and produce a structured JSON manifest.
```

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

### Registry Discovery Interface

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7-web-platform-and-registry

The registry interface provides a user-friendly way to discover and interact with servers. It includes features like tab-based navigation, real-time search and filtering, and detailed server information displayed in cards and modals.

```APIDOC
## Registry Discovery Interface

### Description
The registry interface at `pages/registry/index.html` provides a comprehensive server discovery experience with multiple interaction modes:

**Tab-Based Navigation**: Supports "Registry" for server browsing and "API" for JSON data access, with tab switching managed by `tab-button` elements and `active` class.

**Search and Filter System**: Features real-time search via `search-input`, a tag filter system within `tag-filters` with expand/collapse functionality, and a toggle for additional filters. Active filters are indicated by the `active` class.

**Server Card Components**: Displays server metadata cards in a grid layout (`servers-grid`), including name, description, badges, tags, GitHub stars, and an install button. Hover effects and click handlers for modal activation are included.

**Server Detail Modal**: A modal component (`modal` class) displays detailed manifest information with collapsible sections, JSON syntax highlighting, and copy functionality for API URLs and manifest data. Sections include Basic Info, Categories & Tags, Installations, and Tools/Prompts/Resources.

**API Interface Tab**: Offers an interactive JSON viewer with syntax highlighting for API endpoints like `/api/servers.json` and `/api/categories.json`, live JSON formatting, and an expandable/collapsible tree view.
```

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

### Terminal Animation Flow - MCPM CLI Demo

Source: https://deepwiki.com/pathintegral-institute/mcpm.sh/7.1-mcpm

The landing page includes an animated terminal demonstration simulating common MCPM commands. This feature uses CSS animations and JavaScript to create a typing effect, showcasing core functionalities like profile management, client editing, server running, and sharing.

```markdown
**Terminal Animation Flow**
```


```

The terminal demonstrates these core commands:
  * `mcpm profile add work server`
  * `mcpm client edit cursor`
  * `mcpm run server-name`
  * `mcpm share server-name`
```