> ## Documentation Index
> Fetch the complete documentation index at: https://docs.solvice.io/llms.txt
> Use this file to discover all available pages before exploring further.

# VRP API Changelog

> Track new features, improvements, and updates to the Solvice VRP API

Stay updated with the latest enhancements, features, and improvements to the Solvice Vehicle Routing Problem (VRP) API. Each release brings new capabilities to help you optimize your routing operations more effectively.

<Update label="May 2026" description="Depot management and pooled resource rules">
  ## 🏭 Depot Management Suite

  A set of new capabilities for routing problems that involve loading, unloading, and disposal sites (waste collection, distribution, returns).

  <Tabs>
    <Tab title="Unload Before End of Shift">
      Force a resource to visit a depot to unload its remaining load before finishing its shift.

      ```json theme={null}
      {
        "resources": [{
          "name": "collection-truck",
          "shifts": [{
            "from": "2026-05-01T06:00:00Z",
            "to": "2026-05-01T14:00:00Z",
            "unloadBeforeEndShift": true
          }]
        }]
      }
      ```

      The `unloadBeforeEndShift` flag only fires when the vehicle still carries non-zero load at the end of its route, and only when depots are configured. Without it, a vehicle may end its shift while still loaded.
    </Tab>

    <Tab title="Depot End Weight">
      Tune how strongly the solver favors ending routes near a depot with the new `depotEndWeight` modifier, alongside the existing `depotCostWeight`.

      ```json theme={null}
      {
        "options": {
          "weights": {
            "depotCostWeight": 1,
            "depotEndWeight": 10
          }
        }
      }
      ```
    </Tab>

    <Tab title="Smarter Depot Moves">
      The solver now places depots during construction and can swap depots mid-route, exploring depot assignments far more effectively than before.

      * Depot placement evaluated during initial construction
      * Depot-swap moves between trips
      * Trip-level depot reset move

      No configuration needed — automatically applied when depots are present.
    </Tab>
  </Tabs>

  ## 👥 Pooled Resource Period Rules

  Period rules (work time, service time, drive time, complexity, and job-type limits per period) can now be **shared across a pool of resources** using a `groupTag`.

  ```json theme={null}
  {
    "resources": [{
      "name": "tech-1",
      "rules": [{
        "period": {"from": "2026-05-01T00:00:00Z", "to": "2026-05-08T00:00:00Z"},
        "jobTypeLimitations": {"Initial Appointment": 10},
        "groupTag": "contractor-install-pool"
      }]
    }, {
      "name": "tech-2",
      "rules": [{
        "period": {"from": "2026-05-01T00:00:00Z", "to": "2026-05-08T00:00:00Z"},
        "jobTypeLimitations": {"Initial Appointment": 10},
        "groupTag": "contractor-install-pool"
      }]
    }]
  }
  ```

  When a `groupTag` is set, the limit becomes a single shared bound across every resource that declares an identical rule (same period and fields) with that tag — instead of applying per resource.

  **Use Cases:**

  * Cap how many of a job type a team collectively handles per week
  * Share a contractor budget across multiple vehicles
  * Pool drive-time or complexity limits across a crew
</Update>

<Update label="April 2026" description="Duty breaks, partial sequencing, and per-suggestion explanations">
  ## ☕ Duty Breaks

  A new `DUTY` break type triggers a mandatory break after a cumulative amount of work time (drive + service), complementing the existing `DRIVE` break (which counts driving time only).

  ```json theme={null}
  {
    "resources": [{
      "name": "driver-1",
      "shifts": [{
        "from": "2026-04-01T08:00:00Z",
        "to": "2026-04-01T18:00:00Z",
        "breaks": [{
          "type": "DUTY",
          "workTime": 21600,
          "duration": 1800
        }]
      }]
    }]
  }
  ```

  **Result:** After 6 hours (21600s) of combined driving and service, the driver must take a 30-minute break.

  ## 🔗 True Partial Planning for SEQUENCE

  `SEQUENCE` relations now support genuine partial planning — when some jobs in a sequence can't be assigned, the solver still optimizes the order of the jobs that can be, instead of penalizing the whole relation.

  ## 🔍 Explanations Per Suggestion

  The suggest endpoint can now return a full explanation for each individual suggestion, so you can see exactly why a proposed change scores the way it does — not just the final recommendation.

  ## 🏷️ Request Metadata

  Attach arbitrary `metadata` to any request and have it echoed back on the response — handy for correlating jobs with your own systems.

  ```json theme={null}
  {
    "metadata": {
      "orderId": "ORD-2026-0412",
      "tenant": "acme-logistics"
    }
  }
  ```
