Add MCP Server

.env.example

@@ -0,0 +1,2 @@
+UPSTASH_REDIS_REST_URL=https://your-redis-url.upstash.io
+UPSTASH_REDIS_REST_TOKEN=your-token-here

.gitignore

@@ -0,0 +1,22 @@
+# Environment
+.env
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+venv/
+ENV/
+env/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

DEPLOYMENT.md

@@ -0,0 +1,144 @@
+# Deployment Guide
+
+## Deploying to Hugging Face Spaces
+
+### Step 1: Create a New Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Choose:
+   - **SDK:** Gradio
+   - **Space name:** `ev-utility-function` (or your preferred name)
+   - **License:** Choose appropriate license
+   - **Visibility:** Public or Private
+
+### Step 2: Push Your Code
+
+Option A: Using Git
+
+```bash
+# Clone your space repository
+git clone https://huggingface.co/spaces/YOUR_USERNAME/ev-utility-function
+cd ev-utility-function
+
+# Copy all files from utility-mcp-server directory
+cp -r /path/to/utility-mcp-server/* .
+
+# Remove server.py if you only want the Gradio interface
+# (Keep it if you want to document the MCP server too)
+
+# Add and commit
+git add .
+git commit -m "Initial commit: EV Utility Function Calculator"
+git push
+```
+
+Option B: Using Hugging Face Web Interface
+
+1. Upload the following files through the web interface:
+   - `app.py`
+   - `requirements.txt`
+   - `README.md`
+   - `.gitignore`
+
+### Step 3: Configure Environment Variables
+
+1. Go to your Space settings
+2. Click on "Settings" → "Variables and secrets"
+3. Add the following secrets:
+   - `UPSTASH_REDIS_REST_URL`: Your Upstash Redis URL
+   - `UPSTASH_REDIS_REST_TOKEN`: Your Upstash Redis token
+
+### Step 4: Wait for Build
+
+Your Space will automatically build and deploy. You can monitor the build logs in the "Logs" section.
+
+## Using as an MCP Server
+
+### With Claude Desktop
+
+1. Copy `server.py` to your local machine
+2. Create a `.env` file with your Upstash credentials
+3. Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "ev-utility": {
+      "command": "python",
+      "args": ["/absolute/path/to/utility-mcp-server/server.py"],
+      "env": {
+        "UPSTASH_REDIS_REST_URL": "https://your-redis-url.upstash.io",
+        "UPSTASH_REDIS_REST_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+4. Restart Claude Desktop
+
+### With Other MCP Clients
+
+The server uses stdio for communication. Any MCP-compatible client can connect to it.
+
+## Testing Locally
+
+### Test the Gradio App
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Create .env file with your credentials
+cp .env.example .env
+# Edit .env with your actual credentials
+
+# Run the app
+python app.py
+```
+
+### Test the MCP Server
+
+```bash
+# Run the MCP server
+python server.py
+
+# The server will communicate via stdin/stdout
+# Use an MCP client to test, or integrate with Claude Desktop
+```
+
+## Troubleshooting
+
+### "No module named 'mcp'"
+
+Install the MCP package:
+```bash
+pip install mcp
+```
+
+### "Connection to Redis failed"
+
+1. Check your environment variables are set correctly
+2. Verify your Upstash Redis URL and token
+3. Ensure your IP is not blocked by Upstash
+
+### Space Build Fails
+
+1. Check the build logs in Hugging Face Spaces
+2. Ensure all dependencies are in `requirements.txt`
+3. Verify Python version compatibility (use Python 3.10+)
+
+## Updating the Space
+
+To update your deployed Space:
+
+```bash
+# Make your changes locally
+# Commit and push
+git add .
+git commit -m "Update: description of changes"
+git push
+```
+
+The Space will automatically rebuild with your changes.

README.md

@@ -11,3 +11,102 @@ license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# EV Utility Function MCP Server
+
+An MCP (Model Context Protocol) server that provides utility function calculations for electric vehicles based on user preferences.
+
+## Features
+
+This MCP server exposes two tools:
+
+### 1. `calculate_utility`
+
+Calculate the utility score for a single car based on a user's trained preferences.
+
+**Parameters:**
+
+- `user_id`: Username whose utility function to use
+- `price`: Car price in euros
+- `range`: Range in kilometers
+- `efficiency`: Efficiency in Wh/km
+- `acceleration`: 0-100km/h time in seconds
+- `fast_charge`: Fast charging power in kW
+- `seat_count`: Number of seats
+
+**Returns:** JSON with utility score and coefficients used
+
+### 2. `find_best_car`
+
+Find the best car from an array based on a user's utility function.
+
+**Parameters:**
+
+- `user_id`: Username whose utility function to use
+- `cars`: Array of car objects with the above features
+
+**Returns:** JSON with the best car and all cars ranked by utility
+
+## Setup
+
+### Local Development
+
+1. Install dependencies:
+
+```bash
+pip install -e .
+```
+
+2. Create a `.env` file with your Upstash Redis credentials:
+
+```bash
+UPSTASH_REDIS_REST_URL=https://your-redis-url.upstash.io
+UPSTASH_REDIS_REST_TOKEN=your-token-here
+```
+
+3. Run the MCP server:
+
+```bash
+python server.py
+```
+
+### Using with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "ev-utility": {
+      "command": "python",
+      "args": ["/path/to/utility-mcp-server/server.py"],
+      "env": {
+        "UPSTASH_REDIS_REST_URL": "https://your-redis-url.upstash.io",
+        "UPSTASH_REDIS_REST_TOKEN": "your-token-here"
+      }
+    }
+  }
+}
+```
+
+## Hugging Face Space
+
+This server is also available as a Hugging Face Space for easy web-based access and demonstration.
+
+## How It Works
+
+1. User preferences (coefficients) are stored in Upstash Redis with key format `params:{user_id}`
+2. The server fetches coefficients from Redis when calculating utilities
+3. Features are scaled consistently with the training data
+4. Utility is calculated as a dot product: `utility = Σ(coefficient_i × scaled_feature_i)`
+
+## Default Coefficients
+
+If a user_id is not found in Redis, default coefficients are used:
+
+- price: -0.5
+- range: 0.8
+- efficiency: -0.3
+- acceleration: -0.5
+- fast_charge: 0.6
+- seat_count: 0.4

app.py

@@ -0,0 +1,251 @@
+"""
+Gradio App for EV Utility Function Calculator
+Deployed on Hugging Face Spaces
+"""
+
+import gradio as gr
+import json
+import os
+from upstash_redis import Redis
+
+# Initialize Redis client
+redis = Redis(
+    url=os.getenv("UPSTASH_REDIS_REST_URL"),
+    token=os.getenv("UPSTASH_REDIS_REST_TOKEN")
+)
+
+# Feature keys in order
+FEATURE_KEYS = ["price", "range", "efficiency", "acceleration", "fast_charge", "seat_count"]
+
+# Default coefficients
+DEFAULT_COEFFS = {
+    "price": -0.5,
+    "range": 0.8,
+    "efficiency": -0.3,
+    "acceleration": -0.5,
+    "fast_charge": 0.6,
+    "seat_count": 0.4,
+}
+
+
+def get_user_coefficients(user_id: str) -> dict[str, float]:
+    """Fetch user coefficients from Redis."""
+    redis_key = f"params:{user_id}"
+    data_str = redis.get(redis_key)
+
+    if data_str is None:
+        return DEFAULT_COEFFS
+
+    if isinstance(data_str, bytes):
+        data_str = data_str.decode('utf-8')
+
+    data = json.loads(data_str) if isinstance(data_str, str) else data_str
+    return data.get("coeffs", DEFAULT_COEFFS)
+
+
+def scale_features(car_features: dict[str, float]) -> list[float]:
+    """Scale car features."""
+    def get_val(key: str) -> float:
+        val = car_features.get(key)
+        if val is None:
+            return 0.0
+        return float(val)
+
+    scaled = [
+        get_val("price") / 1000,
+        get_val("range") / 100,
+        get_val("efficiency") / 10,
+        get_val("acceleration"),
+        get_val("fast_charge") / 100,
+        get_val("seat_count"),
+    ]
+    return scaled
+
+
+def calculate_utility_score(car_features: dict[str, float], coeffs: dict[str, float]) -> float:
+    """Calculate utility score."""
+    scaled_features = scale_features(car_features)
+    coeff_array = [coeffs[key] for key in FEATURE_KEYS]
+    utility = sum(f * c for f, c in zip(scaled_features, coeff_array))
+    return utility
+
+
+def calculate_single_utility(user_id: str, price: float, range_km: float, efficiency: float,
+                            acceleration: float, fast_charge: float, seat_count: int) -> str:
+    """Calculate utility for a single car."""
+    try:
+        coeffs = get_user_coefficients(user_id)
+
+        car_features = {
+            "price": price,
+            "range": range_km,
+            "efficiency": efficiency,
+            "acceleration": acceleration,
+            "fast_charge": fast_charge,
+            "seat_count": seat_count
+        }
+
+        utility = calculate_utility_score(car_features, coeffs)
+
+        result = {
+            "user_id": user_id,
+            "utility_score": round(utility, 4),
+            "coefficients_used": {k: round(v, 4) for k, v in coeffs.items()},
+            "car_features": car_features,
+            "note": "Using default coefficients" if coeffs == DEFAULT_COEFFS else "Using saved user preferences"
+        }
+
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+def find_best_from_list(user_id: str, cars_json: str) -> str:
+    """Find the best car from a JSON list."""
+    try:
+        cars = json.loads(cars_json)
+        coeffs = get_user_coefficients(user_id)
+
+        best_car = None
+        best_utility = float('-inf')
+        all_results = []
+
+        for car in cars:
+            utility = calculate_utility_score(car, coeffs)
+            car_result = {**car, "utility": round(utility, 4)}
+            all_results.append(car_result)
+
+            if utility > best_utility:
+                best_utility = utility
+                best_car = car_result
+
+        # Sort by utility descending
+        all_results.sort(key=lambda x: x["utility"], reverse=True)
+
+        result = {
+            "user_id": user_id,
+            "best_car": best_car,
+            "all_cars_ranked": all_results,
+            "coefficients_used": {k: round(v, 4) for k, v in coeffs.items()},
+            "note": "Using default coefficients" if coeffs == DEFAULT_COEFFS else "Using saved user preferences"
+        }
+
+        return json.dumps(result, indent=2)
+    except json.JSONDecodeError:
+        return json.dumps({"error": "Invalid JSON format"}, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+# Example cars JSON
+example_cars = json.dumps([
+    {
+        "name": "Tesla Model 3",
+        "price": 45000,
+        "range": 500,
+        "efficiency": 150,
+        "acceleration": 6.1,
+        "fast_charge": 170,
+        "seat_count": 5
+    },
+    {
+        "name": "Volkswagen ID.4",
+        "price": 40000,
+        "range": 420,
+        "efficiency": 180,
+        "acceleration": 8.5,
+        "fast_charge": 125,
+        "seat_count": 5
+    },
+    {
+        "name": "Hyundai Ioniq 5",
+        "price": 48000,
+        "range": 480,
+        "efficiency": 165,
+        "acceleration": 7.4,
+        "fast_charge": 220,
+        "seat_count": 5
+    }
+], indent=2)
+
+
+# Create Gradio interface
+with gr.Blocks(title="EV Utility Function Calculator") as demo:
+    gr.Markdown("""
+    # 🚗 EV Utility Function Calculator
+
+    This tool calculates utility scores for electric vehicles based on user preferences.
+    User preferences are stored in Upstash Redis with their trained coefficients.
+
+    **Note:** If a user_id is not found, default coefficients will be used.
+    """)
+
+    with gr.Tab("Calculate Single Car Utility"):
+        gr.Markdown("### Calculate the utility score for a single car")
+
+        with gr.Row():
+            with gr.Column():
+                user_id_single = gr.Textbox(label="User ID", value="benjo", placeholder="Enter username")
+                price = gr.Number(label="Price (€)", value=45000)
+                range_km = gr.Number(label="Range (km)", value=500)
+                efficiency = gr.Number(label="Efficiency (Wh/km)", value=150)
+                acceleration = gr.Number(label="0-100km/h (seconds)", value=6.1)
+                fast_charge = gr.Number(label="Fast Charge (kW)", value=170)
+                seat_count = gr.Number(label="Seat Count", value=5, precision=0)
+
+            with gr.Column():
+                output_single = gr.Code(label="Result", language="json")
+
+        calc_btn = gr.Button("Calculate Utility", variant="primary")
+        calc_btn.click(
+            calculate_single_utility,
+            inputs=[user_id_single, price, range_km, efficiency, acceleration, fast_charge, seat_count],
+            outputs=output_single
+        )
+
+    with gr.Tab("Find Best Car"):
+        gr.Markdown("### Find the best car from a list based on user preferences")
+
+        with gr.Row():
+            with gr.Column():
+                user_id_best = gr.Textbox(label="User ID", value="benjo", placeholder="Enter username")
+                cars_json = gr.Code(
+                    label="Cars (JSON Array)",
+                    value=example_cars,
+                    language="json",
+                    lines=20
+                )
+
+            with gr.Column():
+                output_best = gr.Code(label="Result", language="json", lines=25)
+
+        find_btn = gr.Button("Find Best Car", variant="primary")
+        find_btn.click(
+            find_best_from_list,
+            inputs=[user_id_best, cars_json],
+            outputs=output_best
+        )
+
+    gr.Markdown("""
+    ---
+    ## About
+
+    This is the web interface for the EV Utility Function MCP Server.
+
+    ### MCP Server
+
+    This tool is also available as an MCP (Model Context Protocol) server that can be used with Claude Desktop
+    and other MCP-compatible clients.
+
+    **Repository:** [GitHub Link]
+
+    ### How it works:
+
+    1. Users train their preferences through the AutoFinder app
+    2. Preferences are saved to Upstash Redis as coefficients
+    3. This tool fetches those coefficients and calculates utility scores
+    4. Utility = Σ(coefficient × scaled_feature)
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "utility-mcp-server"
+version = "0.1.0"
+description = "MCP server for EV utility function calculations"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp>=1.0.0",
+    "upstash-redis>=1.1.1",
+    "python-dotenv>=1.0.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=5.0.0
+upstash-redis>=1.1.1
+python-dotenv>=1.0.0
+mcp>=1.0.0

server.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""
+MCP Server for EV Utility Function Calculations
+
+This server provides tools to calculate utility scores for electric vehicles
+using personalized coefficients stored in Upstash Redis.
+"""
+
+import json
+import os
+from typing import Any
+from dotenv import load_dotenv
+from upstash_redis import Redis
+
+from mcp.server.models import InitializationOptions
+from mcp.server import NotificationOptions, Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+
+# Load environment variables
+load_dotenv()
+
+# Initialize Redis client
+redis = Redis(
+    url=os.getenv("UPSTASH_REDIS_REST_URL"),
+    token=os.getenv("UPSTASH_REDIS_REST_TOKEN")
+)
+
+# Feature keys in order (must match the order in the coefficient array)
+FEATURE_KEYS = ["price", "range", "efficiency", "acceleration", "fast_charge", "seat_count"]
+
+# Default coefficients if user not found
+DEFAULT_COEFFS = {
+    "price": -0.5,
+    "range": 0.8,
+    "efficiency": -0.3,
+    "acceleration": -0.5,
+    "fast_charge": 0.6,
+    "seat_count": 0.4,
+}
+
+
+def get_user_coefficients(user_id: str) -> dict[str, float]:
+    """
+    Fetch user coefficients from Redis. Returns default if not found.
+    """
+    redis_key = f"params:{user_id}"
+    data_str = redis.get(redis_key)
+
+    if data_str is None:
+        return DEFAULT_COEFFS
+
+    # Parse the JSON data - handle both string and bytes
+    if isinstance(data_str, bytes):
+        data_str = data_str.decode('utf-8')
+
+    data = json.loads(data_str) if isinstance(data_str, str) else data_str
+    return data.get("coeffs", DEFAULT_COEFFS)
+
+
+def scale_features(car_features: dict[str, float]) -> list[float]:
+    """
+    Scale car features to match the training data scaling.
+    """
+    def get_val(key: str) -> float:
+        val = car_features.get(key)
+        if val is None:
+            return 0.0
+        return float(val)
+
+    # ORDER MATTERS: Must match FEATURE_KEYS
+    scaled = [
+        get_val("price") / 1000,
+        get_val("range") / 100,
+        get_val("efficiency") / 10,
+        get_val("acceleration"),
+        get_val("fast_charge") / 100,
+        get_val("seat_count"),
+    ]
+    return scaled
+
+
+def calculate_utility_score(car_features: dict[str, float], coeffs: dict[str, float]) -> float:
+    """
+    Calculate utility score using dot product of features and coefficients.
+    """
+    scaled_features = scale_features(car_features)
+    coeff_array = [coeffs[key] for key in FEATURE_KEYS]
+
+    # Dot product
+    utility = sum(f * c for f, c in zip(scaled_features, coeff_array))
+    return utility
+
+
+# Create the MCP server
+server = Server("utility-function")
+
+
+@server.list_tools()
+async def handle_list_tools() -> list[Tool]:
+    """
+    List available tools.
+    """
+    return [
+        Tool(
+            name="calculate_utility",
+            description="Calculate the utility score for a car based on a user's preferences",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The username/ID whose utility function to use"
+                    },
+                    "price": {
+                        "type": "number",
+                        "description": "Car price in euros"
+                    },
+                    "range": {
+                        "type": "number",
+                        "description": "Range in kilometers"
+                    },
+                    "efficiency": {
+                        "type": "number",
+                        "description": "Efficiency in Wh/km"
+                    },
+                    "acceleration": {
+                        "type": "number",
+                        "description": "0-100km/h time in seconds"
+                    },
+                    "fast_charge": {
+                        "type": "number",
+                        "description": "Fast charging power in kW"
+                    },
+                    "seat_count": {
+                        "type": "number",
+                        "description": "Number of seats"
+                    }
+                },
+                "required": ["user_id", "price", "range", "efficiency", "acceleration", "fast_charge", "seat_count"]
+            }
+        ),
+        Tool(
+            name="find_best_car",
+            description="Find the best car from an array based on a user's utility function",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The username/ID whose utility function to use"
+                    },
+                    "cars": {
+                        "type": "array",
+                        "description": "Array of car objects with features",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {"type": "string"},
+                                "price": {"type": "number"},
+                                "range": {"type": "number"},
+                                "efficiency": {"type": "number"},
+                                "acceleration": {"type": "number"},
+                                "fast_charge": {"type": "number"},
+                                "seat_count": {"type": "number"}
+                            },
+                            "required": ["price", "range", "efficiency", "acceleration", "fast_charge", "seat_count"]
+                        }
+                    }
+                },
+                "required": ["user_id", "cars"]
+            }
+        )
+    ]
+
+
+@server.call_tool()
+async def handle_call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    """
+    Handle tool execution requests.
+    """
+    if name == "calculate_utility":
+        user_id = arguments["user_id"]
+
+        # Get user coefficients
+        coeffs = get_user_coefficients(user_id)
+
+        # Extract car features
+        car_features = {
+            "price": arguments["price"],
+            "range": arguments["range"],
+            "efficiency": arguments["efficiency"],
+            "acceleration": arguments["acceleration"],
+            "fast_charge": arguments["fast_charge"],
+            "seat_count": arguments["seat_count"]
+        }
+
+        # Calculate utility
+        utility = calculate_utility_score(car_features, coeffs)
+
+        result = {
+            "user_id": user_id,
+            "utility": utility,
+            "coefficients_used": coeffs,
+            "car_features": car_features
+        }
+
+        return [TextContent(
+            type="text",
+            text=json.dumps(result, indent=2)
+        )]
+
+    elif name == "find_best_car":
+        user_id = arguments["user_id"]
+        cars = arguments["cars"]
+
+        # Get user coefficients
+        coeffs = get_user_coefficients(user_id)
+
+        # Calculate utility for each car
+        best_car = None
+        best_utility = float('-inf')
+        all_results = []
+
+        for car in cars:
+            utility = calculate_utility_score(car, coeffs)
+            car_result = {**car, "utility": utility}
+            all_results.append(car_result)
+
+            if utility > best_utility:
+                best_utility = utility
+                best_car = car_result
+
+        result = {
+            "user_id": user_id,
+            "best_car": best_car,
+            "all_cars_with_utilities": all_results,
+            "coefficients_used": coeffs
+        }
+
+        return [TextContent(
+            type="text",
+            text=json.dumps(result, indent=2)
+        )]
+
+    else:
+        raise ValueError(f"Unknown tool: {name}")
+
+
+async def main():
+    """
+    Main entry point for the MCP server.
+    """
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="utility-function",
+                server_version="0.1.0",
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                )
+            )
+        )
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

