diff --git a/libs/common/RespMemoryWriter.cs b/libs/common/RespMemoryWriter.cs
index 8d6ee383374..8a6de25e0f6 100644
--- a/libs/common/RespMemoryWriter.cs
+++ b/libs/common/RespMemoryWriter.cs
@@ -57,7 +57,7 @@ public void WriteAsciiDirect(ReadOnlySpan<char> span)
         }
 
         /// <summary>
-        /// Writes an array str to memory.
+        /// Writes an array item to memory.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteArrayItem(long item)
@@ -192,7 +192,6 @@ public void WriteEmptyMap()
         /// Write simple error to memory.
         /// </summary>
         /// <param name="errorString">An ASCII encoded error string. The string mustn't contain a CR (\r) or LF (\n) bytes.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteError(scoped ReadOnlySpan<byte> errorString)
         {
             while (!RespWriteUtils.TryWriteError(errorString, ref curr, end))
@@ -227,6 +226,18 @@ public void TryWriteFalse()
             }
         }
 
+        /// <summary>
+        /// Write Help output
+        /// </summary>
+        public void WriteHelp(params string[] Help)
+        {
+            WriteArrayLength(Help.Length);
+            foreach (var help in Help)
+            {
+                WriteSimpleString(help);
+            }
+        }
+
         /// <summary>
         /// Write integer to memory.
         /// </summary>
diff --git a/libs/resources/RespCommandsDocs.json b/libs/resources/RespCommandsDocs.json
index e4d86c25bb6..1f9b71e000e 100644
--- a/libs/resources/RespCommandsDocs.json
+++ b/libs/resources/RespCommandsDocs.json
@@ -68,6 +68,13 @@
           }
         ]
       },
+      {
+        "Command": "ACL_HELP",
+        "Name": "ACL|HELP",
+        "Summary": "Show helpful text about the different subcommands",
+        "Group": "Server",
+        "Complexity": "O(1)"
+      },
       {
         "Command": "ACL_LIST",
         "Name": "ACL|LIST",
@@ -944,6 +951,13 @@
         "Group": "Connection",
         "Complexity": "O(1)"
       },
+      {
+        "Command": "CLIENT_HELP",
+        "Name": "CLIENT|HELP",
+        "Summary": "Show helpful text about the different subcommands",
+        "Group": "Server",
+        "Complexity": "O(1)"
+      },
       {
         "Command": "CLIENT_ID",
         "Name": "CLIENT|ID",
@@ -1722,6 +1736,13 @@
           }
         ]
       },
+      {
+        "Command": "COMMAND_HELP",
+        "Name": "COMMAND|HELP",
+        "Summary": "Show helpful text about the different subcommands",
+        "Group": "Server",
+        "Complexity": "O(1)"
+      },
       {
         "Command": "COMMAND_INFO",
         "Name": "COMMAND|INFO",
@@ -1779,6 +1800,13 @@
           }
         ]
       },
+      {
+        "Command": "CONFIG_HELP",
+        "Name": "CONFIG|HELP",
+        "Summary": "Show helpful text about the different subcommands",
+        "Group": "Server",
+        "Complexity": "O(1)"
+      },
       {
         "Command": "CONFIG_REWRITE",
         "Name": "CONFIG|REWRITE",
@@ -5335,6 +5363,13 @@
     "Group": "Server",
     "Complexity": "Depends on subcommand.",
     "SubCommands": [
+      {
+        "Command": "MEMORY_HELP",
+        "Name": "MEMORY|HELP",
+        "Summary": "Show helpful text about the different subcommands",
+        "Group": "Server",
+        "Complexity": "O(1)"
+      },
       {
         "Command": "MEMORY_USAGE",
         "Name": "MEMORY|USAGE",
@@ -5499,6 +5534,13 @@
     "Group": "Server",
     "Complexity": "Depends on subcommand.",
     "SubCommands": [
+      {
+        "Command": "MODULE_HELP",
+        "Name": "MODULE|HELP",
+        "Summary": "Show helpful text about the different subcommands",
+        "Group": "Server",
+        "Complexity": "O(1)"
+      },
       {
         "Command": "MODULE_LOADCS",
         "Name": "MODULE|LOADCS",
@@ -5931,6 +5973,13 @@
           }
         ]
       },
+      {
+        "Command": "PUBSUB_HELP",
+        "Name": "PUBSUB|HELP",
+        "Summary": "Show helpful text about the different subcommands",
+        "Group": "Server",
+        "Complexity": "O(1)"
+      },
       {
         "Command": "PUBSUB_NUMPAT",
         "Name": "PUBSUB|NUMPAT",
@@ -6590,6 +6639,13 @@
           }
         ]
       },
+      {
+        "Command": "SCRIPT_HELP",
+        "Name": "SCRIPT|HELP",
+        "Summary": "Show helpful text about the different subcommands",
+        "Group": "Server",
+        "Complexity": "O(1)"
+      },
       {
         "Command": "SCRIPT_LOAD",
         "Name": "SCRIPT|LOAD",
diff --git a/libs/resources/RespCommandsInfo.json b/libs/resources/RespCommandsInfo.json
index f381ba1548f..5e2a784ee7b 100644
--- a/libs/resources/RespCommandsInfo.json
+++ b/libs/resources/RespCommandsInfo.json
@@ -86,6 +86,13 @@
         "Arity": -2,
         "Flags": "Loading, NoScript, Stale",
         "AclCategories": "Slow"
+      },
+      {
+        "Command": "ACL_HELP",
+        "Name": "ACL|HELP",
+        "Arity": 2,
+        "Flags": "Loading, Stale",
+        "AclCategories": "Slow"
       }
     ]
   },
@@ -524,6 +531,13 @@
         "Flags": "Loading, NoScript, Stale",
         "AclCategories": "Connection, Slow"
       },
+      {
+        "Command": "CLIENT_HELP",
+        "Name": "CLIENT|HELP",
+        "Arity": 2,
+        "Flags": "Loading, Stale",
+        "AclCategories": "Slow"
+      },
       {
         "Command": "CLIENT_ID",
         "Name": "CLIENT|ID",
@@ -1018,6 +1032,13 @@
         "Flags": "Loading, Stale",
         "AclCategories": "Connection, Slow"
       },
+      {
+        "Command": "COMMAND_HELP",
+        "Name": "COMMAND|HELP",
+        "Arity": 2,
+        "Flags": "Loading, Stale",
+        "AclCategories": "Slow"
+      },
       {
         "Command": "COMMAND_INFO",
         "Name": "COMMAND|INFO",
@@ -1053,6 +1074,13 @@
         "Flags": "Admin, Loading, NoScript, Stale",
         "AclCategories": "Admin, Dangerous, Slow"
       },
+      {
+        "Command": "CONFIG_HELP",
+        "Name": "CONFIG|HELP",
+        "Arity": 2,
+        "Flags": "Admin, Loading, NoScript, Stale",
+        "AclCategories": "Slow, Garnet"
+      },
       {
         "Command": "CONFIG_REWRITE",
         "Name": "CONFIG|REWRITE",
@@ -2781,8 +2809,8 @@
         "Command": "LATENCY_HELP",
         "Name": "LATENCY|HELP",
         "Arity": 2,
-        "Flags": "Admin, Loading, NoScript, Stale",
-        "AclCategories": "Slow, Garnet"
+        "Flags": "Loading, Stale",
+        "AclCategories": "Slow"
       },
       {
         "Command": "LATENCY_HISTOGRAM",
@@ -3175,6 +3203,13 @@
     "Arity": -2,
     "AclCategories": "Slow",
     "SubCommands": [
+      {
+        "Command": "MEMORY_HELP",
+        "Name": "MEMORY|HELP",
+        "Arity": 2,
+        "Flags": "Loading, Stale",
+        "AclCategories": "Slow"
+      },
       {
         "Command": "MEMORY_USAGE",
         "Name": "MEMORY|USAGE",
@@ -3285,6 +3320,13 @@
         "Arity": -3,
         "Flags": "Admin, NoAsyncLoading, NoScript",
         "AclCategories": "Admin, Dangerous, Slow"
+      },
+      {
+        "Command": "MODULE_HELP",
+        "Name": "MODULE|HELP",
+        "Arity": 2,
+        "Flags": "Loading, Stale",
+        "AclCategories": "Slow"
       }
     ]
   },
