Connect your client

Add https://api.samsa.ai/mcp to your client below. Claude, ChatGPT, and Microsoft Copilot can sign in with OAuth; the remaining clients authenticate with an API key (Authorization: Bearer samsa_sk_…).

The API-key snippets below show the key inline for readability. In any config that is committed or shared, don’t store a real key — use your client’s environment-variable interpolation (shown for Claude Code, Cursor, and VS Code) or keep the config user-level. A leaked samsa_sk_… should be revoked immediately.

Claude (web and desktop) connects to remote MCP servers as a custom connector:

Add the connector

Open Settings → Connectors → Add custom connector and set the URL to https://api.samsa.ai/mcp.

Claude opens Samsa’s OAuth sign-in; sign in and approve the consent screen. Claude’s tools list then shows the Samsa tools.

Exact menu labels vary by version — the essentials are the custom-connector flow and the Samsa server URL. Claude web calls /mcp from the browser with Origin: https://claude.ai, which Samsa allows, so discovery and sign-in work without extra configuration. On desktop, follow Anthropic’s current connector instructions and use the same server URL.

Enable developer mode

In ChatGPT, open Settings → Apps & Connectors and enable developer mode.

Add the connection

Add an app / MCP connection with the URL https://api.samsa.ai/mcp.

ChatGPT runs the OAuth 2.1 sign-in and consent; approve it to expose the Samsa tools.

Exact menu labels vary by version — the essentials are enabling developer mode and adding the Samsa server URL. Custom MCP connections require a ChatGPT plan that includes developer mode / connectors; availability changes over time, so check your plan if the option is missing. ChatGPT calls /mcp with Origin: https://chatgpt.com (or https://chat.openai.com), both of which Samsa allows.

Microsoft connects MCP servers through Copilot Studio. Add Samsa there once, then publish the agent to the Microsoft 365 Copilot and Teams channel so your organization uses it from Copilot chat and Teams.

Add the server

On your agent’s Tools page, select Add a tool → New tool → Model Context Protocol. Set Server URL to https://api.samsa.ai/mcp and give the server a name and description.The agent’s orchestrator reads that description to decide when to call Samsa, so be concrete — for example, “Generates and edits images and video using the organization’s trained Samsa models.”

Pick an authentication type

Samsa works with either option the wizard offers:

OAuth 2.0 → Dynamic discovery — Samsa supports dynamic client registration with discovery, so Copilot Studio finds the endpoints and registers itself. Each user signs in with their own Samsa account and no key is shared.
API key — set Type to Header and the header name to Authorization. The connection value is Bearer samsa_sk_….

Create the connection

Select Create, then Create a new connection, then Add to agent.

Publish to Microsoft 365 Copilot

Publish the agent and, under Turn on Microsoft 365, select Make agent available in Microsoft 365 Copilot. Users then reach Samsa from the Microsoft 365 Copilot app and Teams.

Copilot Studio supports the Streamable transport, which is what Samsa serves. Access to MCP servers runs through Power Platform connectors, so any data policy governing those also governs Samsa’s tools.Microsoft 365 Copilot’s federated connectors are a different feature, scoped to read-only data retrieval. Samsa’s generation tools are added through Copilot Studio as above.

API key · verifiedAdd the server with the HTTP transport and a Bearer header:

claude mcp add --transport http samsa https://api.samsa.ai/mcp \
  --header "Authorization: Bearer samsa_sk_..."

By default this registers the server for your own use (local scope). To share it with your team, add --scope project and Claude Code writes a project .mcp.json. Because that file is committed, keep the key out of it — Claude Code expands environment variables in headers:

{
  "mcpServers": {
    "samsa": {
      "type": "http",
      "url": "https://api.samsa.ai/mcp",
      "headers": { "Authorization": "Bearer ${SAMSA_API_KEY}" }
    }
  }
}

Confirm the connection with claude mcp get samsa — it should report Connected.Prefer OAuth? Run claude mcp add --transport http samsa https://api.samsa.ai/mcp without the header and complete the OAuth sign-in on first use.

Add to ~/.cursor/mcp.json (global) or project .cursor/mcp.json. Cursor interpolates environment variables in headers, so reference the key rather than inlining it in a shared file:

{
  "mcpServers": {
    "samsa": {
      "url": "https://api.samsa.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SAMSA_API_KEY}" }
    }
  }
}

Add to .vscode/mcp.json:

{
  "servers": {
    "samsa": {
      "type": "http",
      "url": "https://api.samsa.ai/mcp",
      "headers": { "Authorization": "Bearer samsa_sk_..." }
    }
  }
}

Don’t commit a real key in a workspace file. VS Code supports ${input:...} variables and user-level MCP config — use one of those so the secret isn’t checked in with your project.

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "samsa": {
      "serverUrl": "https://api.samsa.ai/mcp",
      "headers": { "Authorization": "Bearer samsa_sk_..." }
    }
  }
}

Codex (OpenAI)

Add to ~/.codex/config.toml:

[mcp_servers.samsa]
url = "https://api.samsa.ai/mcp"
http_headers = { Authorization = "Bearer samsa_sk_..." }

n8n — MCP Client node

In the MCP Client node, set:

Endpoint — https://api.samsa.ai/mcp
Transport — HTTP Streamable
Authentication — Header Auth with Authorization: Bearer samsa_sk_...

n8n runs server-side (no browser Origin header), so it connects without any extra configuration.

Gemini CLI

Add an HTTP MCP server to ~/.gemini/settings.json. Config key names differ across Gemini CLI versions — confirm against the current Gemini CLI MCP docs — but the shape is the Samsa URL plus a Bearer header:

{
  "mcpServers": {
    "samsa": {
      "httpUrl": "https://api.samsa.ai/mcp",
      "headers": { "Authorization": "Bearer samsa_sk_..." }
    }
  }
}

Test it — MCP Inspector

To verify the server from a neutral tool, use the MCP Inspector. Drive it from the GUI (or a config file) with the Streamable-HTTP transport:

{
  "mcpServers": {
    "samsa": {
      "type": "streamable-http",
      "url": "https://api.samsa.ai/mcp",
      "headers": { "Authorization": "Bearer samsa_sk_..." }
    }
  }
}

The Inspector uses the same Streamable-HTTP transport Samsa verifies against, and runs on http://localhost:6274, which Samsa allows. Use it to walk the handshake, list the fifteen tools, and make a test call.

Config snippets for Claude Code, Cursor, VS Code, Windsurf, Codex, n8n, Claude web, ChatGPT, and the MCP Inspector come from Samsa’s backend client-config verification matrix. If a step is off, email support@samsa.ai and we’ll fix it fast.