> ## Documentation Index
> Fetch the complete documentation index at: https://docs.samsa.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Connecter ton client
> Configuration unique pour Claude, ChatGPT, Microsoft Copilot, Cursor, VS Code, n8n et plus.
Ajoute `https://api.samsa.ai/mcp` à ton client ci-dessous. **Claude**, **ChatGPT**
et **Microsoft Copilot** peuvent se connecter avec OAuth ; les autres clients
s'authentifient avec une [API key](/fr/guides/authentication)
(`Authorization: Bearer samsa_sk_…`).
Les snippets avec API key ci-dessous montrent la clé en clair pour la lisibilité.
Dans toute config commitée ou partagée, **ne stocke pas de vraie clé** — utilise
l'interpolation de variables d'environnement de ton client (montrée pour Claude
Code, Cursor et VS Code) ou garde la config au niveau utilisateur. Une clé
`samsa_sk_…` divulguée doit être
[révoquée](/fr/guides/authentication#faire-tourner-une-clé) immédiatement.
Claude (web et desktop) se connecte aux MCP servers distants comme un
**connecteur personnalisé** :
Ouvre **Settings → Connectors → Add custom connector** et définis l'URL sur
`https://api.samsa.ai/mcp`.
Claude ouvre la **connexion OAuth** de Samsa ; connecte-toi et approuve
l'écran de consentement. La liste d'outils de Claude affiche alors les
outils Samsa.
Les libellés de menu exacts varient selon la version — l'essentiel est le flux
de connecteur personnalisé et l'URL du server Samsa. Claude web appelle `/mcp`
depuis le navigateur avec `Origin: https://claude.ai`, ce que Samsa autorise,
donc la découverte et la connexion fonctionnent sans configuration
supplémentaire. Sur desktop, suis les instructions de connecteur actuelles
d'Anthropic et utilise la même URL de server.
Dans ChatGPT, ouvre **Settings → Apps & Connectors** et active le **mode
développeur**.
Ajoute une connexion app / MCP avec l'URL `https://api.samsa.ai/mcp`.
ChatGPT exécute la connexion et le consentement **OAuth 2.1** ; approuve-le
pour exposer les outils Samsa.
Les libellés de menu exacts varient selon la version — l'essentiel est d'activer
le mode développeur et d'ajouter l'URL du server Samsa. Les connexions MCP
personnalisées requièrent un plan ChatGPT incluant le mode développeur / les
connecteurs ; la disponibilité change au fil du temps, donc vérifie ton plan si
l'option est absente. ChatGPT appelle `/mcp` avec
`Origin: https://chatgpt.com` (ou `https://chat.openai.com`), que Samsa autorise
tous deux.
Microsoft connecte les MCP servers via **Copilot Studio**. Ajoute Samsa une
fois là-bas, puis publie l'agent sur le canal **Microsoft 365 Copilot et
Teams** pour que ton organisation l'utilise depuis Copilot chat et Teams.
Sur la page **Outils** de ton agent, choisis **Ajouter un outil → Nouvel
outil → Model Context Protocol**. Mets `https://api.samsa.ai/mcp` comme
**URL du server** et donne-lui un nom et une description.
L'orchestrateur de l'agent lit cette description pour décider quand appeler
Samsa — sois donc concret, par exemple « Génère et édite des images et des
vidéos avec les modèles Samsa entraînés de l'organisation ».
Samsa fonctionne avec les deux options proposées par l'assistant :
* **OAuth 2.0 → Dynamic discovery** — Samsa prend en charge
l'enregistrement dynamique de client avec discovery, donc Copilot Studio
trouve les endpoints et s'enregistre lui-même. Chaque personne se
connecte avec son propre compte Samsa, aucune clé n'est partagée.
* **API key** — mets **Type** sur **Header** et le nom du header sur
`Authorization`. La valeur de la connexion est `Bearer samsa_sk_…`.
Choisis **Créer**, puis **Créer une nouvelle connexion**, puis **Ajouter à
l'agent**.
Publie l'agent et, sous **Activer Microsoft 365**, coche **Rendre l'agent
disponible dans Microsoft 365 Copilot**. Les utilisateurs atteignent alors
Samsa depuis l'app Microsoft 365 Copilot et Teams.
Copilot Studio prend en charge le transport **Streamable**, celui que Samsa
sert. L'accès aux MCP servers passe par les connecteurs Power Platform :
toute data policy qui les régit régit donc aussi les outils Samsa.
Les **federated connectors** de Microsoft 365 Copilot sont une autre
fonctionnalité, limitée à la lecture de données. Les outils de génération de
Samsa s'ajoutent via Copilot Studio comme ci-dessus.
**API key · vérifié**
Ajoute le server avec le transport HTTP et un header Bearer :
```bash theme={null}
claude mcp add --transport http samsa https://api.samsa.ai/mcp \
--header "Authorization: Bearer samsa_sk_..."
```
Par défaut, cela enregistre le server pour ton usage personnel (scope local).
Pour le partager avec ton équipe, ajoute `--scope project` et Claude Code écrit
un `.mcp.json` de projet. Comme ce fichier est commité, garde la clé en dehors —
Claude Code développe les variables d'environnement dans `headers` :
```json theme={null}
{
"mcpServers": {
"samsa": {
"type": "http",
"url": "https://api.samsa.ai/mcp",
"headers": { "Authorization": "Bearer ${SAMSA_API_KEY}" }
}
}
}
```
Confirme la connexion avec `claude mcp get samsa` — il devrait indiquer
**Connected**.
Tu préfères OAuth ? Exécute `claude mcp add --transport http samsa
https://api.samsa.ai/mcp` **sans** le header et termine la connexion OAuth à la
première utilisation.
Ajoute à `~/.cursor/mcp.json` (global) ou au `.cursor/mcp.json` de projet.
Cursor interpole les variables d'environnement dans `headers`, donc référence la
clé plutôt que de l'inliner dans un fichier partagé :
```json theme={null}
{
"mcpServers": {
"samsa": {
"url": "https://api.samsa.ai/mcp",
"headers": { "Authorization": "Bearer ${env:SAMSA_API_KEY}" }
}
}
}
```
Ajoute à `.vscode/mcp.json` :
```json theme={null}
{
"servers": {
"samsa": {
"type": "http",
"url": "https://api.samsa.ai/mcp",
"headers": { "Authorization": "Bearer samsa_sk_..." }
}
}
}
```
Ne commite pas de vraie clé dans un fichier de workspace. VS Code prend en charge
les variables `${input:...}` et la config MCP au niveau utilisateur — utilise
l'une d'elles pour que le secret ne soit pas embarqué avec ton projet.
Ajoute à `~/.codeium/windsurf/mcp_config.json` :
```json theme={null}
{
"mcpServers": {
"samsa": {
"serverUrl": "https://api.samsa.ai/mcp",
"headers": { "Authorization": "Bearer samsa_sk_..." }
}
}
}
```
Ajoute à `~/.codex/config.toml` :
```toml theme={null}
[mcp_servers.samsa]
url = "https://api.samsa.ai/mcp"
http_headers = { Authorization = "Bearer samsa_sk_..." }
```
Dans le nœud **MCP Client**, définis :
* **Endpoint** — `https://api.samsa.ai/mcp`
* **Transport** — `HTTP Streamable`
* **Authentication** — Header Auth avec `Authorization: Bearer samsa_sk_...`
n8n tourne côté serveur (pas de header `Origin` de navigateur), donc il se
connecte sans configuration supplémentaire.
Ajoute un MCP server HTTP à `~/.gemini/settings.json`. Les noms de clés de
config diffèrent selon les versions de Gemini CLI — vérifie contre la doc
MCP actuelle de Gemini CLI — mais la forme est l'URL Samsa plus un header
Bearer :
```json theme={null}
{
"mcpServers": {
"samsa": {
"httpUrl": "https://api.samsa.ai/mcp",
"headers": { "Authorization": "Bearer samsa_sk_..." }
}
}
}
```
Pour vérifier le server depuis un outil neutre, utilise le
[MCP Inspector](https://github.com/modelcontextprotocol/inspector).
Pilote-le depuis la GUI (ou un fichier de config) avec le transport
Streamable-HTTP :
```json theme={null}
{
"mcpServers": {
"samsa": {
"type": "streamable-http",
"url": "https://api.samsa.ai/mcp",
"headers": { "Authorization": "Bearer samsa_sk_..." }
}
}
}
```
L'Inspector utilise le même transport Streamable-HTTP contre lequel Samsa
est vérifié, et tourne sur `http://localhost:6274`, que Samsa autorise.
Utilise-le pour parcourir le handshake, lister les quinze outils et faire un
appel de test.
Les snippets de config pour Claude Code, Cursor, VS Code, Windsurf, Codex, n8n,
Claude web, ChatGPT et le MCP Inspector proviennent de la matrice de vérification
de config client du backend de Samsa. Si une étape ne va pas, écris à
[support@samsa.ai](mailto:support@samsa.ai) et nous corrigerons vite.