### Install and Run Redis Server

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/INSTALLATION.md

Provides commands to install and start a Redis server on Debian/Ubuntu, macOS using Homebrew, or run it using Docker. Redis is required for session management.

```bash
# On Debian/Ubuntu:
sudo apt-get update
sudo apt-get install redis-server

# On macOS (using Homebrew):
brew install redis
brew services start redis

# Using Docker (Recommended):
docker run --name mcp-redis -p 6379:6379 -d redis
```

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

### List Protocols Example (curl)

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/API_DOCUMENTATION.md

Example using curl to send a GET request to the /protocols endpoint.

```bash
curl http://localhost:8000/protocols
```

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

### Install @simone-ai/mcp-sdk

Source: https://github.com/dansasser/sim-one/blob/main/code/packages/mcp-sdk/README.md

Instructions for installing the SDK using npm or pnpm package managers.

```bash
npm install @simone-ai/mcp-sdk
# or
pnpm add @simone-ai/mcp-sdk
```

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

### Bash Script for Development Environment Setup

Source: https://github.com/dansasser/sim-one/blob/main/COMPREHENSIVE_OPTIMIZATION_PLAN.md

Bash commands to set up the development environment. This includes installing the Rust toolchain, Python dependencies via pip, and essential development tools like maturin, pytest-benchmark, scalene, and py-spy.

```bash
# Rust toolchain
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup component add clippy rustfmt

# Python dependencies  
pip install -r requirements-dev.txt

# Development tools
pip install maturin pytest-benchmark scalene py-spy
```

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

### Run SIM-ONE Server (Production with Gunicorn)

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/INSTALLATION.md

Demonstrates how to run the SIM-ONE mCP Server using Gunicorn with Uvicorn workers for production deployment. This is recommended over using Uvicorn directly in production.

```bash
gunicorn -w 4 -k uvicorn.workers.UvicornWorker mcp_server.main:app
```

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

### Start Admin UI (Development)

Source: https://github.com/dansasser/sim-one/blob/main/code/ADMIN_PANEL_PLAN.md

Command to start the Admin UI in development mode. Requires setting the VITE_ADMIN_API_BASE_URL environment variable to point to the running Admin API.

```bash
VITE_ADMIN_API_BASE_URL=http://localhost:<admin-api-port> pnpm dev
```

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

### Install Gunicorn for Production Deployment

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/DEPLOYMENT.md

Installs the Gunicorn WSGI/ASGI server, which is recommended for production environments over development servers like uvicorn. This command should be run after adding 'gunicorn' to your project's requirements.

```bash
pip install gunicorn
```

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

### Install Project Dependencies (Bash)

Source: https://github.com/dansasser/sim-one/blob/main/code/astro-chat-interface/README.md

Installs all necessary project dependencies using npm. This is the first step in setting up the development environment.

```bash
npm install
```

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

### Clone and Start SIM-ONE Development Environment with Docker Compose

Source: https://github.com/dansasser/sim-one/blob/main/code/DEPLOYMENT_GUIDE.md

This snippet clones the SIM-ONE repository, sets up the development environment using Docker Compose, and shows how to view logs. It's designed for quick local development with features like hot reload and pre-configured API keys.

```bash
# Clone repository
git clone https://github.com/dansasser/SIM-ONE.git
cd SIM-ONE/code

# Copy environment template
cp .env.production.example .env
# Edit .env with your development values

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

# View logs
docker-compose -f docker-compose.dev.yml logs -f mcp-server
```

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

### Start Admin API (Node.js/FastAPI)

Source: https://github.com/dansasser/sim-one/blob/main/code/ADMIN_PANEL_PLAN.md

Commands to start the Admin API during local development. Supports both Node.js (using pnpm) and FastAPI (using uvicorn). Ensure necessary environment variables like SIMONE_API_URL are set.

```bash
pnpm dev
```

```bash
uvicorn main:app --reload
```

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

### Python Docstring Examples for Agent Core

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/FUTURE_NAMING.md

Demonstrates correct and incorrect Python docstring conventions for the agent core orchestration system. The 'GOOD' example uses future terminology and notes the current directory structure, while the 'AVOID' example reinforces outdated naming.

