### Run Main Example Script

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Execute the primary script to run the Wayfound MCP registry example. This script connects to the server, creates an agent, and runs example queries.

```bash
python main.py
```

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

### Run Remote Server Wizard

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Use this command to initiate the wizard for creating a remote server configuration. The wizard guides you through basic information, server details, remote configuration, and OAuth setup.

```bash
task remote-wizard
```

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

### Install Python Dependencies

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Install the required Python packages for the Wayfound MCP example using pip. Ensure you have Python 3.10+ installed.

```bash
pip install -r requirements.txt
```

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

### Clone Wayfound MCP Example Repository

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Use this bash command to clone the Wayfound MCP example repository and navigate into the project directory.

```bash
git clone https://github.com/Wayfound-AI/wayfound-mcp-example
cd wayfound-mcp-example
```

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

### Full MCP Server Configuration Example

Source: https://github.com/docker/mcp-registry/blob/main/docs/configuration.md

A comprehensive example demonstrating the integration of various configuration options for an MCP Server, including metadata, source pinning, run settings, and detailed config parameters.

```yaml
name: server_name
image: mcp/server_name
type: server
meta:
  category: devops
  tags:
    - server_name
about:
  title: Server Name
  description: Description about my Server. What it does and why it's useful
  icon: https://...
source:
  project: https://github.com/my-org/my-mcp-server
  commit: 0123456789abcdef0123456789abcdef01234567
run:
  command:
  - --transport=stdio
  volumes:
    - '{{server_name.path}}:/data'
  disableNetwork: true
config:
  description: The MCP server is allowed to access these path
  secrets:
  - name: server_name.api_key
    env: API_KEY
    example: YOUR_API_KEY
  env:
    - name: ENVIRONMENT_VARIABLE_NAME
      example: ""
      value: '{{server_name.parameter_name}}'
  parameters:
    type: object
    properties:
      path:
          type: string
        default:
          - /Users/local-test
      parameter_name:
        type: string
    required:
      - path

```

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

### Example Remote Server Structure

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

This illustrates the expected directory structure for a remote server entry, including server configuration, tool definitions, and documentation.

```bash
servers/my-remote-server/
├── server.yaml      # Server configuration
├── tools.json       # Always [] for remote servers
└── readme.md        # Documentation link (required)
```

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

### Example Python Queries for Wayfound MCP Server

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

These Python strings represent example queries you can use to interact with the Wayfound MCP Server for various agent-related tasks.

```python
# Basic agent information
"What are all the agents in my organization?"
"Give me details about the Customer Support agent"
```

```python
# Performance analysis
"Show me the manager analysis for my Sales agent"
"What are the top topics and issues for the Marketing agent?"
```

```python
# Improvement recommendations
"How can I improve my Customer Service agent's performance?"
"What knowledge gaps exist for the Technical Support agent?"
```

```python
# Combined queries
"List all agents and show me which ones have the most issues"
"Compare the performance of my Sales and Marketing agents"
```

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

### Start Streamable HTTP Server

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Start the Streamable HTTP server with explicit risk acknowledgment. The server will be accessible at http://localhost:3000/mcp. Ensure you use streamable HTTP compatible clients to connect.

```bash
# Start server with explicit risk acknowledgment
python main.py --http --iunderstandtherisks

# Server will start on http://localhost:3000/mcp
# Connect using streamable HTTP compatible clients
```

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

### Example `tools.json` for Build Process

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

This `tools.json` file can be placed next to `server.yaml` to specify tools. The build process will read this file instead of running the server to list tools, preventing common PR blocking issues.

```json
[
  {
    "name": "tools_name",
    "description": "description of what you tool does"
    "arguments": [
      {
        "name": "name_of_the_argument",
        "type": "string",
        "desc": ""
      }
    ]
  },
  {
    "name": "another_tool",
    "description": "description of what another tool"
    "arguments": [
      {
        "name": "name_of_the_argument",
        "type": "string",
        "desc": ""
      }
    ]
  }
]
```

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

### Example Natural Language Queries for MCP Database Server

Source: https://github.com/docker/mcp-registry/blob/main/servers/database-server/readme.md