@@ -3636,6 +3678,13 @@
         "Flags": "Loading, PubSub, Stale",
         "AclCategories": "PubSub, Slow"
       },
+      {
+        "Command": "PUBSUB_HELP",
+        "Name": "PUBSUB|HELP",
+        "Arity": 2,
+        "Flags": "Loading, Stale",
+        "AclCategories": "Slow"
+      },
       {
         "Command": "PUBSUB_NUMPAT",
         "Name": "PUBSUB|NUMPAT",
@@ -4035,6 +4084,13 @@
           "response_policy:all_succeeded"
         ]
       },
+      {
+        "Command": "SCRIPT_HELP",
+        "Name": "SCRIPT|HELP",
+        "Arity": 2,
+        "Flags": "Loading, Stale",
+        "AclCategories": "Slow"
+      },
       {
         "Command": "SCRIPT_LOAD",
         "Name": "SCRIPT|LOAD",
diff --git a/libs/server/Lua/LuaCommands.cs b/libs/server/Lua/LuaCommands.cs
index 07d6dcd41ab..05e037e7208 100644
--- a/libs/server/Lua/LuaCommands.cs
+++ b/libs/server/Lua/LuaCommands.cs
@@ -271,6 +271,34 @@ private bool NetworkScriptFlush()
             return true;
         }
 
+
+        /// <summary>
+        /// SCRIPT HELP
+        /// </summary>
+        /// <returns></returns>
+        private bool NetworkScriptHelp()
+        {
+            if (parseState.Count != 0)
+            {
+                return AbortWithWrongNumberOfArguments("script|help");
+            }
+
+            WriteHelp(
+                "SCRIPT <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
+                "EXISTS <sha1> [<sha1> ...]",
+                "\tReturn information about the existence of the scripts in the script cache.",
+                "FLUSH [ASYNC|SYNC]",
+                "\tFlush the Lua scripts cache. Very dangerous on replicas. Valid modes are:",
+                "\t* ASYNC: Asynchronously flush the scripts cache.",
+                "\t* SYNC: Synchronously flush the scripts cache.",
+                "LOAD <script>",
+                "\tLoad a script into the scripts cache without executing it.",
+                "HELP",
+                "\tPrint this help.");
+
+            return true;
+        }
+
         /// <summary>
         /// SCRIPT|LOAD
         /// </summary>
diff --git a/libs/server/Metrics/Latency/RespLatencyCommands.cs b/libs/server/Metrics/Latency/RespLatencyCommands.cs
index d786fd8e083..7e1cacce1c5 100644
--- a/libs/server/Metrics/Latency/RespLatencyCommands.cs
+++ b/libs/server/Metrics/Latency/RespLatencyCommands.cs
@@ -17,18 +17,11 @@ private bool NetworkLatencyHelp()
             // No additional arguments
             if (parseState.Count != 0)
             {
-                return AbortWithErrorMessage($"ERR Unknown subcommand or wrong number of arguments for LATENCY HELP.");
+                return AbortWithWrongNumberOfArguments("latency|help");
             }
 
-            List<string> latencyCommands = RespLatencyHelp.GetLatencyCommands();
-            while (!RespWriteUtils.TryWriteArrayLength(latencyCommands.Count, ref dcurr, dend))
-                SendAndReset();
-
-            foreach (string command in latencyCommands)
-            {
-                while (!RespWriteUtils.TryWriteSimpleString(command, ref dcurr, dend))
-                    SendAndReset();
-            }
+            var latencyCommands = RespLatencyHelp.GetLatencyCommands();
+            WriteHelp(latencyCommands);
 
             return true;
         }
diff --git a/libs/server/Metrics/Latency/RespLatencyHelp.cs b/libs/server/Metrics/Latency/RespLatencyHelp.cs
index 1ba6a2cf392..ac575d42967 100644
--- a/libs/server/Metrics/Latency/RespLatencyHelp.cs
+++ b/libs/server/Metrics/Latency/RespLatencyHelp.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-using System.Collections.Generic;
-
 namespace Garnet.server
 {
     /// <summary>
@@ -14,10 +12,10 @@ static class RespLatencyHelp
         /// Get supported latency commands and a short description
         /// </summary>
         /// <returns></returns>
-        public static List<string> GetLatencyCommands()
+        public static string[] GetLatencyCommands()
         {
-            return new List<string>()
-            {
+            return
+            [
                 "LATENCY <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
                 "HISTOGRAM [EVENT [EVENT...]]",
                 "\tReturn latency histogram of one or more <event> classes.",
@@ -27,7 +25,7 @@ public static List<string> GetLatencyCommands()
                 "\t(default: reset all data for all event classes).",
                 "HELP",
                 "\tPrints this help"
-            };
+            ];
         }
     }
 }
\ No newline at end of file
diff --git a/libs/server/Metrics/Slowlog/RespSlowlogCommands.cs b/libs/server/Metrics/Slowlog/RespSlowlogCommands.cs
index 8dc86db2ee7..3ba5576a5e5 100644
--- a/libs/server/Metrics/Slowlog/RespSlowlogCommands.cs
+++ b/libs/server/Metrics/Slowlog/RespSlowlogCommands.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using Garnet.common;
@@ -23,15 +22,8 @@ private bool NetworkSlowLogHelp()
                 return AbortWithWrongNumberOfArguments(nameof(RespCommand.SLOWLOG_HELP));
             }
 
-            List<string> slowLogCommands = RespSlowLogHelp.GetSlowLogCommands();
-            while (!RespWriteUtils.TryWriteArrayLength(slowLogCommands.Count, ref dcurr, dend))
-                SendAndReset();
-
-            foreach (string command in slowLogCommands)
-            {
-                while (!RespWriteUtils.TryWriteSimpleString(command, ref dcurr, dend))
-                    SendAndReset();
-            }
+            var slowLogCommands = RespSlowLogHelp.GetSlowLogCommands();
+            WriteHelp(slowLogCommands);
 
             return true;
         }
diff --git a/libs/server/Metrics/Slowlog/RespSlowlogHelp.cs b/libs/server/Metrics/Slowlog/RespSlowlogHelp.cs
index 12b6372f7d6..452b60de522 100644
--- a/libs/server/Metrics/Slowlog/RespSlowlogHelp.cs
+++ b/libs/server/Metrics/Slowlog/RespSlowlogHelp.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-using System.Collections.Generic;
-
 namespace Garnet.server
 {
     /// <summary>
@@ -14,10 +12,10 @@ static class RespSlowLogHelp
         /// Get supported latency commands and a short description
         /// </summary>
         /// <returns></returns>
-        public static List<string> GetSlowLogCommands()
+        public static string[] GetSlowLogCommands()
         {
-            return new List<string>()
-            {
+            return
+            [
                 "SLOWLOG <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
                 "GET [<count>]",
                 "\tReturn top <count> entries from the slowlog (default: 10, -1 mean all).",
@@ -30,7 +28,7 @@ public static List<string> GetSlowLogCommands()
                 "\tReset the slowlog.",
                 "HELP",
                 "\tPrints this help"
-            };
+            ];
         }
     }
 }
\ No newline at end of file
diff --git a/libs/server/Resp/ACLCommands.cs b/libs/server/Resp/ACLCommands.cs
index 216363d5b98..a9ee0ceba2c 100644
--- a/libs/server/Resp/ACLCommands.cs
+++ b/libs/server/Resp/ACLCommands.cs
@@ -476,5 +476,48 @@ private bool NetworkAclGetUser()
 
             return true;
         }
