Bring your data. Explore machine learning with WEKA through MCP.

Connect WEKA-MCP to ChatGPT

Available for ChatGPT Plus, Pro, Business, Enterprise, and Education accounts through the ChatGPT web app.

1. Open ChatGPT in a desktop web browser.
2. Open Settings → Security and login.
3. Turn on Developer mode.
4. Open Plugins and select the + button to create a developer-mode app.

5. Enter the following details:

   Name

   WEKA-MCP

   Description

   Access WEKA machine-learning tools through ChatGPT.

   MCP server URL

   MCP endpoint Copy

   https://weka-mcp.ademartutor.com/mcp

   Authentication

   No Authentication

6. Select Create. ChatGPT will connect to the server and display the WEKA-MCP tools it discovers.
7. Start a new conversation.
8. Select the + button beside the message box, then choose Developer mode.
9. Enable WEKA-MCP for the conversation.

You can now ask ChatGPT to use WEKA-MCP tools for machine-learning tasks.

Connect WEKA-MCP to claude.ai

Custom connectors are available on the Free, Pro, Max, Team, and Enterprise plans through the claude.ai web app. Free accounts can hold one custom connector at a time. On Team and Enterprise, an Owner has to add the connector for the organization first. See below.

1. Open claude.ai in a desktop web browser and sign in.
2. Go to Customize → Connectors.
3. Select Add custom connector.

4. Enter the following details:

   Remote MCP server URL

   MCP endpoint Copy

   https://weka-mcp.ademartutor.com/mcp

   Advanced settings

   Leave OAuth Client ID and OAuth Client Secret empty. The hosted server runs in open demo mode and takes no credentials.

   Request headers

   Leave empty. If your build doesn't show this section, ignore it.

   If a Name field appears, enter WEKA-MCP. Otherwise Claude takes the name the server reports.

5. Select Add. Claude connects to the server and lists the WEKA-MCP tools it discovers.
6. Start a new conversation.
7. Select the + button in the chat interface, then Connectors.
8. Toggle WEKA-MCP on for that conversation.

You can now ask Claude to use WEKA-MCP tools for machine-learning tasks. Claude asks for your approval the first time it calls each tool.

On Team and Enterprise plans

Members can't add a custom connector until an Owner has registered it for the organization.

1. An Owner or Primary Owner goes to Organization settings → Connectors.
2. Select Add, then Custom. If Claude asks for a connector type, choose Web.
3. Enter the same MCP endpoint above, leave the OAuth fields empty, and select Add.
4. Each member then opens Customize → Connectors, finds WEKA-MCP under the Custom label, and selects Connect.

If the connector won't attach

• No Add custom connector option. You're on Team or Enterprise, where an Owner has to add it at the organization level first.
• Free plan already has a connector. Free accounts hold one custom connector at a time, so remove the existing one first.
• The connector times out on first add. The server scales from zero. Wait 30 seconds and try again.
• Tools don't appear in chat. Connectors are enabled per conversation. Re-open + → Connectors in the chat you're actually using.
• To turn off individual tools, go to Customize → Connectors, select WEKA-MCP, and set a tool's permission to Blocked.

Connect WEKA-MCP to Claude Desktop

You don't need a config file. WEKA-MCP is a remote connector, and connectors are attached to your Claude account rather than to one app. The same catalog serves claude.ai, Claude Desktop, mobile, and Claude Code.

1. Add the connector once, using the claude.ai steps. You can do this from the desktop app or the browser.
2. Make sure Claude Desktop is signed in to the same account, then restart it so it picks up the new connector.
3. Start a new conversation.
4. Select the + button in the chat box, then Connectors.
5. Toggle WEKA-MCP on for that conversation.

Settings → Extensions in the desktop app is a different thing. That's for desktop extensions and local MCP servers that run on your own machine, so a hosted endpoint like this one doesn't belong there.

Bridging with mcp-remote instead

Only worth doing if you're on an older desktop build without connector support, or you want the server declared in a config file you control. It bridges the remote endpoint to stdio through mcp-remote, and needs Node 20 or newer. Add this to claude_desktop_config.json, then restart Claude Desktop:

{
  "mcpServers": {
    "weka": {
      "command": "npx",
      "args": ["mcp-remote", "https://weka-mcp.ademartutor.com/mcp"]
    }
  }
}

What to expect from the hosted demo

A few important technical considerations before getting started.

