Redis MCP

Instructions

Implementation Reference

• src/services/mcpService.ts:1330-1356 (handler)

  The MCP tool handler method for 'backup_create' that ensures Redis connection, prepares backup options from args, delegates to RedisBackupService.backup(), and formats the response as MCP content.

  private async handleBackupCreate(args: any) {
    this.ensureRedisConnection();
    if (!this.backupService) {
      throw new McpError(
        ErrorCode.InternalError,
        'Backup service not initialized'
      );
    }
    
    const options: RedisBackupOptions = {
      filename: args.filename,
      path: args.path,
      includePatterns: args.includePatterns,
      excludePatterns: args.excludePatterns
    };
    
    const result = await this.backupService.backup(options);
    
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result, null, 2)
        }
      ]
    };
  }

• src/services/mcpService.ts:579-599 (schema)

  Tool metadata and input schema definition for 'backup_create' returned by ListToolsRequestSchema handler.

  {
    name: 'backup_create',
    description: '创建 Redis 数据备份',
    inputSchema: {
      type: 'object',
      properties: {
        filename: { type: 'string', description: '备份文件名（可选）' },
        path: { type: 'string', description: '备份路径（可选）' },
        includePatterns: { 
          type: 'array', 
          items: { type: 'string' },
          description: '包含的键模式数组（可选，默认为 ["*"]）' 
        },
        excludePatterns: { 
          type: 'array', 
          items: { type: 'string' },
          description: '排除的键模式数组（可选）' 
        }
      }
    }
  },

• src/services/mcpService.ts:704-705 (registration)

  Registration/dispatch case in the CallToolRequestSchema switch statement that maps 'backup_create' tool calls to the handler method.

  case 'backup_create':
    return await this.handleBackupCreate(args);

• src/services/backupService.ts:19-141 (helper)

  Core helper method implementing backup logic: processes include/exclude patterns, fetches keys, retrieves data and TTL by Redis data type (string/hash/list/set/zset), saves structured data to timestamped JSON file in backups directory.

  async backup(options: RedisBackupOptions = {}): Promise<RedisOperationResult<string>> {
    try {
      // 设置默认选项
      const filename = options.filename || `redis-backup-${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
      const backupPath = options.path || './backups';
      const includePatterns = options.includePatterns || ['*'];
      const excludePatterns = options.excludePatterns || [];
  
      // 确保备份目录存在
      if (!fs.existsSync(backupPath)) {
        fs.mkdirSync(backupPath, { recursive: true });
      }
  
      const fullPath = path.join(backupPath, filename);
      const backupData: Record<string, any> = {};
  
      // 处理包含的模式
      for (const pattern of includePatterns) {
        // 获取匹配的键
        const keysResult = await this.redisService.keys(pattern);
        if (!keysResult.success || !keysResult.data) {
          continue;
        }
  
        const keys = keysResult.data;
        
        // 过滤排除的键
        const filteredKeys = keys.filter(key => {
          return !excludePatterns.some(excludePattern => {
            // 支持简单的通配符匹配
            const regexPattern = excludePattern
              .replace(/\*/g, '.*')
              .replace(/\?/g, '.');
            return new RegExp(`^${regexPattern}$`).test(key);
          });
        });
  
        // 处理每个键
        for (const key of filteredKeys) {
          const typeResult = await this.redisService.type(key);
          if (!typeResult.success || !typeResult.data) {
            continue;
          }
  
          const type = typeResult.data;
          const ttlResult = await this.redisService.ttl(key);
          const ttl = ttlResult.success ? ttlResult.data : -1;
  
          // 根据类型获取数据
          switch (type) {
            case 'string': {
              const valueResult = await this.redisService.get(key);
              if (valueResult.success && valueResult.data !== null) {
                backupData[key] = {
                  type,
                  ttl,
                  value: valueResult.data
                };
              }
              break;
            }
            case 'hash': {
              const valueResult = await this.redisService.hgetall(key);
              if (valueResult.success && valueResult.data) {
                backupData[key] = {
                  type,
                  ttl,
                  value: valueResult.data
                };
              }
              break;
            }
            case 'list': {
              const valueResult = await this.redisService.lrange(key, 0, -1);
              if (valueResult.success && valueResult.data) {
                backupData[key] = {
                  type,
                  ttl,
                  value: valueResult.data
                };
              }
              break;
            }
            case 'set': {
              const valueResult = await this.redisService.smembers(key);
              if (valueResult.success && valueResult.data) {
                backupData[key] = {
                  type,
                  ttl,
                  value: valueResult.data
                };
              }
              break;
            }
            case 'zset': {
              const valueResult = await this.redisService.zrange(key, 0, -1, true);
              if (valueResult.success && valueResult.data) {
                backupData[key] = {
                  type,
                  ttl,
                  value: valueResult.data
                };
              }
              break;
            }
          }
        }
      }
  
      // 写入备份文件
      fs.writeFileSync(fullPath, JSON.stringify(backupData, null, 2));
  
      return {
        success: true,
        data: `Backup completed successfully. Saved to ${fullPath}`
      };
    } catch (error) {
      return {
        success: false,
        error: `Backup failed: ${error instanceof Error ? error.message : String(error)}`
      };
    }
  }