Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Connecter des LLM à Cloud Storage avec MCP

Ce guide vous explique comment connecter Cloud Storage à des environnements de développement intégrés (IDE) et à des outils pour les développeurs. Pour ce faire, exécutez un serveur MCP local sur votre machine à l'aide de MCP Toolbox for Databases.

MCP Toolbox for Databases est un dépôt Open Source qui contient des connecteurs pour les bases de données et les datastores, y compris Cloud Storage, BigQuery, AlloyDB, Spanner et Cloud SQL. La boîte à outils est compatible avec l'authentification OAuth2 et OIDC, et s'intègre à Open Telemetry pour l'observabilité. L'intégration de la boîte à outils Cloud Storage vous permet d'utiliser un LLM pour effectuer les actions suivantes :

Créer, lister et supprimer des buckets
Obtenez les métadonnées de bucket et d'objet.
Obtenez les stratégies de Identity and Access Management (IAM) sur vos buckets.
Lire, écrire, importer et télécharger des objets
Copiez ou déplacez des objets.

Ce guide explique comment connecter les IDE et outils suivants :

Cursor
Windsurf (anciennement Codeium)
Visual Studio Code (Copilot)
Cline (extension VS Code)
Claude sur ordinateur
Claude Code
Antigravity

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 Google Cloud projet.
Configurez les rôles et autorisations requis pour effectuer cette tâche. L'utilisateur qui appelle les agents LLM a besoin des rôles suivants au niveau du bucket ou du projet :
- Pour lister les buckets, en créer et en supprimer des vides : Administrateur de l'espace de stockage (roles/storage.admin)
- Pour lister ou lire des objets, ou obtenir des métadonnées d'objets ou de buckets : Lecteur des objets Storage (roles/storage.objectViewer)
- Pour écrire du contenu dans un objet ou importer un objet : Créateur d'objets de l'espace de stockage (roles/storage.objectCreator)
- Pour copier, déplacer ou supprimer des objets : Administrateur des objets Storage (roles/storage.objectAdmin)
Configurez les identifiants par défaut de l'application pour votre environnement.

Contacter 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 intégré du magasin MCP.

Pour configurer un serveur MCP personnalisé :

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 magasin 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'ID du projet 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 MCP (Model Context Protocol) 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 en tant que binaire. Sélectionnez le binaire correspondant à votre système d'exploitation (OS) et à l'architecture de votre processeur. Vous devez utiliser la version 1.2.0 ou ultérieure de MCP Toolbox :
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 la boîte à outils.

Configurer les clients et les connexions

Cette section explique comment connecter Cloud Storage à vos outils après avoir installé la 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 rouvre, l'application détecte le serveur MCP configuré.

Claude sur ordinateur

Ouvrez Claude Desktop et accédez à Settings (Paramètres).
Dans l'onglet Développeur, cliquez sur 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 en forme de marteau (MCP) avec le nouveau serveur MCP.

Cline

Ouvrez l'extension Cline dans VS Code, puis cliquez sur l'icône 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 est connecté.

Cursor

Créez le répertoire .cursor dans la racine de votre projet s'il n'existe pas.
Créez le fichier .cursor/mcp.json s'il n'existe pas et 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 du curseur > 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 avec MCP détecte automatiquement la configuration et démarre le serveur.

Windsurf

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é la MCP Toolbox à Cloud Storage, votre agent utilise les outils prédéfinis suivants :

list_buckets : liste les buckets Cloud Storage dans le 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). La taille est limitée à 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 le 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.