Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Connecter des LLM à Cloud Storage avec MCP

Vous pouvez exécuter un serveur MCP (Model Context Protocol) local avec MCP Toolbox for Databases afin d'interagir avec Cloud Storage directement depuis votre IDE et vos outils pour les développeurs. Cette configuration permet aux grands modèles de langage (LLM) de clients tels qu'Antigravity, Claude, Cline, Cursor, Visual Studio Code (Copilot) et Windsurf de créer des buckets, de gérer les données d'objets et d'inspecter les stratégies Identity and Access Management (IAM).

La boîte à outils MCP Open Source est compatible avec l'authentification OAuth2 et OIDC, et s'intègre à OpenTelemetry pour l'observabilité. L'intégration de Cloud Storage nécessite la version 1.2.0 ou ultérieure de MCP Toolbox. Pour exécuter un serveur MCP local autonome sans la boîte à outils, utilisez le dépôt GitHub Cloud Storage MCP.

Avant de commencer

Dans la console Google Cloud , sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud .
Assurez-vous que la facturation est activée pour votre projet Google Cloud .
Activez l'API Cloud Storage dans le projet Google Cloud .
Configurez les rôles et autorisations requis pour effectuer cette tâche. L'utilisateur qui appelle les agents LLM doit disposer des rôles suivants au niveau du bucket ou du projet :
- Pour lister des buckets, en créer et supprimer des buckets vides : Administrateur de l'espace de stockage (roles/storage.admin)
- Pour lister des objets, lire des objets, obtenir des métadonnées d'objets ou des métadonnées de buckets : Lecteur des objets Storage (roles/storage.objectViewer)
- Pour écrire du contenu dans un objet ou importer un objet : Créateur d'objets Storage (roles/storage.objectCreator)
- Pour copier, déplacer ou supprimer des objets : Administrateur des objets de l'espace de stockage (roles/storage.objectAdmin)
Configurez les identifiants par défaut de l'application (ADC) pour votre environnement.

Se connecter avec Antigravity

Vous connectez Cloud Storage à Antigravity à l'aide d'une configuration personnalisée. Dans ce contexte, un serveur MCP personnalisé est un serveur que vous configurez manuellement en modifiant votre fichier de configuration (tel que mcp_config.json). Cette configuration manuelle est utilisée au lieu d'installer le serveur directement à partir du catalogue MCP Store intégré.

Pour configurer un serveur MCP personnalisé, procédez comme suit :

Vérifiez que npx est installé et correctement configuré sur votre système en exécutant npx --version dans votre terminal. Si vous devez installer Node.js, qui inclut npx, consultez le guide npm Télécharger et installer Node.js et npm.
Ouvrez Antigravity et accédez au store MCP à l'aide du menu déroulant "..." en haut du panneau de l'agent de l'éditeur.
Pour ouvrir le fichier mcp_config.json, cliquez sur Serveurs MCP, puis sur Gérer les serveurs MCP > Afficher la configuration brute.

Ajoutez la configuration suivante, remplacez l'espace réservé par l'ID de votre projet, puis enregistrez :

{
  "mcpServers": {
    "storage": {
      "command": "npx",
      "args": ["-y","@toolbox-sdk/server","--prebuilt","cloud-storage","--stdio"],
      "env": {
          "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
      }
    }
  }
}

Installer MCP Toolbox

La boîte à outils est un serveur Model Context Protocol (MCP) Open Source qui s'exécute localement sur votre machine. Le serveur local gère la communication entre votre IDE et Cloud Storage. Cette connexion fournit un environnement sécurisé et efficace pour vos outils d'IA.

Téléchargez la dernière version de MCP Toolbox sous forme de binaire. Sélectionnez le binaire correspondant à votre système d'exploitation (OS) et à l'architecture de votre processeur. Vous devez utiliser MCP Toolbox version 1.2.0 ou ultérieure :
linux/amd64
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/VERSION/linux/amd64/toolbox
Remplacez VERSION par la version de MCP Toolbox (par exemple, v1.2.0).
macOS darwin/arm64
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/VERSION/darwin/arm64/toolbox
Remplacez VERSION par la version de MCP Toolbox (par exemple, v1.2.0).
macOS darwin/amd64
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/VERSION/darwin/amd64/toolbox
Remplacez VERSION par la version de MCP Toolbox (par exemple, v1.2.0).
windows/amd64
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/VERSION/windows/amd64/toolbox
Remplacez VERSION par la version de MCP Toolbox (par exemple, v1.2.0).
Rendez le binaire exécutable :
```
chmod +x toolbox
```
Vérifiez l'installation :
```
./toolbox --version
```

Pour configurer la boîte à outils avec une image de conteneur ou Homebrew, consultez la page Installer Toolbox.

Configurer les clients et les connexions

Cette section explique comment connecter Cloud Storage à vos outils après avoir installé MCP Toolbox.

Claude Code

Installez Claude Code.
Créez un fichier .mcp.json à la racine de votre projet, s'il n'existe pas.
Ajoutez la configuration, remplacez les espaces réservés par vos valeurs, puis enregistrez :
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Remplacez les variables suivantes par vos valeurs :
- ./PATH/TO/toolbox : chemin d'accès à votre binaire toolbox.
- CLOUD_STORAGE_PROJECT : variable d'environnement spécifiant l'ID du projet Google Cloud .
- PROJECT_ID : ID de votre projet Google Cloud .
Redémarrez Claude Code pour charger les nouveaux paramètres. Lorsque Claude Code se rouvre, l'application détecte le serveur MCP configuré.

