Client verbinden

Füge https://api.samsa.ai/mcp zu deinem Client unten hinzu. Claude, ChatGPT und Microsoft Copilot können sich mit OAuth anmelden; die übrigen Clients authentifizieren sich mit einem API key (Authorization: Bearer samsa_sk_…).

Die API-key-Snippets unten zeigen den Key aus Gründen der Lesbarkeit inline. In jeder Konfiguration, die committet oder geteilt wird, speichere keinen echten Key — verwende die Interpolation von Umgebungsvariablen deines Clients (gezeigt für Claude Code, Cursor und VS Code) oder halte die Konfiguration auf Benutzerebene. Ein geleakter samsa_sk_… sollte sofort widerrufen werden.

Claude (Web und Desktop) verbindet sich mit remote MCP servern als Custom Connector:

Füge den Connector hinzu

Öffne Settings → Connectors → Add custom connector und setze die URL auf https://api.samsa.ai/mcp.

Melde dich an

Claude öffnet Samsas OAuth-Login; melde dich an und bestätige den Consent-Screen. Claudes Tool-Liste zeigt dann die Samsa-Tools.

Die genauen Menü-Beschriftungen variieren je nach Version — das Wesentliche ist der Custom-Connector-Flow und die Samsa-Server-URL. Claude Web ruft /mcp aus dem Browser mit Origin: https://claude.ai auf, was Samsa erlaubt, sodass Discovery und Login ohne zusätzliche Konfiguration funktionieren. Folge auf dem Desktop Anthropics aktuellen Connector-Anweisungen und verwende dieselbe Server-URL.

Aktiviere den Developer-Modus

Öffne in ChatGPT Settings → Apps & Connectors und aktiviere den Developer-Modus.

Füge die Verbindung hinzu

Füge eine App-/MCP-Verbindung mit der URL https://api.samsa.ai/mcp hinzu.

Melde dich an

ChatGPT führt den OAuth 2.1-Login und -Consent aus; bestätige ihn, um die Samsa-Tools verfügbar zu machen.

Die genauen Menü-Beschriftungen variieren je nach Version — das Wesentliche ist das Aktivieren des Developer-Modus und das Hinzufügen der Samsa-Server-URL. Custom-MCP-Verbindungen erfordern einen ChatGPT-Plan, der Developer-Modus / Connectors umfasst; die Verfügbarkeit ändert sich mit der Zeit, prüfe also deinen Plan, wenn die Option fehlt. ChatGPT ruft /mcp mit Origin: https://chatgpt.com (oder https://chat.openai.com) auf, beide erlaubt Samsa.

Microsoft verbindet MCP server über Copilot Studio. Füge Samsa dort einmal hinzu und veröffentliche den Agent dann im Kanal Microsoft 365 Copilot und Teams, damit deine Organisation ihn aus Copilot Chat und Teams nutzt.

Server hinzufügen

Wähle auf der Seite Tools deines Agents Tool hinzufügen → Neues Tool → Model Context Protocol. Setze Server-URL auf https://api.samsa.ai/mcp und gib dem Server Namen und Beschreibung.Der Orchestrator des Agents liest diese Beschreibung, um zu entscheiden, wann er Samsa aufruft — sei also konkret, etwa „Erzeugt und bearbeitet Bilder und Video mit den trainierten Samsa-Modellen der Organisation.”

Authentifizierung wählen

Samsa funktioniert mit beiden Optionen des Assistenten:

OAuth 2.0 → Dynamic discovery — Samsa unterstützt Dynamic Client Registration mit Discovery, sodass Copilot Studio die Endpoints findet und sich selbst registriert. Jede Person meldet sich mit dem eigenen Samsa-Konto an, es wird kein Key geteilt.
API key — setze Typ auf Header und den Header-Namen auf Authorization. Der Wert der Verbindung ist Bearer samsa_sk_….

Verbindung erstellen

Wähle Erstellen, dann Neue Verbindung erstellen, dann Zum Agent hinzufügen.

In Microsoft 365 Copilot veröffentlichen

Veröffentliche den Agent und wähle unter Microsoft 365 aktivieren die Option Agent in Microsoft 365 Copilot verfügbar machen. Danach erreichen Nutzer Samsa aus der Microsoft-365-Copilot-App und aus Teams.

Copilot Studio unterstützt den Streamable-Transport, den Samsa bedient. Der Zugriff auf MCP server läuft über Power-Platform-Connectors — jede Data Policy, die diese regelt, regelt damit auch Samsas Tools.Die Federated Connectors von Microsoft 365 Copilot sind eine andere Funktion und auf lesenden Datenabruf beschränkt. Samsas Generierungs-Tools werden wie oben über Copilot Studio eingebunden.

API key · verifiziertFüge den Server mit dem HTTP-Transport und einem Bearer-Header hinzu:

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

Standardmäßig registriert das den Server für deine eigene Nutzung (local scope). Um ihn mit deinem Team zu teilen, füge --scope project hinzu, und Claude Code schreibt eine projektbezogene .mcp.json. Da diese Datei committet wird, halte den Key heraus — Claude Code expandiert Umgebungsvariablen in headers:

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

Bestätige die Verbindung mit claude mcp get samsa — sie sollte Connected melden.Lieber OAuth? Führe claude mcp add --transport http samsa https://api.samsa.ai/mcp ohne den Header aus und schließe den OAuth-Login bei der ersten Nutzung ab.

Füge zu ~/.cursor/mcp.json (global) oder zur projektbezogenen .cursor/mcp.json hinzu. Cursor interpoliert Umgebungsvariablen in headers, referenziere den Key also, statt ihn in einer geteilten Datei inline zu setzen:

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

Füge zu .vscode/mcp.json hinzu:

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

Committe keinen echten Key in einer Workspace-Datei. VS Code unterstützt ${input:...}-Variablen und MCP-Konfiguration auf Benutzerebene — verwende eine davon, damit das Secret nicht mit deinem Projekt eingecheckt wird.

Windsurf

Füge zu ~/.codeium/windsurf/mcp_config.json hinzu:

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

Codex (OpenAI)

Füge zu ~/.codex/config.toml hinzu:

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

n8n — MCP Client node

Setze im MCP Client-Node:

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

n8n läuft serverseitig (kein Browser-Origin-Header), verbindet sich also ohne jede zusätzliche Konfiguration.

Gemini CLI

Füge einen HTTP-MCP-server zu ~/.gemini/settings.json hinzu. Die Namen der Config-Keys unterscheiden sich zwischen Gemini-CLI-Versionen — prüfe sie gegen die aktuelle Gemini-CLI-MCP-Doku — aber die Form ist die Samsa-URL plus ein Bearer-Header:

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

Teste es — MCP Inspector

Um den Server von einem neutralen Tool aus zu verifizieren, verwende den MCP Inspector. Steuere ihn über die GUI (oder eine Config-Datei) mit dem Streamable-HTTP-Transport:

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

Der Inspector verwendet denselben Streamable-HTTP-Transport, gegen den Samsa verifiziert, und läuft auf http://localhost:6274, was Samsa erlaubt. Nutze ihn, um den Handshake durchzugehen, die fünfzehn Tools zu listen und einen Testaufruf zu machen.

Config-Snippets für Claude Code, Cursor, VS Code, Windsurf, Codex, n8n, Claude Web, ChatGPT und den MCP Inspector stammen aus Samsas Backend-Matrix zur Verifizierung der Client-Konfigurationen. Wenn ein Schritt daneben liegt, schreib an support@samsa.ai, und wir beheben es schnell.