### Clone and Setup PAL MCP Server (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This bash script demonstrates how to clone the PAL MCP Server repository and run a setup script for immediate use. The `run-server.sh` script automates environment creation, dependency installation, and configuration.

```bash
# Clone the repository
git clone https://github.com/BeehiveInnovations/pal-mcp-server.git
cd pal-mcp-server

# One-command setup (handles everything)
./run-server.sh

# View configuration for Claude Desktop
./run-server.sh -c

# See all options
./run-server.sh --help
```

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

### PAL MCP Basic Usage Patterns

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

Examples demonstrating how to interact with the PAL MCP server for various tasks. This includes letting Claude pick the model, specifying a model for a task, and orchestrating multi-model workflows.

```bash
"Use pal to analyze this code for security issues"
"Debug this race condition with pal"
"Plan the database migration with pal"

"Use pal with gemini pro to review this complex algorithm"
"Debug with o3 using pal for logical analysis"
"Get flash to quickly format this code via pal"

"Use pal to get consensus from pro and o3 on this architecture"
"Code review with gemini, then precommit validation with o3"
"Analyze with flash, then deep dive with pro if issues found"
```

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

### Cost-Optimized Setup - Environment Variables

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This setup prioritizes cost efficiency by defaulting to the 'flash' model and restricting allowed Gemini models to 'flash'. It requires a Gemini API key.

```env
DEFAULT_MODEL=flash
GEMINI_API_KEY=your-key
GOOGLE_ALLOWED_MODELS=flash
```

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

### Troubleshooting Container Startup (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

Provides commands to diagnose and resolve issues when the PAL MCP Server container fails to start. Includes checking image existence, interactive testing, and verifying environment variables.

```bash
# Check if image exists
docker images pal-mcp-server

# Test container interactively
docker run --rm -it --env-file .env pal-mcp-server:latest bash

# Check environment variables
docker run --rm --env-file .env pal-mcp-server:latest env | grep API

# Test with minimal configuration
docker run --rm -i -e GEMINI_API_KEY="test" pal-mcp-server:latest python server.py
```

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

### Start Local Model Server Examples

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/custom_models.md

These commands demonstrate how to start local AI model servers using Ollama, vLLM, and LM Studio. Ensure the server is running and accessible before configuring the PAL MCP server to use it.

```bash
# Example: Ollama
ollama serve
ollama pull llama3.2
```

```bash
# Example: vLLM
python -m vllm.entrypoints.openai.api_server --model meta-llama/Llama-2-7b-chat-hf
```

```bash
# Example: LM Studio (enable OpenAI compatibility in settings)
# Server runs on localhost:1234
```

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

### Install and Run Ollama for Local Models

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This snippet demonstrates how to install Ollama, start its service, and pull a language model. It's a prerequisite for running local models with the PAL MCP Server. Ensure you have curl and a shell environment to execute these commands.

```bash
# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Start Ollama service
ollama serve

# Pull a model (e.g., Llama 3.2)
ollama pull llama3.2
```

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

### Configure Environment Variables (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

Copies the example environment file and prompts the user to edit it with necessary API keys. This step is crucial for the server to authenticate with external AI services.

```bash
cp .env.example .env

# Edit with your API keys (at least one required)
# Required: GEMINI_API_KEY or OPENAI_API_KEY or XAI_API_KEY
nano .env
```

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

### Setup and Update PAL MCP Server (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/CLAUDE.md

Automates the setup and update process for the PAL MCP Server. This includes creating/updating the virtual environment, installing dependencies, configuring the .env file, setting up MCP with Claude, and verifying API keys.

```bash
# Run setup script (handles everything)
./run-server.sh
```

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

### Local Model Connection Examples

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/custom_models.md

These examples show how to configure CUSTOM_API_URL, CUSTOM_API_KEY, and CUSTOM_MODEL_NAME for various local model providers. Adjust the port numbers and model names according to your specific setup.

