Which integrations are available for this server?

Allows AI tools to read Redux state, list actions, dispatch actions, and reset state history via MCP tools and WebSocket.

How do I use redux-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@redux-mcp show me the current Redux state" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

redux-mcp

by n1snt

Overview Schema Related Servers Score Discussions

TypeScript

Local

redux-mcp

redux-mcp lets AI tools (via MCP) and your app connect to Redux state in a simple way.

It gives you:

MCP tools to read state, list actions, dispatch actions, and reset history
A WebSocket runtime for live state updates
A simple API to register your own Redux stores

What It Does

After integration, LLMs or clients can:

read current Redux state
see available/observed actions
dispatch actions into your store
receive live updates over WebSocket

Related MCP server: Godot MCP Bridge

Install

Use in your app:

npm install redux-mcp

For local development of this repo:

npm install

Integrate In Your App

Quick start (auto-start runtime)

import "redux-mcp";

This auto-starts the runtime WebSocket server on:

ws://localhost:8788/redux-events

Register your Redux stores (recommended)

import { registerStoresForMCP } from "redux-mcp";

registerStoresForMCP({
  stores: [{ storeName: "app", store }],
});

Notes:

store should provide getState() and dispatch(...)
multiple stores are supported
action types are learned from observed dispatched actions

Manual runtime control (optional)

import { startReduxRuntimeServers } from "redux-mcp";

const runtime = startReduxRuntimeServers({
  websocketPort: 8788,
  websocketPathname: "/redux-events",
});

// runtime.stop();

Install MCP In Cursor

Add this to Cursor MCP config:

{
  "mcpServers": {
    "redux-mcp": {
      "command": "npx",
      "args": ["-y", "redux-mcp"]
    }
  }
}

If Cursor cannot find npx (spawn npx ENOENT), use the absolute npx path instead:

{
  "mcpServers": {
    "redux-mcp": {
      "command": "/absolute/path/to/npx",
      "args": ["-y", "redux-mcp"]
    }
  }
}

Then restart MCP servers in Cursor.

Available tools:

redux_get_state
redux_get_state_diff
redux_get_actions
redux_dispatch_action
redux_reset_state

For detailed Cursor setup: documentation/cursor-mcp-setup.md.

Available Tools

5 tools

redux_dispatch_actionDispatch Redux ActionC

Dispatch an action to the Redux store.

ParametersJSON Schema

Name	Required	Description
`type`	Yes	Redux action type to dispatch, for example `counter/increment`.
`payload`	No	Optional action payload passed through as `action.payload`.
`storeName`	No	Optional target store name when multiple stores are registered.

TDQS

C2.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states the tool dispatches an action (implying mutation) but offers no details on side effects, permissions, or reversibility, which is critical for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very concise (one sentence), but it is too sparse given the tool's complexity. It does not include enough information to earn its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations and output schema, and the tool's nature as an action dispatcher with three parameters, the description is insufficient. It lacks information about return values, error conditions, and behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema covers all three parameters (type, payload, storeName) with descriptions, giving schema coverage of 100%. The description adds no additional meaning beyond what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb "Dispatch" and the resource "action to the Redux store," making the basic purpose apparent. However, it does not explicitly distinguish this tool from its siblings (e.g., redux_get_state), though the action is inherently different.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It leaves the agent to infer usage from context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

redux_get_actionsGet Redux ActionsB

Return available actions and optionally dispatched history.

ParametersJSON Schema

Name	Required	Description	Default
`includeHistory`	No	Whether to include previously dispatched actions in the response. Defaults to true.

TDQS

B3.4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries the burden. It states it returns data but does not explicitly confirm it is read-only or non-destructive. However, the name 'get_actions' implies safe retrieval, and no side effects are mentioned. Adequate but not thorough.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, no fluff, front-loads purpose. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, yet the description does not specify the structure of returned actions or history. Lacks details on format (e.g., array of strings, objects) or behavior when includeHistory is false. Incomplete for an agent to fully understand the response.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema describes the single parameter 'includeHistory' with a clear description and default. The tool description adds no further meaning, so scores at baseline given 100% schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns available actions and optionally dispatched history. It distinguishes itself from siblings like redux_dispatch_action and redux_get_state by focusing on action listing and history retrieval.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool vs siblings. Does not mention that it is ideal for inspecting available action types before dispatching or for debugging dispatched actions, nor does it exclude cases where history is not needed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

redux_get_stateGet Redux StateA

Return the current Redux store snapshot.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description 'return' implies a non-destructive read, which is transparent. With no annotations, it carries the burden well by indicating the operation is safe and stateless.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, perfectly front-loaded, no wasted words. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

A simple getter with no output schema; describing the return as 'Redux store snapshot' is sufficient. Could specify depth or format, but not necessary for clarity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so schema coverage is 100% by default. The description provides no parameter info, which is fine since none are needed. Baseline 4 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Return the current Redux store snapshot,' with a specific verb and resource. It distinguishes itself from sibling tools like redux_dispatch_action (dispatch) and redux_get_state_diff (diff).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives. However, the purpose is self-evident as a simple read operation, so it's minimally adequate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