test_local.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+Simple test script to verify the utility calculation functions work correctly.
+This doesn't test the MCP protocol itself, just the core logic.
+"""
+
+import json
+from server import get_user_coefficients, calculate_utility_score
+
+def test_calculate_utility():
+    """Test basic utility calculation."""
+    print("Testing utility calculation...")
+
+    # Test with default coefficients
+    user_id = "test_user_nonexistent"
+    coeffs = get_user_coefficients(user_id)
+    print(f"\nCoefficients for {user_id}:")
+    print(json.dumps(coeffs, indent=2))
+
+    # Example car features
+    car = {
+        "price": 45000,
+        "range": 500,
+        "efficiency": 150,
+        "acceleration": 6.1,
+        "fast_charge": 170,
+        "seat_count": 5
+    }
+
+    utility = calculate_utility_score(car, coeffs)
+    print(f"\nCar features:")
+    print(json.dumps(car, indent=2))
+    print(f"\nCalculated utility: {utility:.4f}")
+
+
+def test_with_saved_user():
+    """Test with a user that has saved preferences."""
+    print("\n" + "="*60)
+    print("Testing with saved user preferences...")
+
+    user_id = "benjo"  # Should exist in Redis from the screenshot
+    coeffs = get_user_coefficients(user_id)
+    print(f"\nCoefficients for {user_id}:")
+    print(json.dumps({k: round(v, 4) for k, v in coeffs.items()}, indent=2))
+
+    # Example cars
+    cars = [
+        {
+            "name": "Tesla Model 3",
+            "price": 45000,
+            "range": 500,
+            "efficiency": 150,
+            "acceleration": 6.1,
+            "fast_charge": 170,
+            "seat_count": 5
+        },
+        {
+            "name": "Volkswagen ID.4",
+            "price": 40000,
+            "range": 420,
+            "efficiency": 180,
+            "acceleration": 8.5,
+            "fast_charge": 125,
+            "seat_count": 5
+        },
+        {
+            "name": "Hyundai Ioniq 5",
+            "price": 48000,
+            "range": 480,
+            "efficiency": 165,
+            "acceleration": 7.4,
+            "fast_charge": 220,
+            "seat_count": 5
+        }
+    ]
+
+    print(f"\nComparing {len(cars)} cars:")
+    results = []
+    for car in cars:
+        utility = calculate_utility_score(car, coeffs)
+        results.append((car["name"], utility))
+        print(f"  {car['name']}: {utility:.4f}")
+
+    # Find best
+    best_car, best_utility = max(results, key=lambda x: x[1])
+    print(f"\n🏆 Best car for {user_id}: {best_car} (utility: {best_utility:.4f})")
+
+
+if __name__ == "__main__":
+    try:
+        test_calculate_utility()
+        test_with_saved_user()
+        print("\n" + "="*60)
+        print("✅ All tests completed successfully!")
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        import traceback
+        traceback.print_exc()