These are example natural language queries that can be used with the `query_database` tool. They cover basic, complex analysis, and data exploration scenarios.

```python
# Basic queries
"Show me all users in the database"
"What tables are available?"
"Describe the products table structure"

# Complex analysis
"Find the top 5 customers by total order value"
"Show me users who registered in the last month"
"What's the average product price by category?"

# Data exploration
"How many orders were placed yesterday?"
"List all products that are out of stock"
"Find duplicate email addresses in the users table"
```

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

### Install Okta MCP Server Dependencies

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Installs the necessary Python dependencies for the Okta MCP Server. Ensure you re-run this command after cloning or updating the repository.

```bash
git clone https://github.com/fctr-id/okta-mcp-server.git
cd okta-mcp-server

python -m venv venv
source venv/bin/activate  # On Windows use: venv\Scripts\activate

pip install -r requirements.txt
```

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

### Example Remote Server YAML with OAuth

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Configuration for a remote MCP server that includes OAuth for authentication. This example specifies the transport type, URL, and OAuth credentials.

```yaml
name: linear
type: remote
dynamic:
  tools: true
meta:
  category: productivity
  tags:
    - productivity
    - project-management
    - remote
about:
  title: Linear
  description: Track issues and plan sprints
  icon: https://www.google.com/s2/favicons?domain=linear.app&sz=64
remote:
  transport_type: streamable-http
  url: https://mcp.linear.app/mcp
oauth:
  - provider: linear
    secret: linear.personal_access_token
    env: LINEAR_PERSONAL_ACCESS_TOKEN
```

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

### Install mcp-remote Globally

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Install the mcp-remote package globally using npm. This is a prerequisite for using the Remote HTTP Access method.

```bash
# 1. Install mcp-remote globally
npm install -g @anthropic/mcp-remote
```

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

### Run SimpleCheckList MCP Server in Both Modes

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/DOCKER-USAGE-INSTRUCTIONS.txt

Starts the MCP server in both backend (HTTP API) and MCP modes. This is more resource-intensive and should only be used if both interfaces are required.

```bash
docker run -d -p 8355:8355 mayurkakade/mcp-server:latest --mode=both
```

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

### MCP Server Configuration File

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

This is an example of a generated `server.yaml` file. It defines the server's name, image, type, metadata, source, and configuration details.

```yaml
name: my-orgdb-mcp
image: mcp/my-orgdb-mcp
type: server
meta:
  category: database
  tags:
    - database
about:
  title: My OrgDB MCP (TODO)
  description: TODO (only to provide a better description than the upstream project)
  icon: https://avatars.githubusercontent.com/u/182288589?s=200&v=4
source:
  project: https://github.com/myorg/my-orgdb-mcp
  commit: 0123456789abcdef0123456789abcdef01234567
config:
  description: Configure the connection to TODO
  secrets:
    - name: my-orgdb-mcp.api_token
      env: API_TOKEN
      example: <API_TOKEN>
```

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

### Start Streamable HTTP Docker Container

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Start the Streamable HTTP transport as a Docker container. This command maps port 3000 and sets the necessary environment variables. Configure your MCP client to connect to http://localhost:3000/mcp.

```bash
# Start the HTTP container
docker run -d --name okta-mcp-http \
  -p 3000:3000 \
  -e OKTA_API_TOKEN=your_api_token \
  -e OKTA_CLIENT_ORGURL=https://your-org.okta.com \
  fctrid/okta-mcp-server:http

# Configure your MCP client to connect to http://localhost:3000/mcp
```

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

### Specify Multiple Environment Variables

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

When creating an MCP server, ensure all necessary environment variables are specified. This example shows how to pass multiple `-e` flags.

```bash
task create -- --category database https://github.com/myorg/my-orgdb-mcp -e API_TOKEN=test -e MY_ORG=my-org
```

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

### Example Remote Server YAML without OAuth

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Configuration for a remote MCP server that does not require OAuth. This example defines the server's metadata, transport type, and URL.

```yaml
name: cloudflare-docs
type: remote
meta:
  category: documentation
  tags:
    - documentation
    - cloudflare
    - remote
about:
  title: Cloudflare Docs
  description: Access the latest documentation on Cloudflare products
  icon: https://www.cloudflare.com/favicon.ico
remote:
  transport_type: sse
  url: https://docs.mcp.cloudflare.com/sse
```

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

