> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sunra.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Serveur MCP

> Apprenez à intégrer le serveur MCP de SUNRA avec Cursor, VS Code, Cline, Windsurf et d'autres environnements de développement pour un accès transparent aux modèles d'IA.

# Configuration du serveur MCP SUNRA

Le serveur MCP (Model Context Protocol) de SUNRA offre une intégration transparente avec les environnements de développement populaires, vous permettant d'accéder aux modèles d'IA de SUNRA directement depuis votre éditeur ou IDE. Ce guide vous expliquera comment configurer le serveur MCP avec divers outils.

## Qu'est-ce que MCP ?

Le protocole de contexte de modèle (MCP) est un moyen normalisé pour les assistants IA d'accéder en toute sécurité à des ressources et outils externes. Le serveur MCP de SUNRA vous permet de :

* **Lister et rechercher des modèles d'IA** disponibles sur SUNRA
* **Soumettre des requêtes** à n'importe quel point de terminaison de modèle
* **Vérifier l'état** et récupérer les résultats du système de file d'attente
* **Télécharger des fichiers** et gérer les schémas de modèle
* **Gérer l'authentification API** de manière transparente

## Prérequis

Avant de configurer le serveur MCP, assurez-vous d'avoir :

1. **Node.js** installé (version 18 ou supérieure)
2. **Clé API SUNRA** de [votre tableau de bord](https://sunra.ai/dashboard/api-tokens)
3. Votre éditeur/IDE préféré installé

## Installation

Le serveur MCP SUNRA est disponible en tant que package npm :

```bash theme={null}
npm install -g @sunra/mcp-server
```

Ou utilisez-le directement avec npx (recommandé) :

```bash theme={null}
npx @sunra/mcp-server
```

## Configuration par éditeur

### Cursor

Cursor prend en charge MCP via son fichier de configuration. Créez ou mettez à jour `.cursor/mcp.json` à la racine de votre projet :

```json theme={null}
{
  "mcpServers": {
    "sunra-mcp-server": {
      "command": "npx",
      "args": ["@sunra/mcp-server"]
    }
  }
}
```

**Configuration globale alternative** dans vos paramètres utilisateur :

1. Ouvrez les paramètres de Cursor
2. Naviguez vers "Serveurs MCP"
3. Ajoutez un nouveau serveur avec :
   * **Nom** : `sunra-mcp-server`
   * **Commande** : `npx`
   * **Args** : `@sunra/mcp-server`

### VS Code

Pour VS Code avec prise en charge de MCP (nécessite une extension compatible) :

Créez `.vscode/mcp.json` :

```json theme={null}
{
  "mcpServers": {
    "sunra-mcp-server": {
      "command": "npx",
      "args": ["@sunra/mcp-server"],
      "env": {
        "SUNRA_KEY": "votre-cle-api-ici"
      }
    }
  }
}
```

### Cline

Cline prend en charge les serveurs MCP via ses paramètres. Ajoutez à votre configuration Cline :

```json theme={null}
{
  "mcpServers": {
    "sunra": {
      "command": "npx",
      "args": ["@sunra/mcp-server"],
      "description": "Accès au modèle SUNRA AI"
    }
  }
}
```

### Windsurf

Pour l'IDE Windsurf, configurez MCP dans les paramètres de l'espace de travail :

```json theme={null}
{
  "mcp": {
    "servers": {
      "sunra-mcp-server": {
        "command": "npx",
        "args": ["@sunra/mcp-server"],
        "timeout": 30000
      }
    }
  }
}
```

### Claude Desktop

Ajoutez à votre fichier de configuration Claude Desktop :

**macOS** : `~/Library/Application Support/Claude/claude_desktop_config.json`
**Windows** : `%APPDATA%\Claude\claude_desktop_config.json`

```json theme={null}
{
  "mcpServers": {
    "sunra-mcp-server": {
      "command": "npx",
      "args": ["@sunra/mcp-server"]
    }
  }
}
```

### Autres outils compatibles MCP

Pour tout autre outil prenant en charge MCP, utilisez ce modèle de configuration général :

```json theme={null}
{
  "mcpServers": {
    "sunra-mcp-server": {
      "command": "npx",
      "args": ["@sunra/mcp-server"],
      "env": {
        "SUNRA_KEY": "${SUNRA_KEY}"
      }
    }
  }
}
```

## Configuration de l'environnement

### Définir votre clé API

Vous pouvez configurer votre clé API SUNRA de plusieurs manières :

#### Option 1 : Variable d'environnement (recommandé)

```bash theme={null}
export SUNRA_KEY="votre-cle-api-ici"
```

Pour Windows :

```cmd theme={null}
set SUNRA_KEY=votre-cle-api-ici
```

#### Option 2 : Fichier de configuration

Certains éditeurs vous permettent de définir des variables d'environnement directement dans la configuration MCP :

```json theme={null}
{
  "mcpServers": {
    "sunra-mcp-server": {
      "command": "npx",
      "args": ["@sunra/mcp-server"],
      "env": {
        "SUNRA_KEY": "votre-cle-api-ici"
      }
    }
  }
}
```

#### Option 3 : Configuration d'exécution

Le serveur MCP prend également en charge la définition de la clé API lors de l'exécution à l'aide de l'outil `set-sunra-key`.

## Outils MCP disponibles

Une fois configuré, vous aurez accès à ces outils via votre assistant IA :

### Gestion des modèles

* `list-models` - Parcourir tous les modèles d'IA disponibles
* `search-models` - Trouver des modèles par mots-clés
* `model-schema` - Obtenir les schémas d'entrée/sortie pour des modèles spécifiques

### Gestion des requêtes

* `submit` - Soumettre des requêtes aux points de terminaison du modèle
* `status` - Vérifier l'état de la requête et les journaux
* `result` - Récupérer les résultats terminés
* `cancel` - Annuler les requêtes en cours
* `subscribe` - Soumettre et attendre la fin

### Gestion des fichiers

* `upload` - Télécharger des fichiers sur le stockage SUNRA

## Exemples d'utilisation

### Lister les modèles disponibles

```
Utilisez l'outil list-models pour me montrer quels modèles d'IA sont disponibles.
```

### Générer une image

```
Utilisez l'outil submit pour générer une image avec le point de terminaison black-forest-labs/flux-1.1-pro/text-to-image. 
Utilisez l'invite : "Un paysage de montagne serein au coucher du soleil"
```

### Vérifier l'état de la requête

```
Vérifiez l'état de l'ID de requête : pd_xxxxxx
```

## Dépannage

### Problèmes courants

**Serveur MCP introuvable**

* Assurez-vous que Node.js est installé et accessible
* Essayez d'installer globalement : `npm install -g @sunra/mcp-server`
* Vérifiez que le chemin de la commande est correct

**Erreurs d'authentification**

* Vérifiez que votre variable d'environnement SUNRA\_KEY est définie
* Vérifiez que votre clé API est valide sur le [tableau de bord SUNRA](https://sunra.ai/dashboard/api-tokens)
* Essayez de définir la clé à l'aide de l'outil `set-sunra-key`

**Délais de connexion**

* Augmentez les valeurs de délai d'attente dans votre configuration
* Vérifiez votre connexion Internet
* Vérifiez l'état de l'API SUNRA

**Erreurs de permission**

* Assurez-vous que les autorisations de fichier sont correctes pour les fichiers de configuration
* Essayez d'exécuter avec les autorisations utilisateur appropriées

### Obtenir de l'aide

Si vous rencontrez des problèmes :

1. Consultez la [documentation SUNRA](https://docs.sunra.ai)
2. Consultez la documentation MCP de votre éditeur
3. Soumettez un problème sur [GitHub](https://github.com/sunra-ai/sunra-clients/issues)

## Prochaines étapes

Une fois votre serveur MCP configuré :

1. **Explorez les modèles** : Utilisez `list-models` pour voir toutes les capacités d'IA disponibles
2. **Essayez des exemples** : Commencez par de simples générations de texte en image ou de texte en vidéo
3. **Créez des flux de travail** : Combinez plusieurs modèles pour des pipelines d'IA complexes
4. **Surveillez l'utilisation** : Suivez votre utilisation de l'API dans le [tableau de bord SUNRA](https://sunra.ai/dashboard/)

L'intégration MCP facilite l'incorporation de modèles d'IA puissants directement dans votre flux de travail de développement, permettant un prototypage rapide et des fonctionnalités basées sur l'IA transparentes dans vos applications.