```bash
# For Ollama, vLLM, LM Studio, etc. running on your machine
CUSTOM_API_URL=http://localhost:11434/v1  # Ollama default port
```

```bash
# Ollama:
CUSTOM_API_URL=http://localhost:11434/v1
CUSTOM_API_KEY=
CUSTOM_MODEL_NAME=llama3.2
```

```bash
# vLLM:
CUSTOM_API_URL=http://localhost:8000/v1
CUSTOM_API_KEY=
CUSTOM_MODEL_NAME=meta-llama/Llama-2-7b-chat-hf
```

```bash
# LM Studio:
CUSTOM_API_URL=http://localhost:1234/v1
CUSTOM_API_KEY=lm-studio  # Or any value, LM Studio often requires some key
CUSTOM_MODEL_NAME=local-model
```

```bash
# text-generation-webui (with OpenAI extension):
CUSTOM_API_URL=http://localhost:5001/v1
CUSTOM_API_KEY=
CUSTOM_MODEL_NAME=your-loaded-model
```

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

### Install WSL Prerequisites and Node.js

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/wsl-setup.md

Installs necessary system packages for WSL, including Python development tools and Node.js, which is required for the Claude Code CLI. This ensures the environment is ready for subsequent installations.

```bash
sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-venv python3-pip curl git
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs
```

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

### Run PAL MCP Server Setup Script

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/wsl-setup.md

Makes the server setup script executable and then runs it. This script handles the final configuration and initialization of the PAL MCP Server within the WSL environment.

```bash
chmod +x run-server.sh
./run-server.sh
```

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

### Start Server and Follow Logs (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/logging.md

Starts the MCP server and automatically tails the server logs in real-time. This is the quickest way to monitor log output as it's generated.

```bash
# Start server and automatically follow MCP logs
./run-server.sh -f
```

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

### Clone and Setup PAL MCP Server

Source: https://context7.com/beehiveinnovations/pal-mcp-server/llms.txt

These bash commands demonstrate how to clone the PAL MCP Server repository and set up the server using the provided script. The `./run-server.sh` script handles virtual environment creation, dependency installation, .env file configuration, and client setup.

```bash
git clone https://github.com/BeehiveInnovations/pal-mcp-server.git
cd pal-mcp-server

# One-command setup - handles venv, dependencies, .env, and client configuration
./run-server.sh

# View configuration for Claude Desktop
./run-server.sh -c
```

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

### Clone Repository and Initial Setup

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/docker-deployment.md

This snippet shows how to clone the PAL MCP Server repository and navigate into its directory. It's the first step in setting up the server locally.

```bash
git clone https://github.com/BeehiveInnovations/pal-mcp-server.git
cd pal-mcp-server
```

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

### Clone and Setup PAL MCP Server (PowerShell)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This PowerShell script provides an alternative to the bash script for setting up the PAL MCP Server on Windows. It mirrors the functionality of `run-server.sh` for PowerShell environments.

```powershell
# Clone the repository
git clone https://github.com/BeehiveInnovations/pal-mcp-server.git
cd pal-mcp-server

# One-command setup (handles everything)
./run-server.ps1
```

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

### Install Specific Python Versions for WSL

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/wsl-setup.md

Installs specific Python versions and their development headers if virtual environment issues arise. This ensures compatibility with the project's Python dependencies.

```bash
sudo apt install -y python3.12-venv python3.12-dev
```

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

### Example Usage Commands (Shell)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/README.md

These are example commands demonstrating how to interact with the pal-mcp-server after setup. They showcase using different AI models (Gemini Pro, O3) for various tasks such as security analysis, debugging, optimization suggestions, and migration planning. The 'clink' command allows for specific model and role assignments.

```shell
"Use pal to analyze this code for security issues with gemini pro"
"Debug this error with o3 and then get flash to suggest optimizations"
"Plan the migration strategy with pal, get consensus from multiple models"
"clink with cli_name=\"gemini\" role=\"planner\" to draft a phased rollout plan"
```

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