</Update>

<Update label="March 2026" description="Curbside-aware routing">
  ## 🛻 Curbside Routing

  Enable curbside-aware routing so vehicles approach each location from the correct side of the road.

  ```json theme={null}
  {
    "options": {
      "curbside": true
    }
  }
  ```

  **Use Cases:**

  * Waste collection on residential streets
  * Right-hand/left-hand-side pickups and drop-offs
  * Any operation where the approach side matters for safety or access
</Update>

<Update label="February 2026" description="Cost-based optimization">
  ## 💶 Cost-Based Optimization

  Optimize routes directly in monetary terms instead of tuning abstract weights. Provide a `costs` configuration and the solver derives its internal weights from your real business costs in EUR/USD.

  <CodeGroup>
    ```json Cost Configuration theme={null}
    {
      "costs": {
        "drivingCostPerHour": 25.0,
        "waitingCostPerHour": 15.0,
        "overtimeCostPerHour": 50.0,
        "distanceCostPerKm": 0.35,
        "timeWindowViolationCostPerHour": 20.0,
        "resourceActivationCost": 100.0
      }
    }
    ```
  </CodeGroup>

  **Key Points:**

  * Costs are more intuitive than manual weight tuning — they map to real business expenses
  * Covers driving, waiting, overtime, distance, time-window violations, preferred-resource and skill/ranking violations, workload imbalance, region adherence, and resource activation
  * If both `costs` and `weights` are provided, `costs` take precedence

  **Use Cases:**

  * Report optimization results in real currency
  * Align routing trade-offs with actual P\&L
  * Compare scenarios by total operating cost
</Update>

<Update label="January 2026" description="AI-assisted routing with MCP integration">
  ## 🤖 MCP Server Integration (AI-Assisted Routing)

  Connect AI assistants directly to the VRP solver through the Model Context Protocol (MCP).

  <Tabs>
    <Tab title="Overview">
      The MCP server exposes 8 action tools that AI assistants can use to solve routing problems:

      * `vrp-solve` / `vrp-solve-sync` - Full route optimization
      * `vrp-evaluate` / `vrp-evaluate-sync` - Score existing solutions
      * `vrp-suggest` / `vrp-suggest-sync` - Get improvement suggestions
      * `vrp-change` / `vrp-change-sync` - Apply incremental changes

      **Key Benefits:**

      * Natural language problem description
      * Real-time streaming via SSE transport
      * AI understands constraints and trade-offs
      * Interactive route refinement
    </Tab>

    <Tab title="Use Cases">
      * **Conversational Planning**: "Schedule these 50 deliveries for tomorrow with 3 drivers"
      * **What-If Analysis**: "What happens if driver-2 calls in sick?"
      * **Constraint Explanation**: "Why wasn't job-15 assigned?"
      * **Iterative Refinement**: "Move the afternoon deliveries to driver-1"
    </Tab>
  </Tabs>
</Update>

<Update label="December 2025" description="Skill-based duration adjustments">
  ## ⚡ Proficiency-Based Duration Modifier

  Adjust job durations based on resource skill levels.

  <Tabs>
    <Tab title="Concept">
      Different resources complete the same job at different speeds. A senior technician might finish an installation in 30 minutes while a junior takes 45 minutes.

      Proficiency modifies the base job duration without changing the job definition.
    </Tab>

    <Tab title="Configuration">
      ```json theme={null}
      {
        "jobs": [{
          "name": "complex-installation",
          "duration": 3600,
          "proficiency": [
            {"resource": "senior-tech", "durationModifier": 0.8},
            {"resource": "junior-tech", "durationModifier": 1.3}
          ]
        }]
      }
      ```

      **Result:**

      * Senior tech: 3600 × 0.8 = 2880s (48 min)
      * Junior tech: 3600 × 1.3 = 4680s (78 min)
    </Tab>
  </Tabs>
