Connect Claude, Cursor, VS Code or any MCP client to the Qurak engine.
An assistant that guesses at arithmetic is wrong just often enough to matter. Connected here, it hands the mathematics to a real engine and returns a computed answer instead of a plausible one — calculus, differential equations, algebra, statistics, plots.
The connection tells your agent the truth about itself before any compute is spent: check_support answers whether a function exists, get_capabilities reports the limits actually in force, and plan_computation turns a goal into a working method with verified recipes attached. An agent keeps calling a tool that says in advance what it cannot do.
It is open on every plan, including the free one, and the whole connection is one URL. What a paid plan buys is compute budget and rate — never access.
| URL | Transport | Use |
|---|---|---|
| https://qurak.com/mcp | Streamable HTTP | Preferred. Use this unless your client can't. |
| https://qurak.com/mcp/sse | HTTP+SSE (2024-11-05) | Deprecated, for older clients only. |
The transport is stateless: it issues no protocol session id, so GET and DELETE on /mcp answer 405 by design. That is separate from the optional session_id the evaluating tools take — see Tools — which is a tool argument you choose, not something the transport hands out.
Most clients handle this for you. Pick your client below and follow the one path it shows — you don't need both.
| Method | How it works | Use it when |
|---|---|---|
| OAuth | The client opens your browser, you sign in to Qurak and approve the request. No credential is ever copied by hand. | Your client asks only for a URL — Claude Desktop and claude.ai have nowhere to put a token. |
| Bearer token | You create a token and put it in an Authorization header in the client's config. | Your client supports headers and you want a fixed credential — useful for CI or a shared machine. |
| Scope | Grants |
|---|---|
| qurak:evaluate | Run expressions and produce plots on your account. Spends your plan's compute budget and rate limit. |
| qurak:docs | Read the function reference. Spends no compute, so a docs-only connection is a safe thing to grant broadly. |
Under the hood this is a standard OAuth 2.1 flow with PKCE, discoverable at /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server (also answered under /.well-known/openid-configuration, which some clients try first). A client can identify itself three ways — a client ID metadata document, dynamic registration, or a client ID and secret you register below — and clients that support any of them will find it on their own.
claude mcp add --transport http qurak https://qurak.com/mcp \
--header "Authorization: Bearer qk_..."<code>type</code> is required. An entry with a <code>url</code> and no <code>type</code> is read as a stdio server and silently skipped.
{
"mcpServers": {
"qurak": {
"type": "http",
"url": "https://qurak.com/mcp",
"headers": { "Authorization": "Bearer qk_..." }
}
}
}Omit the <code>--header</code> flag to use OAuth instead: Claude Code opens a browser on first connect.
This path is OAuth-only by necessity — there is no field for a token. The same steps apply to claude.ai connectors.
Cursor prefers OAuth once a server publishes discovery metadata, which this one does — so a <code>headers</code> block in its config is likely to be ignored. Expect the browser flow, and let it run.
The key is <code>servers</code>, not <code>mcpServers</code>.
{
"servers": {
"qurak": {
"type": "http",
"url": "https://qurak.com/mcp",
"headers": { "Authorization": "Bearer ${input:qurak-token}" }
}
},
"inputs": [
{ "id": "qurak-token", "type": "promptString",
"description": "Qurak Bearer token", "password": true }
]
}Using <code>inputs</code> keeps the token out of the file, so the config is safe to commit.
If your client only speaks the older HTTP+SSE transport, point it at <code>https://qurak.com/mcp/sse</code> instead.
https://qurak.com/mcp| Tool | What it does | Scope |
|---|---|---|
| evaluate | Evaluate a Qurak expression (.wl-compatible syntax). Returns the formatted result, with the time it took. Optional session_id, format (Standard, TeX, JSON) and timeout_ms. | qurak:evaluate |
| plot | Run a plotting expression and return the chart as a PNG image. Takes the same session_id and timeout_ms. | qurak:evaluate |
| clear_session | Discard an evaluation session and everything defined in it. | qurak:evaluate |
| search_docs | Search the function reference by name or description, and the task recipes alongside it. Optional kind (function, task, any); every result says which it is. | qurak:docs |
| get_task | One task recipe in full: its steps in order, and the output each produced when it was verified against this engine. The steps run in sequence in one session. | qurak:docs |
| get_symbol | Everything known about one symbol: availability, forms, options, examples. | qurak:docs |
| check_support | Check whether specific functions are available, before using them. | qurak:docs |
| plan_computation | Grounds a goal before computing: support verdicts for every function in a draft expression, the closest verified recipes, and a routing recommendation in this connection's own budget numbers. Spends no compute. | qurak:docs |
| evaluate_async | Submits an expression as a background job with a minutes-long, plan-dependent budget, for work the interactive budget cannot hold. Returns a job id at once; jobs are a daily allowance. | qurak:evaluate |
| get_job list_jobs cancel_job | A job's status and, once finished, its full result (pass wait_ms and one call long-polls instead of dozens polling tightly); the recent jobs on the account; cancellation. Polling is free. | qurak:evaluate |
| simulate_circuit | Simulates a quantum circuit - ideal statevector, standard gate set - and returns its measurement histogram. Runs as a background job, with a qubit ceiling that follows the plan. | qurak:evaluate |
| save_guide get_guide list_guides delete_guide | Durable notes on the account: save a working model's definitions and assumptions under a name, and read them back in a later conversation. Reading needs the docs scope; writing needs evaluate. | qurak:docs qurak:evaluate |
| get_capabilities | The limits in force for this connection, as numbers: compute budget ceiling, per-minute allowance and what remains of it, largest stored plot, granted scopes, session bounds. No arguments. | any |
| WolframLanguageEvaluator | Legacy alias for evaluate, kept for clients that expect the AgentTools tool name. Same arguments, same behaviour. | qurak:evaluate |
evaluate and plot are stateless unless you pass a session_id. With one, definitions carry over — a = 10 on one call, then a + 5 on the next with the same id, evaluates to 15. Sessions are private to your account, so two accounts using the same id never see each other's variables. They are dropped after 30 minutes idle, when an evaluation in them times out (the engine cannot be interrupted, so the session goes with it), or when you call clear_session.
Compute budget and rate limit follow your plan — see Pricing, or call get_capabilities from the connection itself for the numbers in force. Exceeding either comes back as a tool result with isError set, not a transport error, so your agent can read the message and adjust. The same is true of a syntax error, a timeout, or a failure inside the engine: they are answers, and the connection stays open.
check_support tells you what's available without spending an evaluation. timeout_ms lets a call ask for a shorter budget than the plan allows — useful for failing fast on an expression you expect to be cheap. It is clamped to the plan's own budget, so it cannot buy more time than you have. File, process and network functions are blocked.