### Run SimpleCheckList MCP Server in MCP Mode

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/DOCKER-USAGE-INSTRUCTIONS.txt

Starts the MCP server in MCP mode, utilizing STDIO transport for direct MCP client connections. Requires the interactive mode flag (-i).

```bash
docker run -i mayurkakade/mcp-server:latest --mode=mcp
```

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

### Start MCP Server in Docker

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/README.md

Run the MCP server container in detached mode. The server defaults to 'backend' mode, providing a stable HTTP API.

```bash
docker run -d -p 8355:8355 mayurkakade/mcp-server:latest
```

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

### Configure Claude Desktop for MCP Server

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/README.md

JSON configuration for Claude Desktop to connect to the SimpleCheckList MCP server. This setup uses Docker to run the server in MCP mode.

```json
{
  "mcpServers": {
    "simplechecklist": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "mayurkakade/mcp-server:latest",
        "--mode=mcp"
      ]
    }
  }
}
```

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

### Run SSE Container

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Starts the Server-Sent Events (SSE) container in detached mode. Ensure you replace placeholder values for API token and organization URL.

```bash
docker run -d --name okta-mcp-sse \
  -p 3000:3000 \
  -e OKTA_API_TOKEN=your_api_token \
  -e OKTA_CLIENT_ORGURL=https://your-org.okta.com \
  fctrid/okta-mcp-server:sse
```

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

### Get Improvement Suggestions for Agent API

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Retrieves actionable improvement suggestions for a specific agent, including prompt updates and knowledge recommendations.

```APIDOC
## get_improvement_suggestions_for_agent

### Description
Get improvement suggestions for a specific Agent. This includes suggested system prompt updates and additional knowledge needed.

### Method
GET

### Endpoint
/agents/{agent_id}/suggestions

### Parameters
#### Path Parameters
- **agent_id** (string) - Required - The unique identifier of the agent.

#### Query Parameters
- **organization_id** (string) - Required - The ID of the organization the agent belongs to.

### Response
#### Success Response (200)
- **suggestions** (object) - Actionable improvement recommendations.
  - **system_prompt_updates** (array) - Suggested modifications to the agent's instructions.
  - **additional_knowledge** (array) - Recommended knowledge base additions.
  - **training_suggestions** (array) - Areas for further development.
  - **best_practice_recommendations** (array) - Industry-standard improvements.

### Response Example
{
  "suggestions": {
    "system_prompt_updates": [
      "Emphasize active listening and empathy in customer interactions."
    ],
    "additional_knowledge": [
      "Information on the new product launch.",
      "Updated troubleshooting steps for common issues."
    ],
    "training_suggestions": [
      "Advanced de-escalation techniques."
    ],
    "best_practice_recommendations": [
      "Standardize greeting and closing statements."
    ]
  }
}
```

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

### Generate Server Configuration with Task Wizard

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Use this command to initiate an interactive wizard that helps create your `server.yaml` configuration file. The wizard analyzes a provided GitHub repository with a Dockerfile to pre-populate server defaults, which can be overridden.

```bash
task wizard
```

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

### Configure Okta MCP Server Environment

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Copies the sample environment configuration file and prompts to edit it with your Okta domain, API token, and LLM settings.

```bash
# Copy the sample config
cp .env.sample .env

# Edit the env with your settings
# Required: Okta domain and API token and LLM settings
```

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

### Build and Catalog MCP Server Locally

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Commands to build, catalog, and import an MCP server locally. The `task build` step is optional if a custom image is provided.

```bash
task build -- --tools my-orgdb-mcp # Not needed if providing your own image
task catalog -- my-orgdb-mcp
docker mcp catalog import $PWD/catalogs/my-orgdb-mcp/catalog.yaml
```

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

### Get Agent Details API

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Retrieves detailed information about a specific agent in your Wayfound organization.

