Connect Navo24 to any AI assistant

Some assistants list Navo24 in their own connector directory. The rest let you add a remote MCP server by hand. This page covers the second group: one server address, two ways to sign in, and the exact steps for each assistant.

What you connect

Setting	Value
Server	https://mcp.trackingmcp.com/mcp
Transport	Streamable HTTP
Sign-in	API key (Authorization: Bearer tmcp_…) or your TrackingMCP account (OAuth)

The server is TrackingMCP, the same one behind the TrackingMCP connector in Claude. It offers seven tools:

Tool	What it does
get_shipment_summary	Your portfolio at a glance: active, exceptions, arriving soon, demurrage risk
get_container_detail	Status, route, events, vessel and ETA for one container. A number your account does not track yet is added to tracking and counts toward your plan
get_vessel_position	Last known AIS position of a vessel, with the age of the fix
get_demurrage_report	Containers near or past their free days, with projected cost
get_port_congestion	Wait times and congestion level at one or more ports
add_container	Start tracking a container or bill of lading
get_demurrage_free_time	Free days a carrier gives at a port before charges start

Two ways to sign in

API key. Works in every client on this page. Sign up at trackingmcp.com, open the developer settings and mint a key. It starts with tmcp_. The client sends it as Authorization: Bearer tmcp_YOUR_API_KEY. Where a client can read the key from an environment variable, the examples below do that. Where it cannot, the key sits in that client’s config file, so keep the file private.

TrackingMCP account (OAuth). The client opens a browser, you sign in to TrackingMCP and approve access, and no key is stored by hand. Clients that support OAuth find the sign-in server on their own from the server’s response. If a client cannot complete the sign-in, use the API key instead.

Every section below follows the same pattern: where to add the server, how to sign in, and one question to check it works. The check question is the same everywhere:

Use TrackingMCP to summarise my tracked shipments.

The assistant should call get_shipment_summary and answer with your container counts. A new account with no containers yet answers with zeros, which still proves the connection.

Kimi Code

Kimi Code is Moonshot AI’s coding agent. It comes as a terminal app (CLI), a desktop app and a VS Code extension. The kimi.com chat does not document custom MCP servers, so connect through Kimi Code.

Where to add it. The CLI and the desktop app share one file, ~/.kimi-code/mcp.json. You can edit it directly, or run /mcp-config inside the CLI to add the server interactively. In the VS Code extension, open the gear menu and choose MCP Servers.

Sign in with an API key. Add this entry to ~/.kimi-code/mcp.json:

{
  "mcpServers": {
    "trackingmcp": {
      "url": "https://mcp.trackingmcp.com/mcp",
      "bearerTokenEnvVar": "TRACKINGMCP_API_KEY"
    }
  }
}

Then set the key in the terminal you start the CLI from:

export TRACKINGMCP_API_KEY=tmcp_YOUR_API_KEY

A desktop app opened from the Dock or Start menu does not see that variable, so in the desktop app and in VS Code sign in with your TrackingMCP account instead.

Sign in with your TrackingMCP account. Leave out bearerTokenEnvVar and run /mcp-config login trackingmcp in the CLI. In the VS Code extension, add an http server with the address above and press Authorize.

Check it works. Start a new session (open sessions do not pick up new servers), run /mcp to see the connection status, then ask the check question.

Source: Kimi Code docs for the CLI, the desktop app and VS Code.

Qwen Code

Qwen Code is the Qwen team’s terminal coding agent. This page covers Qwen Code.

Where to add it. Run qwen mcp add in a terminal. It writes the server to ~/.qwen/settings.json. Add --scope project to keep it in the current project’s .qwen/settings.json instead.

Sign in with an API key.

qwen mcp add --transport http trackingmcp https://mcp.trackingmcp.com/mcp \
  --header "Authorization: Bearer tmcp_YOUR_API_KEY"

The same entry written by hand in settings.json:

{
  "mcpServers": {
    "trackingmcp": {
      "httpUrl": "https://mcp.trackingmcp.com/mcp",
      "headers": { "Authorization": "Bearer tmcp_YOUR_API_KEY" }
    }
  }
}

Sign in with your TrackingMCP account. Add the server without --header. On the first connection Qwen Code opens a browser for the TrackingMCP sign-in. It listens for the answer on http://localhost:7777/oauth/callback, so run it on a machine with a browser. Use the /mcp dialog to see or reset the sign-in.

Check it works. Start qwen, run /mcp to confirm trackingmcp is connected, then ask the check question.

Source: Qwen Code MCP docs and the MCP server reference.

DeepSeek

The DeepSeek chat app does not offer MCP connectors. DeepSeek documents its models inside agent apps instead, and those apps do support MCP. Pick one of the two below, choose a DeepSeek model in it, and add the Navo24 server. The assistant then runs on DeepSeek and calls our tools.

OpenCode

OpenCode is an open-source coding agent for the terminal. DeepSeek lists it in its agent integrations.

Choose the DeepSeek model. Run opencode, type /connect, pick deepseek, paste your DeepSeek API key and select the DeepSeek-V4-Flash model.

Where to add it. opencode.json in your project, or ~/.config/opencode/opencode.json for every project.

Sign in with an API key. oauth: false stops OpenCode from starting a browser sign-in, and {env:…} reads the key from your environment:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "trackingmcp": {
      "type": "remote",
      "url": "https://mcp.trackingmcp.com/mcp",
      "oauth": false,
      "headers": { "Authorization": "Bearer {env:TRACKINGMCP_API_KEY}" }
    }
  }
}

Sign in with your TrackingMCP account. Keep only type and url, then run opencode mcp auth trackingmcp. OpenCode registers itself, opens the browser and stores the token.

Check it works. opencode mcp list shows the server and its sign-in status. Then ask the check question.

Source: OpenCode MCP servers.

Claude Code on a DeepSeek model

DeepSeek offers an Anthropic-compatible API and a setup guide for Claude Code. Claude Code connects to MCP servers itself, so our tools work while the model is DeepSeek.

Choose the DeepSeek model. Set these before you start claude. deepseek-flash is the API name of DeepSeek-V4-Flash, and DeepSeek’s guide lists further variables.

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=YOUR_DEEPSEEK_API_KEY
export ANTHROPIC_MODEL=deepseek-flash

Where to add it. Run claude mcp add in a terminal. Add --scope user to use the server in every project.

Sign in with an API key.

claude mcp add --transport http trackingmcp https://mcp.trackingmcp.com/mcp \
  --header "Authorization: Bearer tmcp_YOUR_API_KEY"

Sign in with your TrackingMCP account. Add the server without --header, start claude, run /mcp, choose trackingmcp and sign in in the browser.

Check it works. /mcp lists trackingmcp as connected. Then ask the check question.

Source: Claude Code MCP docs.

Any other MCP client

Most MCP clients take a remote server as a URL plus optional headers. The usual shape:

{
  "mcpServers": {
    "trackingmcp": {
      "url": "https://mcp.trackingmcp.com/mcp",
      "headers": { "Authorization": "Bearer tmcp_YOUR_API_KEY" }
    }
  }
}

Field names differ between clients (url, httpUrl, serverUrl), so check your client’s docs for remote or Streamable HTTP servers. If your client supports OAuth, leave out headers and it will offer the TrackingMCP sign-in.

A client that only runs local stdio servers can reach us through mcp-remote:

{
  "mcpServers": {
    "trackingmcp": {
      "command": "npx",
      "args": ["mcp-remote", "https://mcp.trackingmcp.com/mcp",
               "--header", "Authorization: Bearer tmcp_YOUR_API_KEY"]
    }
  }
}

Then ask the check question. For the other Navo24 servers and REST, see the MCP quickstart.