Claude pour ordinateur

Ouvrez Claude Desktop et accédez à Paramètres.
Dans l'onglet Developer (Développeur), cliquez sur Edit Config (Modifier la configuration) pour ouvrir le fichier de configuration.
Ajoutez la configuration, remplacez les espaces réservés par vos valeurs, puis enregistrez :
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Remplacez les variables suivantes par vos valeurs :
- ./PATH/TO/toolbox : chemin d'accès à votre binaire toolbox.
- CLOUD_STORAGE_PROJECT : variable d'environnement spécifiant l'ID du projet Google Cloud .
- PROJECT_ID : ID de votre projet Google Cloud .
Redémarrez Claude Desktop.
Le nouvel écran de chat affiche une icône de marteau (MCP) avec le nouveau serveur MCP.

Cline

Ouvrez l'extension Cline dans VS Code, puis cliquez sur l'icône MCP Servers (Serveurs MCP).
Cliquez sur Configurer les serveurs MCP pour ouvrir le fichier de configuration.
Ajoutez la configuration suivante, remplacez les espaces réservés par vos valeurs, puis enregistrez :
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Remplacez les variables suivantes par vos valeurs :
- ./PATH/TO/toolbox : chemin d'accès à votre binaire toolbox.
- CLOUD_STORAGE_PROJECT : variable d'environnement spécifiant l'ID du projet Google Cloud .
- PROJECT_ID : ID de votre projet Google Cloud .

Un état actif vert s'affiche une fois que le serveur s'est connecté.

Cursor

Créez le répertoire .cursor à la racine de votre projet s'il n'existe pas.
Créez le fichier .cursor/mcp.json s'il n'existe pas, puis ouvrez-le.
Ajoutez la configuration suivante, remplacez les espaces réservés par vos valeurs, puis enregistrez :
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Remplacez les variables suivantes par vos valeurs :
- ./PATH/TO/toolbox : chemin d'accès à votre binaire toolbox.
- CLOUD_STORAGE_PROJECT : variable d'environnement spécifiant l'ID du projet Google Cloud .
- PROJECT_ID : ID de votre projet Google Cloud .
Ouvrez Cursor, puis accédez à Settings > Cursor Settings > MCP (Paramètres > Paramètres de Cursor > MCP). Un état actif vert s'affiche lorsque le serveur se connecte.

Visual Studio Code (Copilot)

Ouvrez VS Code et créez un répertoire .vscode à la racine de votre projet s'il n'existe pas.
Créez le fichier .vscode/mcp.json s'il n'existe pas, puis ouvrez-le.
Ajoutez la configuration suivante, remplacez les espaces réservés par vos valeurs, puis enregistrez :
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Remplacez les variables suivantes par vos valeurs :
- ./PATH/TO/toolbox : chemin d'accès à votre binaire toolbox.
- CLOUD_STORAGE_PROJECT : variable d'environnement spécifiant l'ID du projet Google Cloud .
- PROJECT_ID : ID de votre projet Google Cloud .
Actualisez la fenêtre VS Code. L'extension compatible MCP détecte automatiquement la configuration et démarre le serveur.

Planche à voile

Ouvrez Windsurf et accédez à l'assistant Cascade.
Cliquez sur l'icône MCP, puis sur Configurer pour ouvrir le fichier de configuration.
Ajoutez la configuration suivante, remplacez les espaces réservés par vos valeurs, puis enregistrez :
```
        {
          "mcpServers": {
            "storage": {
              "command": "./PATH/TO/toolbox",
              "args": ["--prebuilt","cloud-storage","--stdio"],
              "env": {
                "CLOUD_STORAGE_PROJECT": "PROJECT_ID"
              }
            }
          }
        }
        
```
Remplacez les variables suivantes par vos valeurs :
- ./PATH/TO/toolbox : chemin d'accès à votre binaire toolbox.
- CLOUD_STORAGE_PROJECT : variable d'environnement spécifiant l'ID du projet Google Cloud .
- PROJECT_ID : ID de votre projet Google Cloud .

Outils prédéfinis

Une fois que vous avez connecté MCP Toolbox à Cloud Storage, votre agent utilise les outils prédéfinis suivants :

list_buckets : liste les buckets Cloud Storage du projet configuré.
list_objects : liste les objets d'un bucket avec un filtrage facultatif par préfixe et délimiteur.
get_bucket_metadata : renvoie les métadonnées d'un bucket.
get_bucket_iam_policy : renvoie les liaisons de stratégie IAM pour un bucket.
get_object_metadata : renvoie les métadonnées d'un objet.
read_object : lit un objet texte UTF-8 (ou une plage d'octets). Limité à 8 Mio ; les objets binaires sont refusés.
download_object : télécharge un objet vers un chemin d'accès local.
create_bucket : crée un bucket dans le projet configuré.
delete_bucket : supprime un bucket vide.
upload_object : importe un fichier local dans un objet.
write_object : écrit du contenu textuel directement dans un objet.
copy_object : copie un objet vers un objet de destination.
move_object : renomme un objet de manière atomique dans le même bucket.
delete_object : supprime un objet.