Google AlloyDB MCP server

Endpoint: https://alloydb.googleapis.com/mcp · Authentication: Sign in with OAuth

Creates and manages AlloyDB clusters, instances, and users and runs SQL against AlloyDB databases. Requires Google Cloud credentials through OAuth.

Test it live Run the release-readiness report

How do I authenticate?

Add the endpoint in your client, start Connect or Sign in, approve the requested scopes, and return to the client. OAuth discovery finds the authorization server; client registration requirements vary by provider. Follow the provider guidance and client setup below.

Authentication and connection guide

Connection specification

Remote endpoint: https://alloydb.googleapis.com/mcp
Browser access: Not yet measured
Declared MCP transport: Streamable HTTP
Live-validated MCP transport: Streamable HTTP — Observed by the latest catalog validation
Declared authentication: OAuth 2.1
Detected authentication: OAuth 2.1 detected or retained from publisher evidence
Protocol lifecycle: Stateful MCP · 2025-11-25
Authorization server: https://accounts.google.com/
Category: Databases

Product documentation · Official listing documentation

Provider guidance

Initialization and tool listing succeeded without credentials in the 2026-10-20 audit; tool calls require Google Cloud credentials. Google OAuth clients are pre-registered in a Google Cloud project; the server does not advertise Dynamic Client Registration. The MCP server must be enabled per project.

More Databases MCP servers · Browse all MCP servers · Test this endpoint in the MCP Playground

Authorization setup

Registration requirements not verified

The OAuth authorization and app-registration requirements for this exact endpoint have not been verified. A compatible client will request authorization, but follow the publisher documentation and do not guess client credentials or callbacks.

Publisher evidence reviewed 2026-10-20.

Publisher documentation

Connect it

Live-validated endpoint: https://alloydb.googleapis.com/mcp · Streamable HTTP. Registration requirements not verified: The OAuth authorization and app-registration requirements for this exact endpoint have not been verified. A compatible client will request authorization, but follow the publisher documentation and do not guess client credentials or callbacks.

Agent prompt for Claude Code or Codex

Add the Google AlloyDB MCP server to my MCP client configuration and verify that it works.

What it is: Creates and manages AlloyDB clusters, instances, and users and runs SQL against AlloyDB databases. Requires Google Cloud credentials through OAuth.
Server URL: https://alloydb.googleapis.com/mcp
Transport: Streamable HTTP (remote MCP server, no local install).
Authentication: OAuth 2.1. Registration requirements not verified: The OAuth authorization and app-registration requirements for this exact endpoint have not been verified. A compatible client will request authorization, but follow the publisher documentation and do not guess client credentials or callbacks.
Tools (17, as last observed by mcptest): create_backup, create_cluster, create_instance, create_user, execute_sql, execute_sql_read_only, export_data, get_cluster, get_instance, get_operation, get_user, import_data, list_clusters, list_instances, list_users, restore_cluster, update_instance.
Reference: https://mcptest.io/servers/google-alloydb/

Steps:
1. Work out which MCP client I use (Claude Code, Codex, Cursor, VS Code or another) and add the server under the name "google-alloydb" in that client's MCP configuration, user scope unless I ask otherwise.
Claude Code: claude mcp add --transport http --scope user 'google-alloydb' 'https://alloydb.googleapis.com/mcp'
Other clients: use the setup for that client on the reference page.
2. Never write a credential value into a file that could be committed; reference an environment variable or the client's secret store, and ask me for any value you need.
3. Verify: connect to the server and call tools/list. Confirm the tools above are listed, and report any sign-in step I still have to complete.

Claude Code setup

Run in a terminal. This user-scoped entry is available across projects.

claude mcp add --transport http --scope user 'google-alloydb' 'https://alloydb.googleapis.com/mcp'

After adding the server, open Claude Code, run /mcp, select the server, and follow the browser flow to authenticate.

Codex CLI setup

Run in a terminal; Codex stores the entry in ~/.codex/config.toml.

codex mcp add 'google-alloydb' --url 'https://alloydb.googleapis.com/mcp'
codex mcp login 'google-alloydb'

Cursor setup

