# MCP Server Setup

Connect the JondaX MCP server to your AI assistant in a few minutes. The server runs locally via `npx`, so there's nothing to install or host yourself.

## Prerequisites

| Requirement | Notes |
|  --- | --- |
| **Node.js 18+** | The server runs on Node via `npx`. Check with `node --version`. |
| **A JondaX API key** | Get it from the **Integration** section in the [JondaX client portal](https://app.jondax.eu). See [Authentication](/docs/authentication). |
| **An MCP-compatible AI tool** | Any client that supports local (stdio) MCP servers — see the full list in the [Overview](/docs/mcp/overview#supported-ai-clients). |


## Configuration

Every MCP client uses the same underlying command and environment variables — only the location of the config file differs.

| Environment variable | Required | Default | Description |
|  --- | --- | --- | --- |
| `JONDAX_API_KEY` | Yes | — | Your JondaX API token (`jondax_...`). |
| `JONDAX_BASE_URL` | No | `https://app.jondax.eu` | JondaX API base URL. Only change this if directed to a different environment. |


The server is published as [`@jondax/mcp-server`](https://www.npmjs.com/package/@jondax/mcp-server) and launched with `npx -y @jondax/mcp-server`.

## Add JondaX to your AI tool

Claude Desktop
Edit `claude_desktop_config.json`:

- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`


```json
{
  "mcpServers": {
    "jondax": {
      "command": "npx",
      "args": ["-y", "@jondax/mcp-server"],
      "env": {
        "JONDAX_API_KEY": "YOUR_JONDAX_API_KEY",
        "JONDAX_BASE_URL": "https://app.jondax.eu"
      }
    }
  }
}
```

Restart Claude Desktop after saving. The JondaX tools appear in the tools menu once the server connects.

Cursor / Antigravity / Windsurf
Add the server to your MCP config (`mcp.json` / `mcp_config.json`, or the MCP settings panel):

```json
{
  "mcpServers": {
    "jondax": {
      "command": "npx",
      "args": ["-y", "@jondax/mcp-server"],
      "env": {
        "JONDAX_API_KEY": "YOUR_JONDAX_API_KEY",
        "JONDAX_BASE_URL": "https://app.jondax.eu"
      }
    }
  }
}
```

Reload the window (or reconnect the MCP server) so the JondaX tools become available.

Gemini CLI
Edit `~/.gemini/settings.json` (or a project-level `.gemini/settings.json`):

```json
{
  "mcpServers": {
    "jondax": {
      "command": "npx",
      "args": ["-y", "@jondax/mcp-server"],
      "env": {
        "JONDAX_API_KEY": "YOUR_JONDAX_API_KEY",
        "JONDAX_BASE_URL": "https://app.jondax.eu"
      }
    }
  }
}
```

Gemini CLI only launches local MCP servers from trusted folders, so mark the folder as trusted if prompted.

OpenAI Codex CLI
Codex CLI uses TOML, not JSON. Add this to `~/.codex/config.toml`:

```toml
[mcp_servers.jondax]
command = "npx"
args = ["-y", "@jondax/mcp-server"]
env = { JONDAX_API_KEY = "YOUR_JONDAX_API_KEY", JONDAX_BASE_URL = "https://app.jondax.eu" }
```

The tools become available the next time you start Codex CLI.

Other MCP clients
Every stdio-capable client uses the same server definition — only the config file location differs. Provide:

- **Command**: `npx`
- **Args**: `["-y", "@jondax/mcp-server"]`
- **Env**: `JONDAX_API_KEY` (and optionally `JONDAX_BASE_URL`)


See the config-location table below for where your specific client keeps this, and consult your client's docs if it isn't listed.

## Where each client stores its config

The server definition is identical everywhere — the same `mcpServers` block with `command`, `args`, and `env`. Only the location changes:

| AI client | Config location |
|  --- | --- |
| Claude Desktop | `claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/`, Windows: `%APPDATA%\Claude\`) |
| Claude Code | `.mcp.json` in the project root, or via `claude mcp add` |
| Kiro | `.kiro/settings/mcp.json` (workspace) or `~/.kiro/settings/mcp.json` (user) |
| Cursor | `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global) |
| Google Antigravity | MCP settings panel / `mcp_config.json` |
| Windsurf | `~/.codeium/windsurf/mcp_config.json` |
| VS Code (GitHub Copilot) | `.vscode/mcp.json` (workspace) or user settings |
| JetBrains AI Assistant | Settings → Tools → AI Assistant → MCP |
| Zed | `settings.json` under `context_servers` |
| Cline | MCP Servers panel in the extension |
| Continue | `~/.continue/config.yaml` |
| Gemini CLI | `~/.gemini/settings.json` (or project `.gemini/settings.json`) |
| OpenAI Codex CLI | `~/.codex/config.toml` (`[mcp_servers.jondax]`) |
| Amazon Q Developer CLI | `~/.aws/amazonq/mcp.json` |


> Config file names and locations change as clients evolve. If yours differs, check the client's own MCP documentation — the JondaX server definition stays the same.


## Let your AI agent set it up

Many agentic tools can configure the JondaX server for you — just ask. This works with clients that can edit their own MCP config or run shell commands, such as Kiro, Claude Code, Cursor, Windsurf, VS Code Copilot, Gemini CLI, and Codex CLI. Desktop apps like Claude Desktop keep their config behind app settings, so use the manual steps above for those.

Example prompt:

> "Add the JondaX MCP server to my MCP config. Use `npx -y @jondax/mcp-server` and set the `JONDAX_API_KEY` environment variable. Leave the key as a placeholder — I'll fill it in myself."


The agent will write a working baseline like this:

```json
{
  "mcpServers": {
    "jondax": {
      "command": "npx",
      "args": ["-y", "@jondax/mcp-server"],
      "env": {
        "JONDAX_API_KEY": "<YOUR_JONDAX_API_KEY>",
        "JONDAX_BASE_URL": "https://app.jondax.eu"
      }
    }
  }
}
```

A few things to check afterwards:

- **Don't paste your API key into the chat.** Have the agent leave a placeholder (or reference the `JONDAX_API_KEY` environment variable), then add the real key yourself. Pasted keys can persist in chat history.
- Agents often write a minimal config and omit `JONDAX_BASE_URL` — that's fine (it defaults to `https://app.jondax.eu`), but add it if you're pointing at a different environment.
- Restart or reload your client after the config is written so the JondaX tools load.


> **Keep your key private.** Treat `JONDAX_API_KEY` like a password. Don't commit config files containing your key to version control. See [Authentication](/docs/authentication) for key handling rules.


## Verify the connection

Once configured, ask your assistant to list its available tools, or try a simple call:

> "Using JondaX, upload this file and give me the uploadId: /path/to/lab-report.pdf"


If the tools are connected, the assistant runs `upload_pathology_scan` and returns an `uploadId`. If it can't find the tools, check that the server is enabled in your client and that the config file is valid JSON.

## Local development

If you're contributing to or building the server from source:

```bash
git clone https://github.com/JondaHealthTech/jondax-mcp-server.git
cd jondax-mcp-server
npm install
npm run build
```

Then point your MCP client at the local build (`node dist/index.js`) instead of the published package.

## Next steps

- Explore the full [Tools reference](/docs/mcp/tools) for parameters and examples.
- Review [File Requirements](/docs/pathology/file-requirements) for supported inputs.
- Configure a [Callback endpoint](/docs/pathology/callback-config) if you want pathology results delivered to your server automatically.