How to Connect MyNextRow to Claude Desktop and Cursor

The context

Ask a general AI assistant "how hard did I train last week?" and you get a general answer. The assistant has never seen your Concept2 logbook, so it has no idea whether Tuesday was a steady 30 minutes or an hour of intervals, what your splits have been doing, or how many days in a row you have actually rowed.

That is not a prompting failure. It is a plumbing gap, and the plumbing has a name. The Model Context Protocol (MCP) is an open standard for connecting AI applications to external systems, and the protocol's own introduction names Claude, Cursor and VS Code among the applications that speak it ([2] Model Context Protocol 2025). Anthropic open-sourced the protocol in late 2024 precisely so that an assistant could reach the systems where data lives, rather than having that data pasted in by hand every time ([1] Anthropic 2024).

What follows is narrow and mechanical. You run one small program on your own machine, give it a key, and point a client at it. There is no model to train, no plugin to write, and no account to hand over. When it works, your assistant can answer questions grounded in your own rowing. When it does not, the failure has a name, a log file and a fix.

The core idea

Three parts, and almost every setup failure is one of the three being wrong.

The client is the application you talk to — Claude Desktop, Cursor, or any other MCP client. The server is a program running on your own machine. The tools are the named functions that server publishes, each with a name, a description and a schema for its arguments ([6] Model Context Protocol 2025).

The protocol's architecture page makes the relationship concrete: an MCP host creates one MCP client for each server it connects to, and a local server speaking stdio typically serves a single client at a time ([4] Model Context Protocol 2025).

The transport is stdio. The client starts the server as a child process and talks to it over standard input and standard output, one JSON-RPC message per line. The rule that catches people out is short: a stdio server must not write anything to standard output that is not an MCP message, so everything else, logs included, goes to standard error ([5] Model Context Protocol 2025).

MyNextRow's server is exactly this shape. It ships as a Node program, @mynextrow/mcp-server, and the first thing it does at startup is look for MYNEXTROW_API_KEY in the environment. If that variable is missing it prints an error and exits, which is why a blank key shows up as a server that never starts rather than as a tool that returns nothing.

The tools it publishes split into two kinds. Most are reads that return rows out of your own data: your athlete profile, your training load, your recent workouts, your technique and streak, your Concept2 connection status, your credit balance, and a validator for a workout you have in mind. Two are prescriptive — asking the coach a question, and generating a workout — and each of those spends a credit ([8] MyNextRow 2026).

The how-to

Before you start: the packaged server is not on npm yet. @mynextrow/mcp-server is written, tested and ready, but it has not been published to the npm registry, so the npx command in the steps below fails with a 404 until it is. Everything else on this page — the key, the configuration file, the restart, the logs, the failure modes — is exactly as it will be when it does, and the whole of it is worth reading now. If you are here to use it today, one line settles it: npm view @mynextrow/mcp-server version returns a 404. If it returns a version number, the package is there and everything below works as written.

1. Make the key

Log in to MyNextRow and open Settings. Scroll to the Model Context Protocol (MCP) & API Keys card and use the Create Personal Access Token panel to generate a key. Copy it straight away: the card puts it on screen once, with a warning that you will not be able to see it again. The same card hands you a ready-made configuration snippet for Claude and one for Cursor, and a button that masks the key in the snippet so you can share the block without sharing the secret.

2. Claude Desktop

Claude Desktop launches local MCP servers from a JSON file. Open the Claude menu, choose Settings…, go to the Developer tab and press Edit Config. The file is ~/Library/Application Support/Claude/claude_desktop_config.json on macOS and %APPDATA%\Claude\claude_desktop_config.json on Windows ([3] Model Context Protocol 2025). Add the server under the mcpServers key:

{
  "mcpServers": {
    "mynextrow": {
      "command": "npx",
      "args": ["-y", "@mynextrow/mcp-server"],
      "env": {
        "MYNEXTROW_API_KEY": "PASTE_YOUR_KEY_HERE"
      }
    }
  }
}

Save it, then quit Claude Desktop completely and restart it. The application has to restart to load the new configuration and start the server, and once it is up the connectors indicator in the bottom-left corner of the conversation input box is where you check that it connected ([3] Model Context Protocol 2025).

3. Cursor

Cursor takes the same three fields — a command, its arguments, and environment variables — from its own file. Its documentation says to install and manage MCP servers from the Customize page, or to configure them in mcp.json, and that the file lives at .cursor/mcp.json for a single project or ~/.cursor/mcp.json for all of them ([7] Cursor 2025):

{
  "mcpServers": {
    "mynextrow": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@mynextrow/mcp-server"],
      "env": {
        "MYNEXTROW_API_KEY": "PASTE_YOUR_KEY_HERE"
      }
    }
  }
}

