4,500+ servers built on MCP Fusion
Vinkius

Upstash Redis MCP. Manage cache state directly from your chat or terminal.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Upstash Redis MCP on Cursor AI Code Editor MCP Client Upstash Redis MCP on Claude Desktop App MCP Integration Upstash Redis MCP on OpenAI Agents SDK MCP Compatible Upstash Redis MCP on Visual Studio Code MCP Extension Client Upstash Redis MCP on GitHub Copilot AI Agent MCP Integration Upstash Redis MCP on Google Gemini AI MCP Integration Upstash Redis MCP on Lovable AI Development MCP Client Upstash Redis MCP on Mistral AI Agents MCP Compatible Upstash Redis MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Upstash Redis MCP Server connects your AI agent directly to a serverless Redis instance. It lets you query, read, and write key-value data structures without opening a separate database client.

Use it to manage caches, audit TTLs, debug rate limits, or perform quick atomic operations like incrementing counters straight from your chat or IDE.

What your AI agents can do

Delete

Wipes one or more specified keys from Redis cache.

Get

Pulls the string value associated with a specific key.

Get key info

Reports the data type and Time-To-Live (TTL) remaining on a key.

+ 4 more capabilities included
Read Key Value Data

Retrieves the exact string value stored at a specified key using the get tool.

Set/Update Keys with TTL

Writes a new string value to a key and optionally specifies how long it remains active (TTL) using the set tool.

Scan Key Patterns

Searches for keys matching a specified glob pattern across the database using the list_keys tool.

Check Key Metadata

Gets the data type and current Time-To-Live (TTL) of any key using the get_key_info tool.

Increment/Decrement Counters

Atomically increases or decreases a numeric counter at a specific key, ideal for rate limiting logic via the increment tool.

Clean Up Cache Data

Removes one or more specified keys from the database using the delete tool.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Upstash Redis MCP Server: 7 Tools for Data Operations

These tools let you query, delete, increment, and set string values within your Upstash Redis data structures directly through the agent.

action019d75fd

delete

Wipes one or more specified keys from Redis cache.

action019d75fd

get

Pulls the string value associated with a specific key.

get019d75fd

get key info

Reports the data type and Time-To-Live (TTL) remaining on a key.

action019d75fd

increment

Atomically increases or decreases a numeric counter stored at a key.

list019d75fd

list keys

Scans the database for all keys matching a provided pattern.

action019d75fd

ping

Tests Redis connectivity to verify the instance is running and reachable.

action019d75fd

set

Writes a string value to a key, allowing you to set an optional expiration time (TTL).

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with Upstash Redis, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

Listen up. The Upstash Redis MCP Server connects your agent straight to a serverless Redis cache. You don't gotta open some clunky database client or mess with REST API calls yourself; your AI client handles all that plumbing for you. It lets you treat the cache like it’s right in your terminal, letting you read and write key-value data structures without lifting a finger.

This is how you debug rate limits or manage session caches straight from your chat window.

Reading Data & Writing Values

If you need to grab a value, you use the get tool. You just point it at a specific key, and it pulls out the exact string stored there. Need to put something new in? The set tool handles that. You write a brand-new string value to a given key, and here's the trick: when you run set, you can also tack on an optional expiration time (TTL).

This means you tell it exactly how long that data needs to stay alive before Redis automatically wipes it clean. It’s perfect for temporary session tokens or cached API responses.

Inspecting the Cache State

You gotta know what's in there, right? To see if a key is doing its job, you run get_key_info. This tells you two things: first, what kind of data type it is (is it a string, or something else?), and second, how much Time-To-Live (TTL) it's got left. Need to know everything in the database? Use list_keys.

You feed it a glob pattern—like an asterisk matching anything—and it scans the whole thing, spitting out every key that matches your criteria. That lets you audit large sections of cached data fast.

Handling Counters and Maintenance

Sometimes you're not dealing with strings; you're counting things. The increment tool is for that. You use it to atomically increase or decrease a numeric counter tied to a specific key. This mechanism is killer for rate limiting logic or tracking how many times a user has hit an endpoint—it guarantees the count stays accurate, no matter what.

