> For the complete documentation index, see [llms.txt](https://notara.gitbook.io/notara-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://notara.gitbook.io/notara-docs/mcp/other-clients.md).

# Other MCP Clients

Any client that speaks the Model Context Protocol can connect to Notara. This guide covers the general connection pattern for clients not specifically listed.

## Connection Details

| Parameter          | Value                                             |
| ------------------ | ------------------------------------------------- |
| **Transport**      | SSE (Server-Sent Events)                          |
| **Endpoint URL**   | `https://app.notara.ai/mcp/g/<workspace>/<group>` |
| **Authentication** | `Authorization: Bearer <token>` header            |
| **Protocol**       | MCP 2024-11                                       |

Your specific endpoint URL and token are available in the dashboard under **Connect → MCP Endpoints**.

## General HTTP Pattern

If your MCP client requires manual configuration, here's the request pattern:

```
GET https://app.notara.ai/mcp/g/acme/engineering
Authorization: Bearer ntr_your_token_here
Accept: text/event-stream
```

The SSE stream returns MCP protocol messages. Your client should handle the standard MCP handshake (initialize → initialized → tools/list, etc.).

## Example: Custom Agent (Node.js)

Using the `@modelcontextprotocol/sdk` package:

```typescript
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

const transport = new SSEClientTransport(
  new URL("https://app.notara.ai/mcp/g/acme/engineering"),
  {
    headers: {
      Authorization: "Bearer ntr_your_token_here",
    },
  }
);

const client = new Client({ name: "my-agent", version: "1.0.0" }, {});
await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log(tools.map(t => t.name));

// Call a tool
const result = await client.callTool({
  name: "linear_search_issues",
  arguments: { query: "auth timeout", limit: 5 },
});
```

## What's Exposed

### Tools

All connector tools the group has access to, subject to tool permission filtering. Tools are built from a persisted cache — not a live fetch — so they're fast and consistent on every agent turn.

Tool names follow the pattern `<connector>_<action>`, for example:

* `linear_search_issues`
* `linear_create_issue`
* `github_list_repos`
* `slack_post_message`
* `stripe_get_customer`
* `search_context` (built-in context search)
* `read_context_document` (built-in document reader)

### Resources

Context documents from the group's libraries, accessible as MCP resources. Spine and on-demand documents are exposed; documents with `never` load policy are excluded.

### Prompts

Skills in the group's skill library are exposed as MCP prompts. You can list them via `prompts/list` and fetch them via `prompts/get`. When you `prompts/get` a skill, you receive the full prompt text and any bundled assets.

## Tool Permissions for MCP Callers

MCP callers are subject to the same permission system as Slack users:

| Tool Capability | Default Behavior for MCP Callers                         |
| --------------- | -------------------------------------------------------- |
| `read`          | Executes immediately                                     |
| `write`         | Queued for admin approval (same Block Kit flow as Slack) |
| `destructive`   | Requires explicit confirmation (synchronous response)    |

**Important:** MCP callers are never treated as system actors. The automatic bypass that applies to scheduled tasks (where an admin authorized the task at config time) does NOT apply to MCP tokens. Every write and destructive call requires the appropriate approval.

### Unlabeled Remote Tools

If your group uses a **Remote MCP Connector** (a third-party MCP server plugged into Notara), any tools from that server that don't have an explicit capability label default to `write → requires_approval`. This is a deliberate safe default — you can loosen it per-tool from the permissions dashboard, but the initial posture is conservative.

## Security Notes

* **Token scope:** each token is scoped to a single group endpoint. A token for the `engineering` group cannot access the `marketing` group's endpoint.
* **Token revocation:** tokens can be revoked instantly from **Connect → MCP Endpoints**. There is no expiry by default.
* **SSRF protection:** Notara validates all MCP endpoint URLs against an allowlist at save time. Inbound webhook and remote MCP URLs are checked against a DNS rebinding guard.
* **Multi-instance:** MCP sessions are currently process-local. If you run multiple Notara server instances, use sticky routing on the `mcp-session-id` header to ensure session continuity.

## Troubleshooting

**401 Unauthorized:** your token is wrong or has been revoked. Regenerate from the dashboard.

**Empty tools list:** the group has no active connectors. Connect at least one tool from the dashboard before connecting an MCP client.

**SSE stream closes immediately:** check that your HTTP client supports streaming responses (chunked transfer encoding + `text/event-stream` content type). Some HTTP libraries buffer the full response before processing, which breaks SSE.

**Tool call returns "permission denied":** the tool's permission level doesn't allow the calling token's access level. Check the permissions dashboard and adjust the tool's permission level if appropriate.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://notara.gitbook.io/notara-docs/mcp/other-clients.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.