How do I connect an MCP client that only supports stdio servers to a Tares HTTP endpoint?

Tares connects stdio-only MCP clients in two ways: run tares-mcp as the stdio server, or bridge to the HTTP endpoint with npx mcp-remote. Either way the client gets the same Tares tools and answers from the correlated timeline. Pick tares-mcp when the agent runs on the same machine as the daemon, and the bridge when you want to reach an HTTP endpoint.

How it works

The Tares MCP server supports two transports, and a stdio-only client can use either route to reach it.

• Native stdio with tares-mcp. The client spawns tares-mcp as a subprocess. It proxies to the Tares daemon at TARESD_URL. The tares-mcp command is installed with the tares package, so the package must be installed where the agent runs. This suits an agent on the same machine as the daemon, and you do not have to run the HTTP server.
• Bridge with mcp-remote. You set npx mcp-remote http://localhost:8788/mcp as the stdio command. The client talks stdio to the bridge, and the bridge talks to the HTTP endpoint. Use this when the endpoint is not on the client’s machine, because streamable HTTP is the only transport for remote instances.

The HTTP endpoint depends on where Tares runs. On your machine it is http://localhost:8788/mcp, and you start the MCP server first. On your own server it is your domain followed by /mcp. On Tares Cloud, the console shows it under Connect, and each instance has its own hostname.

On a secured instance (tares up --auth, every server and every Tares Cloud instance), the MCP surface needs a credential. Over stdio you set TARES_AUTH_TOKEN in the environment of tares-mcp. Over HTTP the client sends an Authorization Bearer header holding an API key. On an open instance started with plain tares up, no credential is needed. The full list of client configs is on the Connecting agents page.

Set it up

Option 1: tares-mcp over stdio

1. Install the tares package on the machine where the agent runs:

   uv tool install tares                # or: pipx install tares

2. Make sure the Tares daemon is running and reachable. On a local setup, start it with tares up. It listens on http://localhost:8787.

3. Add the Tares server to your client’s MCP config. Set TARESD_URL to the daemon address:

   {
     "mcpServers": {
       "tares": {
         "command": "tares-mcp",
         "env": {
           "TARESD_URL": "http://localhost:8787",
           "TARES_AUTH_TOKEN": "<api-key, only on a secured instance>"
         }
       }
     }
   }

4. On an open local instance, drop the TARES_AUTH_TOKEN line. On a secured instance, set it to an API key. Prefer a scoped key with the read scope over the root token. For an agent that should work inside one project only, use a project key instead. It reads that project and records findings in it, and nothing else.

Option 2: bridge with mcp-remote

1. Get your HTTP endpoint. Locally, start the MCP server as a second process, because the daemon alone does not serve /mcp:

   tares mcp --transport streamable-http --port 8788 --taresd http://localhost:8787

   On a server or Tares Cloud instance the MCP server is already running, so there is nothing to start.

2. In your client, register npx mcp-remote followed by your endpoint URL as the stdio command. Locally that is npx mcp-remote http://localhost:8788/mcp.

3. For a secured remote instance, the endpoint expects Authorization: Bearer with an API key. The console’s Connect page generates the exact commands with your endpoint and token filled in.

Verify

Ask your client:

Use tares: what are you ingesting right now?

The client should call catalog_list and answer with your sources, triggers and projects. In the console, Reads lists each read as it happens, tagged client = mcp.

What you get

• A stdio-only client that reads the same Tares tools as any HTTP client: read, catalog_list, catalog_describe and the rest.
• Answers from the correlated timeline, with logs, metrics, alerts and findings in one read. This is what makes the connection useful for the investigations described in AI SRE.
• A credential that matches your instance: no token on an open local instance, and an API key on a secured one. A project key keeps the agent inside one project.
• Visible reads in the console, so you can confirm the client is connected and see what it asked.

When something else fits

• If your client supports remote servers, skip both options and connect over streamable HTTP with the URL and an Authorization Bearer header. The Connecting agents page has the config for Claude Code, Codex, Cursor and others.
• If the agent runs on a different machine from the daemon, use the mcp-remote bridge, since tares-mcp is meant for an agent on the same machine as the daemon.
• If you only want to explore your data, the in-app Ask chat in the console needs no external client.

Related