• It can't open files on your computer. The server runs in our cloud, so when you hand weka_upload_dataset a path like /Users/you/data.csv, it goes looking for that path on our machine and doesn't find it. You get back ENOENT: no such file or directory with your own path quoted in the error. Size has nothing to do with it, by the way. The 20 MB cap is a local install thing. If you want to work with your own data, install locally.
• Treat it as a public sandbox. Everyone shares the same dataset and model storage, and none of it is locked down. Anyone connected can list what's there, download it, or delete it. So don't put anything private on it, and don't be surprised if something you saved yesterday is gone today.
• Switch the delete tools to "Ask." In the connector's tool permissions, find Delete dataset and Delete model and move them from "Always allow" to the ask icon. Storage is shared, so a careless delete takes out someone else's work along with yours. Worth doing the same for Import model, which loads serialized Java objects.
• The first call after a quiet period can be slow. The server scales to zero when it's not being used, so it may take 10–30 seconds to wake up. This is normal and doesn't mean something has failed. If the connector shows "Connection issue," click it and try again.
• If the tools disappear during a conversation, the server may have gone idle and dropped the connection. The simplest fix is to start a new conversation. Connections are established when a session begins, so an existing session can't currently reconnect once the connection is lost.
• Long training runs get cut off around 240 seconds by the ingress timeout. iris has 150 rows and finishes instantly, so you'll never run into it there. Push up to 10,000 rows with RandomForest or cross validation and you'll hit the ceiling. That kind of work belongs on a local install.

Drive WEKA-MCP over plain HTTP

You can drive the whole server with curl. Every call is a single POST: no session to open, no handshake to send first, nothing left running in the background. Two things to get right. Your Accept header has to name both application/json and text/event-stream, and the endpoint only answers POST.

Request format

Every request is a POST to the same URL, with the same two headers and a JSON-RPC 2.0 body. Only the body changes between calls:

curl -s https://weka-mcp.ademartutor.com/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Body fields:

• jsonrpc is always "2.0".
• id is any number or string. The response echoes it back, so you can match replies to requests.
• method is tools/list or tools/call. ping and initialize also answer; prompts/* and resources/* return Method not found.
• params is required for tools/call and carries name plus arguments.
• arguments is required even when the tool takes none. Send {}, not nothing, or the call fails validation.

Save yourself the retyping

Since only the body changes, wrap everything else in a shell function. Paste this once into bash or zsh and the examples below stay short:

weka() {
  curl -s https://weka-mcp.ademartutor.com/mcp \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json, text/event-stream' \
    -d "$1"
}

Things to call

These are not steps. Run any one of them on its own, in any order. None of them takes arguments, so they work no matter what state the server is in:

# every tool name
weka '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | jq -r '.result.tools[].name'

# is the server awake?
weka '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"weka_health","arguments":{}}}' | jq -r '.result.content[0].text'
{ "status": "ok", "wekaVersion": "3.9.6" }

# which datasets are uploaded?
weka '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"weka_list_datasets","arguments":{}}}' | jq -r '.result.content[0].text'

# which models are trained?
weka '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"weka_list_models","arguments":{}}}' | jq -r '.result.content[0].text'

Passing arguments

Tools that need input read it from params.arguments. Each tool's inputSchema, in the tools/list output, tells you which fields it expects. Swap the placeholders below for real names from the two list calls above. This is a public sandbox, so what's on it depends on who used it last:

weka '{"jsonrpc":"2.0","id":5,"method":"tools/call","params":{"name":"weka_evaluate",
       "arguments":{"model":"YOUR_MODEL","dataset":"YOUR_DATASET",
                    "method":"cross_validation","folds":10}}}' | jq -r '.result.content[0].text'

Reading a result

Results come back double wrapped. The payload you want is a JSON string sitting inside result.content[0].text, rather than JSON at the top level. That is why every example above ends in jq -r. To pull out a single field, decode it twice:

weka '{"jsonrpc":"2.0","id":6,"method":"tools/call","params":{"name":"weka_health","arguments":{}}}' \
  | jq -r '.result.content[0].text' | jq -r '.wekaVersion'
3.9.6

Reading an error

A tool call that fails still comes back as HTTP 200, so don't go by the status code. Check result.isError instead. When it is true, the text payload holds the details:

{
  "code": "DATASET_NOT_FOUND",
  "technicalMessage": "dataset not found: does-not-exist",
  "userMessage": "The dataset could not be found.",
  "recoverable": false,
  "allowedRecoveries": ["stop"]
}

Two responses that look like bugs but aren't

• 406 Not Acceptable means your Accept header didn't name both application/json and text/event-stream. Listing only one of them still fails.
• 404 on a GET is expected. There is no stream to subscribe to, so every call has to be a POST.