Add to .cursor/mcp.json for this project, or ~/.cursor/mcp.json for all projects.

{
  "mcpServers": {
    "google-alloydb": {
      "url": "https://alloydb.googleapis.com/mcp"
    }
  }
}

VS Code setup

Add to .vscode/mcp.json, or run “MCP: Open User Configuration” for a private user-level entry.

{
  "servers": {
    "google-alloydb": {
      "type": "http",
      "url": "https://alloydb.googleapis.com/mcp"
    }
  }
}

Claude setup

Add the endpoint above in Claude:

Customize > Connectors > Add custom connector
Team/Enterprise: Organization settings > Connectors > Add > Custom > Web

Claude Desktop setup

Add the endpoint above in Claude Desktop:

Remote: Customize > Connectors (same as claude.ai)
Local: Settings > Developer > Edit Config, or Settings > Extensions for .mcpb files
~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows), local servers only

ChatGPT setup

Add the endpoint above in ChatGPT:

ChatGPT web: Plugins > Add custom MCP server, then configure authentication and accept the risk warning

Windsurf setup

Add the endpoint above in Windsurf:

~/.config/devin/mcp_config.json (%APPDATA%\devin\mcp_config.json on Windows), serverUrl or url
Cascade panel > ... > MCPs > Open MCP config file

Gemini CLI setup

Add the endpoint above in Gemini CLI:

gemini mcp add --transport http <name> <url>
~/.gemini/settings.json (user) or .gemini/settings.json (project), mcpServers

MCP SDK setup

Add the endpoint above in MCP SDK:

Programmatic: new Client(...).connect(new StreamableHTTPClientTransport(url))

Notes for every client

Publisher evidence (reviewed 2026-10-20): https://docs.cloud.google.com/alloydb/docs/ai/use-alloydb-mcp
Provider guidance: Initialization and tool listing succeeded without credentials in the 2026-10-20 audit; tool calls require Google Cloud credentials. Google OAuth clients are pre-registered in a Google Cloud project; the server does not advertise Dynamic Client Registration. The MCP server must be enabled per project.

Client compatibility

Client	Status	Why
Claude Code	Supported	Claude Code supports Streamable HTTP servers and OAuth sign-in.
Codex	Supported	Codex supports Streamable HTTP servers and OAuth sign-in.
Cursor	Supported	Cursor supports Streamable HTTP servers and OAuth sign-in.
VS Code	Supported	VS Code supports Streamable HTTP servers and OAuth sign-in.
Claude	Supported	Claude supports Streamable HTTP servers and OAuth sign-in.
Claude Desktop	Supported	Claude Desktop supports Streamable HTTP servers and OAuth sign-in.
ChatGPT	Partial	Stateful routing needs operational care: ChatGPT can preserve MCP sessions, but the deployment must route a session consistently and retain its state.
Windsurf	Partial	Windsurf's documentation does not state support for OAuth sign-in.
Gemini CLI	Supported	Gemini CLI supports Streamable HTTP servers and OAuth sign-in.
MCP SDK	Supported	MCP SDK supports Streamable HTTP servers and OAuth sign-in.

Computed from this server's validated transport, protocol and authentication against documented client support. Checks the catalog has not observed are not counted.

Similar servers

Supabase — Remote MCP server for Supabase projects, Postgres databases, backend tooling, and documentation. OAuth 2.1
Neon — Remote MCP server for Neon Postgres projects, branches, SQL, and documentation. OAuth 2.1
Prisma — Creates and manages Prisma Postgres databases, connection strings, backups, Prisma Compute apps, and Object Storage buckets in a Prisma workspace. Requires Prisma OAuth. OAuth 2.1
PlanetScale — Lists PlanetScale organizations, databases, and branches, reads Insights and schema recommendations, and runs read or write queries with short-lived credentials. Requires PlanetScale OAuth. OAuth 2.1
Google BigQuery — Lists BigQuery datasets and tables, reads table schemas, and runs SQL queries in a Google Cloud project. Requires Google Cloud credentials through OAuth. OAuth 2.1
InstantDB — Creates and manages Instant apps, including their schema and permission rules. Requires Instant account OAuth. OAuth 2.1

Guides for this server