```APIDOC
## get_agent_details

### Description
Get the details of a specific Agent in your Wayfound organization.

### Method
GET

### Endpoint
/agents/{agent_id}

### Parameters
#### Path Parameters
- **agent_id** (string) - Required - The unique identifier of the agent.

#### Query Parameters
- **organization_id** (string) - Required - The ID of the organization the agent belongs to.

### Response
#### Success Response (200)
- **agent_details** (object) - Detailed information about the agent.
  - **agent_id** (string) - The unique identifier for the agent.
  - **agent_name** (string) - The name of the agent.
  - **role** (string) - The role and purpose of the agent.
  - **goals** (array) - An array of strings describing the agent's goals and objectives.
  - **guidelines** (array) - An array of strings outlining the agent's guidelines and constraints.
  - **configuration** (object) - Configuration settings for the agent.

### Response Example
{
  "agent_details": {
    "agent_id": "agent-123",
    "agent_name": "Customer Support",
    "role": "Provide customer support and resolve issues.",
    "goals": [
      "Achieve high customer satisfaction scores.",
      "Reduce average resolution time."
    ],
    "guidelines": [
      "Always be polite and empathetic.",
      "Escalate complex issues to a human agent."
    ],
    "configuration": {
      "model": "gpt-4",
      "temperature": 0.7
    }
  }
}
```

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

### Launch Okta MCP CLI Client

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Navigates to the clients directory and launches the command-line interface client for the Okta MCP Server. This client does not use memory.

```bash
cd clients
python mcp-cli-stdio-client.py
```

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

### MCP Server Health Check Response

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/README.md

Example of the expected JSON response from the /api/health endpoint, indicating the server is operational.

```json
{
  "status": "OK",
  "timestamp": "2025-09-17T12:00:00Z",
  "version": "v1.0.1",
  "mode": "backend"
}
```

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

### Get Manager Analysis for Agent API

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Retrieves Wayfound Manager analysis for a specific agent, including performance metrics and insights.

```APIDOC
## get_manager_analysis_for_agent

### Description
Get Wayfound Manager analysis for a specific Agent. This includes top topics, potential issues, tool call data, knowledge gaps, user ratings, sentiment, and guideline issues.

### Method
GET

### Endpoint
/agents/{agent_id}/analysis

### Parameters
#### Path Parameters
- **agent_id** (string) - Required - The unique identifier of the agent.

#### Query Parameters
- **organization_id** (string) - Required - The ID of the organization the agent belongs to.

### Response
#### Success Response (200)
- **analysis** (object) - Comprehensive performance analysis.
  - **top_topics** (array) - An array of strings representing the most frequently discussed subjects.
  - **potential_issues** (array) - An array of strings identifying potential problems or concerns.
  - **tool_call_data** (object) - Usage statistics and patterns of tool calls.
  - **knowledge_gaps** (array) - An array of strings indicating areas where the agent lacks information.
  - **user_ratings** (object) - Customer satisfaction scores.
  - **sentiment_analysis** (object) - Overall user sentiment trends.
  - **guideline_issues** (array) - An array of strings detailing guideline violations or deviations.

### Response Example
{
  "analysis": {
    "top_topics": ["Billing", "Account Management"],
    "potential_issues": ["Slow response time on weekends"],
    "tool_call_data": {
      "total_calls": 150,
      "successful_calls": 130
    },
    "knowledge_gaps": ["New product features"],
    "user_ratings": {
      "average_rating": 4.5,
      "total_ratings": 100
    },
    "sentiment_analysis": {
      "positive": 0.7,
      "neutral": 0.2,
      "negative": 0.1
    },
    "guideline_issues": ["Did not escalate a sensitive issue"]
  }
}
```

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

### Run Streamable HTTP MCP CLI Client

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Navigate to the clients directory and run the mcp-cli-streamable-client.py script to test the Streamable HTTP transport.

```bash
cd clients
python mcp-cli-streamable-client.py
```

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

### Generate MCP Server Configuration

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Use this command to automate the creation of MCP server configuration files. Pass the category, GitHub URL, and any required environment variables.

```bash
task create -- --category database https://github.com/myorg/my-orgdb-mcp -e API_TOKEN=test
```

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

### Configure STDIO Transport in claude_desktop_config.json

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Use this JSON configuration for the Standard I/O (STDIO) transport in Claude Desktop. Replace `DIR` with your absolute directory path and `OKTA_API_TOKEN` with your actual token.