```python
"""
Agent Core Orchestration System

This module coordinates cognitive protocols and manages the execution
of multi-step workflows through the SIM-ONE agent core.

Historical Note: Package currently located in `mcp_server/` directory.
"""

"""
MCP Server Orchestration

This module manages the MCP server operations..."""
```

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

### Start Development Server (Bash)

Source: https://github.com/dansasser/sim-one/blob/main/code/astro-chat-interface/README.md

Starts the local development server for the Astro project. This allows for real-time preview and testing during development.

```bash
npm run dev
```

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

### Install Development Dependencies

Source: https://github.com/dansasser/sim-one/blob/main/benchmarks/README.md

Installs the necessary development requirements for the project using pip. This command reads dependencies from the 'requirements-dev.txt' file, ensuring all required packages are available.

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

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

### Install Rust and Python Development Tools (Bash)

Source: https://github.com/dansasser/sim-one/blob/main/close-to-the-metal.md

Installs the Rust toolchain, updates it, and adds clippy and rustfmt components. It also installs Python development tools like maturin, pytest-benchmark, scalene, and py-spy.

```bash
# Install Rust toolchain
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup update stable
rustup component add clippy rustfmt

# Install Python development tools
pip install maturin pytest-benchmark scalene py-spy
```

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

### Prometheus Configuration Example

Source: https://github.com/dansasser/sim-one/blob/main/code/README.md

An example configuration file for Prometheus to scrape metrics from the mCP Server, enabling monitoring of governance and recovery metrics.

```yaml
# Prometheus example config: see `code/config/prometheus.yml`.
```

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

### Setup SIM-ONE and Import AdvancedREP

Source: https://github.com/dansasser/sim-one/blob/main/tutorials/rep_reasoning_tutorial.ipynb

This snippet sets up the Python environment by adding the SIM-ONE root directory to the system path and importing the AdvancedREP class. It configures plotting preferences and confirms the setup is complete.

```python
# Standard library imports
import sys
import json
from pathlib import Path
from typing import Dict, Any, Optional, List, Tuple
import pandas as pd
import matplotlib.pyplot as plt
import networkx as nx
from datetime import datetime

# Add SIM-ONE to Python path
SIMONE_ROOT = Path("../code").resolve()
sys.path.insert(0, str(SIMONE_ROOT))

# Import REP protocol directly
from mcp_server.protocols.rep.rep import AdvancedREP

# Configure plotting
%matplotlib inline
plt.rcParams['figure.figsize'] = (12, 8)

print("[OK] Setup complete")
```

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

### Verify Python and Git Installation

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/INSTALLATION.md

Checks if the required Python and Git versions are installed on the system. This is a prerequisite for the installation process.

```bash
python3 --version
git --version
```

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

### Check Rule Set Completeness with VVP

Source: https://github.com/dansasser/sim-one/blob/main/tutorials/vvp_validation_tutorial.ipynb

This example demonstrates how to use VVP to check if a rule set covers all expected cases. It defines rules for water phase transitions and specifies expected coverage. The output includes the coverage percentage, covered cases, and any missing cases.

```python
# Define rule set for checking completeness
rules_with_gaps = {
    "rules": [
        ([["Temperature > 0°C", "Pressure = 1 atm"], "Water is liquid"]),
        ([["Temperature > 100°C", "Pressure = 1 atm"], "Water is gas"]),
        # Missing: What about temperature < 0°C? (water is solid/ice)
    ],
    "context": {
        "domain": "Water phase transitions",
        "expected_coverage": ["solid", "liquid", "gas"]
    }
}

# Validate rules
result = vvp.execute(rules_with_gaps)

print("VVP Completeness Check:")
print("=" * 80)

print(f"Status: {result.get('status', 'Unknown')}")

if result.get("completeness"):
    comp = result["completeness"]
    print(f"\nCompleteness Analysis:")
    print(f"  Coverage: {comp.get('coverage_percentage', 0):.1f}%")
    print(f"  Covered Cases: {comp.get('covered_cases', [])}")
    print(f"  Missing Cases: {comp.get('missing_cases', [])}")

if result.get("suggestions"):
    print(f"\n💡 Suggestions for Improvement:")
    for suggestion in result["suggestions"]:
        print(f"  - {suggestion}")
```

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