+
+        /// <summary>
+        /// Processes ACL HELP subcommand.
+        /// </summary>
+        /// <returns>true if parsing succeeded correctly, false if not all tokens could be consumed and further processing is necessary.</returns>
+        private bool NetworkAclHelp()
+        {
+            // No arguments allowed
+            if (parseState.Count != 0)
+            {
+                return AbortWithWrongNumberOfArguments("acl|help");
+            }
+
+            WriteHelp(
+                "ACL <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
+                "CAT [<category>]",
+                "\tList all commands that belong to <category>, or all command categories",
+                "\twhen no category is specified.",
+                "DELUSER <username> [<username> ...]",
+                "\tDelete a list of users.",
+                "GETUSER <username>",
+                "\tGet the user's details.",
+                "GENPASS [<bits>]",
+                "\tGenerate a secure 256-bit user password. The optional `bits` argument can",
+                "\tbe used to specify a different size.",
+                "LIST",
+                "\tShow users details in config file format.",
+                "LOAD",
+                "\tReload users from the ACL file.",
+                "SAVE",
+                "\tSave the current config to the ACL file.",
+                "SETUSER <username> <attribute> [<attribute> ...]",
+                "\tCreate or modify a user with the specified attributes.",
+                "USERS",
+                "\tList all the registered usernames.",
+                "WHOAMI",
+                "\tReturn the current connection username.",
+                "HELP",
+                "\tPrint this help."
+                );
+
+            return true;
+        }
     }
 }
\ No newline at end of file
diff --git a/libs/server/Resp/AdminCommands.cs b/libs/server/Resp/AdminCommands.cs
index 634203a3f9a..7ea7253d159 100644
--- a/libs/server/Resp/AdminCommands.cs
+++ b/libs/server/Resp/AdminCommands.cs
@@ -39,6 +39,7 @@ private void ProcessAdminCommands<TGarnetApi>(RespCommand command, ref TGarnetAp
             _ = command switch
             {
                 RespCommand.CONFIG_GET => NetworkCONFIG_GET(),
+                RespCommand.CONFIG_HELP => NetworkCONFIG_HELP(),
                 RespCommand.CONFIG_REWRITE => NetworkCONFIG_REWRITE(),
                 RespCommand.CONFIG_SET => NetworkCONFIG_SET(),
                 RespCommand.FAILOVER or
@@ -65,6 +66,7 @@ RespCommand.MIGRATE or
                 RespCommand.ACL_DELUSER => NetworkAclDelUser(),
                 RespCommand.ACL_GENPASS => NetworkAclGenPass(),
                 RespCommand.ACL_GETUSER => NetworkAclGetUser(),
+                RespCommand.ACL_HELP => NetworkAclHelp(),
                 RespCommand.ACL_LIST => NetworkAclList(),
                 RespCommand.ACL_LOAD => NetworkAclLoad(),
                 RespCommand.ACL_SETUSER => NetworkAclSetUser(),
@@ -72,6 +74,7 @@ RespCommand.MIGRATE or
                 RespCommand.ACL_SAVE => NetworkAclSave(),
                 RespCommand.DEBUG => NetworkDebug(),
                 RespCommand.REGISTERCS => NetworkRegisterCs(storeWrapper.customCommandManager),
+                RespCommand.MODULE_HELP => NetworkModuleHelp(),
                 RespCommand.MODULE_LOADCS => NetworkModuleLoad(storeWrapper.customCommandManager),
                 RespCommand.PURGEBP => NetworkPurgeBP(),
                 _ => cmdFound = false
@@ -523,6 +526,27 @@ private bool NetworkRegisterCs(CustomCommandManager customCommandManager)
             return true;
         }
 
+        private bool NetworkModuleHelp()
+        {
+            if (parseState.Count != 0)
+            {
+                return AbortWithWrongNumberOfArguments($"{RespCommand.MODULE}|{Encoding.ASCII.GetString(CmdStrings.HELP)}");
+            }
+
+            if (!CanRunModule())
+            {
+                return AbortWithErrorMessage(CmdStrings.GenericErrCommandDisallowedWithOption, RespCommand.MODULE, "enable-module-command");
+            }
+
+            WriteHelp(
+                "MODULE <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
+                "LOADCS <path>",
+                "\tLoad a module library from <path>",
+                "HELP",
+                "\tPrint this help.");
+            return true;
+        }
+
         private bool NetworkModuleLoad(CustomCommandManager customCommandManager)
         {
             if (parseState.Count < 1) // At least module path is required
@@ -753,8 +777,13 @@ private bool NetworkDebug()
 
             if (command.EqualsUpperCaseSpanIgnoringCase(CmdStrings.HELP))
             {
-                var help = new string[]
+                if (parseState.Count != 1)
                 {
+                    return AbortWithWrongNumberOfArgumentsOrUnknownSubcommand(Encoding.ASCII.GetString(command),
+                                                                              nameof(RespCommand.DEBUG));
+                }
+
+                WriteHelp(
                     "DEBUG <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
                     "ERROR <string>",
                     "\tReturn a Redis protocol error with <string> as message. Useful for clients",
@@ -765,13 +794,7 @@ private bool NetworkDebug()
                     "\tCrash the server simulating a panic.",
                     "HELP",
                     "\tPrints this help"
-                };
-
-                WriteArrayLength(help.Length);
-                foreach (var line in help)
-                {
-                    WriteSimpleString(line);
-                }
+                );
                 return true;
             }
 
diff --git a/libs/server/Resp/BasicCommands.cs b/libs/server/Resp/BasicCommands.cs
index a81fec8caeb..0614b193fe0 100644
--- a/libs/server/Resp/BasicCommands.cs
+++ b/libs/server/Resp/BasicCommands.cs
@@ -1252,6 +1252,42 @@ private bool NetworkCOMMAND_GETKEYSANDFLAGS()
             return true;
         }
 
+        /// <summary>
+        /// Processes COMMAND HELP subcommand.
+        /// </summary>
+        private bool NetworkCOMMAND_HELP()
+        {
+            // No arguments allowed
+            if (parseState.Count != 0)
+            {
+                return AbortWithWrongNumberOfArguments("command|help");
+            }
+
+            WriteHelp(
+                 "COMMAND <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
+                 "(no subcommand)",
+                 "\tReturn details about all commands.",
+                 "COUNT",
+                 "\tReturn the total number of commands in this server.",
+                 "INFO [<command-name> ...]",
+                 "\tReturn details about multiple commands.",
+                 "\tIf no command names are given, documentation details for all",
+                 "\tcommands are returned.",
+                 "DOCS [<command-name> ...]",
+                 "\tReturn documentation details about multiple commands.",
+                 "\tIf no command names are given, documentation details for all",
+                 "\tcommands are returned.",
+                 "GETKEYS <full-command>",
+                 "\tReturn the keys from a full command.",
+                 "GETKEYSANDFLAGS <full-command>",
+                 "\tReturn the keys and the access flags from a full command.",
+                 "HELP",
+                 "\tPrint this help."
+            );
+
+            return true;
+        }
+
         private bool NetworkECHO()
         {
             if (parseState.Count != 1)
@@ -1415,6 +1451,27 @@ private bool NetworkAUTH()
             return true;
         }
 
+        //MEMORY HELP
+        private bool NetworkMemoryHelp()
+        {
+            // No arguments allowed
+            if (parseState.Count != 0)
+            {
+                return AbortWithWrongNumberOfArguments("memory|help");
+            }
+
+            WriteHelp(
+                 "MEMORY <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
+                 "USAGE <key> [SAMPLES <count>]",
+                 "\tReturn memory in bytes used by <key> and its value. Nested values are",
+                 "\tsampled up to <count> times (default: 5, 0 means sample all).",
+                 "HELP",
+                 "\tPrint this help."
+            );
+
+            return true;
+        }
+
         //MEMORY USAGE key [SAMPLES count]
         private bool NetworkMemoryUsage<TGarnetApi>(ref TGarnetApi storageApi)
             where TGarnetApi : IGarnetApi
