MCP Integration

JAOT exposes its optimization capabilities through the Model Context Protocol (MCP), allowing AI agents and LLM-powered applications to discover and use optimization tools without custom integration code.

What is MCP?

The Model Context Protocol is an open standard that lets AI applications discover and call external tools. Instead of writing bespoke API integrations, an MCP client (such as Claude Desktop, Cursor, or any compatible agent) connects to an MCP server and automatically discovers the tools it provides.

For JAOT, this means any MCP-compatible AI assistant can:

• Solve optimization problems by describing them in conversation
• Browse the template library and marketplace
• Author, version, and solve first-class model projects
• Fork marketplace models and execute them with user data
• Check execution results

Connecting to JAOT via MCP

JAOT runs an MCP server at the /mcp endpoint using HTTP (Streamable HTTP) transport.

Endpoint:

https://jaot.io/mcp

The MCP endpoint is publicly accessible — no authentication is needed to connect and discover tools. Individual tools that modify data require a Bearer API key, which is passed as a header on tool invocations.

Self-hosters: replace https://jaot.io/mcp with http://localhost:8001/mcp or your own domain.

Client setup

Claude Code (CLI)

Use claude mcp add with the --transport http flag:

claude mcp add --transport http jaot https://jaot.io/mcp \
  --header "Authorization: Bearer ok_live_your_key_here"

To browse templates and the marketplace without authenticating, omit the --header flag — those tools work without a key.

Claude Desktop

Claude Desktop does not support remote HTTP servers via claude_desktop_config.json directly. Add JAOT through the Settings → Connectors UI at claude.ai/settings/connectors:

1. Click Add custom connector
2. Enter https://jaot.io/mcp
3. Complete any authentication prompts

If you prefer to use the config file with the mcp-remote bridge (requires Node.js):

{
  "mcpServers": {
    "jaot": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://jaot.io/mcp",
        "--header",
        "Authorization: Bearer ok_live_your_key_here"
      ]
    }
  }
}

After saving, restart Claude Desktop.

opencode

Add JAOT to your opencode.json (or opencode.jsonc) config file:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "jaot": {
      "type": "remote",
      "url": "https://jaot.io/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer ok_live_your_key_here"
      }
    }
  }
}

OpenAI (Responses API)

Pass JAOT as an MCP tool in the tools array of a Responses API request:

{
  "model": "gpt-4o",
  "tools": [
    {
      "type": "mcp",
      "server_label": "jaot",
      "server_url": "https://jaot.io/mcp",
      "headers": {
        "Authorization": "Bearer ok_live_your_key_here"
      },
      "require_approval": "never"
    }
  ],
  "input": "List the available optimization templates."
}

Omit headers (or the Authorization entry) to use only the public catalog and marketplace browse tools.

Cursor

Create or edit .cursor/mcp.json in your project (or ~/.cursor/mcp.json for global):

{
  "mcpServers": {
    "jaot": {
      "url": "https://jaot.io/mcp",
      "headers": {
        "Authorization": "Bearer ok_live_your_key_here"
      }
    }
  }
}

VS Code (GitHub Copilot)

Create or edit .vscode/mcp.json in your workspace. VS Code uses a "servers" root key (not "mcpServers") and requires "type": "http" for remote servers:

{
  "servers": {
    "jaot": {
      "type": "http",
      "url": "https://jaot.io/mcp",
      "headers": {
        "Authorization": "Bearer ok_live_your_key_here"
      }
    }
  }
}

Available Tools

JAOT exposes 34 MCP tools organized into eight categories:

Solve Tools

Catalog Tools

File I/O Tools

Marketplace Tools

Using a marketplace model is fork-first: create_model_project_from_marketplace (below) forks it into a model project of your organization.

Execution Tools

Analysis Tools

Everything the analysis page computes is available to an agent — as facts, not prose. There is no "explain it in words" tool on purpose: an MCP client is already a language model, so it reads the numbers and writes its own explanation.