redux_get_state_diffGet Redux State DiffA

Return field-level changes between current state and the previous snapshot (or a provided baseline).

ParametersJSON Schema

Name	Required	Description	Default
`previousState`	No	Optional baseline state to diff against. If omitted, the tool uses its last remembered snapshot.
`rememberCurrentAsPrevious`	No	Whether to store the current state as the next baseline snapshot. Defaults to true.

TDQS

A4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries full burden. It discloses the side effect of rememberCurrentAsPrevious (storing the snapshot), and clearly states the tool provides diffs. However, it does not explicitly state whether the tool is read-only overall or if authentication is required, though the getter-like name implies safety.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, well-structured sentence that front-loads the core purpose. Every word adds value with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (2 params, no output schema, no nested objects), the description sufficiently explains the operation. It could mention the return format (e.g., a diff object) but is otherwise complete for its scope.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and schema descriptions already explain both parameters clearly. The tool description adds context about 'field-level changes' and 'previous snapshot' but does not significantly enhance meaning beyond the schema's own descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns field-level changes between current state and a previous snapshot or provided baseline. It uses a specific verb ('Return') and resource ('field-level changes'), and distinguishes itself from siblings like redux_get_state (which returns the whole state) by focusing on diffs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage through the parameter explanation ('if omitted, uses last remembered snapshot'), but lacks explicit guidance on when to use this tool versus alternatives like redux_get_state or redux_get_actions. No mention of prerequisites or when not to use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

redux_reset_stateReset Redux StateA

Reset Redux state and action history to initial values.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses resetting state and action history but fails to mention side effects (e.g., irreversibility, loss of unsaved data) or any behavioral traits beyond the basic action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, front-loaded sentence with no wasted words. Every part is necessary and immediately conveys the tool's purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is adequate for a zero-parameter tool but lacks behavioral context (e.g., whether the reset is reversible, affects other users, or returns a confirmation). Given no output schema or annotations, more detail would be helpful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters, so description does not need to add param info. Baseline is 4; the description correctly identifies what is reset, which is sufficient.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Reset' and the resource 'Redux state and action history', distinguishing it from siblings which perform reading (get_state, get_actions) or dispatching actions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives; it does not specify prerequisites, consequences, or conditions under which resetting is appropriate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

5 tool updatesv0.1.3Jul 12, 2026
- First observedredux_dispatch_action
- First observedredux_get_actions
- First observedredux_get_state
- First observedredux_get_state_diff
- First observedredux_reset_state

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.8/5.0

Disambiguation5/5

Each tool serves a unique purpose: dispatching actions, retrieving actions/history, getting state, computing state diffs, and resetting state. No overlaps exist.

Naming Consistency5/5

All tools follow the consistent pattern 'redux_verb_noun', using snake_case and clear verbs (dispatch, get, reset). No deviations.

Tool Count5/5

Five tools cover the essential operations for Redux state management without being excessive or insufficient. The count matches the domain scope.

Completeness5/5

The set covers all key Redux interactions: dispatching, reading state, diffing, resetting, and viewing action history. No obvious gaps for a basic server.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

6DuckLearn MCP
com.6ducklearn
Connect agents to 6DuckLearn memory, approvals, and runtime control.
Knowledge & Memory Autonomous Agents
21
mcpOAuth
com.vibgrate
Query your team's drift, vulnerability, and upgrade data from any AI assistant. OAuth 2.1, 51 tools.
Security Monitoring
2
mcp-serverOAuth
com.make
Give your AI agents the tools to build, manage, and run automation workflows.
App Automation Developer Tools Workplace & Productivity
2
alloyOAuth
ai.usealloy
Connect Claude, Cursor, Codex, and other AI tools to your robotics mission data.
Data Platforms AI & Machine Learning
2

Related MCP Servers

SillyTavern MCP Server
Agent Orchestration Developer Tools
CG-Labs
F
license
Not graded
quality
C
maintenance
Enables external tool registration and execution through WebSocket-based communication, providing a unified interface for real-time tool management within SillyTavern.
Updated 2 years ago (2025-01-23 21:58 UTC)
27
-
Godot MCP Bridge
Games & Gamification Developer Tools
farrasfadhils
F
license
C
quality
F
maintenance
Enables AI assistants to control Godot game engine projects through a WebSocket bridge. Supports scene editing, node manipulation, script management, and project introspection via 163 registered tools.
Updated 5 months ago (2026-04-04 10:09 UTC)
100
1
-
Tesseron
App Automation Developer Tools Autonomous Agents
Eigenwise
F
license
Not graded
quality
B
maintenance
Enables MCP-compatible AI agents to execute typed live-app actions over WebSocket, allowing agents to directly interact with real application state without browser automation or scraping.
Updated 16 days ago (2026-08-21 07:33 UTC)
20
-
state-bridge-mcp
jonjoe
F
license
A
quality
D
maintenance
Bridges Zustand stores over WebSocket, enabling MCP-capable AI to inspect and manipulate live application state.
Updated 6 months ago (2026-03-12 20:51 UTC)
5
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/n1snt/redux-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server