Deploy a model

A deployment is solver code plus data, deployed under a name. Once it exists, anyone in your company can create a project from <company>/<name> and start solving.

The layout contract

The server expects two trees. The solver reads ../data/ at solve time, so the same solver can run against a different dataset.

• Directoryrun/

  • pyproject.toml the solver package’s own manifest
  • run.py
  • Directorysrc/

    • Directorysolver/

      • **/*.py
• Directorydata/

  • instances.json
  • distances.csv

checkDeployment validates this server-side and reports what is missing.

Deploying

CLI

aura deploy reads a [tool.aura.deployment.<name>] table, normally in the model folder’s own pyproject.toml — the file that lands as run/pyproject.toml. Build backends ignore unknown tool tables, so the manifest travels with the artifact without affecting it.

pyproject.toml

[tool.aura.deployment.vrp]
model_folder = "."               # uploaded under run/   (default ".")
data_folder  = "../define/data"  # uploaded under data/  (required)
include      = ["pyproject.toml", "run.py", "src/solver/**"]
data_include = ["**"]
exclude      = ["notes/**", "personal_infos.txt"]

aura init                 # scaffold the section above
aura deploy --dry-run     # print exactly what would upload, change nothing
aura deploy               # upload
aura deployment check     # server-side run contract

Several deployments may live in one pyproject.toml; aura deploy <name> picks one, and the name is optional when only one is defined. aura deploy searches upward from the current directory for a pyproject.toml carrying a [tool.aura] table, or takes --config <path>.

TypeScript

import { AuraClient, deployFromFolder } from "@strangeworks/aura-sdk";

const aura = new AuraClient({ apiKey: process.env.AURA_API_KEY! });

await aura.createDeployment("vrp");

await deployFromFolder(aura, "vrp", "./my-model/solver", { destPrefix: "run/" });
await deployFromFolder(aura, "vrp", "./my-model/data", { destPrefix: "data/" });

const check = await aura.checkDeployment("vrp");
if (!check.ok) {
  throw new Error(`Deployment not runnable: ${check.missing.join(", ")}`);
}

Python

import asyncio, os
from aura_sdk import AuraClient, deploy_from_folder

async def deploy() -> None:
    async with AuraClient(api_key=os.environ["AURA_API_KEY"]) as aura:
        await aura.create_deployment("vrp")

        await deploy_from_folder(aura, "vrp", "./my-model/solver", dest_prefix="run/")
        await deploy_from_folder(aura, "vrp", "./my-model/data", dest_prefix="data/")

        check = await aura.check_deployment("vrp")
        if not check.ok:
            raise RuntimeError(f"Deployment not runnable: {', '.join(check.missing)}")

asyncio.run(deploy())

Choosing what uploads

CLI

include and data_include are glob lists relative to their folder; exclude applies to both and wins over include.

include      = ["pyproject.toml", "run.py", "README.md", "src/solver/**"]
data_include = ["*.csv", "instances/**"]
exclude      = ["**/scratch/**", "notes.md"]

Built-in excludes always apply on top: dot-prefixed files and directories (.git, .venv, .env, …), __pycache__, node_modules, dist, venv, *.pyc. The server additionally rejects dot-prefixed and executable paths.

Preview what would upload:

aura deploy --dry-run

TypeScript

filter keeps only the paths you return true for; paths are POSIX-relative to the folder.

await deployFromFolder(aura, "vrp", "./my-model/solver", {
  destPrefix: "run/",
  filter: (path) => !path.includes("/scratch/"),
  concurrency: 8,
  onFileUploaded: (path) => console.log(`uploaded ${path}`),
});

Python

include is a predicate over the POSIX-relative path.

await deploy_from_folder(
    aura,
    "vrp",
    "./my-model/solver",
    dest_prefix="run/",
    include=lambda path: "/scratch/" not in path,
    concurrency=8,
    on_file_uploaded=lambda path: print(f"uploaded {path}"),
)

Redeploying is a sync

Remote run/ and data/ are made to match your local folders: after the uploads, remote files no longer present locally are removed, so renames and deletions leave nothing stale. If an upload fails, the sync stops without pruning.

Your key never touches the file bytes

Uploads are three steps: request an upload plan, PUT the bytes to the URL the plan returns using only the plan’s headers, then complete. Your API key authenticates the plan and the completion, not the payload.

Create a project from it

1. Check it is runnable:

   aura deployment check vrp

2. Create a project from the handle, <company>/<name>:

   aura project create acme/vrp --name "vrp demo"

3. Chat with it.

Retiring a deployment is permanent

aura deployment delete <name> removes a deployment: every file under it is purged and the name is freed, so a later deployment may claim it and starts empty. There is no undelete. Projects already created from the deployment keep their own copy of its files and go on working — the command reports how many there were.