The what-if batch is asynchronous because each scenario is a full re-solve: start it, then poll until the status leaves running. Starting it twice is safe — a request that arrives while a batch is in flight joins it instead of queueing a second one, and a finished batch is served from the cache.

Solver Comparison Tools

These answer "which solver should I use for this model", not "what is the answer". The same problem goes to every solver you name, with the same time limit, the same gap tolerance and the same thread count, on one machine, one run after another. Seconds measured any other way are not comparable.

Both shapes are asynchronous: the launch returns 202 with a table of pending rows, and you poll until the status leaves pending and running. Each solver counts as one execution against the daily quota, so a matrix of 3 datasets and 4 solvers costs 12. A comparison that cannot afford all of its runs is rejected whole.

A solver that cannot express the model gets a row saying so with its reason — never an empty cell, and never a missing row. Read the machine_note field before quoting any timing: it records the machine the runs happened on, and times from two different comparisons cannot be put side by side.

Model Project Tools

Create, version, analyze, and solve a first-class model — the same "Model, Analyze & Solve" workspace an agent can drive over MCP.

Example Workflows

Solving a Problem from Scratch

An AI agent using JAOT's MCP tools might follow this flow:

1. User: "I need to optimize my delivery routes for 5 warehouses and 20 customers."
2. Agent calls solve_problem with a vehicle routing formulation:

{
  "name": "delivery_routing",
  "variables": [
    {"name": "route_1_2", "type": "binary"},
    {"name": "route_1_3", "type": "binary"}
  ],
  "objective": {
    "sense": "minimize",
    "expression": "12*route_1_2 + 8*route_1_3 + ..."
  },
  "constraints": [
    {"name": "visit_customer_2", "expression": "route_1_2 + route_3_2 + route_4_2 = 1"}
  ],
  "options": {"time_limit_seconds": 60}
}

3. The solver returns the optimal routes with the minimum total distance.

Using a Template

A simpler path for well-known problem types:

1. Agent calls list_templates to see what is available
2. Agent calls get_template("knapsack") to get the input schema
3. User provides item data
4. Agent calls solve_with_template("knapsack", {"capacity": 50, "items": [...]}) to get the solution

Marketplace Path

For pre-built domain-specific models — fork first, then run your copy:

1. Agent calls list_catalog_models to browse the marketplace
2. Agent calls get_catalog_model("cat_abc123") to check model details
3. Agent calls get_catalog_model_schema("cat_abc123") to see the customizable inputs
4. Agent calls create_model_project_from_marketplace("cat_abc123", {"user_input": {...}}) to fork it into the organization's studio
5. Agent calls execute_model("mp_xyz789", {"input_data": {...}}) to run the fork
6. Agent calls get_execution to retrieve results

Agent Authoring Path

An agent can drive the whole "Model, Analyze & Solve" workspace over MCP — building a versioned model instead of a one-off solve:

1. Agent calls create_model_project({"name": "Line scheduling"}) for a fresh versioned project
2. Agent calls update_model_project_draft("mp_abc", {"model_json": {...}}) to write the model
3. Agent calls commit_model_version("mp_abc", {"summary": "v1 — initial model"}) to record it
4. Agent calls solve_model_project("mp_abc", solution_filter="nonzero") — the compact solution omits near-zero variables (variables_omitted reports how many)
5. Agent calls get_execution_insights for quality/gap/time insights on the run

Authentication for MCP Tools

Tools marked "Auth: Yes" require a valid API key. Pass your key in the MCP connection headers as shown in the configuration section above. If a tool requiring auth is called without credentials, it returns an error message explaining how to authenticate.

Tools marked "Auth: No" are publicly accessible and can be used without any API key. This allows agents to browse templates and the marketplace catalog before the user decides to authenticate.

AI Discovery: llms.txt

JAOT also provides standardized discovery documents for AI agents at well-known URLs:

These documents follow the llms.txt specification and allow AI agents to understand JAOT's capabilities without parsing HTML documentation.