```json
{
  "mcpServers": {
    "okta-mcp-server": {
      "command": "DIR/okta-mcp-server/venv/Scripts/python",
      "args": [
        "DIR/okta-mcp-server/main.py"
      ],
      "env": {
        "OKTA_CLIENT_ORGURL": "https://dev-1606.okta.com",
        "OKTA_API_TOKEN": "OKTA_API_TOKEN"
      }
    }
  }
}
```

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

### Configure Environment Variables for Wayfound MCP

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Create a .env file in the project root and add your Wayfound MCP and OpenAI API keys. Keep this file secure and do not commit it to version control.

```env
# Wayfound MCP Server Configuration
WAYFOUND_MCP_API_KEY=your_mcp_api_key_here

# OpenAI Configuration (required for the Agents SDK)
OPENAI_API_KEY=your_openai_api_key_here
```

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

### Configure STDIO Docker Transport for Claude Desktop

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Configure Claude Desktop to use the Docker container for STDIO transport. Ensure the environment variables `OKTA_CLIENT_ORGURL` and `OKTA_API_TOKEN` are set correctly.

```json
{
  "mcpServers": {
    "okta-mcp-server": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "OKTA_CLIENT_ORGURL",
        "-e", "OKTA_API_TOKEN",
        "fctrid/okta-mcp-server:stdio"
      ],
      "env": {
        "OKTA_CLIENT_ORGURL": "https://your-org.okta.com",
        "OKTA_API_TOKEN": "your_api_token"
      }
    }
  }
}
```

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

### Test Remote Server Locally

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Commands to test a newly added remote server configuration locally. This includes importing the catalog, enabling the server, and authorizing OAuth if applicable.

```bash
task catalog -- my-remote-server
docker mcp catalog import $PWD/catalogs/my-remote-server/catalog.yaml
docker mcp server enable my-remote-server
```

```bash
docker mcp oauth authorize my-remote-server
```

```bash
docker mcp catalog reset
```

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

### Docker Compose for MCP Server Production Deployment

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/DOCKER-USAGE-INSTRUCTIONS.txt

A sample docker-compose.yml file for deploying the SimpleCheckList MCP Server in a production environment. It includes port mapping, volume mounting for data persistence, environment variables, restart policy, and health checks.

```yaml
version: '3.8'
services:
  simplechecklist:
    image: mayurkakade/mcp-server:latest
    ports:
      - "8355:8355"
    volumes:
      - ./data:/app/data
    environment:
      - MODE=backend
      - LOG_LEVEL=info
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8355/api/health"]
      interval: 30s
      timeout: 10s
      retries: 3
```

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

### Build MCP Server Variants

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Builds different variants of the MCP server image locally. Use the --target flag to specify the desired variant (stdio, http, or sse).

```bash
docker build --target stdio -t okta-mcp-server:stdio .
```

```bash
docker build --target http -t okta-mcp-server:http .
```

```bash
docker build --target sse -t okta-mcp-server:sse .
```

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

### Deploy MCP Server with Persistent Storage

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/README.md

Run the MCP server container, mapping a host directory to the container's data volume for persistent storage of the SQLite database.

```bash
docker run -d \
  -p 8355:8355 \
  -v /host/data:/app/data \
  mayurkakade/mcp-server:latest
```

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

### Enable Debug Logging

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Import the logging module and configure it to display debug messages. This is useful for troubleshooting and understanding the script's execution flow.

```python
import logging
logging.basicConfig(level=logging.DEBUG)
```

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

### Configure Remote HTTP Access in Claude Desktop

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Configure Claude Desktop to use the mcp-remote command for connecting to an MCP server running in HTTP mode. Replace `your_actual_api_token` with your Okta API token.

```json
{
  "mcpServers": {
    "okta-mcp-server": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:3000/mcp"
      ],
      "env": {
        "OKTA_CLIENT_ORGURL": "https://dev-1606.okta.com",
        "OKTA_API_TOKEN": "your_actual_api_token"
      }
    }
  }
}
```

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

### Configure MCP Server with Environment Variables

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/DOCKER-USAGE-INSTRUCTIONS.txt