### Health Check Example (curl)

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/API_DOCUMENTATION.md

Example using curl to send a GET request to the root endpoint for a health check.

```bash
curl http://localhost:8000/
```

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

### Git Commit Message Style Guide

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/FUTURE_NAMING.md

Provides examples of recommended Git commit message formats using conventional commits. 'GOOD' examples use descriptive component names and scopes, while 'AVOID' examples use generic or outdated terms like 'mcp'.

```bash
# ✅ GOOD
git commit -m "feat(orchestrator): Add adaptive protocol scheduling"
git commit -m "docs(agent-core): Update terminology to use 'agent core'"
git commit -m "refactor(protocols): Improve REP reasoning chain"

# ❌ AVOID
git commit -m "fix(mcp): Fix mcp server bug"  # use descriptive component names
```

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

### Install Dependencies with Pip

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/DEPLOYMENT.md

Installs project dependencies from a requirements file. This command is crucial after pulling updates to ensure all necessary libraries are present and up-to-date.

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

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

### Systemd Commands for Managing Gunicorn Service

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/DEPLOYMENT.md

Commands to manage the systemd service for the SIM-ONE mCP Server. These commands reload the systemd daemon to recognize the new service file, start the service, and enable it to start automatically on system reboot.

```bash
sudo systemctl daemon-reload
sudo systemctl start mcp-server
sudo systemctl enable mcp-server
```

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

### Markdown Documentation for Tool Entrypoints

Source: https://github.com/dansasser/sim-one/blob/main/phase-22-000.md

An example of a documentation section, likely for a README file, that describes the tool entrypoints available in the project. It explains their purpose for agentizing and auto-tool-indexing, and maps protocols to their respective wrapper scripts.

```markdown
# 🛠️ Tool Entrypoints for Extraction
Each major protocol is exposed as a CLI/standalone tool in `/tools/`.
These wrappers are for agentizing and auto-tool-indexing.

```

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

### Run Server on Different Port

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/TROUBLESHOOTING.md

Starts the uvicorn server on a specified port, useful for avoiding port conflicts. Replace '8001' with your desired port number.

```bash
uvicorn mcp_server.main:app --port 8001
```

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

### Tools Manifest Example

Source: https://github.com/dansasser/sim-one/blob/main/phase-22-000.md

An example of a simple manifest file (e.g., 'tools_manifest.py' or 'paper2agent_index.md') used to list available tools and their corresponding wrapper scripts. This helps discovery tools like Paper2Agent identify and index the project's functionalities.

```text
SEP: run_sep_tool.py
REP: run_rep_tool.py
CCP: run_ccp_tool.py
...

```

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

### Create and Activate Python Virtual Environment

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/INSTALLATION.md

Creates a Python virtual environment named 'venv' to isolate project dependencies. It also shows how to activate it on different operating systems.

```bash
python3 -m venv venv
# On Linux/macOS:
source venv/bin/activate
# On Windows:
.\venv\Scripts\activate
```

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

### Set Up Python Virtual Environment

Source: https://github.com/dansasser/sim-one/blob/main/code/README.md

Creates and activates a Python virtual environment to manage project dependencies. This ensures that project-specific packages do not conflict with system-wide Python installations.

```bash
python3 -m venv venv
source venv/bin/activate
```

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

### Configure SIM-ONE Server Environment Variables

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/INSTALLATION.md

Creates a '.env' file in the project root and sets essential configuration variables, such as an API key and Redis connection details. This file is used to configure the server's behavior.

```dotenv
# .env file
MCP_API_KEY="your-super-secret-and-long-api-key"

# If your Redis server is not on localhost, specify its location
# REDIS_HOST=your-redis-host
# REDIS_PORT=your-redis-port
```

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

### Deploy SIM-ONE Production Environment with Docker Compose

Source: https://github.com/dansasser/sim-one/blob/main/code/DEPLOYMENT_GUIDE.md

This command sequence deploys the SIM-ONE MCP Server in a production environment using Docker Compose. It includes loading environment variables, starting the services, monitoring logs, and verifying the deployment's health.