diff --git a/libs/server/Resp/ClientCommands.cs b/libs/server/Resp/ClientCommands.cs
index 2264677a146..1826e17e2f9 100644
--- a/libs/server/Resp/ClientCommands.cs
+++ b/libs/server/Resp/ClientCommands.cs
@@ -199,6 +199,61 @@ private bool NetworkCLIENTINFO()
             return true;
         }
 
+        /// <summary>
+        /// CLIENT HELP
+        /// </summary>
+        /// <returns></returns>
+        private bool NetworkCLIENTHELP()
+        {
+            if (parseState.Count != 0)
+            {
+                return AbortWithWrongNumberOfArguments("client|help");
+            }
+
+            WriteHelp(
+                "CLIENT <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
+                "GETNAME",
+                "\tReturn the name of the current connection.",
+                "ID",
+                "\tReturn the ID of the current connection.",
+                "INFO",
+                "\tReturn information about the current client connection.",
+                "KILL <ip:port>",
+                "\tKill connection made from <ip:port>.",
+                "KILL <option> <value> [<option> <value> [...]]",
+                "\tKill connections. Options are:",
+                "\t* ADDR (<ip:port>|<unixsocket>:0)",
+                "\t  Kill connections made from the specified address",
+                "\t* LADDR (<ip:port>|<unixsocket>:0)",
+                "\t  Kill connections made to specified local address",
+                "\t* TYPE (NORMAL|MASTER|REPLICA|PUBSUB)",
+                "\t  Kill connections by type.",
+                "\t* USER <username>",
+                "\t  Kill connections authenticated by <username>.",
+                "\t* SKIPME (YES|NO)",
+                "\t  Skip killing current connection (default: yes).",
+                "\t* ID <client-id>",
+                "\t  Kill connections by client id.",
+                "\t* MAXAGE <maxage>",
+                "\t  Kill connections older than the specified age.",
+                "LIST [options ...]",
+                "\tReturn information about client connections. Options:",
+                "\t* TYPE (NORMAL|MASTER|REPLICA|PUBSUB)",
+                "\t  Return clients of specified type.",
+                "SETNAME <name>",
+                "\tAssign the name <name> to the current connection.",
+                "SETINFO <option> <value>",
+                "\tSet client meta attr. Options are:",
+                "\t* LIB-NAME: the client lib name.",
+                "\t* LIB-VER: the client lib version.",
+                "UNBLOCK <clientid> [TIMEOUT|ERROR]",
+                "\tUnblock the specified blocked client.",
+                "HELP",
+                "\tPrint this help.");
+
+            return true;
+        }
+
         /// <summary>
         /// CLIENT KILL
         /// </summary>
diff --git a/libs/server/Resp/Parser/RespCommand.cs b/libs/server/Resp/Parser/RespCommand.cs
index 9d4224d56c8..a384bdb49a7 100644
--- a/libs/server/Resp/Parser/RespCommand.cs
+++ b/libs/server/Resp/Parser/RespCommand.cs
@@ -234,6 +234,7 @@ public enum RespCommand : ushort
         // Pub/Sub commands
         PUBSUB,
         PUBSUB_CHANNELS,
+        PUBSUB_HELP,
         PUBSUB_NUMPAT,
         PUBSUB_NUMSUB,
         PUBLISH,
@@ -247,6 +248,7 @@ public enum RespCommand : ushort
         ECHO,
 
         CLIENT,
+        CLIENT_HELP,
         CLIENT_ID,
         CLIENT_INFO,
         CLIENT_LIST,
@@ -256,8 +258,11 @@ public enum RespCommand : ushort
         CLIENT_SETINFO,
         CLIENT_UNBLOCK,
 
+        MEMORY_HELP,
+
         MONITOR,
         MODULE,
+        MODULE_HELP,
         MODULE_LOADCS,
         REGISTERCS,
 
@@ -294,6 +299,7 @@ public enum RespCommand : ushort
         SCRIPT,
         SCRIPT_EXISTS,
         SCRIPT_FLUSH,
+        SCRIPT_HELP,
         SCRIPT_LOAD,
 
         ACL,
@@ -301,6 +307,7 @@ public enum RespCommand : ushort
         ACL_DELUSER,
         ACL_GENPASS,
         ACL_GETUSER,
+        ACL_HELP,
         ACL_LIST,
         ACL_LOAD,
         ACL_SAVE,
@@ -314,12 +321,14 @@ public enum RespCommand : ushort
         COMMAND_INFO,
         COMMAND_GETKEYS,
         COMMAND_GETKEYSANDFLAGS,
+        COMMAND_HELP,
 
         MEMORY,
         // MEMORY_USAGE is a read-only command, so moved up
 
         CONFIG,
         CONFIG_GET,
+        CONFIG_HELP,
         CONFIG_REWRITE,
         CONFIG_SET,
 
@@ -411,6 +420,7 @@ public static class RespCommandExtensions
             RespCommand.SWAPDB,
             RespCommand.ECHO,
             RespCommand.MONITOR,
+            RespCommand.MODULE_HELP,
             RespCommand.MODULE_LOADCS,
             RespCommand.REGISTERCS,
             RespCommand.INFO,
@@ -421,6 +431,7 @@ public static class RespCommandExtensions
             RespCommand.ACL_DELUSER,
             RespCommand.ACL_GENPASS,
             RespCommand.ACL_GETUSER,
+            RespCommand.ACL_HELP,
             RespCommand.ACL_LIST,
             RespCommand.ACL_LOAD,
             RespCommand.ACL_SAVE,
@@ -428,6 +439,7 @@ public static class RespCommandExtensions
             RespCommand.ACL_USERS,
             RespCommand.ACL_WHOAMI,
             // Client
+            RespCommand.CLIENT_HELP,
             RespCommand.CLIENT_ID,
             RespCommand.CLIENT_INFO,
             RespCommand.CLIENT_LIST,
@@ -443,8 +455,10 @@ public static class RespCommandExtensions
             RespCommand.COMMAND_INFO,
             RespCommand.COMMAND_GETKEYS,
             RespCommand.COMMAND_GETKEYSANDFLAGS,
+            RespCommand.COMMAND_HELP,
             RespCommand.MEMORY_USAGE,
             // Config
+            RespCommand.CONFIG_HELP,
             RespCommand.CONFIG_GET,
             RespCommand.CONFIG_REWRITE,
             RespCommand.CONFIG_SET,
@@ -1847,6 +1861,11 @@ private RespCommand SlowParseCommand(ReadOnlySpan<byte> command, ref int count,
                     return RespCommand.SCRIPT_EXISTS;
                 }
 
+                if (subCommand.SequenceEqual(CmdStrings.HELP))
+                {
+                    return RespCommand.SCRIPT_HELP;
+                }
+
                 string errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
                                               Encoding.UTF8.GetString(subCommand),
                                               nameof(RespCommand.SCRIPT));
@@ -1903,18 +1922,22 @@ private RespCommand SlowParseCommand(ReadOnlySpan<byte> command, ref int count,
                 {
                     return RespCommand.CONFIG_GET;
                 }
-                else if (subCommand.SequenceEqual(CmdStrings.REWRITE))
+                if (subCommand.SequenceEqual(CmdStrings.REWRITE))
                 {
                     return RespCommand.CONFIG_REWRITE;
                 }
-                else if (subCommand.SequenceEqual(CmdStrings.SET))
+                if (subCommand.SequenceEqual(CmdStrings.SET))
                 {
                     return RespCommand.CONFIG_SET;
                 }
+                if (subCommand.SequenceEqual(CmdStrings.HELP))
+                {
+                    return RespCommand.CONFIG_HELP;
+                }
 
-                string errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
-                                              Encoding.UTF8.GetString(subCommand),
-                                              nameof(RespCommand.CONFIG));
+                var errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
+                                           Encoding.UTF8.GetString(subCommand),
+                                           nameof(RespCommand.CONFIG));
                 specificErrorMsg = Encoding.UTF8.GetBytes(errMsg);
                 return RespCommand.INVALID;
             }