Watch this server for breaking changes

Share and embed

Maintain Google AlloyDB? Embed this badge in your README. It follows the latest catalog validation result and links to this server profile.

Markdown

[![Tested on mcptest.io](https://mcptest.io/badge/server/google-alloydb.svg)](https://mcptest.io/servers/google-alloydb/)

HTML

<a href="https://mcptest.io/servers/google-alloydb/"><img src="https://mcptest.io/badge/server/google-alloydb.svg" alt="Tested on mcptest.io"></a>

reStructuredText

.. image:: https://mcptest.io/badge/server/google-alloydb.svg
   :alt: Tested on mcptest.io
   :target: https://mcptest.io/servers/google-alloydb/

Latest validation evidence

Validation status: Online when last tested
Validation checked at: Oct 26, 2026 at 11:06 AM
Validation detail: Negotiated stateful MCP 2025-11-25 at https://alloydb.googleapis.com/mcp; detected transport streamable-http; authentication oauth

Tool inventory

What the catalog validator observed on Oct 26, 2026 at https://alloydb.googleapis.com/mcp without credentials. The live server may have changed since; connect in the Playground for the current list.

Tools provided by Google AlloyDB 17

Some details were sanitized for public display.

create_backupoutputSchema declared
Creates a backup for an AlloyDB cluster. ***Requirements*** * The cluster that the backup is being created for must exist and be in a READY state. You can use the `list_clusters` tool to list all clusters in a project. ***Usage*** 1. Call `create_cluster` to create a cluster if it doesn't exist. 2. Call `create_backup` to create a backup for the cluster. 3. This will return a long-running operation that indicates the progress of the backup creation. 4. You can poll the status of the operation using the `get_operation` tool. Generally the creation time can vary depending on the size of the data
Input backupId: string, cluster: string, encryptionConfig?: any, parent: string
- backupId: stringrequired
  Required. The backup ID is the unique user-assigned ID of the backup. It should be an alphanumeric string that can consist of lowercase letters, numerical digits, or dash characters ("-"). This field is REQUIRED.
- cluster: stringrequired
  Required. The full resource name of the backup source cluster. The value must have a format of projects/{project}/locations/{region}/clusters/{cluster_id}. - {project} is the project that the cluster resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive integer. - {location} is the Google Cloud region that the cluster resides in. Regions will have format like "us-central1" or "us-west2". - {cluster_id} is the ID of cluster. It s
- encryptionConfig?: anyoptional
  Optional. The encryption config can be specified to encrypt the backup with a customer-managed encryption key (CMEK). When this field is not specified, the backup will then use default encryption scheme to protect the user data. This field is OPTIONAL.
- parent: stringrequired
  Required. The parent resource in which to create the backup. The value must have a format of projects/{project}/locations/{location}. - {project} is the project that the backup resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive integer. - {location} is the Google Cloud region that the backup resides in. Regions will have format like "us-central1" or "us-west2". The field is REQUIRED.
create_clusteroutputSchema declared
Creates an AlloyDB cluster. ***Requirements*** * The project the cluster is being created in must exist. * The location the cluster is being created in must be a supported AlloyDB location. ***Usage*** 1. Call `create_cluster` to create a cluster. 2. This will return a long-running operation that indicates the progress of the cluster creation. 3. You can poll the status of the operation using the `get_operation` tool. 4. Once the long-running operation is complete, the cluster will be in a READY state.
Input clusterId: string, expressConfig?: any, network?: string, parent: string, pscEnabled?: boolean
- clusterId: stringrequired
  Required. The cluster ID is the unique user-assigned ID of the cluster. It should be an alphanumeric string that can can consist of lowercase letters, numerical digits, or dash ("-") characters. This field is REQUIRED.
- expressConfig?: anyoptional
  Optional. The Express configuration for the cluster, which lets you create an AlloyDB Express cluster instead of a standard AlloyDB cluster. If unspecified, a standard AlloyDB cluster is created.
- network?: stringoptional
  The network is the VPC network that the cluster will reside in. Specifying this field will enable Private Google Access. This field is OPTIONAL, and if specified, it should have format like "projects/{project}/global/networks/{network_id}". This field should not be be specified if psc_enabled is true.
- parent: stringrequired
  Required. Identifier. The parent resource in which to create the cluster. The value must have a format of projects/{project}/locations/{location}. - {project} is the project that the cluster resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive integer. - {location} is the Google Cloud region that the cluster resides in. Regions will have format like "us-central1" or "us-west2". The field is REQUIRED.
- pscEnabled?: booleanoptional
  Configures whether Private Service Connect is enabled for the cluster. This field is OPTIONAL. If neither network nor psc_enabled is specified, the default behavior will be to enable Private Service Connect.
create_instanceoutputSchema declared
Creates an AlloyDB instance, which is a child resource of a cluster. ***Requirements*** * The cluster that the instance is being created in must exist and be in a READY state. You can use the `list_clusters` tool to list all clusters in a project. * If you're trying to create a PRIMARY instance, then the cluster must not already have a PRIMARY instance. * If you're trying to create a READ_POOL instance, then the cluster must already have a PRIMARY instance. ***Usage*** 1. Call `create_cluster` to create a cluster if it doesn't exist. 2. Call `create_instance` to create an instance within the c
Input authorizedExternalNetworks?: array, cpuCount?: integer, dbIamAuthentication?: boolean, enablePublicIp?: boolean, instanceId: string, machineType?: string, parent: string, pscInstanceConfig?: any, publicDnsEnabled?: boolean, readPoolNodeCount?: integer, type?: string
- authorizedExternalNetworks?: arrayoptional
  Optional. A list of CIDR ranges that are authorized to connect to public IP. Authorized external networks are only allowed for instances with public IP enabled. This field is OPTIONAL.
- cpuCount?: integeroptional
  Optional. The number of CPUs for the instance. If unspecified, it will default to 4. This field is OPTIONAL.
- dbIamAuthentication?: booleanoptional
  Optional. Enables DB IAM authentication for this instance. Sets the "alloydb.iam_authentication" db flag to "on"/"off". This field is OPTIONAL. If unspecified, it will default to true.
- enablePublicIp?: booleanoptional
  Optional. Enables Public IP for this instance. Enabling public IP requires having the database flag `password.enforce_complexity` enabled. The `password.enforce_complexity` flag will be enabled automatically if public IP is enabled for instance creation. This field is OPTIONAL. If unspecified, it will default to false.
- instanceId: stringrequired
  Required. The instance ID is the unique user-assigned ID of the instance. It should be an alphanumeric string that can consist of lowercase letters, numerical digits, or dash characters ("-"). This field is REQUIRED.
- machineType?: stringoptional
  Optional. The machine type of the instance. If unspecified, it will default to n2-highmem-4. This field is OPTIONAL.
- parent: stringrequired
  Required. Identifier. The parent resource in which to create the instance. The value must have a format of projects/{project}/locations/{location}/clusters/{cluster_id}. - {project} is the project that the cluster resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive integer. - {location} is the Google Cloud region that the cluster resides in. Regions will have format like "us-central1" or "us-west2". - {cluster_id} is the ID of
- pscInstanceConfig?: anyoptional
  Optional. The configuration for Private Service Connect (PSC) for the instance. If automatic creation of PSC endpoints is desired, then configs for PSC auto connections must be specified. If unspecified, PSC endpoints will need to be created manually. This field is OPTIONAL.
- publicDnsEnabled?: booleanoptional
  Optional. Enables a publicly available Domain Name System (DNS) domain name at which the AlloyDB instance can be reached. Public DNS is only supported for instances in AlloyDB Express clusters, where it enables public access to the instance instead of `enable_public_ip`. This field is OPTIONAL. If unspecified, it will default to `false`.
- readPoolNodeCount?: integeroptional
  Optional. The number of read pool nodes for the instance. If unspecified, it will default to 1. This field is OPTIONAL.
- type?: stringoptional
  Optional. The type of the instance. The allowed values are: - PRIMARY - An AlloyDB instance that will accept both read and write Postgres transactions. You can have only one primary instance per cluster. - READ_POOL - An AlloyDB instance that will only accept read Postgres transactions. You can have multiple read pool instances per cluster, but they can only be created after the primary instance has been created. This field is OPTIONAL. If unspecified, it will default to PRIMARY.
create_useroutputSchema declared
Create a new user in a given project, location, and cluster. ***Requirements*** * The cluster that the user is being created in must exist and be in a READY state. You can use the `list_clusters` tool to list all clusters in a project. * A PRIMARY instance must exist and be in a READY state. You can use the `list_instances` tool to list all instances in a cluster. * Only an IAM_BASED type user is supported. * The "postgres" database role should be assigned to the user if the user wants to access the default postgres database. ***Usage*** 1. Call `create_cluster` to create a cluster if it doesn
Input databaseRoles?: array, parent: string, userId: string
- databaseRoles?: arrayoptional
  Optional. List of database roles that the user will have, which controls which database/relations they can access. By default, we recommend that you add "postgres" value to this field, which will allow the user to access the default postgres database. The database role strings are subject to the PostgreSQL naming conventions. This field is OPTIONAL.
- parent: stringrequired
  Required. Identifier. The parent resource in which to create the user. The value must have a format of projects/{project}/locations/{location}/clusters/{cluster_id}. - {project} is the project that the cluster resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive integer. - {location} is the Google Cloud region that the cluster resides in. Regions will have format like "us-central1" or "us-west2". - {cluster_id} is the ID of clu
- userId: stringrequired
  Required. The user ID is the username of the user created in the Postgres database. It should be an alphanumeric string that can can consist of lowercase letters, numerical digits, or dash characters ("-"). For an IAM user account, supply the user account's full email address. For example, [email protected]. For an IAM service account, supply the service account's address without the .gserviceaccount.com suffix. For example, to specify the service account [email protected], you would use the value [email protected] here. This field is REQUIRED.
execute_sqloutputSchema declared
Execute a SQL query on an instance. ***Requirements*** * The cluster must exist and be in a READY state. You can use the `list_clusters` tool to list all clusters in a project. * The instance must exist and be in a READY state. You can use the `list_instances` tool to list all instances in a cluster. * The user must exist and have the appropriate permissions to execute the SQL query. You can use the `list_users` tool to list all users in a cluster. ***Usage*** 1. Call `create_cluster` to create a cluster if it doesn't exist. 2. Call `create_instance` to create an instance if it doesn't exist.
Input database: string, instance: string, sqlStatement: string, validateOnly?: boolean
- database: stringrequired
  Required. Name of the database where the query will be executed. You can use the default "postgres" database if a different database is not created. Note - Value provided should be the same as expected from `SELECT current_database();` and NOT as a resource reference. This field is REQUIRED.
- instance: stringrequired
  Required. Identifier. The name of the instance resource with the format: * projects/{project}/locations/{region}/clusters/{cluster_id}/instances/{instance_id} where the cluster and instance ID segments should satisfy the regex expression `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`, e.g. 1-63 characters of lowercase letters, numbers, and dashes, starting with a letter, and ending with a letter or number. The prefix of the instance resource name is the name of the parent resource: * projects/{project}/locations/{region}/clusters/{cluster_id} This field is REQUIRED.
- sqlStatement: stringrequired
  Required. SQL statement to execute on database. Any valid statement is permitted, including DDL, DML, DQL statements. This field is REQUIRED.
- validateOnly?: booleanoptional
  Optional. If set, validates the sql statement by performing syntax and semantic validation and doesn't execute the query. This field is OPTIONAL. If unspecified, it will default to false.
execute_sql_read_onlyoutputSchema declared
Execute a SQL query on an instance in read-only mode. ***Requirements*** * The cluster must exist and be in a READY state. You can use the `list_clusters` tool to list all clusters in a project. * The instance must exist and be in a READY state. You can use the `list_instances` tool to list all instances in a cluster. * The user must exist and have the appropriate permissions to execute the SQL query. You can use the `list_users` tool to list all users in a cluster. ***Usage*** 1. Call `create_cluster` to create a cluster if it doesn't exist. 2. Call `create_instance` to create an instance if
Input database: string, instance: string, sqlStatement: string
- database: stringrequired
  Required. Name of the database where the query will be executed. You can use the default "postgres" database if a different database is not created. Note - Value provided should be the same as expected from `SELECT current_database();` and NOT as a resource reference. This field is REQUIRED.
- instance: stringrequired
  Required. Identifier. The name of the instance resource with the format: * projects/{project}/locations/{region}/clusters/{cluster_id}/instances/{instance_id} where the cluster and instance ID segments should satisfy the regex expression `[a-z]([a-z0-9-]{0,61}[a-z0-9])?`, e.g. 1-63 characters of lowercase letters, numbers, and dashes, starting with a letter, and ending with a letter or number. The prefix of the instance resource name is the name of the parent resource: * projects/{project}/locations/{region}/clusters/{cluster_id} This field is REQUIRED.
- sqlStatement: stringrequired
  Required. SQL statement to execute on database. Any valid read-only statement is permitted. DDL and DML statements are not allowed. This field is REQUIRED.
export_dataoutputSchema declared
Exports data from an AlloyDB cluster to a file in Google Cloud Storage. ***Requirements*** * The cluster and primary instance must exist and be in a READY state. * The Google Cloud Storage bucket must exist. * The AlloyDB service account must have the `storage.objectAdmin` IAM role to write to the bucket. The AlloyDB service account is in the format of service-{project_number}@gcp-sa-alloydb.iam.gserviceaccount.com. {project_number} is a valid base-10 encoded positive integer. ***Usage*** 1. Call `export_data` to export data from a cluster to a Cloud Storage bucket. 2. This will return a long-
Input csvExportOptions?: any, database: string, gcsDestination: any, name: string, sqlExportOptions?: any
- csvExportOptions?: anyoptional
  Options for exporting data in CSV format. Required field to be set for CSV file type. Only one of this field or sqlExportOptions should be set.
- database: stringrequired
  Required. Name of the database where the export command will be executed. Note - Value provided should be the same as expected from `SELECT current_database();` and NOT as a resource reference.
- gcsDestination: anyrequired
  Required. Option to export data to cloud storage.
- name: stringrequired
  Required. The resource name of the cluster.
- sqlExportOptions?: anyoptional
  Options for exporting data in SQL format. Required field to be set for SQL file type. Only one of this field or csvExportOptions should be set.
get_clusteroutputSchema declared
Get a cluster
Input name: string, view?: string
- name: stringrequired
  Required. The name of the resource. For the required format, see the comment on the Cluster.name field.
- view?: stringoptional
  Optional. The view of the cluster to return. Returns all default fields if not set.
get_instanceoutputSchema declared
Get an instance
Input name: string, view?: string
- name: stringrequired
  Required. The name of the resource. For the required format, see the comment on the Instance.name field.
- view?: stringoptional
  The view of the instance to return.
get_operationoutputSchema declared
Gets the status of a long-running operation. ***Usage*** Some tools (for example, `create_cluster` and `create_instance`) return a long-running operation. You can use this tool to get the status of the operation. A long-running operation can take several minutes to complete. If an operation takes an extended amount of time, then wait at least 30 seconds between each call to this tool to check the status of the operation. **Parameters** * `name`: The name of the operation to get. * `name` should be the name returned by the tool that initiated the operation. * `name` should be in the format of `
Input name?: string
- name?: stringoptional
  The name of the operation resource.
get_useroutputSchema declared
Get a user in a given project, location, and cluster
Input name: string
- name: stringrequired
  Required. The name of the resource. For the required format, see the comment on the User.name field.
import_dataoutputSchema declared
Imports data into an AlloyDB cluster from a file stored in a Google Cloud Storage bucket. ***Requirements*** * The cluster must exist, and be in a READY state. * The primary instance must exist and be in a READY state. * The import file must be located in a Cloud Storage bucket. * The AlloyDB cluster's storage will scale up to only the storage quota limit. The imported data should be less than that limit. Compressed data (.gz) is supported to reduce the import size. * The AlloyDB service account must have the `storage.objectViewer` IAM role to read from the bucket. The AlloyDB service account
Input csvImportOptions?: any, database?: string, gcsUri: string, name: string, sqlImportOptions?: any, user?: string
- csvImportOptions?: anyoptional
  Options for importing data in CSV format. Only one of this field or sqlImportOptions should be set.
- database?: stringoptional
  Optional. Name of the database to which the import will be done. For import from SQL file, this is required only if the file does not specify a database. Note - Value provided should be the same as expected from `SELECT current_database();` and NOT as a resource reference.
- gcsUri: stringrequired
  Required. The path to the file in Google Cloud Storage where the source file for import will be stored. The URI is in the form `[REDACTED URI]
- name: stringrequired
  Required. The resource name of the cluster.
- sqlImportOptions?: anyoptional
  Options for importing data in SQL format. Only one of this field or csvImportOptions should be set.
- user?: stringoptional
  Optional. Database user to be used for importing the data. Note - Value provided should be the same as expected from `SELECT current_user;` and NOT as a resource reference.
list_clustersoutputSchema declared
List all clusters
Input filter?: string, orderBy?: string, pageSize?: integer, pageToken?: string, parent: string
- filter?: stringoptional
  Optional. Filtering results
- orderBy?: stringoptional
  Optional. Hint for how to order the results
- pageSize?: integeroptional
  Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
- pageToken?: stringoptional
  A token identifying a page of results the server should return.
- parent: stringrequired
  Required. The name of the parent resource. For the required format, see the comment on the Cluster.name field. Additionally, you can perform an aggregated list operation by specifying a value with the following format: * projects/{project}/locations/-
list_instancesoutputSchema declared
List all instances in a cluster
Input filter?: string, orderBy?: string, pageSize?: integer, pageToken?: string, parent: string
- filter?: stringoptional
  Optional. Filtering results
- orderBy?: stringoptional
  Optional. Hint for how to order the results
- pageSize?: integeroptional
  Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
- pageToken?: stringoptional
  A token identifying a page of results the server should return.
- parent: stringrequired
  Required. The name of the parent resource. For the required format, see the comment on the Instance.name field. Additionally, you can perform an aggregated list operation by specifying a value with one of the following formats: * projects/{project}/locations/-/clusters/- * projects/{project}/locations/{region}/clusters/-
list_usersoutputSchema declared
List all users in a given project, location, and cluster
Input filter?: string, orderBy?: string, pageSize?: integer, pageToken?: string, parent: string
- filter?: stringoptional
  Optional. Filtering results
- orderBy?: stringoptional
  Optional. Hint for how to order the results
- pageSize?: integeroptional
  Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
- pageToken?: stringoptional
  Optional. A token identifying a page of results the server should return.
- parent: stringrequired
  Required. Parent value for ListUsersRequest
restore_clusteroutputSchema declared
Restores an AlloyDB cluster from a given backup or a source cluster and a timestamp. ***Requirements*** * Depending on the source type, the requirements are different. * For a backup source, the backup resource must exist. The backup resource can be created on-demand or from an automated system. * For a continuous backup (also known as PITR) source, the source cluster must exist and have continuous backup enabled. * For a backup and disaster recovery source, the backup resource must exist inside the backup vault. * For a backup and disaster recovery point in time recovery source, the data sour
Input backupdrBackupSource?: any, backupdrPitrSource?: any, backupSource?: any, clusterId: string, continuousBackupSource?: any, network?: string, parent: string, pscEnabled?: boolean
- backupdrBackupSource?: anyoptional
  Backup and Disaster Recovery backup source. The name of the backup resource must be in the format of projects/{project}/locations/{location}/backupVaults/{backupvault_id}/dataSources/{datasource_id}/backups/{backup_id}. - {project} is the project that the backup resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive integer. - {location} is the Google Cloud region that the backup resides in. Regions will have format like "us-cent
- backupdrPitrSource?: anyoptional
  Backup and Disaster Recovery source used for point in time recovery. The name of the backup resource with the format: projects/{project}/locations/{location}/backupVaults/{backupvault_id}/dataSources/{datasource_id}. - {project} is the project that the backup resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive integer. - {location} is the Google Cloud region that the backup resides in. Regions will have format like "us-central
- backupSource?: anyoptional
  AlloyDB backup to restore from. This must either be the full backup name or the backup_id. In the second case, the project and location are assumed to be the same as the restored clusters that is being created. If using the full backup name, then it must be in the format of projects/{project}/locations/{location}/backups/{backup_id}. - {project} is the project that the backup resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive
- clusterId: stringrequired
  Required. The cluster ID is the unique user-assigned ID of the restored cluster. It should be an alphanumeric string that can consist of lowercase letters, numerical digits, or dash characters ("-"). This field is REQUIRED.
- continuousBackupSource?: anyoptional
  The continuous backup source can be specified to use a source cluster from which to restore, and the point in time to restore to. Continuous backup needs to be enabled in the source cluster for this operation to succeed. The source cluster needs to be in the format of projects/{project}/locations/{location}/clusters/{cluster_id}. - {project} is the project that the cluster resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive in
- network?: stringoptional
  The network is the VPC network that the cluster will reside in. Specifying this field will enable Private Google Access. This field is OPTIONAL, and if specified, it should have format like "projects/{project}/global/networks/{network_id}". This field should not be specified if psc_enabled is true.
- parent: stringrequired
  Required. The parent resource in which to create the backup. The value must have a format of projects/{project}/locations/{location}. - {project} is the project that the backup resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ("-") characters. - Project number: A valid base-10 encoded positive integer. - {location} is the Google Cloud region that the backup resides in. Regions will have format like "us-central1" or "us-west2". The field is REQUIRED.
- pscEnabled?: booleanoptional
  Configures whether Private Service Connect is enabled for the cluster. This field is OPTIONAL. If neither network nor psc_enabled is specified, the default behavior will be to enable Private Service Connect.
update_instanceoutputSchema declared
Updates an AlloyDB instance. ***Requirements*** * The instance that is being updated must exist and be in a READY state. You can use the `list_instances` tool to list all instances in a cluster. ***Usage*** 1. Call `update_instance` to update an instance. 2. This will return a long-running operation that indicates the progress of the instance update. 3. You can poll the status of the operation using the `get_operation` tool. 4. Once the long-running operation is complete, the instance will be in a READY state.
Input activationPolicy?: string, authorizedExternalNetworks?: array, availabilityType?: string, cpuCount?: integer, databaseFlags?: object, enablePublicIp?: boolean, instance: string, machineType?: string, pscInstanceConfig?: any, readPoolNodeCount?: integer
- activationPolicy?: stringoptional
  Optional. The activation policy for the instance. This field is OPTIONAL.
- authorizedExternalNetworks?: arrayoptional
  Optional. A list of CIDR ranges that are authorized to connect to public IP. Authorized external networks are only allowed for instances with public IP enabled. This field is OPTIONAL.
- availabilityType?: stringoptional
  Optional. The availability type of the instance. This field is OPTIONAL.
- cpuCount?: integeroptional
  Optional. The number of CPUs for the instance. This field is OPTIONAL.
- databaseFlags?: objectoptional
  Optional. The database flags for the instance. This field is OPTIONAL.
- enablePublicIp?: booleanoptional
  Optional. Enables Public IP for this instance. Enabling public IP requires having the database flag `password.enforce_complexity` enabled. This field is OPTIONAL.
- instance: stringrequired
  Required. Identifier. The name of the instance resource. The value must have a format of projects/{project}/locations/{region}/clusters/{cluster_id}/instances/{instance_id}. - {project} is the project that the instance resides in. This field can be specified either as: - Project ID: An alphanumeric string that can consist of lowercase letters, numerical digits, or dash ('-') characters. - Project number: A valid base-10 encoded positive integer. - {region} is the Google Cloud region that the instance resides in. Regions will have a format like "us-central1" or "us-west2". - {cluster_id} is the
- machineType?: stringoptional
  Optional. The machine type of the instance. This field is OPTIONAL.
- pscInstanceConfig?: anyoptional
  Optional. The configuration for Private Service Connect (PSC) for the instance. If automatic creation of PSC endpoints is desired, then configs for PSC auto connections must be specified. If unspecified, PSC endpoints will need to be created manually. This field is OPTIONAL.
- readPoolNodeCount?: integeroptional
  Optional. The number of read pool nodes for the instance. This field is OPTIONAL.