```bash
# Load environment
export $(cat .env.production | xargs)

# Deploy with production configuration
docker-compose -f docker-compose.prod.yml up -d

# Monitor deployment
docker-compose -f docker-compose.prod.yml logs -f

# Verify health
curl -f https://yourdomain.com/health
```

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

### Abductive Reasoning for System Diagnosis (Python)

Source: https://github.com/dansasser/sim-one/blob/main/tutorials/rep_reasoning_tutorial.ipynb

This snippet demonstrates how to perform abductive reasoning to diagnose server performance degradation. It takes a list of facts and potential hypotheses, then identifies the most likely explanation. The output includes the best explanation, confidence score, ranked hypotheses, and a textual explanation.

```python
# Competing hypotheses to evaluate
hypotheses = [
    "Database query is inefficient",
    "Network congestion is occurring",
    "Memory leak is present",
    "CPU-intensive algorithm is running",
    "Disk is failing"
]

# Execute abductive reasoning
result = rep.perform_reasoning(
    reasoning_type="abductive",
    facts=facts,
    hypotheses=hypotheses,
    context="Server performance degradation diagnosis"
)

print("Abductive Reasoning Result:")
print("=" * 80)

if result.get("best_explanation"):
    print(f"[OK] Best Explanation: {result['best_explanation']}")
    print(f"  Confidence: {result.get('confidence', 0):.2f}")

if result.get("ranked_hypotheses"):
    print(f"\n[CHART] Ranked Hypotheses:")
    for i, hyp in enumerate(result["ranked_hypotheses"], 1):
        print(f"  {i}. {hyp['hypothesis']} (score: {hyp['score']:.2f})")

if result.get("explanation"):
    print(f"\n[TIP] Explanation:")
    print(f"  {result['explanation']}")

# Visualize hypothesis rankings
if result.get("ranked_hypotheses"):
    hyp_data = result["ranked_hypotheses"]
    labels = [h['hypothesis'][:30] + "..." if len(h['hypothesis']) > 30 else h['hypothesis']
              for h in hyp_data]
    scores = [h['score'] for h in hyp_data]

    plt.figure(figsize=(10, 6))
    plt.barh(labels, scores, color='steelblue', alpha=0.8)
    plt.xlabel("Explanation Score", fontsize=12)
    plt.title("Abductive Reasoning: Hypothesis Rankings", fontsize=14)
    plt.tight_layout()
    plt.savefig("abductive_hypotheses.png", dpi=150, bbox_inches='tight')
    plt.show()

```

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

### Clone SIM-ONE Repository and Setup Development Environment

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/protocols/sep/README.md

Provides bash commands to clone the SIM-ONE repository, create a new feature branch, install development dependencies including testing tools, and run the tests for the SEP protocol. This facilitates local development and contribution.

```bash
# Clone the repository
git clone https://github.com/dansasser/SIM-ONE.git
cd SIM-ONE

# Create feature branch
git checkout -b features/sep-enhancement

# Install development dependencies
pip install -r code/mcp_server/protocols/sep/requirements.txt
pip install pytest pytest-asyncio pytest-cov

# Run tests
pytest code/mcp_server/protocols/sep/tests/
```

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

### Systemd Service File for Gunicorn

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/DEPLOYMENT.md

Configuration for a systemd service file to manage the Gunicorn-based SIM-ONE mCP Server. This ensures the server runs continuously, restarts on failure, and starts on system boot. It specifies the user, group, working directory, environment path, and the command to execute.

```ini
[Unit]
Description=mCP Server Gunicorn Instance
After=network.target

[Service]
User=your-user
Group=your-group
WorkingDirectory=/path/to/your/SIM-ONE
Environment="PATH=/path/to/your/SIM-ONE/venv/bin"
ExecStart=/path/to/your/SIM-ONE/venv/bin/gunicorn -w 4 -k uvicorn.workers.UvicornWorker mcp_server.main:app -b 0.0.0.0:8000

[Install]
WantedBy=multi-user.target
```

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

### Simulate Iterative Text Refinement Workflow (Python)

Source: https://github.com/dansasser/sim-one/blob/main/tutorials/five_laws_validator_tutorial.ipynb