@@ -1968,6 +1991,10 @@ private RespCommand SlowParseCommand(ReadOnlySpan<byte> command, ref int count,
                 {
                     return RespCommand.CLIENT_UNBLOCK;
                 }
+                else if (subCommand.SequenceEqual(CmdStrings.HELP))
+                {
+                    return RespCommand.CLIENT_HELP;
+                }
 
                 string errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
                                               Encoding.UTF8.GetString(subCommand),
@@ -2028,6 +2055,11 @@ private RespCommand SlowParseCommand(ReadOnlySpan<byte> command, ref int count,
                     return RespCommand.COMMAND_GETKEYSANDFLAGS;
                 }
 
+                if (subCommand.SequenceEqual(CmdStrings.HELP))
+                {
+                    return RespCommand.COMMAND_HELP;
+                }
+
                 string errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
                                               Encoding.UTF8.GetString(subCommand),
                                               nameof(RespCommand.COMMAND));
@@ -2395,9 +2427,14 @@ private RespCommand SlowParseCommand(ReadOnlySpan<byte> command, ref int count,
                     return RespCommand.MEMORY_USAGE;
                 }
 
-                string errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
-                                              Encoding.UTF8.GetString(subCommand),
-                                              nameof(RespCommand.MEMORY));
+                if (subCommand.EqualsUpperCaseSpanIgnoringCase(CmdStrings.HELP))
+                {
+                    return RespCommand.MEMORY_HELP;
+                }
+
+                var errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
+                                           Encoding.UTF8.GetString(subCommand),
+                                           nameof(RespCommand.MEMORY));
                 specificErrorMsg = Encoding.UTF8.GetBytes(errMsg);
                 return RespCommand.INVALID;
             }
@@ -2439,6 +2476,10 @@ private RespCommand SlowParseCommand(ReadOnlySpan<byte> command, ref int count,
                 {
                     return RespCommand.ACL_GETUSER;
                 }
+                else if (subCommand.SequenceEqual(CmdStrings.HELP))
+                {
+                    return RespCommand.ACL_HELP;
+                }
                 else if (subCommand.SequenceEqual(CmdStrings.LIST))
                 {
                     return RespCommand.ACL_LIST;
@@ -2501,6 +2542,11 @@ private RespCommand SlowParseCommand(ReadOnlySpan<byte> command, ref int count,
                     return RespCommand.MODULE_LOADCS;
                 }
 
+                if (subCommand.SequenceEqual(CmdStrings.HELP))
+                {
+                    return RespCommand.MODULE_HELP;
+                }
+
                 string errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
                                               Encoding.UTF8.GetString(subCommand),
                                               nameof(RespCommand.MODULE));
@@ -2529,18 +2575,25 @@ private RespCommand SlowParseCommand(ReadOnlySpan<byte> command, ref int count,
                 {
                     return RespCommand.PUBSUB_CHANNELS;
                 }
-                else if (subCommand.SequenceEqual(CmdStrings.NUMSUB))
+
+                if (subCommand.SequenceEqual(CmdStrings.NUMSUB))
                 {
                     return RespCommand.PUBSUB_NUMSUB;
                 }
-                else if (subCommand.SequenceEqual(CmdStrings.NUMPAT))
+
+                if (subCommand.SequenceEqual(CmdStrings.NUMPAT))
                 {
                     return RespCommand.PUBSUB_NUMPAT;
                 }
 
-                string errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
-                                              Encoding.UTF8.GetString(subCommand),
-                                              nameof(RespCommand.PUBSUB));
+                if (subCommand.SequenceEqual(CmdStrings.HELP))
+                {
+                    return RespCommand.PUBSUB_HELP;
+                }
+
+                var errMsg = string.Format(CmdStrings.GenericErrUnknownSubCommandNoHelp,
+                                           Encoding.UTF8.GetString(subCommand),
+                                           nameof(RespCommand.PUBSUB));
                 specificErrorMsg = Encoding.UTF8.GetBytes(errMsg);
                 return RespCommand.INVALID;
             }
diff --git a/libs/server/Resp/PubSubCommands.cs b/libs/server/Resp/PubSubCommands.cs
index 2f7a9a249f9..cf39b7a294d 100644
--- a/libs/server/Resp/PubSubCommands.cs
+++ b/libs/server/Resp/PubSubCommands.cs
@@ -419,6 +419,28 @@ private bool NetworkPUBSUB_CHANNELS()
             return true;
         }
 