Deploys the MCP server with custom environment variables for mode, port, database path, and log level. Ensure the container is run in detached mode (-d) and ports are mapped.

```bash
docker run -d \
  -p 8355:8355 \
  -e MODE=backend \
  -e PORT=8355 \
  -e LOG_LEVEL=info \
  mayurkakade/mcp-server:latest
```

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

### Generate MCP Server with Custom Docker Image

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Specify a custom Docker image using the `--image` flag during server creation. This bypasses the automatic image build process.

```bash
task create -- --category database --image myorg/my-mcp https://github.com/myorg/my-orgdb-mcp -e API_TOKEN=test
```

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

### Define MCP Server Parameters

Source: https://github.com/docker/mcp-registry/blob/main/docs/configuration.md

Define parameters for user configuration within the `server.yaml`. These parameters can be of various types and some can be marked as required.

```yaml
config:
  parameters:
    type: object
    properties:
      my_param:
        type: string
    required:
      - my_param
```

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

### Run MCP Database Server with Persistent SQLite Storage using Docker

Source: https://github.com/docker/mcp-registry/blob/main/servers/database-server/readme.md

This command runs the MCP Database Server with persistent SQLite storage. It maps port 3000, mounts a volume for data persistence, and sets the DATABASE_URL.

```bash
# Run with persistent SQLite storage
docker run -d \
  -p 3000:3000 \
  -v /host/data:/data \
  -e DATABASE_URL=sqlite+aiosqlite:///data/mydb.db \
  souhardyak/mcp-db-server
```

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

### SQLite Database Configuration for MCP Server

Source: https://github.com/docker/mcp-registry/blob/main/servers/database-server/readme.md

Configure the MCP Database Server to use SQLite by setting the DATABASE_URL environment variable. This is recommended for testing purposes.

```bash
DATABASE_URL=sqlite+aiosqlite:///data/mydb.db
```

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

### List Running MCP Server Containers

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/DOCKER-USAGE-INSTRUCTIONS.txt

Filters and lists all running Docker containers that are instances of the mayurkakade/mcp-server:latest image.

```bash
docker ps --filter "ancestor=mayurkakade/mcp-server:latest"
```

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

### Configure Volumes for MCP Server

Source: https://github.com/docker/mcp-registry/blob/main/docs/configuration.md

Define volumes for an MCP Server using the `run.volumes` attribute. User-defined host directories can be managed by creating a corresponding parameter.

```yaml
run:
  volumes:
    - '{{server_name.volume_path}}:/path/inside/container'
config:
  description: example of a volume
  parameters:
    type: object
    properties:
      volume_path:
        type: string
    required:
      - volume_path
```

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

### Configure Environment Variables for MCP Server

Source: https://github.com/docker/mcp-registry/blob/main/docs/configuration.md

Set environment variables for an MCP Server by defining a parameter and then mapping it to an environment variable name using Jinja templating.

```yaml
config:
  env:
    - name: ENVIRONMENT_VARIABLE_NAME
      example: ""
      value: '{{server_name.parameter_name}}'
  parameters:
    type: object
    properties:
      parameter_name:
        type: string
    required:
      - parameter_name
```

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

### MCP Server Configuration with Secrets and Environment Variables

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

This configuration block demonstrates how to define secrets and environment variables for an MCP server. It includes details for AWS credentials and endpoint URLs.

```yaml
config:
  description: Configure the connection to AWS
  secrets:
    - name: tigris.aws_secret_access_key
      env: AWS_SECRET_ACCESS_KEY
      example: YOUR_SECRET_ACCESS_KEY_HERE
  env:
    - name: AWS_ACCESS_KEY_ID
      example: YOUR_ACCESS_KEY_HERE
      value: '{{tigris.aws_access_key_id}}'
    - name: AWS_ENDPOINT_URL_S3
      example: https://fly.storage.tigris.dev
      value: '{{tigris.aws_endpoint_url_s3}}'
  parameters:
    type: object
    properties:
      aws_access_key_id:
        type: string
    required:
      - aws_access_key_id
```

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

### PostgreSQL Database Configuration for MCP Server

Source: https://github.com/docker/mcp-registry/blob/main/servers/database-server/readme.md

