# Routific MCP for AI Agents AI Agent Connect

> Routific MCP connects your AI assistant to Routific to solve complex vehicle routing problems, dispatch drivers, and manage global delivery timelines. It allows your agent to build multi-stop routes, manage outstanding jobs, and push dispatch tasks directly to drivers' mobile apps. Use it to automate your fleet operations and move from manual data entry to conversational logistics.

## Overview
- **Category:** productivity
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_8iCA9lUJ5A922UmQpuJnnULTrZGCsvWghbWOMcS8/ai-agent-connect
- **Tags:** route-optimization, last-mile-delivery, fleet-dispatch, logistics-management, delivery-tracking, api-integration

## Description

This Connector connects your AI assistant to Routific to solve complex vehicle routing problems, dispatch drivers, and manage global delivery timelines natively through chat. It turns your agent into a high-speed dispatcher that handles the heavy lifting of logistics. You can build multi-stop route solutions securely, manage outstanding delivery jobs, and push dispatch tasks directly to drivers' mobile apps in one window. Instead of clicking through a dozen dashboard tabs, you can just tell your agent what needs to happen. This integration lets you audit orders, create new jobs with specific constraints, and push finalized routes to the field. By adding this to your Vinkius catalog, you're giving your agent the ability to act as a logistics command center. It's a way to keep your fleet moving while you stay focused on the bigger picture. You can handle massive batch routing tasks or handle live chaos with simple conversational overrides. You get the ability to manage a complex logistics fleet using plain text commands, moving from manual data entry to a conversational workflow.

## Tools

### update_saas_job
Modifies an existing delivery job in your platform. Use this to change order details on the fly.

### cancel_saas_job
Permanently deletes a delivery job from your platform. Use this to clear out completed or cancelled orders.

### create_platform_route
Builds a new route plan within the Routific system. This helps you organize your fleet's daily journey.

### create_saas_job
Adds a new delivery job to the platform using specific order details. It handles your incoming orders automatically.

### get_route_timeline
Fetches the stop-by-stop ETA for a specific route. This is perfect for providing customers with precise updates.

### list_platform_jobs
Shows every delivery job currently in your Routific platform. Use this to get a bird's eye view of your workload.

### poll_async_solution
Checks the status of a large, background routing calculation. Use this for massive batch jobs that take time to solve.

### solve_standalone_vrp
Calculates a single route for a specific set of visits and vehicles. Use this for quick, one-off route planning.

### publish_route_to_driver
Sends the finished route to the driver's mobile app. This ensures your drivers see the latest plan instantly.

### solve_async_vrp_long
Submits a massive routing problem to be solved in the background. This is for complex, high-volume logistics.

## Prompt Examples

**Prompt:** 
```
List all my current delivery jobs.
```

**Response:** 
```
I've pulled your current active jobs from the platform. Here is what's pending:

| Job ID | Customer | Status | Priority |
| :--- | :--- | :--- | :--- |
| #4402 | Jane Doe | Pending | High |
| #4405 | Acme Corp | Pending | Medium |
| #4409 | John Smith | In Progress | Low |

Would you like me to update any of these or start building a route for the pending ones?
```

**Prompt:** 
```
Generate a route for 3 stops in downtown and send it to the driver.
```

**Response:** 
```
I've calculated the optimal route for your 3 downtown stops. 

**Route Summary:**
* **Total Distance:** 8.4 miles
* **Estimated Time:** 22 minutes
* **Stops:** 3

I'm now pushing this to the driver's mobile app. They'll receive a notification with the new manifest shortly!
```

**Prompt:** 
```
Check the ETA for the next stop on my main route.
```

**Response:** 
```
Checking the timeline for your primary route now...

**Next Stop:** 123 Maple St.
**Estimated Arrival:** 2:45 PM
**Status:** On Schedule

Would you like me to notify the customer of this ETA?
```

## Capabilities

### Solve complex vehicle routing problems
Your agent calculates the most efficient paths for multiple stops and vehicles based on your specific constraints.

### Create and update delivery jobs
Inject new orders into your platform or modify existing ones with specific priority and constraint data.

### Push routes to drivers
Send finalized routes directly to your drivers' mobile apps with a single command.

### Retrieve stop-by-stop ETAs
Get precise arrival times for every stop in a route to keep your customers informed.

### Audit outstanding orders
List and manage every pending delivery job in your platform from one central chat interface.

## Use Cases

### Handling a sudden order spike
A dispatcher gets 20 new orders in 10 minutes. They tell the agent to create jobs and solve the route using `create_saas_job` and `solve_standalone_vrp`.

### Correcting a driver's route
A driver calls saying they can't make a stop. The dispatcher asks the agent to update the job and recalculate the path using `update_saas_job`.

### Preparing the daily manifest
An ops manager wants to see tomorrow's plan. They ask for a list of all jobs and the ETAs using `list_platform_jobs` and `get_route_timeline`.

### Processing massive batch routes
An engineer needs to route 500 stops across 10 depots. They use `solve_async_vrp_long` and `poll_async_solution` to handle the scale.

## Benefits

- Stop manual data entry by using `create_saas_job` to inject new orders into your system via simple text prompts.
- Get instant visibility into your fleet's schedule by using `list_platform_jobs` to see every pending delivery at once.
- Eliminate route planning headaches with `solve_standalone_vrp` to calculate the best paths for any group of stops.
- Keep drivers informed in real time by using `publish_route_to_driver` to push updates directly to their phones.
- Handle massive logistics batches without lag by using `solve_async_vrp_long` for complex, multi-depot routing problems.
- Provide customers with accurate info by using `get_route_timeline` to pull specific stop-by-stop ETAs.

## How It Works

The bottom line is you get to manage a complex logistics fleet using plain text commands.

1. Install the Routific MCP into your active AI client.
2. Generate a unique API Token from your Routific backend settings under the developer section.
3. Paste your token into the secure component form to start issuing chat commands for your fleet.

## Frequently Asked Questions

**Can the Routific MCP handle multi-stop routes?**
Yes, it's built specifically for that. It can calculate the most efficient path for multiple stops across your entire fleet.

**How does the Routific MCP send info to drivers?**
The Connector pushes the finalized route directly to the driver's mobile app, so they get instant updates on their manifests.

**Can I use the Routific MCP to update existing orders?**
Absolutely. You can tell your agent to update specific job details, like priorities or order constraints, in real time.

**Is the Routific MCP good for large-scale logistics?**
Yes, it handles massive batch routing problems in the background, making it ideal for high-volume delivery operations.

**Does the Routific MCP provide real-time ETAs?**
Yes, it can pull stop-by-stop ETAs from the system so you can keep your customers informed on their delivery status.

**How do I get my orders into the Routific MCP?**
You can simply describe the orders to your agent or provide a list of details, and it will create the jobs in the platform for you.

**Can the AI push routes dynamically to drivers' smartphones automatically?**
Yes! Activating the `publish_route_to_driver` function dynamically interacts with the saas infrastructure, natively pushing an authorized manifest to the delivery team's active Routific phone apps flawlessly.

**Does `solve_standalone_vrp` handle extremely large thousands of stops simultaneously efficiently?**
For very large batches, use `solve_async_vrp_long` instead. It processes the request asynchronously and you can poll for results with `poll_async_solution`. The standalone solver is best for smaller, real-time requests.

**Can the integration update a delivery job after it has been created?**
Yes. Use `update_saas_job` to modify constraints, priorities, or delivery details on an existing job without having to delete and recreate it.