+        private bool NetworkPUBSUB_HELP()
+        {
+            if (parseState.Count != 0)
+            {
+                return AbortWithWrongNumberOfArguments("pubsub|help");
+            }
+
+            WriteHelp(
+                "PUBSUB <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
+                "CHANNELS [<pattern>]",
+                "\tReturn the currently active channels matching a <pattern> (default: '*').",
+                "NUMPAT",
+                "\tReturn number of subscriptions to patterns.",
+                "NUMSUB [<channel>...]",
+                "\tReturn the number of subscribers for the specified channels, excluding",
+                "\tpattern subscriptions(default: no channels).",
+                "HELP",
+                "\tPrint this help.");
+
+            return true;
+        }
+
         private bool NetworkPUBSUB_NUMPAT()
         {
             if (parseState.Count > 0)
diff --git a/libs/server/Resp/RespServerSession.cs b/libs/server/Resp/RespServerSession.cs
index aeb3e966c36..5c0b15a5b5e 100644
--- a/libs/server/Resp/RespServerSession.cs
+++ b/libs/server/Resp/RespServerSession.cs
@@ -807,6 +807,7 @@ private bool ProcessArrayCommands<TGarnetApi>(RespCommand cmd, ref TGarnetApi st
                 RespCommand.UNSUBSCRIBE => NetworkUNSUBSCRIBE(),
                 RespCommand.PUNSUBSCRIBE => NetworkPUNSUBSCRIBE(),
                 RespCommand.PUBSUB_CHANNELS => NetworkPUBSUB_CHANNELS(),
+                RespCommand.PUBSUB_HELP => NetworkPUBSUB_HELP(),
                 RespCommand.PUBSUB_NUMSUB => NetworkPUBSUB_NUMSUB(),
                 RespCommand.PUBSUB_NUMPAT => NetworkPUBSUB_NUMPAT(),
                 // Custom Object Commands
@@ -961,6 +962,7 @@ private bool ProcessOtherCommands<TGarnetApi>(RespCommand command, ref TGarnetAp
             {
                 RespCommand.AUTH => NetworkAUTH(),
                 RespCommand.MEMORY_USAGE => NetworkMemoryUsage(ref storageApi),
+                RespCommand.MEMORY_HELP => NetworkMemoryHelp(),
                 RespCommand.CLIENT_ID => NetworkCLIENTID(),
                 RespCommand.CLIENT_INFO => NetworkCLIENTINFO(),
                 RespCommand.CLIENT_LIST => NetworkCLIENTLIST(),
@@ -969,12 +971,14 @@ private bool ProcessOtherCommands<TGarnetApi>(RespCommand command, ref TGarnetAp
                 RespCommand.CLIENT_SETNAME => NetworkCLIENTSETNAME(),
                 RespCommand.CLIENT_SETINFO => NetworkCLIENTSETINFO(),
                 RespCommand.CLIENT_UNBLOCK => NetworkCLIENTUNBLOCK(),
+                RespCommand.CLIENT_HELP => NetworkCLIENTHELP(),
                 RespCommand.COMMAND => NetworkCOMMAND(),
                 RespCommand.COMMAND_COUNT => NetworkCOMMAND_COUNT(),
                 RespCommand.COMMAND_DOCS => NetworkCOMMAND_DOCS(),
                 RespCommand.COMMAND_INFO => NetworkCOMMAND_INFO(),
                 RespCommand.COMMAND_GETKEYS => NetworkCOMMAND_GETKEYS(),
                 RespCommand.COMMAND_GETKEYSANDFLAGS => NetworkCOMMAND_GETKEYSANDFLAGS(),
+                RespCommand.COMMAND_HELP => NetworkCOMMAND_HELP(),
                 RespCommand.ECHO => NetworkECHO(),
                 RespCommand.HELLO => NetworkHELLO(),
                 RespCommand.TIME => NetworkTIME(),
@@ -998,6 +1002,7 @@ private bool ProcessOtherCommands<TGarnetApi>(RespCommand command, ref TGarnetAp
                 RespCommand.SCRIPT_EXISTS => NetworkScriptExists(),
                 RespCommand.SCRIPT_FLUSH => NetworkScriptFlush(),
                 RespCommand.SCRIPT_LOAD => NetworkScriptLoad(),
+                RespCommand.SCRIPT_HELP => NetworkScriptHelp(),
 
                 RespCommand.EVAL => TryEVAL(),
                 RespCommand.EVALSHA => TryEVALSHA(),
diff --git a/libs/server/Resp/RespServerSessionOutput.cs b/libs/server/Resp/RespServerSessionOutput.cs
index 40ac592401a..21334e1f6cd 100644
--- a/libs/server/Resp/RespServerSessionOutput.cs
+++ b/libs/server/Resp/RespServerSessionOutput.cs
@@ -123,6 +123,15 @@ private void WriteError(ReadOnlySpan<char> errorString)
                 SendAndReset();
         }
 
+        private void WriteHelp(params string[] Help)
+        {
+            WriteArrayLength(Help.Length);
+            foreach (var help in Help)
+            {
+                WriteSimpleString(help);
+            }
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void WriteInt32(int value)
         {
diff --git a/libs/server/ServerConfig.cs b/libs/server/ServerConfig.cs
index 707077d4d9f..e0e4f001fbe 100644
--- a/libs/server/ServerConfig.cs
+++ b/libs/server/ServerConfig.cs
@@ -105,6 +105,26 @@ ReadOnlySpan<byte> GetDatabases()
             return true;
         }
 
+        private bool NetworkCONFIG_HELP()
+        {
+            if (parseState.Count != 0)
+            {
+                return AbortWithWrongNumberOfArguments($"{nameof(RespCommand.CONFIG)}|{nameof(CmdStrings.HELP)}");
+            }
+
+            WriteHelp("CONFIG <subcommand> [<arg> [value] [opt] ...]. Subcommands are:",
+                      "GET <pattern>",
+                      "\tReturn parameters matching the glob-like <pattern> and their values.",
+                      "SET <directive> <value>",
+                      "\tSet the configuration <directive> to <value>.",
+                      "REWRITE",
+                      "\tRewrite the configuration file.",
+                      "HELP",
+                      "\tPrint this help.");
+
+            return true;
+        }
+
         private bool NetworkCONFIG_REWRITE()
         {
             if (parseState.Count != 0)
diff --git a/playground/CommandInfoUpdater/SupportedCommand.cs b/playground/CommandInfoUpdater/SupportedCommand.cs
index 89d9a8da159..8d20b545551 100644
--- a/playground/CommandInfoUpdater/SupportedCommand.cs
+++ b/playground/CommandInfoUpdater/SupportedCommand.cs
@@ -18,6 +18,7 @@ public class SupportedCommand
                 new("ACL|DELUSER", RespCommand.ACL_DELUSER),
                 new("ACL|GENPASS", RespCommand.ACL_GENPASS),
                 new("ACL|GETUSER", RespCommand.ACL_GETUSER),
+                new("ACL|HELP", RespCommand.ACL_HELP),
                 new("ACL|LIST", RespCommand.ACL_LIST),
                 new("ACL|LOAD", RespCommand.ACL_LOAD),
                 new("ACL|SAVE", RespCommand.ACL_SAVE),
@@ -54,6 +55,7 @@ public class SupportedCommand
                 new("CLIENT|SETNAME", RespCommand.CLIENT_SETNAME),
                 new("CLIENT|SETINFO", RespCommand.CLIENT_SETINFO),
                 new("CLIENT|UNBLOCK", RespCommand.CLIENT_UNBLOCK),
+                new("CLIENT|HELP", RespCommand.CLIENT_HELP),
             ]),
             new("CLUSTER", RespCommand.CLUSTER,
             [
@@ -110,11 +112,13 @@ public class SupportedCommand
                 new("COMMAND|DOCS", RespCommand.COMMAND_DOCS),
                 new("COMMAND|GETKEYS", RespCommand.COMMAND_GETKEYS),
                 new("COMMAND|GETKEYSANDFLAGS", RespCommand.COMMAND_GETKEYSANDFLAGS),
+                new("COMMAND|HELP", RespCommand.COMMAND_HELP),
             ]),
             new("COMMITAOF", RespCommand.COMMITAOF),
             new("CONFIG", RespCommand.CONFIG,
             [
                 new("CONFIG|GET", RespCommand.CONFIG_GET),
+                new("CONFIG|HELP", RespCommand.CONFIG_HELP),
                 new("CONFIG|SET", RespCommand.CONFIG_SET),
                 new("CONFIG|REWRITE", RespCommand.CONFIG_REWRITE),
             ]),
@@ -215,6 +219,7 @@ public class SupportedCommand
             new("LTRIM", RespCommand.LTRIM),
             new("MEMORY", RespCommand.MEMORY,
             [
+                new("MEMORY|HELP", RespCommand.MEMORY_HELP),
                 new("MEMORY|USAGE", RespCommand.MEMORY_USAGE),
             ]),
             new("MGET", RespCommand.MGET),
@@ -222,6 +227,7 @@ public class SupportedCommand
             new("PURGEBP", RespCommand.PURGEBP),
             new("MODULE", RespCommand.MODULE,
             [
+                new("MODULE|HELP", RespCommand.MODULE_HELP),
                 new("MODULE|LOADCS", RespCommand.MODULE_LOADCS),
             ]),
             new("MONITOR", RespCommand.MONITOR),
@@ -243,6 +249,7 @@ public class SupportedCommand
             new("PUBSUB", RespCommand.PUBSUB,
             [
                 new("PUBSUB|CHANNELS", RespCommand.PUBSUB_CHANNELS),
+                new("PUBSUB|HELP", RespCommand.PUBSUB_HELP),
                 new("PUBSUB|NUMPAT", RespCommand.PUBSUB_NUMPAT),
                 new("PUBSUB|NUMSUB", RespCommand.PUBSUB_NUMSUB),
             ]),
@@ -360,6 +367,7 @@ public class SupportedCommand
             [
                 new("SCRIPT|EXISTS", RespCommand.SCRIPT_EXISTS),
                 new("SCRIPT|FLUSH", RespCommand.SCRIPT_FLUSH),
+                new("SCRIPT|HELP", RespCommand.SCRIPT_HELP),
                 new("SCRIPT|LOAD", RespCommand.SCRIPT_LOAD),
             ])
         ];
diff --git a/test/Garnet.test/Resp/ACL/RespCommandTests.cs b/test/Garnet.test/Resp/ACL/RespCommandTests.cs
index 3b02ac68853..34ad91da264 100644
--- a/test/Garnet.test/Resp/ACL/RespCommandTests.cs
+++ b/test/Garnet.test/Resp/ACL/RespCommandTests.cs
@@ -212,6 +212,21 @@ static async Task DoAclGetUserAsync(GarnetClient client)
             }
         }
 
+        [Test]
+        public async Task AclHelpACLsAsync()
+        {
+            await CheckCommandsAsync(
+                "ACL HELP",
+                [DoAclListAsync]
+            );
+
+            static async Task DoAclListAsync(GarnetClient client)
+            {
+                string[] val = await client.ExecuteForStringArrayResultAsync("ACL", ["HELP"]);
+                ClassicAssert.IsNotNull(val);
+            }
+        }
+
         [Test]
         public async Task AclListACLsAsync()
         {
@@ -689,6 +704,21 @@ static async Task DoBitPosStartEndByteAsync(GarnetClient client)
             }
         }
 
