Google Cloud Memorystore for Redis API
Browse all Google APIs42
AI ReadinessFoundational (D-)42/100
Official vendor OpenAPI document · agent-readyStorageDatabaseoauth220 EndpointsREST
For Agents
Provision, scale, back up, and fail over fully managed Redis instances on Google Cloud, and retrieve their connection auth strings programmatically.
Use for: Provision a 5GB managed Redis instance in europe-west1 for a session cache, Trigger a failover on the staging Redis instance to test replica promotion, Export the production Redis instance to Cloud Storage as a backup, Get the AUTH string for connecting to my Memorystore instance
Not supported: Does not execute Redis data-plane commands such as GET, SET, or PUBLISH, transfer data between regions automatically, or run the Redis protocol - use for control-plane lifecycle of managed instances only.
The Google Cloud Memorystore for Redis API creates and manages fully managed Redis instances and clusters on Google Cloud, including provisioning, resizing, version upgrades, failover, backup, import, and export operations. It exposes long-running operations for instance lifecycle changes, retrieves auth strings for client connection, and supports cluster maintenance scheduling and rescheduling. The service is a drop-in target for applications using Redis caching, session storage, and pub/sub patterns inside Google Cloud.
Install Jentic One Beta
Connect the Google Cloud Memorystore for Redis API to your agent
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Google Cloud Memorystore for Redis API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
1
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fgoogleapis.com%2Fredis" | sh2
Step 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fgoogleapis.com%2Fredis" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
Capabilities
What an agent can do with Google Cloud Memorystore for Redis API.
Provision and delete managed Redis instances across regions with configurable tier and memory size
Trigger manual failover from a primary to replica node to validate high-availability behavior
Export an instance to a Cloud Storage RDB file and import a snapshot back into a target instance
Schedule and reschedule cluster maintenance windows to control when patching occurs
Retrieve the AUTH string for a Redis instance so clients can authenticate without storing static secrets
Track long-running operations for create, update, and import flows until they complete or are cancelled
Use Cases
Patterns agents use Google Cloud Memorystore for Redis API for, with concrete tasks.
★ Self-service Redis provisioning
Application teams request a Redis instance through an internal portal, an agent calls the Memorystore API to create it with the right tier and memory size, polls the returned long-running operation, and stores the resulting auth string in the team's secret manager. The instance is ready for use without an SRE manually clicking through the console.
Call POST /v1beta1/{+parent}/instances with tier=STANDARD_HA and memorySizeGb=5, poll the returned operation until done, then GET /v1beta1/{+name}/authString.
Disaster recovery snapshots
An agent runs a nightly backup job that exports each production Redis instance to a regional Cloud Storage bucket, retains the last 14 RDB files, and validates that the export operation completed successfully. The Memorystore export endpoint produces RDB files that can be imported back into a recovery instance during incident response.
Iterate Redis instances under projects/my-prod, call POST /v1beta1/{+name}:export with destination=gs://backups/redis/INSTANCE-DATE.rdb on each, and verify the long-running operations complete.
Failover testing on a schedule
Resilience engineers run a weekly chaos test: an agent calls failover on a non-production Redis instance, monitors the operation, runs a synthetic workload to confirm replica promotion, and reports the recovery time back to a metrics store. The Memorystore failover endpoint accepts a data protection mode parameter for limiting data loss tolerance.
Call POST /v1beta1/{+name}:failover on staging-cache with dataProtectionMode=LIMITED_DATA_LOSS and capture the elapsed time of the returned operation.
Agent-managed cache lifecycle through Jentic
An AI agent provisions ephemeral Redis instances for short-lived test environments through Jentic. It searches for the create operation by intent, runs the call, captures the auth string, hands it to the test runner, and tears the instance down on completion. Credentials never enter the agent's context.
Search Jentic for 'provision google cloud redis instance', execute the create call against projects/test-env, then call delete after the test job exits.
Key Endpoints
20 endpoints — the google cloud memorystore for redis api creates and manages fully managed redis instances and clusters on google cloud, including provisioning, resizing, version upgrades, failover, backup, import, and export operations.
METHOD
PATH
DESCRIPTION
POST
/v1beta1/{+parent}/instances
Create a Redis instance
GET
/v1beta1/{+name}
Get a Redis instance or operation
PATCH
/v1beta1/{+name}
Update a Redis instance
DELETE
/v1beta1/{+name}
Delete a Redis instance
GET
/v1beta1/{+name}/authString
Retrieve the AUTH string for an instance
POST
/v1beta1/{+name}:failover
Trigger a failover to a replica
POST
/v1beta1/{+name}:export
Export an instance to Cloud Storage
POST
/v1beta1/{+name}:import
Import an RDB snapshot into an instance
POST
/v1beta1/{+parent}/instances
Create a Redis instance
GET
/v1beta1/{+name}
Get a Redis instance or operation
PATCH
/v1beta1/{+name}
Update a Redis instance
DELETE
/v1beta1/{+name}
Delete a Redis instance
GET
/v1beta1/{+name}/authString
Retrieve the AUTH string for an instance
POST
/v1beta1/{+name}:failover
Trigger a failover to a replica
POST
/v1beta1/{+name}:export
Export an instance to Cloud Storage
POST
/v1beta1/{+name}:import
Import an RDB snapshot into an instance
Jentic AI Readiness Score
This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.
G
Google Cloud Memorystore for Redis API
- Foundational (D-)42/100
51
Foundational Compliance56
Developer Experience & Jentic Compatibility20
AI-Readiness & Agent Experience94
Agent Usability63
Security61
AI DiscoverabilityPowered by JenticScoring Framework 1.0.0 | Scoring Engine 0.4.0
Show dimension breakdown
51
Foundational Compliance
Base layer of spec validity and structural soundness.
Grade: C-Signals: 4
63%
Lint Results
Aggregated quality score from linter diagnostics, weighted by severity.
100%
Resolution Completeness
Percentage of `$ref` references that resolve successfully.
0%
Specification Validity
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
42%
Structural Integrity
Structural correctness score based on schema issues using logarithmic dampening.
56
Developer Experience & Jentic Compatibility
Clarity, completeness, and ingestion readiness for developers and tooling.
Grade: CSignals: 4
0%
Example Density
How richly the API is illustrated with examples.
100%
Example Validity
Percentage of examples that conform to their schemas.
25%
Response Coverage
Percentage of operations with complete response definitions (success, client error, server error).
100%
Tooling Readiness
Health of API ingestion, bundling, and resolution within Jentic pipelines.
20
AI-Readiness & Agent Experience
Semantic breadth, depth, and agent comprehension for AI systems.
Grade: FSignals: 4
81%
Description Coverage
Coverage of descriptions across API elements.
0%
Error Standardization
Coverage of RFC 9457 Problem Details for error responses.
0%
OperationId Quality
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
0%
Summary Coverage
Coverage of summaries across operations/tags/info.
94
Agent Usability
Functional utility, complexity comfort, and AI orchestration readiness.
Grade: A+Signals: 1
94%
Complexity Comfort
Agent comfort level based on API operational and structural complexity.
63
Security
Trust, risk posture, and security compliance.
Grade: B-Signals: 1
62%
Authentication Strength
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
61
AI Discoverability
Findability, semantic richness, and reasoning readiness.
Grade: B-Signals: 1
61%
Descriptive Richness
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>Why Jentic?
What agents get from Jentic-routed access to this vendor.
Setup
Wiring the Memorystore for Redis API by hand means configuring Google OAuth 2.0, refreshing scoped access tokens, and tracking instance resource names across the control-plane and long-running operations on redis.googleapis.com. Through Jentic you install once, import the Memorystore for Redis API from the API Directory, store the OAuth credential once, and your agent calls it.
Permission scoping
This API puts the instance in the URL path (/v1beta1/{+name} and /v1beta1/{+parent}/instances), so a rule can pin your agent to one Memorystore instance: it can read and patch that instance and nothing else. You choose the operations it may call, so state-changing ones like failover, import, or delete are not included unless you add them.
Credential isolation
Your Google OAuth credential is stored once, encrypted, by your own Jentic One instance and a scoped access token is injected at execution time. The credential never enters the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'create a Redis instance' or 'failover a Memorystore instance', and Jentic returns the matching Memorystore operation with its input schema so the agent calls the right endpoint without reading the discovery document.
Related APIs
Alternatives and complements available in the Jentic catalogue.
FAQs
Specific to using Google Cloud Memorystore for Redis API through Jentic.
What authentication does the Memorystore for Redis API use?
The control-plane API uses Google OAuth 2.0 with the cloud-platform scope, declared as Oauth2 and Oauth2c. Once an instance exists, the data-plane Redis connection uses the AUTH string returned from /v1beta1/{+name}/authString, which Jentic stores encrypted in its vault rather than exposing to the agent context.
Can I run a manual Redis failover with the Memorystore API?
Yes. POST /v1beta1/{+name}:failover triggers a failover from primary to replica on STANDARD_HA tier instances, with an optional dataProtectionMode parameter of LIMITED_DATA_LOSS or FORCE_DATA_LOSS. The call returns a long-running operation that the agent can poll with GET /v1beta1/{+name}/operations until done.
What are the rate limits for the Memorystore for Redis API?
Google Cloud applies per-project quotas to control-plane Memorystore calls; mutating operations such as create, update, and import are limited to a small number of concurrent long-running operations per project, while reads have a per-minute quota that can be raised through the Cloud Console. There is no per-call charge inside the documented quotas.
How do I provision a Redis instance through Jentic?
Search Jentic for 'provision google cloud redis instance', load the schema for POST /v1beta1/{+parent}/instances, and execute with the desired tier and memorySizeGb. Jentic surfaces the long-running operation handle so the agent can poll for completion before retrieving the auth string.
Is Memorystore for Redis free?
The API itself is free to call within Google Cloud quotas, but Memorystore instances are billed per gigabyte-hour by tier (BASIC or STANDARD_HA) and region. Backup exports incur Cloud Storage charges for the resulting RDB files.
Can I import an RDB snapshot back into a Memorystore instance?
Yes. POST /v1beta1/{+name}:import accepts a Cloud Storage URI to an RDB file and replaces the contents of the target instance. The instance must be of an equal or larger memory size than the snapshot, and the operation is exposed as a long-running operation suitable for polling.
Can I limit what my agent is allowed to do with the Google Cloud Memorystore for Redis API?
Yes. Because this API puts the instance in the URL path (/v1beta1/{+name} and /v1beta1/{+parent}/instances), a rule in your self-hosted Jentic One can pin the agent to a single Memorystore instance, letting it read and patch that instance and nothing else. You decide which operations the agent may call, so state-changing ones like failover, import, and delete are excluded unless you add them yourself. Your Google OAuth credential stays under your own control and a scoped token is injected only at execution time, so it never reaches the agent's context.
GET STARTED