</Update>

<Update label="November 2025" description="Return-to-depot optimization">
  ## 🏁 Last Location Drive Time Optimization

  Improved constraint ordering for efficient return-to-depot routing.

  The solver now better considers travel time from the last job back to the resource's end location when ordering constraints, ensuring routes don't end far from the depot.

  **How it works:**

  * Automatically factors in return travel when comparing route options
  * Penalizes routes that end geographically far from the depot
  * Works with existing `driveTimeWeight` for consistent optimization

  **Benefits:**

  * Prevents routes ending far from depot
  * Reduces dead-heading at end of day
  * Better overall route efficiency
  * No configuration needed - automatically applied
</Update>

<Update label="October 2025" description="Clustering, distance limits, and debugging tools">
  ## 📍 Geographic Clustering & Job Proximity

  Improve route compactness with intelligent job proximity scoring.

  <CodeGroup>
    ```json Enable Job Proximity theme={null}
    {
      "options": {
        "weights": {
          "jobProximityWeight": 25
        }
      }
    }
    ```
  </CodeGroup>

  **Benefits:**

  * Reduces backtracking between distant jobs
  * Creates more geographically compact routes
  * Configurable weight to balance with other objectives
  * Better cluster assignment for multi-vehicle problems

  ## 🔷 H3 Grid System for Geographic Clustering

  Leverage Uber's H3 hexagonal grid system for precise geographic clustering via the clustering endpoint.

  <CodeGroup>
    ```json POST /v2/clust/solve theme={null}
    {
      "locations": [
        {"latitude": 50.8503, "longitude": 4.3517, "name": "Brussels"},
        {"latitude": 51.0543, "longitude": 3.7174, "name": "Ghent"},
        {"latitude": 51.2213, "longitude": 4.4051, "name": "Antwerp"}
      ],
      "options": {
        "clusterSize": 10,
        "maxClusters": 5,
        "h3Resolution": 7
      }
    }
    ```
  </CodeGroup>

  **H3 Resolution Guide:**

  | Resolution | Hex Size    | Use Case                 |
  | ---------- | ----------- | ------------------------ |
  | 5          | \~250 km²   | Regional planning        |
  | 7          | \~5 km²     | Urban delivery           |
  | 9          | \~174m edge | Default, fine clustering |

  ## 📏 Maximum Drive Distance

  Limit total kilometers per resource shift.

  ```json theme={null}
  {
    "resources": [{
      "name": "driver-1",
      "maxDriveDistance": 200000,  // 200 km max
      "shift": {
        "from": "2025-01-01T08:00:00Z",
        "to": "2025-01-01T18:00:00Z"
      }
    }]
  }
  ```

  **Use Cases:**

  * Vehicle range limitations (EVs)
  * Company policy compliance
  * Lease mileage restrictions
  * Driver safety regulations

  ## 🐛 Debug Endpoint

  New `/debug` endpoint for troubleshooting solver behavior.

  ```bash theme={null}
  GET /v2/vrp/debug/{jobId}
  ```

  **Returns:**

  * Internal solver state
  * Constraint violation details
  * Score breakdown
  * Shadow variable values
  * Diagnostic information for support tickets
</Update>

<Update label="September 2025" description="Relation weight customization">
  ## ⚖️ Custom Relation Weights

  Fine-tune the importance of individual relations with custom weight modifiers.

  ```json theme={null}
  {
    "relations": [{
      "type": "SAME_RESOURCE",
      "jobs": ["pickup", "delivery"],
      "weight": 50
    }, {
      "type": "SEQUENCE",
      "jobs": ["prep", "install"],
      "weight": 100
    }]
  }
  ```

  **Use Cases:**

  * Prioritize certain relations over others
  * Make critical sequences non-negotiable (high weight)
  * Allow flexibility on less important pairings (low weight)
  * Balance relation penalties with other optimization objectives