Illustrates a simulated iterative refinement process where text is progressively improved across multiple iterations to meet a validation threshold. This example demonstrates how feedback from validation can guide AI-driven text refinement, showing score improvements over time.

```python
print("\n" + "=" * 80)
print("\nExample 3: Simulated Iterative Refinement Workflow")
print("-" * 80)
print("(Demonstrating how AI client refines text across iterations)
")

# Iteration 1
iter1_text = "Use AI for analysis"
print(f"Iteration 1: \"{iter1_text}\"")
iter1 = iterative_validate_with_refinement(iter1_text, threshold=75.0)
print(f"  Score: {iter1['validation_result']['overall_compliance']:.1f}% | Passed: {iter1['validation_result']['passed_threshold']}")

# Iteration 2 (simulated AI revision)
iter2_text = "Use coordinated protocol architecture with ESL for emotion analysis and REP for structured reasoning"
print(f"\nIteration 2: \"{iter2_text}\"")
iter2 = iterative_validate_with_refinement(iter2_text, threshold=75.0)
print(f"  Score: {iter2['validation_result']['overall_compliance']:.1f}% | Passed: {iter2['validation_result']['passed_threshold']}")

# Iteration 3 (further refinement)
iter3_text = "Implement coordinated multi-protocol architecture where ESL analyzes emotional context, REP performs deductive reasoning, and results are validated deterministically against ground truth for reliable outcomes"
print(f"\nIteration 3: \"{iter3_text[:70]}...\"")
iter3 = iterative_validate_with_refinement(iter3_text, threshold=75.0)
print(f"  Score: {iter3['validation_result']['overall_compliance']:.1f}% | Passed: {iter3['validation_result']['passed_threshold']}")

print(f"\n{'='*80}")
print("Summary: Score improved from {:.1f}% -> {:.1f}% -> {:.1f}% across iterations".format(
    iter1['validation_result']['overall_compliance'],
    iter2['validation_result']['overall_compliance'],
    iter3['validation_result']['overall_compliance']
))
print("Workflow shows how AI client uses validation feedback to refine responses")
```

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

### Visualize Analogy Mapping with NetworkX and Matplotlib

Source: https://github.com/dansasser/sim-one/blob/main/tutorials/rep_reasoning_tutorial.ipynb

This code snippet visualizes analogical mappings by constructing a graph where nodes represent source and target elements of analogies. It uses NetworkX to build the graph and Matplotlib to render it, differentiating nodes by domain (source/target) and saving the output as 'analogical_mapping.png'. Dependencies include NetworkX and Matplotlib.

```python
import networkx as nx
import matplotlib.pyplot as plt

# Assuming 'result' is a dictionary containing 'analogies'
# Example structure for result:
# result = {
#     "analogies": [
#         {"source": "Heart", "target": "Pump"},
#         {"source": "Blood Vessels", "target": "Pipes"},
#         {"source": "Oxygen", "target": "Fuel"}
#     ]
# }

if result.get("analogies"):
    G = nx.Graph()

    # Add nodes for source and target
    for analogy in result["analogies"]:
        source = analogy["source"]
        target = analogy["target"]
        G.add_node(source, domain="source")
        G.add_node(target, domain="target")
        G.add_edge(source, target)

    pos = nx.spring_layout(G, k=2, iterations=50)

    plt.figure(figsize=(14, 8))

    # Draw nodes by domain
    source_nodes = [n for n, d in G.nodes(data=True) if d.get("domain") == "source"]
    target_nodes = [n for n, d in G.nodes(data=True) if d.get("domain") == "target"]

    nx.draw_networkx_nodes(G, pos, nodelist=source_nodes, node_color='lightblue',
                           node_size=3000, label='Source Domain')
    nx.draw_networkx_nodes(G, pos, nodelist=target_nodes, node_color='lightcoral',
                           node_size=3000, label='Target Domain')
    nx.draw_networkx_edges(G, pos, alpha=0.5, width=2)
    nx.draw_networkx_labels(G, pos, font_size=9, font_weight='bold')

    plt.title("Analogical Mapping: Circulatory System <-> Traffic System", fontsize=14)
    plt.legend(fontsize=11)
    plt.axis('off')
    plt.tight_layout()
    plt.savefig("analogical_mapping.png", dpi=150, bbox_inches='tight')
    plt.show()
```

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

