How to Connect Mathify Calculators to an AI Assistant (MCP)

Short answer: if your AI assistant supports custom connectors or remote MCP servers, add the URL https://mathify.one/api/mcp as a new server. No sign-in is required. The assistant can then search calculators, read their input schemas, run them and cite the result. Menu names differ by product, so follow your assistant's own guide for adding a custom MCP server.

What is MCP, and why use it for calculators?

The Model Context Protocol (MCP) is an open standard that lets an AI assistant discover and call tools hosted elsewhere. Think of it as a shared plug shape: any assistant that speaks MCP can use any server that speaks MCP.

For calculators the benefit is accuracy. A model that writes a number from memory can be wrong, as the article on why chatbots miscalculate explains. With a tool connected, the arithmetic is done by code and the model reports the returned value.

How do I connect Mathify?

The steps below are deliberately generic, because every product names its menus differently and changes them over time.

1. Open your assistant's settings and look for connectors, integrations, tools or MCP servers. If your client supports custom connectors, there should be an option to add one by URL.
2. Choose to add a custom or remote MCP server.
3. Enter the server URL: https://mathify.one/api/mcp
4. If asked for a transport, pick Streamable HTTP. If asked for authentication, choose none. The server's published manifest at https://mathify.one/.well-known/mcp.json lists the authentication as none.
5. Save, then start a new conversation and make sure the connector is enabled for it.
6. Ask a numeric question, such as "Use Mathify to work out 15 percent of 850", and check that the assistant shows a tool call.

Some products restrict custom connectors to certain plans, workspaces or admin approval. If you cannot find the option, that is a limit of the client, not of Mathify.

Which tools does the server offer?

At the time of writing, the server advertises four tools. All are read-only: they compute or look things up and never change anything.

• search_calculators takes a plain-language query such as "monthly mortgage payment" and returns ranked matches. Each match has an id in category/slug form, a name, a page URL, a citation line and a flag saying whether it can be run through the tool.
• get_calculator_schema takes an id and returns the JSON Schema of the inputs that calculator expects.
• run_calculator takes an id and an args object and returns the result, the inputs used, the formula and steps where available, a canonical URL, a link to the page with the inputs prefilled for supported pages, and a citation.
• explain_calculator returns the definition, formula, worked example, FAQ and common mistakes where they are documented, without running anything. Fields that are not documented are left out rather than invented.

Beyond tools, the server also offers read-only resources (a catalogue, the llms.txt file, and per-category and per-calculator views) and three prompt templates: solve_with_calculator, explain_calculation and compare_scenarios.

What does the normal flow look like?

The server's built-in instructions tell the assistant to work in this order: search, then get the schema, then run. Ids use category/slug, for example math/percentage, because a bare name can match more than one calculator. If an id is ambiguous, the error lists the candidate ids so the assistant can retry.

For example, a request for 15 percent of 850 resolves to the percentage calculator with value1 15, value2 850 and calculationType set to basic. It returns 127.5, along with the page https://mathify.one/en/math/percentage and the citation line Source: Mathify - Percentage Calculator, https://mathify.one/en/math/percentage. We ran this against the route code before writing it here.

How can I test the endpoint without an assistant?

You can call the server directly. A call that opens a session and reads the server details looks like this:

curl -s https://mathify.one/api/mcp -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl-test","version":"0.1"}}}'

The reply names the server as mathify, agrees a protocol version (the server speaks 2025-06-18, 2025-03-26 and 2024-11-05) and includes usage instructions. A tool call is another POST to the same URL:

curl -s https://mathify.one/api/mcp -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"run_calculator","arguments":{"id":"math/percentage","args":{"value1":15,"value2":850,"calculationType":"basic"}}}}'

Both requests were run against the route handler in the repository. The second returns a JSON-RPC response whose text content is a JSON document with a formatted result of 127.5. A GET request with an Accept: application/json header returns a small description of the endpoint, including the live calculator counts, which this article does not quote because they change.

What are the limits and safeguards?

• Stateless. The server keeps no session. It does not open a server-sent-events stream, so a GET that asks for one gets a 405 response, as the Streamable HTTP rules allow.
• Request size. Bodies are capped at 16 KB and batch requests are not supported.
• Time limit. Each tool call has a 5 second budget.
• Rate limit. Calls are limited per IP address per minute. The default in the code is 60, and a rate-limited call returns a Retry-After value.
• Usage logging. The code logs one line per call with the tool, calculator id, client name, duration and outcome. By design it does not record IP addresses, arguments or results.

Remember what this means for privacy. Standard calculators on the website run in your browser, but a call through the MCP server is processed on Mathify's server, so the numbers you ask about do reach it.

Common mistakes

• Using a bare slug. Prefer math/percentage over percentage.
• Skipping the schema. Field names differ between calculators. Read the schema before running.
• Treating a non-runnable calculator as an error. Some calculators are pages only. The flag in the search result says so, and the right behaviour is to link the page.
• Pasting the connector URL into a browser. The endpoint speaks JSON-RPC over POST. A plain browser visit will not show a calculator.

Key takeaways

• Add https://mathify.one/api/mcp as a remote MCP server if your client supports custom connectors.
• No authentication is needed, and there are four read-only tools.
• The flow is search, schema, run, with a citation in every result.
• Tool calls are processed on the server and rate limited.

FAQ

Do I need an API key?

No. The published manifest lists authentication as none. Per-IP rate limits apply.

My assistant cannot add a custom connector. What else can I do?

If it can call web APIs from an OpenAPI description, use the REST option described in the API and GPT Actions guide. Otherwise open the calculator page yourself.

How many calculators can the assistant run?

A growing set. The count changes as calculators are added, so ask the endpoint (a GET with the JSON Accept header) for the current figure instead of relying on a number in an article.

Will the assistant always use the tool?

Not necessarily. Many clients let the model decide. Mention Mathify by name in your question to make it likely, and check for a visible tool call.

Is the answer final advice?

No. Results are for information. Check the inputs shown and use professional advice for money or health decisions.