Cursor passes API keys and tokens through the config's environment variables, and its own guidance for MCP servers is to keep secrets there rather than hard-coding them, and to run sensitive servers locally over stdio ([7] Cursor 2025).

4. Prove it

Do not open with a workout request. Open with a read. Ask the client for your training load and have it call the training-load tool. Reads cost nothing, so if your own numbers come back, the whole chain — client, transport, key, API — is working ([8] MyNextRow 2026).

The number you get back is worth understanding. MyNextRow's coach works from four load numbers read off your logbook: chronic training load, acute training load, training stress balance, and the acute-to-chronic workload ratio ([9] MyNextRow 2026). A tool handing you those four is not a summary of your training. It is the same starting material the coach reasons from.

The trade-offs

What the tool can and cannot see

The tools return data. The coach reasons over it, and the gap between those two things is where a connected assistant earns or loses its keep.

A training-load tool can hand back a workload ratio. It cannot tell you whether that ratio is the reason today should be an easy row, because that decision needs the rest of your week: the Tuesday you missed, the four hours of sleep, the back that is still sore. Any coaching relationship is judged on whether it absorbs real-life variance rather than reporting numbers back at you ([10] MyNextRow 2026).

The four ways it breaks

The server never starts. Usually the environment variable: the server exits immediately if MYNEXTROW_API_KEY is absent, and on Windows a config that points at %APPDATA% can fail with an expansion error that needs the expanded path pasted into the env block instead ([3] Model Context Protocol 2025). There is another cause as well, and it is the runtime. npx needs Node installed, and it can keep failing if npm was never installed globally ([3] Model Context Protocol 2025).

There is one cause that sits in front of both of those, and it is the one to check first. If the package has not been published to npm, npx cannot fetch it and the server never gets far enough to read your key, look at your Node installation or write anything at all: it fails at the download. The symptom is the same from the outside — the server never starts, the log file is empty, the connector never appears — but the cause is different, and no amount of fixing the key or the runtime will change it. The way to tell the two apart is to run the command by hand in a terminal and read what it prints. A missing package says so, in as many words, and it names the package it could not find. An empty terminal and no output at all means the server started and exited on the key. If you would rather not run the command by hand, npm view @mynextrow/mcp-server version is the one-line check: a version number means the package is there and the problem is yours, and a 404 means it is not there yet and nothing you change will fix it.

The client cannot find it. Claude Desktop only reads its configuration when it starts, so a saved file with no restart is an invisible server. Cursor isolates a server that fails, leaves the others running, and marks the failed tool call as failed in the chat ([7] Cursor 2025).

The tool returns nothing. Read the logs before you change anything. In Claude Desktop the MCP logs live in ~/Library/Logs/Claude on macOS and %APPDATA%\Claude\logs on Windows, and the file named after your server holds that server's standard error, which for a stdio server means all of its logging rather than only failures ([3] Model Context Protocol 2025). An empty log file means the server never ran. A log full of authentication errors means the key is wrong. If the file tells you nothing, run the server yourself from a terminal and read what it prints.

The session is not authenticated. A valid key is not a login. Your Concept2 link and your MyNextRow account live behind the API, so a good key with an unlinked logbook returns reads with holes in them rather than an error you can see. The connection-status tool exists for exactly this question, it reports whether your logbook is linked and reachable, and asking it is free ([8] MyNextRow 2026).

The failure that is not a failure

If the reply says you are out of credits, the connection is working. The tool spent a credit, and your credits are shared between the web app and the client you are connected to ([8] MyNextRow 2026).

Keeping the key yours

The key belongs in your client's configuration file and nowhere else. Do not commit a file containing MYNEXTROW_API_KEY to a public repository, and revoke any key that has ended up in a screenshot, a chat or a support ticket. The Privacy Policy covers what MyNextRow does with your data; this guide only covers what your key can reach.

What to do tomorrow

1. Make the key, put it somewhere safe, and do not paste it into the assistant. It is a credential, not a prompt.
2. Configure one client, not two. Claude Desktop is the quicker of the two because the Settings card hands you the exact block to paste. Get that one answering a read before you touch anything else.
3. Verify with a read, not a prescription. "What are my current training load numbers?" costs nothing and proves the whole chain in one question.
4. Then ask a real question. "What did I actually do last Tuesday, and what does it mean for today?" is the prompt that shows what the connection bought you. A vague question gets a vague answer from any assistant, connected or not. Cursor's own guidance is to name the tool you want or describe precisely what you need, because the model picks tools from what you give it ([7] Cursor 2025).
5. When something breaks, read the MCP log first. In Cursor that is the MCP Logs channel in the Output panel, which shows server initialisation, tool calls and errors ([7] Cursor 2025). The server tells you what it thinks is wrong; guessing from the chat window wastes the fastest diagnostic you have.