### Run SIM-ONE mCP Server with Gunicorn

Source: https://github.com/dansasser/sim-one/blob/main/code/mcp_server/docs/DEPLOYMENT.md

Starts the SIM-ONE mCP Server using Gunicorn with Uvicorn workers. This command configures Gunicorn to use 4 worker processes, specifies the Uvicorn worker class, points to the FastAPI application instance, and binds the server to all network interfaces on port 8000.

```bash
gunicorn -w 4 -k uvicorn.workers.UvicornWorker mcp_server.main:app -b 0.0.0.0:8000
```

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

### Protocol Coordination Example (Python)

Source: https://github.com/dansasser/sim-one/blob/main/README.md

Demonstrates how multiple cognitive protocols can be loaded and coordinated using the ProtocolManager to achieve emergent intelligence, aligning with the First Law of Cognitive Governance. It shows the dynamic loading and orchestration of specialized protocols for tasks like cognitive control, readability enhancement, validation, and monitoring.

```python
from mcp_server.protocols import ProtocolManager

# Load and coordinate multiple protocols
pm = ProtocolManager()
protocols = {
    'cognitive_control': pm.get_protocol('CognitiveControlProtocol'),
    'readability': pm.get_protocol('ReadabilityEnhancementProtocol'), 
    'validation': pm.get_protocol('ValidationAndVerificationProtocol'),
    'monitoring': pm.get_protocol('RealTimeMonitoringProtocol')
}

# Intelligence emerges from coordination, not individual protocol complexity
result = protocols['cognitive_control'].coordinate(
    input_data, 
    [protocols['readability'], protocols['validation']], 
    monitoring=protocols['monitoring']
)
```

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

### Preview Production Build (Bash)

Source: https://github.com/dansasser/sim-one/blob/main/code/astro-chat-interface/README.md

Starts a local server to preview the production build of the Astro project. This helps in verifying the production output before deployment.

```bash
npm run preview
```

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

### Execute VVP Completeness Check in Python

Source: https://github.com/dansasser/sim-one/blob/main/tutorials/vvp_validation_tutorial.ipynb

Executes a completeness check using the VVP protocol with a defined set of rules and context. This example demonstrates how to identify missing cases in rule coverage and retrieve suggestions for improvement. It requires the VVP object to be initialized.

```python
# Define rule set for checking completeness
rules_with_gaps = {
    "rules": [
        [["Temperature > 0 deg C", "Pressure = 1 atm"], "Water is liquid"],
        [["Temperature > 100 deg C", "Pressure = 1 atm"], "Water is gas"],
        # Missing: What about temperature < 0 deg C? (water is solid/ice)
    ],
    "context": {
        "domain": "Water phase transitions",
        "expected_coverage": ["solid", "liquid", "gas"]
    }
}

# Validate rules
result = vvp.execute(rules_with_gaps)

print("VVP Completeness Check:")
print("=" * 80)

print(f"Status: {result.get('status', 'Unknown')}")

if result.get("completeness"):
    comp = result["completeness"]
    print(f"\nCompleteness Analysis:")
    print(f"  Coverage: {comp.get('coverage_percentage', 0):.1f}%")
    print(f"  Covered Cases: {comp.get('covered_cases', [])}")
    print(f"  Missing Cases: {comp.get('missing_cases', [])}")

if result.get("suggestions"):
    print(f"\n[TIP] Suggestions for Improvement:")
    for suggestion in result["suggestions"]:
        print(f"  - {suggestion}")

```

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

### Run SIM-ONE MCP Server and Monitoring

Source: https://github.com/dansasser/sim-one/blob/main/README.md

Commands to start the SIM-ONE MCP Server and its real-time monitoring service. These commands assume you are in the 'code' directory of the SIM-ONE project.

```bash
# Run the SIM-ONE MCP Server
python -m mcp_server.main

# Start real-time monitoring
python -m mcp_server.protocols.monitoring.real_time_monitor
```