JAOT — Just Another Optimization Tool

A self-hostable optimization platform. Describe a problem in natural language or JSON, get the optimal solution back — no solver expertise required. Build models with an AI assistant, share them in a marketplace, expose them to AI agents over MCP, or just hit the REST API.

<!-- TODO(owner): drop a 30–60s demo GIF here — NL prompt → model → solve → marketplace → MCP call. -->

---

What it is

JAOT wraps industrial MIP/LP solvers (SCIP, HiGHS) behind a multi-tenant API, a visual builder, and an LLM formulation assistant. It is a platform, not a library and not a hosted SaaS — you run it yourself with docker compose up.

• Solver-agnostic core — an OptimizationProblem schema that stays independent of the solver. Ships SCIP (via PySCIPOpt) and HiGHS (via highspy); an optional Hexaly adapter is bring-your-own-license.
• LLM formulation assistant — turn a natural-language description into a runnable model, grounded in a RAG index over the template library (Qdrant + local sentence-transformers; no data leaves your box except the Claude calls you opt into).
• Model marketplace — publish and activate pre-built models, priced in credits or free. As far as we know, the only optimization-model marketplace that exists.
• MCP server — exposes solver tools to AI agents (Claude, etc.) via the Model Context Protocol.
• 102 templates + 27 problem generators — knapsack, vehicle routing, scheduling, production planning, portfolio, a full MDPDP-TW formulation, and more.
• Credits ledger, multi-tenant auth, admin panel, i18n (en/es/ca/fr/de), and a Prometheus/Grafana/Alertmanager monitoring stack — included.

Payments are optional and bring-your-own Stripe keys: the billing code is complete but has never been exercised against live Stripe — test before you charge real money.

---

Quickstart

git clone https://github.com/avallavall/jaot.git && cd jaot
cp .env.example .env   # includes first-run admin credentials — change the password
docker compose up -d   # migrates, seeds the catalog, creates your admin on first boot

Open http://localhost:3000 and log in with your SEED_ADMIN_* credentials — or mint an API key and solve over HTTP:

docker compose exec api python scripts/ensure_admin_api_key.py   # prints your API key

curl -X POST http://localhost:8001/api/v2/solve \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Content-Type: application/json" \
  -d '{"name":"test","variables":[{"name":"x","type":"continuous","lower_bound":0,"upper_bound":10}],"objective":{"sense":"maximize","expression":"3*x"},"constraints":[{"name":"c1","expression":"x <= 5"}]}'

Returns {"status":"optimal","objective_value":15.0,...}. Full setup guide → docs/getting-started/QUICKSTART.md.

---

How it compares

	JAOT	OR-Tools / Pyomo / PuLP	NEOS Server	Nextmv / solver clouds
Shape	Self-hosted platform	Libraries (you write the code)	Hosted academic solve service	Closed SaaS
Run it yourself	✅ docker compose up	✅ (it's your code)	❌	❌
REST API + async execution	✅	✗ (DIY)	partial	✅
NL → model assistant	✅	✗	✗	✗
Model marketplace	✅	✗	✗	✗
MCP server for AI agents	✅	✗	✗	✗
License	Apache-2.0	mixed OSS	terms vary	proprietary

If you want a Python library to embed in your own code, OR-Tools or Pyomo are the right tools. JAOT is for when you want the platform around the solver — API, UI, accounts, history, sharing, an AI front door — without building it.

---

Architecture

┌──────────────────────────────────────────────┐
│  Next.js 16 frontend  (5 locales)             │
└───────────────┬──────────────────────────────┘
                │ REST + SSE + WebSocket
┌───────────────▼──────────────────────────────┐
│  FastAPI (Python 3.12)                        │
│  auth · solve · LLM/RAG · credits ·           │
│  marketplace · triggers · MCP server          │
└──┬─────────┬──────────┬──────────┬────────────┘
   │         │          │          │
┌──▼──┐ ┌────▼────┐ ┌──▼──┐ ┌─────▼─────┐ ┌────────────┐
│ Pg  │ │RabbitMQ │ │Redis│ │  Qdrant   │ │ Anthropic  │
│ 18  │ │+ Celery │ │     │ │ (RAG)     │ │ Claude API │
└─────┘ │ workers │ └─────┘ └───────────┘ └────────────┘
        │ SCIP /  │
        │ HiGHS / │
        │ Hexaly  │
        └─────────┘

A modular monolith: the solver is the first extracted bounded context (app/domains/solver/), behind a SolverAdapter protocol enforced by import-linter contracts. Adding a solver means writing one adapter — see docs/ARCHITECTURE/OVERVIEW.md.

---

Documentation

Doc	Description
Quickstart	From zero to first solve
Architecture	System design, components, data model
Roadmap	What's shipped, what's next, where to help
Contributing	Dev setup and conventions
Testing & Quality	Test strategy, coverage, mutation scores
Deployment	Production deployment and monitoring
Disaster Recovery	Incident response runbook
MDPDP Spec	A worked mathematical formulation

---

Built with

JAOT stands on the SCIP Optimization Suite (Zuse Institute Berlin) and HiGHS — full attributions in THIRD_PARTY_LICENSES.

Built solo and AI-accelerated. What you can verify rather than take on faith: tests run against real PostgreSQL (no mocked DB), domain boundaries are enforced by import-linter contracts, and every change is gated by lint, tests, and security scans (bandit, pip-audit, npm audit). Details, coverage, and mutation-test scores in Testing & Quality.

Maintained best-effort — monthly issue triage, quarterly dependency/CVE pass. Issues and focused PRs welcome; see CONTRIBUTING.md and SECURITY.md.

---

License

Apache License 2.0 — see also NOTICE. Third-party license attributions are in THIRD_PARTY_LICENSES.