### PAL MCP Test Commands

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

A collection of example commands to test the PAL MCP integration with various CLI tools. These commands cover listing models, general chat interactions, specific tool usage with model selection, and debugging.

```bash
"Use pal to list available models"
"Chat with pal about the best approach for API design"
"Use pal thinkdeep with gemini pro about scaling strategies"
"Debug this error with o3: [paste error]"
```

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

### Chat Tool - Example Prompt for Redis vs. Memcached

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/tools/chat.md

This example demonstrates how to use the chat tool to compare two technologies (Redis and Memcached) for session storage. It involves analyzing project code, getting an expert opinion, and engaging in a discussion with Gemini Pro to reach a final conclusion.

```text
I need to pick between Redis and Memcached for session storage and I need an expert opinion for the project
I'm working on. Take a look at the code and get an idea of what this project does, pick one of the two options
and then chat with gemini pro and continue discussing pros and cons to come to a final conclusion. I need a one
word verdict in the end.
```

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

### Troubleshooting Permission Issues (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

Offers solutions for permission-related problems, including commands to fix log directory permissions on Linux/macOS and advice for Windows users.

```bash
# Fix log directory permissions (Linux/macOS)
sudo chown -R $USER:$USER logs/
chmod 755 logs/

# Windows: Run Docker Desktop as Administrator if needed
```

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

### Troubleshooting Memory/Performance Issues (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

Provides commands to monitor container resource usage and run the server with memory limits. It also includes instructions for logging Docker output.

```bash
# Check container resource usage
docker stats

# Run with memory limits
docker run --rm -i --memory="512m" --env-file .env pal-mcp-server:latest

# Monitor Docker logs
docker run --rm -i --env-file .env pal-mcp-server:latest 2>&1 | tee docker.log
```

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

### Build Docker Image (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

Builds the Docker image for the PAL MCP Server. It provides commands for direct Docker build and using provided build scripts for Bash and PowerShell.

```bash
# Build the Docker image
docker build -t pal-mcp-server:latest .

# Or use the build script (Bash)
chmod +x docker/scripts/build.sh
./docker/scripts/build.sh
```

```powershell
docker/scripts/build.ps1
```

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

### Upgrade Pip in WSL

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/wsl-setup.md

Upgrades the pip package installer to the latest version. This is a common troubleshooting step for Python-related installation or dependency issues.

```bash
python3 -m pip install --upgrade pip
```

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

### Install Claude Code CLI

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/wsl-setup.md

Installs the Claude Code Command Line Interface globally using npm. This tool is essential for interacting with and managing the MCP server.

```bash
npm install -g @anthropic-ai/claude-code
```

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

### Planner Tool Example (Python)

Source: https://context7.com/beehiveinnovations/pal-mcp-server/llms.txt

Demonstrates the planner tool's ability to break down complex projects into actionable steps. It includes an example of planning the implementation of real-time notifications, showing the MCP tool call and the resulting structured plan with phases and dependencies.

```python
# Example: Feature planning
# User prompt: "Use pal's planner to show me how to add real-time notifications"

# MCP Tool Call
{
  "tool": "planner",
  "arguments": {
    "prompt": "Plan the implementation of real-time push notifications for our mobile app. Consider iOS/Android, backend infrastructure, and user preferences.",
    "model": "pro"
  }
}

# Response with structured plan:
{
  "status": "success",
  "content": "## Implementation Plan: Real-Time Notifications\n\n### Phase 1: Infrastructure (Week 1-2)\n1. Set up WebSocket server or Firebase Cloud Messaging\n2. Design notification payload schema\n3. Implement server-side event triggers\n\n### Phase 2: Backend Integration (Week 2-3)\n1. Create notification service module\n2. Implement user preference storage\n3. Add rate limiting and batching\n\n### Phase 3: Mobile Implementation (Week 3-4)\n...\n\n### Dependencies\n- Firebase SDK or custom WebSocket implementation\n- Database schema updates for preferences",
  "continuation_id": "bb0e8400-e29b-41d4-a716-446655440006"
}
```

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