</Update>

<Update label="August 2025" description="Custom maps and relation constraints">
  ## 🗺️ External Distance Matrices

  Use pre-computed distance matrices from external services with time-of-day traffic patterns.

  External distance matrices allow you to provide custom travel time and distance data instead of relying on built-in routing engines. This is perfect for:

  * **Faster Processing**: Skip real-time distance calculations using pre-computed matrices
  * **Custom Traffic**: Use your own traffic data or specialized routing services
  * **Time-Based Routing**: Different matrices for morning rush, midday, evening periods
  * **Vehicle-Specific**: Separate matrices for cars, trucks, bikes with their unique constraints
  * **Enterprise Integration**: Seamlessly integrate with existing routing infrastructure

  Upload your distance matrices to [routing.solvice.io/table/upload](https://routing.solvice.io/table/upload) and reference them by ID.

  <CodeGroup>
    ```json External Distance Matrix Example theme={null}
    {
      "jobs": [
        {"name": "delivery-1", "location": {"latitude": 51.1279, "longitude": 17.0485}},
        {"name": "delivery-2", "location": {"latitude": 51.1350, "longitude": 17.0600}}
      ],
      "resources": [{
        "name": "driver-1",
        "category": "CUSTOM_VEHICLE",
        "shift": {
          "from": "2025-01-01T08:00:00Z",
          "to": "2025-01-01T18:00:00Z"
        }
      }],
      "customDistanceMatrices": {
        "profileMatrices": {
          "CAR": {
            "8": "matrix-car-morning-rush",    // 8 AM matrix ID
            "12": "matrix-car-midday",        // 12 PM matrix ID
            "16": "matrix-car-evening-rush"   // 4 PM matrix ID
          },
          "TRUCK": {
            "6": "matrix-truck-early",
            "12": "matrix-truck-midday"
          }
        }
      }
    }
    ```
  </CodeGroup>

  ## ⚖️ Hard Minimum Wait for Job Relations

  Fine-tune constraint strength for job relations with the `hardMinWait` flag.

  ```json theme={null}
  {
    "relations": [{
      "type": "SEQUENCE",
      "jobs": ["job-a", "job-b"],
      "minTimeInterval": 3600,
      "hardMinWait": true
    }]
  }
  ```

  When `hardMinWait: true` (default), the minimum time interval becomes a hard constraint that cannot be violated. Set to `false` to make it a soft preference that can be traded off against other objectives.

  **Use Cases:**

  * Mandatory cooling/drying periods between services
  * Required waiting time for concrete curing, paint drying
  * Compliance with safety regulations
</Update>

<Update label="Q2 2025" description="Enhanced preference systems and intelligent job handling">
  ## 🎯 Resource Ranking System

  Express nuanced preferences for resource-job assignments with our new flexible ranking system.

  <Tabs>
    <Tab title="Overview">
      The ranking system allows you to specify preferred resources for each job on a 1-100 scale, where lower values indicate stronger preference.

      **Key Benefits:**

      * Implement customer preferences without hard constraints
      * Balance skill levels across assignments
      * Optimize for service quality alongside efficiency
      * Maintain flexibility in resource allocation
    </Tab>

    <Tab title="Implementation">
      ```json theme={null}
      {
        "jobs": [{
          "name": "Premium-Service",
          "rankings": [
            {"name": "Senior-Tech-1", "ranking": 10},  // Strongly preferred
            {"name": "Junior-Tech-1", "ranking": 70}   // Acceptable if needed
          ]
        }],
        "weights": {
          "rankingWeight": 10
        }
      }
      ```
    </Tab>

    <Tab title="Use Cases">
      * **Customer Preferences**: Honor requests for specific technicians
      * **Skill Matching**: Assign complex jobs to experienced resources
      * **Team Continuity**: Keep the same resource for repeat visits
      * **Training**: Gradually introduce junior staff to certain customers
    </Tab>
  </Tabs>

  <Note>
    Rankings work alongside existing constraints like tags and regions. They provide soft preferences that the optimizer considers when making assignments.
  </Note>

  ## 📍 Location Inheritance

  Simplify multi-stop scenarios where jobs share locations through automatic location inheritance.

  <CodeGroup>
    ```json Before - Redundant Locations theme={null}
    {
      "jobs": [
        {
          "name": "pickup",
          "location": {"latitude": 51.1279, "longitude": 17.0485}
        },
        {
          "name": "delivery",
          "location": {"latitude": 51.1279, "longitude": 17.0485}  // Duplicate
        }
      ]
    }
    ```

    ```json After - Inherited Location theme={null}
    {
      "jobs": [
        {
          "name": "pickup",
          "location": {"latitude": 51.1279, "longitude": 17.0485}
        },
        {
          "name": "delivery"
          // Location inherited from related job
        }
      ],
      "relations": [{
        "type": "SAME_RESOURCE",
        "jobs": ["pickup", "delivery"]
      }]
    }
    ```
  </CodeGroup>

  **Perfect for:**

  * Pickup and delivery pairs
  * Multi-service appointments at same address
  * Loading/unloading operations
  * Any co-located job sequences

  ## 🔍 Enhanced Unassigned Job Explanations

  Get detailed, actionable insights when jobs cannot be assigned to understand exactly why and how to resolve issues.

  **Common Unassignment Reasons:**

  * `DATE_TIME_WINDOW_CONFLICT` - No overlap between job window and shifts
  * `CAPACITY_EXCEEDED` - Vehicle capacity insufficient
  * `SKILL_MISMATCH` - Required tags not available
  * `DISTANCE_CONSTRAINT` - Location outside service area
  * `BREAK_CONFLICT` - Mandatory breaks prevent service

  ## ⚖️ Job Complexity & Fair Distribution

  Define job difficulty independent of duration to ensure fair workload distribution across your team.

  <Tabs>
    <Tab title="Concept">
      Job complexity represents the mental, physical, or technical difficulty of a task, separate from how long it takes.

      **Examples:**

      * Simple delivery: Duration 30min, Complexity 20
      * Complex installation: Duration 30min, Complexity 80
      * Heavy lifting: Duration 15min, Complexity 70
    </Tab>

    <Tab title="Configuration">
      ```json theme={null}
      {
        "jobs": [{
          "name": "Technical-Installation",
          "duration": 3600,
          "complexity": 80  // High complexity
        }, {
          "name": "Standard-Delivery",
          "duration": 3600,
          "complexity": 20  // Low complexity
        }],
        "options": {
          "fairness": {
            "complexityFairness": true,
            "targetComplexityPerResource": 200
          },
          "weights": {"complexityWeight": 15}
        }
      }
      ```
    </Tab>

    <Tab title="Benefits">
      * **Prevent Burnout**: Distribute challenging tasks evenly
      * **Skill Development**: Gradually increase complexity for training
      * **Fair Compensation**: Track difficulty for performance metrics
      * **Better Planning**: Account for mental/physical load
    </Tab>
  </Tabs>

  ## 🚦 Full TomTom Traffic Integration

  Enhanced real-time and predictive traffic routing with complete TomTom API integration.

  ```json theme={null}
  {
    "options": {
      "routingEngine": "TOMTOM",
      "traffic": 1.2  // Traffic modifier for TOMTOM routing
    }
  }
  ```

  **Key Enhancements:**

  * **Live Traffic**: Real-time congestion avoidance
  * **Predictive Routing**: Historical patterns for future planning
  * **Departure Optimization**: Find best start times to avoid traffic
  * **Vehicle-Specific Routes**: Truck restrictions and clearances
  * **15% Average Time Savings**: Compared to static routing

  ## 💰 Resource Hourly Wage Optimization

  Optimize routes considering different hourly rates to balance service quality with labor costs.

  <CodeGroup>
    ```json Simple Hourly Rates theme={null}
    {
      "resources": [{
        "name": "Senior-Tech",
        "hourlyCost": 75
      }, {
        "name": "Junior-Tech", 
        "hourlyCost": 45
      }]
    }
    ```

    ```json Advanced Cost Model theme={null}
    {
      "resources": [{
        "name": "Contractor",
        "hourlyCost": 95
      }],
      "weights": {
        "minimizeResourcesWeight": 150  // Activation cost equivalent
      }
    }
    ```
  </CodeGroup>

  **Optimization Strategies:**

  * Assign simple tasks to lower-cost resources
  * Use senior staff for complex/critical jobs
  * Minimize overtime by balancing workloads
  * Consider total cost including travel time

  ## 🚫 Unavailability Breaks

  Model realistic schedules with unavailability periods for meetings, training, or personal time.

  ```json theme={null}
  {
    "resources": [{
      "name": "Tech-1",
      "shifts": [{
        "from": "2025-01-01T08:00:00Z",
        "to": "2025-01-01T17:00:00Z",
        "breaks": [{
          "type": "UNAVAILABILITY",
          "from": "2025-01-01T10:00:00Z",
          "to": "2025-01-01T11:30:00Z",
          "location": {"latitude": 51.1079, "longitude": 17.0385}
        }, {
          "type": "WINDOWED",
          "from": "2025-01-01T12:00:00Z",
          "to": "2025-01-01T13:00:00Z", 
          "duration": 3600
        }]
      }]
    }]
  }
  ```

  **Supported Break Types:**

  * `UNAVAILABILITY` - Cannot be scheduled during this period
  * `WINDOWED` - Flexible timing within window
  * `DRIVE` - Mandatory after specified driving time
</Update>

<Update label="Q1 2025" description="New relation types and large-scale optimizations">
  ## 🥇 First Job Relation

  Force specific jobs to be scheduled first in a resource's route with the new `FIRST_JOB` relation type.

  <CodeGroup>
    ```json Single First Job theme={null}
    {
      "jobs": [{
        "name": "warehouse-pickup"
      }],
      "relations": [{
        "type": "SEQUENCE",
        "jobs": ["warehouse-pickup"]
      }]
    }
    ```

    ```json Alternative Approach theme={null}
    {
      "jobs": [{
        "name": "morning-task",
        "windows": [{
          "from": "2025-01-01T08:00:00Z",
          "to": "2025-01-01T08:30:00Z"  // Tight early window
        }],
        "priority": 100
      }]
    }
    ```
  </CodeGroup>

  **Common Use Cases:**

  * Warehouse pickups before deliveries
  * Equipment collection at start of day
  * Mandatory briefings or check-ins
  * Load vehicles before service rounds

  ## 🔤 Group Sequence Relations

  Define execution order between groups of jobs using tags with the `GROUP_SEQUENCE` relation.

  ```json theme={null}
  {
    "jobs": [
      {"name": "urgent-1", "tags": [{"name": "priority-high"}]},
      {"name": "urgent-2", "tags": [{"name": "priority-high"}]},
      {"name": "normal-1", "tags": [{"name": "priority-normal"}]},
      {"name": "low-1", "tags": [{"name": "priority-low"}]}
    ],
    "relations": [{
      "type": "GROUP_SEQUENCE",
      "tags": ["priority-high", "priority-normal", "priority-low"]
    }]
  }
  ```

  **Benefits:**

  * Implement service level agreements
  * Handle emergency vs routine work
  * Manage phased operations
  * Prioritize revenue-generating activities

  ## 🚀 Large-Scale TSP Optimizations

  Significant performance improvements for Traveling Salesman Problem instances with 100+ stops.

  <Tabs>
    <Tab title="Improvements">
      **Algorithm Enhancements:**

      * Advanced nearest neighbor initialization
      * Parallel 2-opt and 3-opt local search
      * Adaptive neighborhood sizing
      * Memory-efficient distance matrix handling

      **Performance Gains:**

      * 65% faster for 500+ job instances
      * 40% memory reduction
      * Better solution quality (+8% average)
      * Stable performance up to 10,000 jobs
    </Tab>

    <Tab title="Configuration">
      ```json theme={null}
      {
        "options": {
          "partialPlanning": true,
          "minimizeResources": true
        }
      }
      ```
    </Tab>

    <Tab title="Best Practices">
      * Use location IDs for repeated coordinates
      * Provide distance matrices when available
      * Set appropriate time limits for size
      * Consider chunking very large problems
      * Enable progress callbacks for monitoring
    </Tab>
  </Tabs>
</Update>

<Update label="Q4 2024" description="10,000+ job support and dynamic traffic routing">
  ## 📈 Enterprise-Scale Problem Handling

  Revolutionary improvements for handling massive routing problems with 10,000+ jobs.

  <Steps>
    <Step title="Intelligent Chunking">
      Dynamic partitioning based on geographic clusters and time windows for optimal sub-problem creation.
    </Step>

    <Step title="Parallel Processing">
      Multi-threaded execution with smart work distribution across CPU cores.
    </Step>

    <Step title="Adaptive Algorithms">
      Automatic algorithm selection based on problem characteristics and size.
    </Step>

    <Step title="Memory Optimization">
      Streaming distance calculations and compressed data structures reduce memory by 60%.
    </Step>
  </Steps>

  **Real-World Results:**

  * **Before**: 5,000 job limit, 45-minute processing
  * **After**: 50,000 jobs supported, 15-minute average
  * **Quality**: Maintained 98%+ optimality
  * **Stability**: 99.9% completion rate

  ## 🗺️ TomTom Traffic Integration

  Time-dependent routing with real-world traffic conditions for accurate ETAs and optimal departure times.

  <Accordion title="How It Works">
    The solver now uses a three-dimensional distance cube (origin × destination × time) instead of a static two-dimensional matrix:

    1. **Morning Rush (6-9 AM)**: Increased travel times on highways
    2. **Midday (9 AM-4 PM)**: Normal traffic conditions
    3. **Evening Rush (4-7 PM)**: City center congestion
    4. **Night (7 PM-6 AM)**: Reduced traffic, faster routes

    The optimizer automatically:

    * Adjusts departure times to avoid traffic
    * Reroutes around predicted congestion
    * Updates ETAs based on time of day
    * Balances traffic avoidance with service windows
  </Accordion>

  **Configuration Example:**

  ```json theme={null}
  {
    "options": {
      "routingEngine": "TOMTOM",
      "traffic": 1.1  // Traffic multiplier
    }
  }
  ```
</Update>

<Update label="Q3 2024" description="Extended planning horizons and synchronous processing">
  ## 📅 Multi-Day Job Support

  Execute long-duration jobs across multiple shifts and days with intelligent work continuation.

  <CodeGroup>
    ```json Multi-Day Installation theme={null}
    {
      "jobs": [{
        "name": "major-project",
        "duration": 72000,  // 20 hours total
        "resumable": true,
        "windows": [
          {"from": "2024-07-01T08:00:00Z", "to": "2024-07-01T17:00:00Z"},
          {"from": "2024-07-02T08:00:00Z", "to": "2024-07-02T17:00:00Z"},
          {"from": "2024-07-03T08:00:00Z", "to": "2024-07-03T17:00:00Z"}
        ]
      }],
      "resources": [{
        "name": "tech-1",
        "shifts": [
          {"from": "2024-07-01T08:00:00Z", "to": "2024-07-01T17:00:00Z"},
          {"from": "2024-07-02T08:00:00Z", "to": "2024-07-02T17:00:00Z"},
          {"from": "2024-07-03T08:00:00Z", "to": "2024-07-03T17:00:00Z"}
        ]
      }]
    }
    ```

    ```json Expected Result theme={null}
    {
      "schedule": [
        {"date": "2024-07-01", "work": "08:00-17:00 (8h)"},
        {"date": "2024-07-02", "work": "08:00-17:00 (8h)"},
        {"date": "2024-07-03", "work": "08:00-12:00 (4h)"}
      ],
      "totalDuration": 72000,
      "completionTime": "2024-07-03T12:00"
    }
    ```
  </CodeGroup>

  ## ⚡ Synchronous API Endpoints

  New `/sync/*` endpoints for immediate responses perfect for interactive applications.

  <Tabs>
    <Tab title="Overview">
      **Available Endpoints:**

      * `/sync/solve` - Instant route optimization
      * `/sync/evaluate` - Real-time solution scoring
      * `/sync/suggest` - Live optimization hints

      **Key Features:**

      * Sub-2 second response times
      * No webhook configuration
      * Automatic timeout handling
      * Perfect for UI integration
    </Tab>

    <Tab title="When to Use">
      **Synchronous** (\< 50 jobs):

      * Interactive route builders
      * Real-time modifications
      * What-if scenarios
      * Live dashboards

      **Asynchronous** (50+ jobs):

      * Batch processing
      * Overnight optimization
      * Large-scale problems
      * Background jobs
    </Tab>

    <Tab title="Example">
      ```javascript theme={null}
      // Synchronous call for immediate response
      const response = await fetch('/v2/vrp/sync/solve', {
        method: 'POST',
        body: JSON.stringify({
          jobs: [...],  // Limited to 50 jobs
          resources: [...],
          options: { timeout: 2000 }
        })
      });

      const solution = await response.json();
      // Solution returned directly, no polling needed
      ```
    </Tab>
  </Tabs>

  <Warning>
    Synchronous endpoints have strict limits:

    * Maximum 50 jobs per request
    * 2-second timeout (configurable up to 5s)
    * Automatic fallback to async for larger problems
  </Warning>
</Update>

<Update label="Q1 2023" description="Complete architectural overhaul">
  ## 🎉 VRP API v2 Release

  After 2 years of development, v2 brings a complete architectural redesign focused on scalability, reliability, and performance.

  ### Architecture Evolution

  <Tabs>
    <Tab title="Infrastructure">
      **From Kubernetes to Serverless:**

      * Google Cloud Run for auto-scaling
      * Cloud Pub/Sub for async processing
      * Cloud Storage for results
      * 90% reduction in operational overhead
      * 99.99% uptime SLA
    </Tab>

    <Tab title="Performance">
      **Optimization Improvements:**

      * 3x faster constraint checking
      * Handles 10x more time windows per job
      * 50% reduction in memory usage
      * Smart caching for repeat requests
      * Parallel route evaluation
    </Tab>

    <Tab title="API Enhancements">
      **Developer Experience:**

      * Comprehensive validation with clear errors
      * Granular rate limiting per operation
      * Detailed solution statistics
      * Extended configuration options
      * Backward compatibility mode
    </Tab>
  </Tabs>

  ### Migration Guide

  <Steps>
    <Step title="Update Base URL">
      Change from `api.solvice.io/v1` to `api.solvice.io/v2`
    </Step>

    <Step title="Review Breaking Changes">
      * `vehicle` renamed to `resource`
      * `timeWindow` now supports arrays
      * New required fields in response
    </Step>

    <Step title="Test Thoroughly">
      Use our migration validator endpoint to check your requests
    </Step>

    <Step title="Gradual Rollout">
      Run v1 and v2 in parallel during transition
    </Step>
  </Steps>

  <Check>
    **Success Story**: Major logistics provider migrated 50,000 daily optimizations to v2 with zero downtime and 35% cost reduction.
  </Check>
</Update>

## Stay Updated

<CardGroup cols={2}>
  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Detailed documentation for all endpoints
  </Card>

  <Card title="Migration Guide" icon="arrow-right" href="/guides/vrp/quickstart">
    Step-by-step v1 to v2 migration
  </Card>

  <Card title="Feature Guides" icon="book" href="/guides/vrp/features">
    In-depth guides for each feature
  </Card>

  <Card title="Release Notes" icon="newspaper" href="https://github.com/solvice/releases">
    Detailed technical release notes
  </Card>
</CardGroup>

<Note>
  Subscribe to our RSS feed or follow [@solvice\_io](https://twitter.com/solvice_io) for real-time updates about new features and improvements.
</Note>