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
Execute activated models with user data
Check credit balances and execution results

Connecting to JAOT via MCP

JAOT runs an MCP server at the /mcp endpoint using HTTP+SSE transport.

Endpoint:

https://api.jaot.io/mcp

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

Claude Desktop Configuration

Add JAOT as an MCP server in your Claude Desktop configuration file (claude_desktop_config.json):

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

After saving, restart Claude Desktop. The JAOT tools appear in the tool list and Claude can use them during conversations.

Other MCP Clients

Any MCP client that supports HTTP+SSE transport can connect to JAOT. Point the client to https://api.jaot.io/mcp and configure authentication headers as required by the client.

Available Tools

JAOT exposes 12 MCP tools organized into five categories:

Solve Tools

Tool	Auth	Description
`solve_problem`	Yes	Solve an optimization problem defined as variables, constraints, and an objective
`validate_problem`	Yes	Validate a problem definition without solving (no credits charged)

Catalog Tools

Tool	Auth	Description
`list_templates`	No	List available problem templates with names, categories, and descriptions
`get_template`	No	Get a specific template's details, input schema, and example input
`solve_with_template`	Yes	Solve a problem using a template and user-provided input data

Marketplace Tools

Tool	Auth	Description
`list_catalog_models`	No	Browse published models in the marketplace
`get_catalog_model`	No	Get a specific marketplace model's details
`get_catalog_model_schema`	No	Get the input schema for a marketplace model
`activate_catalog_model`	Yes	Activate (purchase) a marketplace model for your organization

Execution Tools

Tool	Auth	Description
`execute_model`	Yes	Execute an activated model with input data
`get_execution`	Yes	Retrieve execution results and status

Credits Tools

Tool	Auth	Description
`get_credit_balance`	Yes	Check your organization's current credit balance

Example Workflows

Solving a Problem from Scratch

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

User: "I need to optimize my delivery routes for 5 warehouses and 20 customers."
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}
}

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

Using a Template

A simpler path for well-known problem types:

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

Marketplace Path

For pre-built domain-specific models:

Agent calls list_catalog_models to browse the marketplace
Agent calls get_catalog_model("cat_abc123") to check model details
Agent calls get_catalog_model_schema("cat_abc123") to see required inputs
Agent calls activate_catalog_model("cat_abc123") to activate for the organization
Agent calls execute_model("orgmdl_xyz789", {"input_data": {...}}) to run it
Agent calls get_execution to retrieve results

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:

URL	Content
`/.well-known/llms.txt`	Concise discovery document with endpoint list and MCP tool names
`/.well-known/llms-full.txt`	Comprehensive documentation including authentication guide, full API reference, problem JSON schema, and optimization concepts

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

Credit Consumption

MCP tool calls that trigger optimization solves consume credits from your organization's balance, following the same pricing formula as direct API calls. Use get_credit_balance to check your balance, and the validate_problem tool to estimate credit cost before solving.

See Rate Limits and Credits for the complete credit pricing formula and plan details.