DEV Community: JustRouting

Build a Delivery AI Agent with MCP and Routing APIs

JustRouting — Mon, 12 Oct 2026 14:47:00 +0000

AI agents are getting better at understanding requests, reasoning about problems, and completing complex tasks.

But real-world operations need more than language.

A delivery assistant needs to answer questions like:

Which driver should handle this order?
How long will delivery take?
What is the most efficient route?
How should multiple vehicles be assigned?

These are not text problems.

They are routing problems.

In this tutorial, we will build a delivery AI agent that uses the Model Context Protocol (MCP) to access routing capabilities.

The agent will be able to:

convert addresses into coordinates
compare drivers by travel time
calculate routes
optimize multiple deliveries

The final architecture:

flowchart TD
    U[User Request]
        --> A[AI Agent]

    A --> M[MCP Server]

    M --> G[Geocoding]
    M --> R[Routing]
    M --> O[Optimization]

    G --> J[JustRouting API]
    R --> J
    O --> J

The stack:

MCP for connecting AI agents with tools
JustRouting MCP server for routing capabilities
Southeast Asia routing data

Why delivery agents need routing tools

A language model can understand:

"Which driver should deliver this order?"

But it does not know:

road distances
travel times
geographic relationships
delivery optimization

The AI agent decides what to do.

The routing system calculates what is physically possible.

LLM = reasoning

Routing engine = transportation intelligence

This separation is important.

The AI agent handles:

user intent
business rules
decision making

The routing layer handles:

maps
distances
travel time
optimization

Install the MCP routing server

JustRouting provides an MCP server that exposes Southeast Asia routing capabilities to AI clients.

Install:

curl -fsSL https://raw.githubusercontent.com/justrouting/mcp/main/install.sh | sh

Configure your MCP client:

{
  "mcpServers": {
    "justrouting": {
      "command": "justrouting-mcp",
      "env": {
        "JUSTROUTING_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

The MCP server provides four tools:

Tool	Purpose
`geocode`	Convert addresses into coordinates
`route`	Calculate routes
`table`	Compare travel times
`optimize`	Plan vehicle routes

Example 1: Assign the closest driver

A dispatcher asks:

Assign the closest driver to Mondrian Singapore Duxton.

Available drivers:

D1: Marina Bay Sands
D2: Waterford Residence
D3: IKEA Alexandra
D4: VivoCity

The AI agent creates a workflow:

flowchart LR
    A[Customer Address]
        --> B[Geocode]

    B --> C[Calculate Travel Times]

    C --> D[Compare Drivers]

    D --> E[Recommend Driver]

The routing result:

Driver   Location              Distance    Drive time

D1       Marina Bay Sands      3.60 km     ~8 min
D2       Waterford Residence   2.78 km     ~6 min
D3       IKEA Alexandra        5.33 km     ~13 min
D4       VivoCity              3.30 km     ~7 min

The agent responds:

Assign D2.

Reason:
- Shortest driving distance: 2.78 km
- Estimated arrival: ~6 minutes

The AI agent handles the business question:

"Who should deliver this order?"

The routing layer provides the transportation intelligence:

"These are the actual driving costs."

Example 2: Route planning

A user asks:

How long does it take to drive from Marina Bay Sands Singapore to Changi Airport?

The AI agent calls the route tool.

Result:

Distance:
~19.1 km

Duration:
~23 minutes

Main roads:
East Coast Parkway
Airport Boulevard

The agent can explain:

The fastest driving route takes about 23 minutes.

The route uses ECP and Airport Boulevard.
ERP charges may apply.

The user asks:

What if I'm riding a motorcycle?

The agent changes routing profiles:

Car:

Distance: ~19.1 km
Time: ~23.6 min


Motorcycle:

Distance: ~19.1 km
Time: ~26.5 min

The user adds:

What if I want to avoid tolls?

The agent applies a routing constraint:

Motorcycle with tolls:

Distance: ~19.1 km
Time: ~26.5 min


Motorcycle without tolls:

Distance: ~21.6 km
Time: ~35 min

The AI agent understands:

"drive" → driving profile
"motorcycle" → motorcycle profile
"avoid tolls" → routing constraint

The routing layer handles the geography.

Example 3: Fleet optimization

Single-driver dispatch is useful.

But real logistics problems are more complex.

A dispatcher asks:

I have two vans and six pickup locations. Create today's routes.

Vehicles:

V1: 249 Sixth Ave, Singapore

V2: 8 Harlyn Rd, Singapore

Customers:

C1: 75 Jln Kelabu Asap

C2: 20 Mount Sinai Rd

C3: 10 Bin Tong Park

C4: 9 Cluny Park

C5: 28 Nassim Rd

C6: 30 Chancery Ln

The AI agent calls:

optimize

The optimization engine returns:

Van V1

Start: 249 Sixth Ave

Route: C2 → C1 → C3

Total: ~19.4 minutes

and:

Van V2

Start: 8 Harlyn Rd

Route: C6 → C5 → C4

Total: ~29.0 minutes

Final answer:

All six deliveries assigned.

No customer left unserved.

Combined fleet driving time:

~48.5 minutes.

The AI agent does not manually solve the vehicle routing problem.

It delegates mathematical optimization to a specialized routing engine.

The complete delivery AI architecture

flowchart TD
    U[User]
        --> A[AI Agent]

    A --> M[MCP Server]

    M --> G[Geocode]
    M --> R[Route]
    M --> T[Travel Time Matrix]
    M --> O[Optimize]

    G --> J[JustRouting]
    R --> J
    T --> J
    O --> J

Each component has a clear responsibility.

AI Agent

Understands:

user requests
business rules
priorities

MCP

Provides:

standardized tool access
discoverable capabilities

Routing API

Handles:

maps
distances
travel times
optimization

Why MCP changes application architecture

Before MCP:

AI application

      |

Custom integration

      |

External services

Every AI application needs to build its own connectors.

With MCP:

flowchart TD
    A[AI Application]
        --> M[MCP Tools]

    M --> C[Reusable Capabilities]

    C --> R[Routing]
    C --> S[Search]
    C --> P[Payments]

A routing server becomes a reusable capability that can be used by:

delivery agents
fleet assistants
travel planners
field service systems
logistics copilots

Beyond delivery

The same pattern applies to many physical-world applications.

Ride-hailing

Question:

Which driver should accept this passenger?

Needs:

geocoding
ETA calculation
distance comparison

Field service

Question:

Which technician should visit this customer?

Needs:

location matching
scheduling
routing

Emergency response

Question:

Which vehicle can arrive fastest?

Needs:

route calculation
travel-time estimation

Build AI applications that understand the physical world

Large language models provide reasoning.

MCP provides tool access.

Routing provides location intelligence.

Together they enable AI systems that can make decisions in the real world.

A delivery AI agent is not just a chatbot.

It is a system that can:

understand a request
call specialized tools
evaluate options
take action

The next generation of logistics software will not only show routes.

It will reason about movement.

Learn more:

JustRouting: https://justrouting.tech
MCP Server: https://github.com/justrouting/mcp
Documentation: https://docs.justrouting.tech

AI Agents Need a Routing Layer: Building Location Intelligence for Southeast Asia

JustRouting — Mon, 12 Oct 2026 14:26:49 +0000

AI agents are becoming better at understanding users, planning tasks, and making decisions.

But there is one important limitation:

AI agents do not understand the physical world by default.

They know language.

They can reason about goals.

They can call tools.

But they still need external capabilities to answer questions like:

"Which driver should deliver this order?"
"What is the fastest way to visit these five locations?"
"How long will it take to reach the airport?"
"Which warehouse is closest to this customer?"

These are not language problems.

They are routing problems.

And routing is becoming a fundamental capability for AI agents operating in the real world.

From API calls to agent capabilities

Traditional software integration looks like this:

Application → API → Response

A developer writes code:

collect coordinates
call a routing API
parse the response
implement business logic

This works well for traditional applications.

But AI agents introduce a different model:

AI Agent → Tools → Capabilities

The agent does not need to know every API detail.

It needs tools it can discover and use.

This is where the Model Context Protocol (MCP) becomes interesting.

MCP provides a standard way for AI applications to connect with external capabilities.

Instead of building custom integrations for every agent, developers can expose tools that agents can call when needed.

Routing becomes one of those tools.

Why AI agents need routing

Many real-world tasks require spatial reasoning.

Consider a delivery assistant:

"I have 20 orders in Jakarta. Assign them to three drivers and optimize today's routes."

A general-purpose AI model cannot solve this alone.

It needs:

address → coordinates conversion
road network knowledge
travel time estimation
distance matrix calculation
vehicle routing optimization

A routing layer provides these capabilities.

The AI agent handles the reasoning:

"We have three drivers, 20 deliveries, and a priority customer."

The routing system handles the geography:

"These are the realistic driving times and optimized sequences."

Together they create a complete workflow.

Why Southeast Asia needs a specialized routing layer

Most global mapping platforms are designed for global coverage.

That is useful.

But Southeast Asia has unique routing challenges:

motorcycles are a primary transportation mode
dense urban areas create complex travel patterns
delivery businesses depend heavily on two-wheel vehicles
addresses are often less structured than Western markets
local road access rules matter

A routing layer optimized for Southeast Asia can provide better building blocks for applications such as:

food delivery
last-mile logistics
fleet management
ride-hailing
e-commerce fulfillment
field service operations

The goal is not to replace global maps.

The goal is to provide the right routing capability for the region where your users actually operate.

Introducing JustRouting MCP Server

JustRouting provides an MCP server that exposes Southeast Asia routing capabilities to AI agents.

The server provides four core tools:

`route`

Calculate a route between locations.

Example:

"How long does it take to drive from Marina Bay Sands to Changi Airport?"

The agent can geocode the locations and request the driving route.

`geocode`

Convert human places into coordinates.

Example:

"Find the location of this customer address."

The agent does not need users to provide latitude and longitude manually.

`table`

Calculate travel-time matrices.

Example:

"Which warehouse is closest to these five customers?"

The agent can compare multiple origins and destinations efficiently.

`optimize`

Solve vehicle routing problems.

Example:

"Plan today's delivery routes for five drivers."

The agent can use optimization tools instead of manually reasoning through hundreds of possible routes.

Installing the MCP server

Installation:

curl -fsSL https://raw.githubusercontent.com/justrouting/mcp/main/install.sh | sh

Configure your MCP client:

{
  "mcpServers": {
    "justrouting": {
      "command": "justrouting-mcp",
      "env": {
        "JUSTROUTING_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Now an MCP-compatible AI client can access routing capabilities directly.

Three examples: from answering questions to making decisions

A routing layer becomes more valuable when an AI agent can use it as a tool.

The agent does not need to understand road graphs, coordinates, or optimization algorithms.

It only needs to understand the user's intent and call the right capability.

Here are three examples.

1. Route: answering real-world travel questions

User:

How long does it take to drive from Marina Bay Sands Singapore to Changi Airport?

The AI agent can use the route tool:

User request
      |
      v
  geocode places
      |
      v
  calculate route
      |
      v
  explain result

The response:

Driving from Marina Bay Sands to Changi Airport takes about
23-24 minutes, covering roughly 19 km.

Route details:
- Main roads: East Coast Parkway (ECP), Airport Boulevard
- Distance: ~19.1 km
- Time: ~23 min 36 s
- Tolls: Yes (ERP charges may apply)

The same question can include transportation preferences:

What if I'm riding a motorcycle?

The agent can switch routing profiles:

Car:
  Distance: ~19.1 km
  Time: ~23.6 min

Motorcycle:
  Distance: ~19.1 km
  Time: ~26.5 min

Or apply constraints:

What if I want to avoid tolls?

The agent can request a different route:

Motorcycle with tolls:
  Distance: ~19.1 km
  Time: ~26.5 min

Motorcycle without tolls:
  Distance: ~21.6 km
  Time: ~35 min

The important part is not the API call.

The agent understands the intent:

"drive" → driving profile
"motorcycle" → motorcycle profile
"avoid tolls" → routing constraint

The routing layer handles the geography.

2. Dispatch: making operational decisions

Now consider a logistics assistant.

A dispatcher asks:

I need to assign a delivery to the closest available driver by driving distance.

Customer:

Mondrian Singapore Duxton

Available drivers:

D1: Marina Bay Sands
D2: Waterford Residence
D3: IKEA Alexandra
D4: VivoCity

A human might estimate based on a map.

An AI agent can calculate the actual driving distance:

Driver  Location              Distance    Drive time

D1      Marina Bay Sands      3.60 km     ~8 min
D2      Waterford Residence   2.78 km     ~6 min
D3      IKEA Alexandra        5.33 km     ~13 min
D4      VivoCity              3.30 km     ~7 min

Recommendation:

Assign D2.

Reason:
- Shortest driving distance: 2.78 km
- Fastest estimated arrival: ~6 minutes

The AI agent handles the business reasoning:

"Find the closest available driver."

The routing layer provides the transportation intelligence:

"These are the real driving costs."

This pattern applies to:

food delivery
courier dispatch
field service
ride-hailing
emergency response

3. Optimize: planning an entire fleet

The next level is multi-vehicle optimization.

User:

I have two vans available to pick up packages from six customers. How should these pickup tasks be assigned and ordered?

Vehicles:

V1:
249 Sixth Ave, Singapore

V2:
8 Harlyn Rd, Singapore

Customers:

C1: 75 Jln Kelabu Asap
C2: 20 Mount Sinai Rd
C3: 10 Bin Tong Park
C4: 9 Cluny Park
C5: 28 Nassim Rd
C6: 30 Chancery Ln

The AI agent calls the optimize tool.

The routing optimizer returns:

Van V1

Start:
249 Sixth Ave

Route:
C2 → C1 → C3

Total:
~19.4 minutes

and:

Van V2

Start:
8 Harlyn Rd

Route:
C6 → C5 → C4

Total:
~29.0 minutes

Final plan:

All 6 jobs assigned.
No customer left unserved.

Combined fleet driving time:
~48.5 minutes

The AI agent did not manually solve the vehicle routing problem.

It delegated the mathematical optimization to a specialized routing engine.

That is the future architecture:

AI Agent
    |
    |
    +---- Understand user goal
    |
    +---- Call routing tools
              |
              +---- Geocode
              |
              +---- Route
              |
              +---- Matrix
              |
              +---- Optimize

Large language models are good at reasoning.

Routing engines are good at transportation mathematics.

Together they create AI systems that can operate in the physical world.

The future architecture: AI + specialized infrastructure

The future of AI applications will not be one giant model doing everything.

It will look more like this:

                 AI Agent

                    |
        ---------------------------
        |            |            |
    Routing       Payments      Search
      Tool          Tool         Tool

        |
  Specialized Infrastructure

Large language models provide reasoning.

Specialized services provide reliable capabilities.

Routing is one of those capabilities.

Building the physical world layer for AI

The next generation of AI applications will interact with the real world:

robots
delivery systems
transportation networks
warehouses
field operations

They will need more than text generation.

They will need location intelligence.

A routing layer gives AI agents the ability to understand movement, distance, and time.

For Southeast Asia, that means providing routing capabilities designed around the region's transportation reality.

The future AI agent will not only answer questions.

It will make decisions in the physical world.

And every physical decision needs a map.

Learn more:

JustRouting: https://justrouting.tech
MCP Server: https://github.com/justrouting/mcp
Documentation: https://docs.justrouting.tech

Route planning for Southeast Asia without self-hosting OSRM

JustRouting — Sat, 03 Oct 2026 12:05:28 +0000

Ask anyone who has operated OSRM in production and they will tell you the same thing: the routing engine is excellent, but running the infrastructure behind it is not trivial.

A global OpenStreetMap graph can require serious hardware and long preprocessing times. Even a Southeast Asia extract — the region many applications actually need — still means managing large map files, running osrm-extract and osrm-contract, monitoring memory usage, and rebuilding everything whenever OpenStreetMap data changes.

The hidden cost is not only the server.

Someone has to maintain the pipeline:

download updated OSM extracts
rebuild routing graphs
monitor failed preprocessing jobs
keep production instances healthy
remember how everything works months later

For many teams, routing is not the product. It is just a capability inside a logistics app, delivery platform, marketplace, or AI agent.

You need routes. You do not want to become a routing infrastructure company.

The alternative: managed routing infrastructure

JustRouting is a hosted routing API focused on Southeast Asia.

Instead of running your own routing stack, you get ready-to-use APIs for:

directions
distance matrices
map matching
nearest-road lookup
geocoding
fleet optimization

The underlying routing engines are powered by open-source technology, but the infrastructure work — servers, preprocessing, updates, and operations — is handled for you.

The important parts:

Driving and motorcycle profiles. Motorcycle routing matters in Southeast Asia, where two-wheel delivery and transportation are everywhere.
A simple REST API. Use it from any language with JSON requests.
Official SDKs for Python, JavaScript/TypeScript, and Go.
A free tier for experiments and small projects. No credit card required.

Five lines of Python

import justrouting

client = justrouting.Client("YOUR_API_KEY")

route = client.routes.get(justrouting.RouteRequest(
    origin=[106.8146, -6.1352],       # Jakarta Kota
    destination=[107.6191, -6.9175],  # Bandung
))

print(f"{route.distance / 1000:.1f} km, {route.duration / 60:.0f} min")

Need a motorcycle route?

route = client.routes.get(justrouting.RouteRequest(
    origin=[106.8146, -6.1352],
    destination=[107.6191, -6.9175],
    profile="motorcycle",
))

Distance matrices are also available:

matrix = client.matrix.get(justrouting.MatrixRequest(
    coordinates=[depot, stop_a, stop_b],
    sources=[0],
    destinations=[1, 2],
))

You can request only the rows and columns you need instead of calculating a full N×N matrix.

For delivery fleets, use optimization:

plan = client.optimization.solve(justrouting.OptimizationRequest(
    vehicles=[
        justrouting.Vehicle(
            id=1,
            start=[106.8146, -6.1352],
            end=[106.8146, -6.1352],
        )
    ],
    jobs=[
        justrouting.Job(
            id=101,
            location=[106.8451, -6.2146],
        )
    ],
))

The API returns the optimized sequence for each vehicle.

The same routing capability from Node.js

import { Client } from '@justrouting/client';

const client = new Client('YOUR_API_KEY');

const route = await client.routes.get({
    origin: [106.8146, -6.1352],
    destination: [107.6191, -6.9175],
});

console.log(`${(route.distance / 1000).toFixed(1)} km`);

Both SDKs are lightweight and dependency-free.

Routing for AI agents: introducing MCP

Traditional applications call routing APIs directly:

Application → Routing API → Route result

But AI applications work differently.

An AI agent needs tools it can discover and call dynamically:

AI Agent → Tools → Routing capability

This is where the Model Context Protocol (MCP) becomes interesting.

Instead of writing custom glue code that converts addresses into coordinates, calls geocoding, builds matrices, and parses routing responses, an MCP-compatible agent can use routing as a native capability.

JustRouting provides an official MCP server.

Install it:

curl -fsSL https://raw.githubusercontent.com/justrouting/mcp/main/install.sh | sh

Configure your MCP client:

{
  "mcpServers": {
    "justrouting": {
      "command": "justrouting-mcp",
      "env": {
        "JUSTROUTING_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

The server provides four tools:

route — calculate driving routes
geocode — convert places into coordinates
table — calculate travel-time matrices
optimize — solve vehicle routing problems

Now an AI assistant can reason about real-world transportation problems.

For example:

"Which driver should deliver this order in Jakarta?"

The agent can:

geocode the customer's address
calculate travel times from multiple drivers
compare routes
select the closest driver

No manual coordinate lookup.
No custom API integration.
No routing-specific code.

Routing becomes a capability that AI agents can use directly.

Try it before building infrastructure

The interactive demo in JustRouting lets you test routes, matrices, and fleet optimization directly from your browser.

The documentation includes API references and examples.

A free API key takes about thirty seconds.

To be clear about the trade-off:

If you need global coverage, offline routing, or complete control over your routing graph, self-hosting OSRM is still a great option.

But if your users are in Southeast Asia and you simply need reliable routing capabilities, a managed API removes a large amount of operational work.

Keep the open-source routing technology.

Skip the server farm.

Build your product.