When you're done with data or need to clear out old garbage, delete does the dirty work. You specify which one or more keys are stale, and it wipes them from the cache entirely. It’s your clean-up crew. Before you trust anything, though, you run ping. This simple check confirms Redis is actually running and reachable, making sure your agent doesn't throw a fit when it tries to connect.

You use these tools together—get pulls data, set writes new data with expiration rules, list_keys finds everything matching a pattern, get_key_info checks the metadata and TTL, increment counts up or down, delete clears out what's stale, and ping confirms you’re live. That gives your agent full command over your cache layer.

How Upstash Redis MCP Works

  1. 1 First, you authorize the Upstash Redis MCP component in your AI client's extensions. You must provide both the REST URL and the REST Token connected to your specific database.
  2. 2 Next, you talk to your agent normally. Instead of typing commands into a CLI, you ask: 'What are all my active session keys?' or 'Increment the user counter for ID 45.'
  3. 3 The agent handles the rest, calling the appropriate tool (like list_keys or increment) and returning the clean, structured data result to you.

The bottom line is: it lets your AI client treat the database like an extension of its own memory, making data operations conversational.

Who Is Upstash Redis MCP For?

Backend developers who hate switching context between their IDE and a separate Redis GUI. DevOps engineers who need to audit rate limits or clear stale cache entries during an active incident. System architects building complex, stateful systems that rely on fast key-value lookups.

Backend Developer

Checks if a cached user profile is valid by running get or clears stale session data using the delete tool without leaving their coding environment.

DevOps Engineer

Audits system rate limits by checking counter keys with list_keys and manually adjusting them via increment during a production incident investigation.

System Architect

Tests data persistence logic by setting temporary mock parameters using set, ensuring the correct TTL is applied before committing code.

What Changes When You Connect

  • Stop opening separate database clients. You manage all key-value data—from basic reads (get) to complex scans (list_keys)—right inside your conversation window.
  • Control time limits instantly. Use the set tool to write a value and enforce an exact TTL, guaranteeing the cache expires when it should.
  • Debug rate limiting on the fly. The increment tool lets you safely increase or decrease numerical counters for testing operational throughput without manual CLI access.
  • Audit data integrity fast. Instead of guessing, run get_key_info to immediately check a key's type and see exactly how many seconds TTL it has left.
  • System health checks are simple. Run the ping tool to confirm connectivity before your agent tries to read or write anything important.

Real-World Use Cases

01

Debugging Stale Session Data

A user notices a cached profile is showing old data. They ask their agent, 'What keys match session:*?'. The agent runs list_keys. The developer then uses the get_key_info tool on one key to verify its TTL and decides to use delete to clear the stale cache entry.

02

Validating Rate Limit Counters

An API endpoint hits a rate limit error. The developer prompts, 'Show me the current user count for ID 789.' The agent uses list_keys to find the counter key, then uses get_key_info and finally runs increment to simulate one more successful call.

03

Seeding Mock Cache Parameters

A developer needs to test a feature that relies on specific product data. Instead of updating the real database, they instruct their agent to use the set tool: 'Set cache:mock_product_id 12345 with a TTL of 60 seconds.' This allows testing without side effects.

04

Full Cache Cleanup

After an application deploy, the team needs to wipe out all temporary data. They prompt: 'Delete every key starting with temp:' The agent uses delete to clear the entire set of keys based on a pattern.

The Tradeoffs

Using broad patterns for scanning

Asking the agent to run 'list_keys' with just '*', expecting it to return everything. This hammers the database and slows down operations.

Always scope your scan. Instead of *, use a specific pattern like 'session:*' or 'cache:product:*'. If you need all data, check documentation first.

Assuming persistence without TTL

Setting a value with the intention that it expires naturally, but forgetting to specify an expiration time. The key stays forever.

Always use set and include a specific TTL parameter (e.g., 'set:mykey myval 3600'). This forces temporary data cleanup.

Reading complex objects via GET

Attempting to retrieve structured JSON or nested object state using only the get tool, which treats everything as a single string.

If you need structure, you must handle the deserialization in your agent client's code. Use get_key_info first to confirm the key type if you aren't sure.

When It Fits, When It Doesn't