+        [Test]
+        public async Task ClientHelpACLsAsync()
+        {
+            await CheckCommandsAsync(
+                "CLIENT HELP",
+                [DoClientHelpAsync]
+            );
+
+            static async Task DoClientHelpAsync(GarnetClient client)
+            {
+                var result = await client.ExecuteForStringArrayResultAsync("CLIENT", ["HELP"]);
+                ClassicAssert.IsNotNull(result);
+            }
+        }
+
         [Test]
         public async Task ClientIdACLsAsync()
         {
@@ -2613,6 +2643,36 @@ static async Task DoConfigGetOneAsync(GarnetClient client)
             }
         }
 
+        [Test]
+        public async Task CommandHelpACLsAsync()
+        {
+            await CheckCommandsAsync(
+                "COMMAND HELP",
+                [DoCommandHelpAsync]
+            );
+
+            static async Task DoCommandHelpAsync(GarnetClient client)
+            {
+                var result = await client.ExecuteForStringArrayResultAsync("COMMAND", ["HELP"]);
+                ClassicAssert.IsNotNull(result);
+            }
+        }
+
+        [Test]
+        public async Task ConfigHelpACLsAsync()
+        {
+            await CheckCommandsAsync(
+                "CONFIG HELP",
+                [DoCommandHelpAsync]
+            );
+
+            static async Task DoCommandHelpAsync(GarnetClient client)
+            {
+                var result = await client.ExecuteForStringArrayResultAsync("CONFIG", ["HELP"]);
+                ClassicAssert.IsNotNull(result);
+            }
+        }
+
         [Test]
         public async Task ConfigRewriteACLsAsync()
         {
@@ -2833,6 +2893,21 @@ async Task DoEvalShaAsync(GarnetClient client)
             }
         }
 
+        [Test]
+        public async Task ScriptHelpACLsAsync()
+        {
+            await CheckCommandsAsync(
+                "SCRIPT",
+                [DoScriptHelpAsync]
+            );
+
+            static async Task DoScriptHelpAsync(GarnetClient client)
+            {
+                var result = await client.ExecuteForStringArrayResultAsync("SCRIPT", ["HELP"]);
+                ClassicAssert.IsNotNull(result);
+            }
+        }
+
         [Test]
         public async Task ScriptLoadACLsAsync()
         {
@@ -4705,6 +4780,21 @@ static async Task DoLSetAsync(GarnetClient client)
             }
         }
 
+        [Test]
+        public async Task MemoryHelpACLsAsync()
+        {
+            await CheckCommandsAsync(
+                "MEMORY HELP",
+                [DoMemoryHelpAsync]
+            );
+
+            static async Task DoMemoryHelpAsync(GarnetClient client)
+            {
+                var result = await client.ExecuteForStringArrayResultAsync("MEMORY", ["HELP"]);
+                ClassicAssert.IsNotNull(result);
+            }
+        }
+
         [Test]
         public async Task MemoryUsageACLsAsync()
         {
@@ -4815,10 +4905,25 @@ static async Task DoPurgeBPAsync(GarnetClient client)
         }
 
         [Test]
-        public async Task ModuleLoadCSACLsAsync()
+        public async Task ModuleHelpACLsAsync()
         {
             // MODULE isn't a proper redis command, but this is the placeholder today... so validate it for completeness
+            await CheckCommandsAsync(
+                "MODULE HELP",
+                [DoModuleHelpAsync]
+            );
+
+            static async Task DoModuleHelpAsync(GarnetClient client)
+            {
+                var result = await client.ExecuteForStringArrayResultAsync("MODULE", ["HELP"]);
+                ClassicAssert.IsNotNull(result);
+            }
+        }
 
+        [Test]
+        public async Task ModuleLoadCSACLsAsync()
+        {
+            // MODULE isn't a proper redis command, but this is the placeholder today... so validate it for completeness
             await CheckCommandsAsync(
                 "MODULE",
                 [DoModuleLoadAsync]
@@ -5176,6 +5281,21 @@ static async Task DoPubSubChannelsAsync(GarnetClient client)
             }
         }
 