### High-Performance Setup - Environment Variables

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

Designed for maximum performance, this configuration uses 'auto' as the default model and specifies high-performance models for both Gemini and OpenAI. API keys for both services are necessary.

```env
DEFAULT_MODEL=auto
GEMINI_API_KEY=your-key
OPENAI_API_KEY=your-key
GOOGLE_ALLOWED_MODELS=pro
OPENAI_ALLOWED_MODELS=gpt-5.1-codex,gpt-5.2
```

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

### Continue Planning with Consensus Tool (PAL)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/tools/planner.md

This example shows how to continue a planning process by using the consensus tool with the output from a previous plan. It demonstrates the interoperability between different PAL tools for iterative decision-making.

```text
Continue with pal's consensus tool and find out what o3:for and flash:against think of the plan 
```

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

### Development Setup (Balanced) - Environment Variables

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This configuration balances performance and cost for development environments. It sets a default model to 'auto' and specifies allowed models for both Gemini and OpenAI, requiring API keys for both services.

```env
DEFAULT_MODEL=auto
GEMINI_API_KEY=your-key
OPENAI_API_KEY=your-key
GOOGLE_ALLOWED_MODELS=flash,pro
OPENAI_ALLOWED_MODELS=gpt-5.1-codex-mini,gpt-5-mini,o4-mini
```

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

### Local-First Setup - Environment Variables

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This configuration enables a local-first approach by setting a custom API URL and model name for local inference. Cloud APIs like Gemini can be configured as backups, requiring their respective API keys.

```env
DEFAULT_MODEL=auto
CUSTOM_API_URL=http://localhost:11434/v1
CUSTOM_MODEL_NAME=llama3.2
# Add cloud APIs as backup
GEMINI_API_KEY=your-key
```

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

### Instant Setup with uvx (JSON Configuration)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/README.md

This JSON configuration is used with uvx for an instant setup of the pal-mcp-server. It specifies the command to execute, arguments for cloning the repository, and environment variables including API keys and tool configurations. This method allows for quick deployment and integration with various AI models.

```json
// Add to ~/.claude/settings.json or .mcp.json
// Don't forget to add your API keys under env
{
  "mcpServers": {
    "pal": {
      "command": "bash",
      "args": ["-c", "for p in $(which uvx 2>/dev/null) $HOME/.local/bin/uvx /opt/homebrew/bin/uvx /usr/local/bin/uvx uvx; do [ -x \"$p\" ] && exec \"$p\" --from git+https://github.com/BeehiveInnovations/pal-mcp-server.git pal-mcp-server; done; echo 'uvx not found' >&2; exit 1"],
      "env": {
        "PATH": "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:~/.local/bin",
        "GEMINI_API_KEY": "your-key-here",
        "DISABLED_TOOLS": "analyze,refactor,testgen,secaudit,docgen,tracer",
        "DEFAULT_MODEL": "auto"
      }
    }
  }
}
```

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

### Plan Natural Language Support for Cooking App (PAL Planner)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/tools/planner.md

This example demonstrates using the planner tool within a sub-task to outline the steps for adding natural language support to a cooking application. It highlights the tool's capability to break down complex features into actionable steps.

```text
Create two separate sub-tasks: in one, using planner tool show me how to add natural language support 
to my cooking app. In the other sub-task, use planner to plan how to add support for voice notes to my cooking app. 
Once done, start a consensus by sharing both plans to o3 and flash to give me the final verdict. Which one do 
I implement first?
```

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