Configure the MCP Database Server to use PostgreSQL by setting the DATABASE_URL environment variable with your connection details.

```bash
DATABASE_URL=postgresql+asyncpg://user:password@localhost:5432/mydb
```

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

### MySQL Database Configuration for MCP Server

Source: https://github.com/docker/mcp-registry/blob/main/servers/database-server/readme.md

Configure the MCP Database Server to use MySQL by setting the DATABASE_URL environment variable with your connection details.

```bash
DATABASE_URL=mysql+aiomysql://user:password@localhost:3306/mydb
```

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

### Persist Data with Docker Volumes

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/DOCKER-USAGE-INSTRUCTIONS.txt

Mounts a host directory to the container's data path to ensure persistent storage for the SQLite database and task data. This is crucial for maintaining data across container restarts.

```bash
docker run -d \
  -p 8355:8355 \
  -v /host/path/to/data:/app/data \
  mayurkakade/mcp-server:latest
```

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

### Run MCP Database Server with SQLite using Docker

Source: https://github.com/docker/mcp-registry/blob/main/servers/database-server/readme.md

This command runs the MCP Database Server in detached mode using SQLite. It maps port 3000 and sets the DATABASE_URL environment variable.

```bash
# Run with SQLite (simplest setup)
docker run -d \
  -p 3000:3000 \
  -e DATABASE_URL=sqlite+aiosqlite:///data/mydb.db \
  souhardyak/mcp-db-server
```

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

### Run MCP Database Server with PostgreSQL using Docker

Source: https://github.com/docker/mcp-registry/blob/main/servers/database-server/readme.md

This command runs the MCP Database Server in detached mode using PostgreSQL. It maps port 3000 and sets the DATABASE_URL environment variable with PostgreSQL connection details.

```bash
# Run with PostgreSQL
docker run -d \
  -p 3000:3000 \
  -e DATABASE_URL=postgresql+asyncpg://user:password@host:5432/db \
  souhardyak/mcp-db-server
```

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

### View MCP Server Container Logs

Source: https://github.com/docker/mcp-registry/blob/main/servers/simplechecklist/DOCKER-USAGE-INSTRUCTIONS.txt

Retrieves the logs for a specific MCP server container. Replace `<container-id>` with the actual ID of your running container.

```bash
docker logs <container-id>
```

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

### Configure Container User for MCP Server

Source: https://github.com/docker/mcp-registry/blob/main/docs/configuration.md

Specify the user for running the MCP Server container using the `run.user` attribute. The user can be made configurable via a parameter.

```yaml
run:
  user: '{{server_name.container_user}}'
config:
  description: example of a user
  parameters:
    type: object
    properties:
      container_user:
        type: string
```

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

### List Agents API

Source: https://github.com/docker/mcp-registry/blob/main/servers/wayfound/readme.md

Retrieves a list of all agents configured in your Wayfound organization.

```APIDOC
## list_agents

### Description
Get the list of all Agents in your Wayfound organization.

### Method
GET

### Endpoint
/agents

### Parameters
#### Query Parameters
- **organization_id** (string) - Required - The ID of the organization to list agents from.

### Response
#### Success Response (200)
- **agents** (array) - A list of agent objects, each containing basic information.
  - **agent_id** (string) - The unique identifier for the agent.
  - **agent_name** (string) - The name of the agent.

### Response Example
{
  "agents": [
    {
      "agent_id": "agent-123",
      "agent_name": "Customer Support"
    },
    {
      "agent_id": "agent-456",
      "agent_name": "Sales"
    }
  ]
}
```

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

### Reset MCP Catalog

Source: https://github.com/docker/mcp-registry/blob/main/CONTRIBUTING.md

Command to reset the MCP catalog to its original state after testing.

```bash
docker mcp catalog reset
```

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

### Run MCP Server in SSE Mode

Source: https://github.com/docker/mcp-registry/blob/main/servers/okta-mcp-fctr/README.md

Run the MCP server in Server-Sent Events (SSE) mode with explicit risk acknowledgment. This is a deprecated transport method and not recommended for new implementations.

```bash
# Run in SSE mode (requires explicit risk acknowledgment)
python main.py --sse --iunderstandtherisks
```