Use this MCP Server if your primary task involves reading, writing, or manipulating ephemeral data that lives in a simple key-value format (caching, rate limiting, session state). It’s perfect for quick operational checks and data seeding.

Don't use it if you need to perform complex joins, aggregate results across multiple tables, or handle relational logic. For those tasks—like 'show me all users who bought product X in the last week'—you need a full SQL database connection. This tool only deals with simple strings and counters.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Upstash Redis. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 7 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

delete get get_key_info increment list_keys ping set

Checking cache data usually requires jumping between three different tools.

Today, checking if a piece of cached user data is still valid means opening RedisInsight or the command line. You type `GET mykey`, then you run `TTL mykey` to check expiration, and finally, if it's stale, you have to manually issue the `DEL mykey` command. It’s a multi-step process involving context switching.

With this MCP Server, that entire flow is reduced to natural language prompts. You ask your agent to 'Check the session key for user 123.' The agent runs `get_key_info`, tells you the TTL, and if necessary, uses `delete`—all in one turn.

Upstash Redis MCP Server: Manage data persistence from your chat.

Previously, adjusting a counter for testing was cumbersome. You had to switch terminals and remember the exact syntax for incrementing a key, risking typos or running the wrong command entirely.

Now, you just tell your agent: 'Bump the traffic counter by one.' The agent executes `increment` reliably, letting you test operational logic immediately without touching a terminal.

Common Questions About Upstash Redis MCP

How do I check if my cache key is still active using Upstash Redis MCP Server? +

Use the get_key_info tool. This query reports both the data type and the remaining Time-to-Live (TTL) on the key, letting you know exactly how long it's safe to rely on.

What is the best way to clear all temporary cache keys? +

Use list_keys first with a specific pattern, like 'temp:', and then pass that list of keys to the delete tool. Don't use '' for safety.

Can I simulate increasing a rate limit counter using Upstash Redis MCP Server? +

Yes, run the increment tool. It handles atomic counting safely, so you can test what happens when the counter hits its maximum value without risking data corruption.

How do I make sure my connection to Upstash Redis is working? +

Run the ping tool. This immediately verifies connectivity and ensures the service endpoint is responsive before your agent attempts any read or write operation.

Upstash Redis MCP Server — How do I use the `set` tool to give a key a specific Time-To-Live (TTL)? +

You specify the expiration time in seconds when calling set. This ensures the data automatically vanishes after its useful life. Use this when you need temporary cache entries that shouldn't persist forever.

Upstash Redis MCP Server — What pattern should I use with the `list_keys` tool to scan for specific types of data, like user IDs? +

Use a glob pattern that matches your naming convention, such as 'user:'. Remember, avoid broad patterns like '' on large databases; stick to narrow prefixes to keep scans fast.

Upstash Redis MCP Server — If I use the `get` tool for a key that doesn't exist, what response should I expect? +

The system returns null or an empty value. This is standard behavior and lets your agent know cleanly that the data was never stored or has already expired.

Upstash Redis MCP Server — Can I use the `increment` tool to track multiple related operational metrics? +

The increment tool operates on a single key at a time. You must call it separately for each unique metric counter you want to update, like 'login_count' or 'api_call_attempts'.

Where do I locate my Upstash REST URL and Token? +

Sign into your Upstash management console and load your specific Redis cluster. Scroll down visually on the main 'Details' page until you hit the 'REST API' section block. You will see both your 'UPSTASH_REDIS_REST_URL' and the alphanumeric 'UPSTASH_REDIS_REST_TOKEN' ready to be copied.

Can the agent interact with standard Redis connections (redis://)? +

No, this specific MCP connection module specifically utilizes Upstash's serverless HTTP/REST endpoints. It bypasses conventional persistent TCP Redis sockets to provide highly secure and connection-agnostic read/write integrations optimized for AI servers.

Are there limitations to wildcard patterns when doing list_keys? +

Yes, standard Redis operational caveats apply. Searching broadly via a '' (asterisk) scan across massively populated environments isn't recommended. Aim to request the AI narrow down patterns, like 'session:' instead of blank wildcards.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 7 tools

We've already built the connector for Upstash Redis. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 7 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.