### Configure OpenCode CLI for PAL MCP Server

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This JSON configuration is for the OpenCode CLI, to be edited in `~/.config/opencode/opencode.json`. It defines the local setup for the PAL MCP Server, specifying the Python executable, server script, working directory, and environment variables.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "pal": {
      "type": "local",
      "command": [
        "/path/to/pal-mcp-server/.pal_venv/bin/python",
        "/path/to/pal-mcp-server/server.py"
      ],
      "cwd": "/path/to/pal-mcp-server",
      "enabled": true,
      "environment": {
        "GEMINI_API_KEY": "your_api_key_here"
      }
    }
  }
}
```

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

### Plan CoreData Sync for App (PAL Planner)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/tools/planner.md

This example demonstrates using the planner tool to create a plan for adding CoreData synchronization to an application, including any necessary sub-steps. It highlights the tool's capacity for detailed planning.

```text
Using the planner tool, show me how to add CoreData sync to my app, include any sub-steps
```

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

### Test PAL MCP Server Docker Image

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

These bash commands are used to quickly test the PAL MCP Server Docker image. The first command checks if the container starts and Python is accessible, while the second tests the health check endpoint.

```bash
# Test container starts correctly
docker run --rm pal-mcp-server:latest python --version

# Test health check
docker run --rm -e GEMINI_API_KEY="test" pal-mcp-server:latest python /usr/local/bin/healthcheck.py
```

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

### Deploy and Manage with Docker Compose (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

Provides commands for deploying and managing the PAL MCP Server using Docker Compose. Includes scripts for deployment, interactive mode, and service management commands.

```bash
# Deploy with Docker Compose
chmod +x docker/scripts/deploy.sh
./docker/scripts/deploy.sh

# Or use PowerShell script
docker/scripts/deploy.ps1

# Interactive stdio mode
docker-compose exec pal-mcp python server.py
```

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

### Configure Claude Desktop for PAL MCP Server

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This JSON configuration is for Claude Desktop's developer settings. It specifies the command and environment variables required to connect to the PAL MCP Server using `uvx`. Ensure `uvx` is installed and accessible in your PATH.

```json
{
  "mcpServers": {
    "pal": {
      "command": "sh",
      "args": [
        "-c", 
        "for p in $(which uvx 2>/dev/null) $HOME/.local/bin/uvx /opt/homebrew/bin/uvx /usr/local/bin/uvx uvx; do [ -x \"$p\" ] && exec \"$p\" --from git+https://github.com/BeehiveInnovations/pal-mcp-server.git pal-mcp-server; done; echo 'uvx not found' >&2; exit 1"
      ],
      "env": {
        "PATH": "/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:~/.local/bin",
        "GEMINI_API_KEY": "your_api_key_here"
      }
    }
  }
}
```

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

### Configure API Keys in .env file

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/getting-started.md

This snippet shows the format for configuring API keys for various AI providers within the `.env` file for the cloned PAL MCP Server installation. It includes keys for Gemini, OpenAI, XAI, OpenRouter, and optional DIAL platform settings, as well as custom/local model configurations.

```env
# Choose your providers (at least one required)
GEMINI_API_KEY=your-gemini-api-key-here      # For Gemini models  
OPENAI_API_KEY=your-openai-api-key-here      # For GPT-5.2, GPT-5.1-Codex, O3
XAI_API_KEY=your-xai-api-key-here            # For Grok models
OPENROUTER_API_KEY=your-openrouter-key       # For multiple models

# DIAL Platform (optional)
DIAL_API_KEY=your-dial-api-key-here
DIAL_API_HOST=https://core.dialx.ai          # Default host (optional)
DIAL_API_VERSION=2024-12-01-preview          # API version (optional) 
DIAL_ALLOWED_MODELS=o3,gemini-2.5-pro       # Restrict models (optional)