+        [Test]
+        public async Task PubSubHelpACLsAsync()
+        {
+            await CheckCommandsAsync(
+                "PUBSUB",
+                [DoPubSubHelpAsync]
+            );
+
+            static async Task DoPubSubHelpAsync(GarnetClient client)
+            {
+                var result = await client.ExecuteForStringArrayResultAsync("PUBSUB", ["HELP"]);
+                ClassicAssert.IsNotNull(result);
+            }
+        }
+
         [Test]
         public async Task PubSubNumPatACLsAsync()
         {
diff --git a/test/Garnet.test/RespCommandTests.cs b/test/Garnet.test/RespCommandTests.cs
index f04feb86e9f..b672846f417 100644
--- a/test/Garnet.test/RespCommandTests.cs
+++ b/test/Garnet.test/RespCommandTests.cs
@@ -432,16 +432,19 @@ public void AofIndependentCommandsTest()
                 RespCommand.SWAPDB,
                 RespCommand.ECHO,
                 RespCommand.MONITOR,
+                RespCommand.MODULE_HELP,
                 RespCommand.MODULE_LOADCS,
                 RespCommand.REGISTERCS,
                 RespCommand.INFO,
                 RespCommand.TIME,
                 RespCommand.LASTSAVE,
+
                 // ACL
                 RespCommand.ACL_CAT,
                 RespCommand.ACL_DELUSER,
                 RespCommand.ACL_GENPASS,
                 RespCommand.ACL_GETUSER,
+                RespCommand.ACL_HELP,
                 RespCommand.ACL_LIST,
                 RespCommand.ACL_LOAD,
                 RespCommand.ACL_SAVE,
@@ -449,6 +452,7 @@ public void AofIndependentCommandsTest()
                 RespCommand.ACL_USERS,
                 RespCommand.ACL_WHOAMI,
                 // Client
+                RespCommand.CLIENT_HELP,
                 RespCommand.CLIENT_ID,
                 RespCommand.CLIENT_INFO,
                 RespCommand.CLIENT_LIST,
@@ -464,8 +468,10 @@ public void AofIndependentCommandsTest()
                 RespCommand.COMMAND_INFO,
                 RespCommand.COMMAND_GETKEYS,
                 RespCommand.COMMAND_GETKEYSANDFLAGS,
+                RespCommand.COMMAND_HELP,
                 RespCommand.MEMORY_USAGE,
                 // Config
+                RespCommand.CONFIG_HELP,
                 RespCommand.CONFIG_GET,
                 RespCommand.CONFIG_REWRITE,
                 RespCommand.CONFIG_SET,
diff --git a/website/docs/commands/acl.md b/website/docs/commands/acl.md
index 29348968f3c..3826a3950bd 100644
--- a/website/docs/commands/acl.md
+++ b/website/docs/commands/acl.md
@@ -38,6 +38,8 @@ Delete all the specified ACL users and terminate all the connections that are au
 
 Integer reply: the number of users that were deleted. This number will not always match the number of arguments since certain users may not exist.
 
+---
+
 ### ACL GETUSER
 
 #### Syntax
@@ -78,6 +80,16 @@ If bits was given, the output string length is the number of specified bits (rou
 
 ---
 
+### ACL HELP
+
+```bash
+    ACL HELP
+```
+
+The ACL HELP command returns a helpful text describing the different subcommands.
+
+---
+
 ### ACL LIST
 
 #### Syntax
diff --git a/website/docs/commands/analytics.md b/website/docs/commands/analytics.md
index 69a1c43851f..1b3edeaf7cf 100644
--- a/website/docs/commands/analytics.md
+++ b/website/docs/commands/analytics.md
@@ -234,6 +234,16 @@ Array reply: a list of active channels, optionally matching the specified patter
 
 ---
 
+### PUBSUB HELP
+
+```bash
+    PUBSUB HELP
+```
+
+The PUBSUB HELP command returns a helpful text describing the different subcommands.
+
+---
+
 ### PUBSUB NUMPAT
 #### Syntax
 
diff --git a/website/docs/commands/api-compatibility.md b/website/docs/commands/api-compatibility.md
index dfb9ab38087..96ddf770c87 100644
--- a/website/docs/commands/api-compatibility.md
+++ b/website/docs/commands/api-compatibility.md
@@ -46,7 +46,7 @@ Note that this list is subject to change as we continue to expand our API comman
 |  | [GETUSER](acl.md#acl-getuser) | ➕ |  |
 |  | [LIST](acl.md#acl-list) | ➕ |  |
 |  | [LOAD](acl.md#acl-load) | ➕ |  |
-|  | HELP | ➖ |  |
+|  | HELP | ➕ |  |
 |  | LOG | ➖ |  |
 |  | [SAVE](acl.md#acl-save) | ➕ |  |
 |  | [SETUSER](acl.md#acl-setuser) | ➕ |  |
@@ -63,7 +63,7 @@ Note that this list is subject to change as we continue to expand our API comman
 | <span id="client">**CLIENT**</span> | CACHING | ➖ |  |
 |  | [GETNAME](client.md#client-getname) | ➕ |  |
 |  | GETREDIR | ➖ |  |
-|  | HELP | ➖ |  |
+|  | HELP | ➕ |  |
 |  | [ID](client.md#client-id) | ➕ |  |
 |  | [INFO](client.md#client-info) | ➕ |  |
 |  | [KILL](client.md#client-kill) | ➕ |  |
@@ -113,7 +113,7 @@ Note that this list is subject to change as we continue to expand our API comman
 |  | [DOCS](server.md#command-docs) | ➕ |  |
 |  | [GETKEYS](server.md#command-getkeys) | ➕ |  |
 |  | [GETKEYSANDFLAGS](server.md#command-getkeysandflags) | ➕ |  |
-|  | HELP | ➖ |  | 
+|  | HELP | ➕ |  | 
 |  | [INFO](server.md#command-info) | ➕ |  | 
 |  | LIST | ➖ |  | 
 | <span id="connection">**CONNECTION**</span> | [AUTH](generic-commands.md#auth) | ➕ |  |
@@ -203,7 +203,7 @@ Note that this list is subject to change as we continue to expand our API comman
 |  | MOVE | ➖ |  |
 | <span id="latency">**LATENCY**</span> | DOCTOR | ➖ |  |
 |  | GRAPH | ➖ |  |
-|  | HELP | ➖ |  |
+|  | HELP | ➕ |  |
 |  | [HISTOGRAM](server.md#latency-histogram) | ➕ |  |
 |  | HISTORY | ➖ |  |
 |  | LATEST | ➖ |  |
@@ -231,12 +231,12 @@ Note that this list is subject to change as we continue to expand our API comman
 |  | [RPUSH](data-structures.md#rpush) | ➕ |  |
 |  | [RPUSHX](data-structures.md#rpushx) | ➕ |  |
 | <span id="memory">**MEMORY**</span> | DOCTOR | ➖ |  |
-|  | HELP | ➖ |  |
+|  | HELP | ➕ |  |
 |  | MALLOC-STATS | ➖ |  |
 |  | PURGE | ➖ |  |
 |  | STATS | ➖ |  |
 |  | [USAGE](server.md#memory-usage) | ➕ |  |
-| <span id="module">**MODULE**</span> | HELP | ➖ |  |
+| <span id="module">**MODULE**</span> | HELP | ➕ |  |
 |  | LIST | ➖ |  |
 |  | LOAD | ➖ |  |
 |  | LOADEX | ➖ |  |
@@ -249,7 +249,7 @@ Note that this list is subject to change as we continue to expand our API comman
 | <span id="pubsub">**PUB/SUB**</span> | [PSUBSCRIBE](analytics.md#psubscribe) | ➕ |  |
 |  | [PUBLISH](analytics.md#publish) | ➕ |  |
 |  | [PUBSUB CHANNELS](analytics.md#pubsub-channels) | ➕ |  |
-|  | PUBSUB HELP | ➖ |  |
+|  | PUBSUB HELP | ➕ |  |
 |  | [PUBSUB NUMPAT](analytics.md#pubsub-numpat) | ➕ |  |
 |  | [PUBSUB NUMSUB](analytics.md#pubsub-numsub) | ➕ |  |
 |  | PUBSUB SHARDCHANNELS | ➖ |  |
@@ -264,7 +264,7 @@ Note that this list is subject to change as we continue to expand our API comman
 |  | SCRIPT DEBUG | ➖ |  |
 |  | [SCRIPT EXISTS](scripting-and-functions.md#script-exists) | ➕ |  |
 |  | [SCRIPT FLUSH](scripting-and-functions.md#script-flush) | ➕ |  |
-|  | SCRIPT HELP | ➖ |  |
+|  | SCRIPT HELP | ➕ |  |
 |  | SCRIPT KILL | ➖ |  |
 |  | [SCRIPT LOAD](scripting-and-functions.md#script-load) | ➕ |  |
 | <span id="server">**SERVER**</span> | ACL | ➖ |  |
@@ -272,7 +272,7 @@ Note that this list is subject to change as we continue to expand our API comman
 |  | [BGSAVE](checkpoint.md#bgsave) | ➕ |  |
 |  | [COMMITAOF](server.md#commitaof) | ➕ |  |
 |  | [CONFIG GET](server.md#config-get) | ➕ |  |
-|  | CONFIG HELP | ➖ |  |
+|  | CONFIG HELP | ➕ |  |
 |  | CONFIG RESETSTAT | ➖ |  |
 |  | CONFIG REWRITE | ➖ |  |
 |  | [CONFIG SET](server.md#config-set) | ➕ |  |
diff --git a/website/docs/commands/client.md b/website/docs/commands/client.md
index 9169a9d010f..16572532d22 100644
--- a/website/docs/commands/client.md
+++ b/website/docs/commands/client.md
@@ -56,6 +56,16 @@ Bulk string reply: the name of the client, or an empty string if no name is set.
 
 ---
 
+### CLIENT HELP
+
+```bash
+    CLIENT HELP
+```
+
+The CLIENT HELP command returns a helpful text describing the different subcommands.
+
+---
+
 ### CLIENT SETNAME
 
 #### Syntax
diff --git a/website/docs/commands/scripting-and-functions.md b/website/docs/commands/scripting-and-functions.md
index b4837bbe79b..e172279f5c4 100644
--- a/website/docs/commands/scripting-and-functions.md
+++ b/website/docs/commands/scripting-and-functions.md
@@ -69,6 +69,16 @@ Simple string reply: OK.
 
 ---
 
+### SCRIPT HELP
+
+```bash
+    SCRIPT HELP
+```
+
+The SCRIPT HELP command returns a helpful text describing the different subcommands.
+
+---
+
 ### SCRIPT LOAD
 
 #### Syntax
diff --git a/website/docs/commands/server.md b/website/docs/commands/server.md
index aa0ed624dd8..0cca4a386d2 100644
--- a/website/docs/commands/server.md
+++ b/website/docs/commands/server.md
@@ -85,6 +85,16 @@ Array reply: a nested array where each item contains:
 1. The key name
 2. An array of access flag strings that apply to that key
 
+---
+
+### COMMAND HELP
+
+```bash
+    COMMAND HELP
+```
+
+The COMMAND HELP command returns a helpful text describing the different subcommands.
+
 ---
 ### COMMAND INFO
 #### Syntax
@@ -131,6 +141,16 @@ The CONFIG GET command is used to read the configuration parameters of a running
 
 Array reply: a list of configuration parameters matching the provided arguments.
 
+---
+
+### CONFIG HELP
+
+```bash
+    CONFIG HELP
+```
+
+The CONFIG HELP command returns a helpful text describing the different subcommands.
+
 ---
 ### CONFIG SET
 #### Syntax
@@ -277,6 +297,16 @@ SLOWLOG HELP
 
 Returns a list of supported SLOWLOG sub-commands.
 
+---
+
+### MEMORY HELP
+
+```bash
+    MEMORY HELP
+```
+
+The MEMORY HELP command returns a helpful text describing the different subcommands.
+
 ---
 ### MEMORY USAGE
 #### Syntax