# Custom/Local models (Ollama, vLLM, etc.)
CUSTOM_API_URL=http://localhost:11434/v1     # Ollama example
CUSTOM_API_KEY=                              # Empty for Ollama
CUSTOM_MODEL_NAME=llama3.2                   # Default model name
```

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

### Plan React App Migration to TypeScript (PAL Planner)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/tools/planner.md

This example demonstrates using the planner tool to create a migration plan for moving a React application from JavaScript to TypeScript. It showcases the tool's utility in managing complex code refactoring and modernization efforts.

```text
Create a plan using pal for migrating our React app from JavaScript to TypeScript
```

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

### Run Server Directly with Docker (Bash)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

Demonstrates two methods for running the PAL MCP Server directly using `docker run`. It covers using an environment file and providing environment variables inline, along with volume mounting for logs.

```bash
# Run with environment file
docker run --rm -i --env-file .env \
  -v $(pwd)/logs:/app/logs \
  pal-mcp-server:latest

# Run with inline environment variables
docker run --rm -i \
  -e GEMINI_API_KEY="your_key_here" \
  -e LOG_LEVEL=INFO \
  -v $(pwd)/logs:/app/logs \
  pal-mcp-server:latest
```

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

### Install WSL2 on Windows

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/troubleshooting.md

Installs the Windows Subsystem for Linux 2 (WSL2) with the Ubuntu distribution. This is a prerequisite for Windows users to run the PAL MCP Server, as it requires a Linux environment.

```powershell
wsl --install -d Ubuntu
```

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

### Custom Stance Instructions for Models (JSON)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/tools/consensus.md

Allows for detailed guidance on how models should approach their assigned stance using a 'stance_prompt'. This enables more nuanced and focused analysis.

```json
[
    {"model": "o3", "stance": "for", "stance_prompt": "Focus on implementation benefits and user value"},
    {"model": "flash", "stance": "against", "stance_prompt": "Identify potential risks and technical challenges"}
]
```

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

### Run PAL MCP Server with Docker Compose

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docker/README.md

This command uses docker-compose to run the PAL MCP Server, referencing a specific docker-compose.yml file. This is an advanced option that assumes a pre-configured compose setup.

```json
{
  "servers": {
    "pal-docker": {
      "command": "docker-compose",
      "args": [
        "-f",
        "/absolute/path/to/pal-mcp-server/docker-compose.yml",
        "run",
        "--rm",
        "pal-mcp"
      ]
    }
  }
}
```

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

### Consensus Tool Usage: With Visual Context (Text)

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/tools/consensus.md

Illustrates how to use the consensus tool with visual context, directing specific models to support or critique provided mockups.

```text
Use consensus to evaluate this new UI design mockup - have flash support it and pro be critical
```

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

### Start PAL MCP Service with Docker Compose

Source: https://github.com/beehiveinnovations/pal-mcp-server/blob/main/docs/docker-deployment.md

This snippet shows how to start the PAL MCP Server using Docker Compose, either in detached mode (background) or attached mode to view logs in real-time.

```bash
# Start in background
docker-compose up -d

# Start with logs
docker-compose up
```

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

### List Models Tool Example (Python)

Source: https://context7.com/beehiveinnovations/pal-mcp-server/llms.txt

The listmodels tool displays all available AI models, organized by provider, along with their capabilities, context windows, and configuration status. The example shows an MCP tool call and a sample response detailing models from Google, OpenAI, and custom/local sources.

```python
# Example: List available models
# User prompt: "Use pal to list available models"

# MCP Tool Call
{
  "tool": "listmodels",
  "arguments": {}
}

# Response:
{
  "status": "success",
  "content": "## Available Models by Provider\n\n### Google (Gemini) - Configured\n- **pro** (gemini-2.5-pro): 1M context, thinking modes, vision\n- **flash** (gemini-2.5-flash): 1M context, ultra-fast\n\n### OpenAI - Configured\n- **gpt-5.2**: 400K context, reasoning tokens, streaming\n- **gpt-5.1-codex**: 400K context, coding specialization\n- **o3**: 200K context, strong reasoning\n- **o4-mini**: 200K context, latest balanced\n\n### Custom/Local - Configured\n- **llama3.2**: 128K context, local inference\n- Endpoint: http://localhost:11434/v1\n\n### Model Restrictions Active\n- OpenAI: gpt-5.1-codex-mini, o4-mini\n- Google: flash, pro"
}

```