diff --git a/src/main/java/io/lettuce/core/AbstractRedisAsyncCommands.java b/src/main/java/io/lettuce/core/AbstractRedisAsyncCommands.java
index 9c8b52849b..c9ba85d2de 100644
--- a/src/main/java/io/lettuce/core/AbstractRedisAsyncCommands.java
+++ b/src/main/java/io/lettuce/core/AbstractRedisAsyncCommands.java
@@ -2414,6 +2414,11 @@ public RedisFuture<StringMatchResult> stralgoLcs(StrAlgoArgs args) {
         return dispatch(commandBuilder.stralgoLcs(args));
     }
 
+    @Override
+    public RedisFuture<StringMatchResult> lcs(LcsArgs args) {
+        return dispatch(commandBuilder.lcs(args));
+    }
+
     @Override
     public RedisFuture<Set<V>> sunion(K... keys) {
         return dispatch(commandBuilder.sunion(keys));
diff --git a/src/main/java/io/lettuce/core/AbstractRedisReactiveCommands.java b/src/main/java/io/lettuce/core/AbstractRedisReactiveCommands.java
index eb7e911ca4..4e4f1a4d20 100644
--- a/src/main/java/io/lettuce/core/AbstractRedisReactiveCommands.java
+++ b/src/main/java/io/lettuce/core/AbstractRedisReactiveCommands.java
@@ -2499,6 +2499,11 @@ public Mono<StringMatchResult> stralgoLcs(StrAlgoArgs strAlgoArgs) {
         return createMono(() -> commandBuilder.stralgoLcs(strAlgoArgs));
     }
 
+    @Override
+    public Mono<StringMatchResult> lcs(LcsArgs lcsArgs) {
+        return createMono(() -> commandBuilder.lcs(lcsArgs));
+    }
+
     @Override
     public Flux<V> sunion(K... keys) {
         return createDissolvingFlux(() -> commandBuilder.sunion(keys));
diff --git a/src/main/java/io/lettuce/core/LcsArgs.java b/src/main/java/io/lettuce/core/LcsArgs.java
new file mode 100644
index 0000000000..a1b671ad13
--- /dev/null
+++ b/src/main/java/io/lettuce/core/LcsArgs.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2011-Present, Redis Ltd. and Contributors
+ * All rights reserved.
+ *
+ * Licensed under the MIT License.
+ */
+package io.lettuce.core;
+
+import io.lettuce.core.internal.LettuceAssert;
+import io.lettuce.core.protocol.CommandArgs;
+import io.lettuce.core.protocol.CommandKeyword;
+
+/**
+ * Argument list builder for the Redis <a href="https://redis.io/commands/lcs">LCS</a> command. Static import the methods from
+ * {@link LcsArgs.Builder} and call the methods: {@code keys(…)} .
+ * <p>
+ * {@link LcsArgs} is a mutable object and instances should be used only once to avoid shared mutable state.
+ *
+ * @author Seonghwan Lee
+ * @since 6.6
+ * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
+ */
+public class LcsArgs implements CompositeArgument {
+
+    private boolean justLen;
+
+    private int minMatchLen;
+
+    private boolean withMatchLen;
+
+    private boolean withIdx;
+
+    private String[] keys;
+
+    /**
+     * Builder entry points for {@link LcsArgs}.
+     */
+    public static class Builder {
+
+        /**
+         * Utility constructor.
+         */
+        private Builder() {
+        }
+
+        /**
+         * Creates new {@link LcsArgs} by keys.
+         *
+         * @return new {@link LcsArgs} with {@literal By KEYS} set.
+         */
+        public static LcsArgs keys(String... keys) {
+            return new LcsArgs().by(keys);
+        }
+
+    }
+
+    /**
+     * restrict the list of matches to the ones of a given minimal length.
+     *
+     * @return {@code this} {@link LcsArgs}.
+     */
+    public LcsArgs minMatchLen(int minMatchLen) {
+        this.minMatchLen = minMatchLen;
+        return this;
+    }
+
+    /**
+     * Request just the length of the match for results.
+     *
+     * @return {@code this} {@link LcsArgs}.
+     */
+    public LcsArgs justLen() {
+        justLen = true;
+        return this;
+    }
+
+    /**
+     * Request match len for results.
+     *
+     * @return {@code this} {@link LcsArgs}.
+     */
+    public LcsArgs withMatchLen() {
+        withMatchLen = true;
+        return this;
+    }
+
+    /**
+     * Request match position in each string for results.
+     *
+     * @return {@code this} {@link LcsArgs}.
+     */
+    public LcsArgs withIdx() {
+        withIdx = true;
+        return this;
+    }
+
+    public LcsArgs by(String... keys) {
+        LettuceAssert.notEmpty(keys, "Keys must not be empty");
+
+        this.keys = keys;
+        return this;
+    }
+
+    public boolean isWithIdx() {
+        return withIdx;
+    }
+
+    @Override
+    public <K, V> void build(CommandArgs<K, V> args) {
+        for (String key : keys) {
+            args.add(key);
+        }
+        if (justLen) {
+            args.add(CommandKeyword.LEN);
+        }
+        if (withIdx) {
+            args.add(CommandKeyword.IDX);
+        }
+
+        if (minMatchLen > 0) {
+            args.add(CommandKeyword.MINMATCHLEN);
+            args.add(minMatchLen);
+        }
+
+        if (withMatchLen) {
+            args.add(CommandKeyword.WITHMATCHLEN);
+        }
+    }
+
+}
diff --git a/src/main/java/io/lettuce/core/RedisCommandBuilder.java b/src/main/java/io/lettuce/core/RedisCommandBuilder.java
index ff403c6dda..aa1ce4435b 100644
--- a/src/main/java/io/lettuce/core/RedisCommandBuilder.java
+++ b/src/main/java/io/lettuce/core/RedisCommandBuilder.java
@@ -58,6 +58,7 @@
  * @author Mikhael Sokolov
  * @author Tihomir Mateev
  * @author Ali Takavci
+ * @author Seonghwan Lee
  */
 @SuppressWarnings({ "unchecked", "varargs" })
 class RedisCommandBuilder<K, V> extends BaseRedisCommandBuilder<K, V> {
@@ -2912,6 +2913,14 @@ Command<K, V, StringMatchResult> stralgoLcs(StrAlgoArgs strAlgoArgs) {
         return createCommand(STRALGO, new StringMatchResultOutput<>(codec), args);
     }
 
+    Command<K, V, StringMatchResult> lcs(LcsArgs lcsArgs) {
+        LettuceAssert.notNull(lcsArgs, "lcsArgs" + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        lcsArgs.build(args);
+        return createCommand(LCS, new StringMatchResultOutput<>(codec), args);
+    }
+
     Command<K, V, Set<V>> sunion(K... keys) {
         notEmpty(keys);
 
diff --git a/src/main/java/io/lettuce/core/StrAlgoArgs.java b/src/main/java/io/lettuce/core/StrAlgoArgs.java
index 2df6daccac..2aed2c9bad 100644
--- a/src/main/java/io/lettuce/core/StrAlgoArgs.java
+++ b/src/main/java/io/lettuce/core/StrAlgoArgs.java
@@ -32,8 +32,11 @@
  * {@link StrAlgoArgs} is a mutable object and instances should be used only once to avoid shared mutable state.
  *
  * @author dengliming
+ * @deprecated As of 6.6 in favor of {@link LcsArgs}
+ * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
  * @since 6.0
  */
+@Deprecated
 public class StrAlgoArgs implements CompositeArgument {
 
     private boolean justLen;
diff --git a/src/main/java/io/lettuce/core/api/async/RedisStringAsyncCommands.java b/src/main/java/io/lettuce/core/api/async/RedisStringAsyncCommands.java
index 1e5b1d3d05..7b524c0925 100644
--- a/src/main/java/io/lettuce/core/api/async/RedisStringAsyncCommands.java
+++ b/src/main/java/io/lettuce/core/api/async/RedisStringAsyncCommands.java
@@ -27,6 +27,7 @@
 import io.lettuce.core.KeyValue;
 import io.lettuce.core.RedisFuture;
 import io.lettuce.core.SetArgs;
+import io.lettuce.core.LcsArgs;
 import io.lettuce.core.StrAlgoArgs;
 import io.lettuce.core.StringMatchResult;
 import io.lettuce.core.output.KeyValueStreamingChannel;
@@ -410,6 +411,8 @@ public interface RedisStringAsyncCommands<K, V> {
     /**
      * The STRALGO command implements complex algorithms that operate on strings. This method uses the LCS algorithm (longest
      * common substring).
+     * <p>
+     * Command is no longer available in Redis server versions 7.0.x and later.
      *
      * <ul>
      * <li>Without modifiers the string representing the longest common substring is returned.</li>
@@ -422,10 +425,30 @@ public interface RedisStringAsyncCommands<K, V> {
      *
      * @param strAlgoArgs command arguments.
      * @return StringMatchResult.
+     * @deprecated since 6.6 in favor of {@link #lcs(LcsArgs)}.
      * @since 6.0
      */
+    @Deprecated
     RedisFuture<StringMatchResult> stralgoLcs(StrAlgoArgs strAlgoArgs);
 
+    /**
+     * The LCS command implements the longest common subsequence algorithm.
+     *
+     * <ul>
+     * <li>Without modifiers, the string representing the longest common substring is returned.</li>
+     * <li>When {@link LcsArgs#justLen() LEN} is given the command returns the length of the longest common substring.</li>
+     * <li>When {@link LcsArgs#withIdx() IDX} is given the command returns an array with the LCS length and all the ranges in
+     * both the strings, start and end offset for each string, where there are matches. When {@link LcsArgs#withMatchLen()
+     * WITHMATCHLEN} is given each array representing a match will also have the length of the match.</li>
+     * </ul>
+     *
+     * @param lcsArgs command arguments supplied by the {@link LcsArgs}.
+     * @return StringMatchResult
+     * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
+     * @since 6.6
+     */
+    RedisFuture<StringMatchResult> lcs(LcsArgs lcsArgs);
+
     /**
      * Get the length of the value stored in a key.
      *
diff --git a/src/main/java/io/lettuce/core/api/reactive/RedisStringReactiveCommands.java b/src/main/java/io/lettuce/core/api/reactive/RedisStringReactiveCommands.java
index 817c235375..e7722b4394 100644
--- a/src/main/java/io/lettuce/core/api/reactive/RedisStringReactiveCommands.java
+++ b/src/main/java/io/lettuce/core/api/reactive/RedisStringReactiveCommands.java
@@ -28,6 +28,7 @@
 import io.lettuce.core.KeyValue;
 import io.lettuce.core.SetArgs;
 import io.lettuce.core.StrAlgoArgs;
+import io.lettuce.core.LcsArgs;
 import io.lettuce.core.StringMatchResult;
 import io.lettuce.core.Value;
 import io.lettuce.core.output.KeyValueStreamingChannel;
@@ -414,6 +415,8 @@ public interface RedisStringReactiveCommands<K, V> {
     /**
      * The STRALGO command implements complex algorithms that operate on strings. This method uses the LCS algorithm (longest
      * common substring).
+     * <p>
+     * Command is no longer available in Redis server versions 7.0.x and later.
      *
      * <ul>
      * <li>Without modifiers the string representing the longest common substring is returned.</li>
@@ -426,10 +429,30 @@ public interface RedisStringReactiveCommands<K, V> {
      *
      * @param strAlgoArgs command arguments.
      * @return StringMatchResult.
+     * @deprecated since 6.6 in favor of {@link #lcs(LcsArgs)}.
      * @since 6.0
      */
+    @Deprecated
     Mono<StringMatchResult> stralgoLcs(StrAlgoArgs strAlgoArgs);
 
+    /**
+     * The LCS command implements the longest common subsequence algorithm.
+     *
+     * <ul>
+     * <li>Without modifiers, the string representing the longest common substring is returned.</li>
+     * <li>When {@link LcsArgs#justLen() LEN} is given the command returns the length of the longest common substring.</li>
+     * <li>When {@link LcsArgs#withIdx() IDX} is given the command returns an array with the LCS length and all the ranges in
+     * both the strings, start and end offset for each string, where there are matches. When {@link LcsArgs#withMatchLen()
+     * WITHMATCHLEN} is given each array representing a match will also have the length of the match.</li>
+     * </ul>
+     *
+     * @param lcsArgs command arguments supplied by the {@link LcsArgs}.
+     * @return StringMatchResult
+     * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
+     * @since 6.6
+     */
+    Mono<StringMatchResult> lcs(LcsArgs lcsArgs);
+
     /**
      * Get the length of the value stored in a key.
      *
diff --git a/src/main/java/io/lettuce/core/api/sync/RedisStringCommands.java b/src/main/java/io/lettuce/core/api/sync/RedisStringCommands.java
index 03280bf924..df13a42aef 100644
--- a/src/main/java/io/lettuce/core/api/sync/RedisStringCommands.java
+++ b/src/main/java/io/lettuce/core/api/sync/RedisStringCommands.java
@@ -27,6 +27,7 @@
 import io.lettuce.core.KeyValue;
 import io.lettuce.core.SetArgs;
 import io.lettuce.core.StrAlgoArgs;
+import io.lettuce.core.LcsArgs;
 import io.lettuce.core.StringMatchResult;
 import io.lettuce.core.output.KeyValueStreamingChannel;
 
@@ -409,6 +410,8 @@ public interface RedisStringCommands<K, V> {
     /**
      * The STRALGO command implements complex algorithms that operate on strings. This method uses the LCS algorithm (longest
      * common substring).
+     * <p>
+     * Command is no longer available in Redis server versions 7.0.x and later.
      *
      * <ul>
      * <li>Without modifiers the string representing the longest common substring is returned.</li>
@@ -421,10 +424,30 @@ public interface RedisStringCommands<K, V> {
      *
      * @param strAlgoArgs command arguments.
      * @return StringMatchResult.
+     * @deprecated since 6.6 in favor of {@link #lcs(LcsArgs)}.
      * @since 6.0
      */
+    @Deprecated
     StringMatchResult stralgoLcs(StrAlgoArgs strAlgoArgs);
 
+    /**
+     * The LCS command implements the longest common subsequence algorithm.
+     *
+     * <ul>
+     * <li>Without modifiers, the string representing the longest common substring is returned.</li>
+     * <li>When {@link LcsArgs#justLen() LEN} is given the command returns the length of the longest common substring.</li>
+     * <li>When {@link LcsArgs#withIdx() IDX} is given the command returns an array with the LCS length and all the ranges in
+     * both the strings, start and end offset for each string, where there are matches. When {@link LcsArgs#withMatchLen()
+     * WITHMATCHLEN} is given each array representing a match will also have the length of the match.</li>
+     * </ul>
+     *
+     * @param lcsArgs command arguments supplied by the {@link LcsArgs}.
+     * @return StringMatchResult
+     * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
+     * @since 6.6
+     */
+    StringMatchResult lcs(LcsArgs lcsArgs);
+
     /**
      * Get the length of the value stored in a key.
      *
diff --git a/src/main/java/io/lettuce/core/cluster/api/async/NodeSelectionStringAsyncCommands.java b/src/main/java/io/lettuce/core/cluster/api/async/NodeSelectionStringAsyncCommands.java
index 1ee831ab69..93e1701b1f 100644
--- a/src/main/java/io/lettuce/core/cluster/api/async/NodeSelectionStringAsyncCommands.java
+++ b/src/main/java/io/lettuce/core/cluster/api/async/NodeSelectionStringAsyncCommands.java
@@ -28,6 +28,7 @@
 import io.lettuce.core.SetArgs;
 import io.lettuce.core.StrAlgoArgs;
 import io.lettuce.core.StringMatchResult;
+import io.lettuce.core.LcsArgs;
 import io.lettuce.core.output.KeyValueStreamingChannel;
 
 /**
@@ -409,6 +410,8 @@ public interface NodeSelectionStringAsyncCommands<K, V> {
     /**
      * The STRALGO command implements complex algorithms that operate on strings. This method uses the LCS algorithm (longest
      * common substring).
+     * <p>
+     * Command is no longer available in Redis server versions 7.0.x and later.
      *
      * <ul>
      * <li>Without modifiers the string representing the longest common substring is returned.</li>
@@ -421,10 +424,30 @@ public interface NodeSelectionStringAsyncCommands<K, V> {
      *
      * @param strAlgoArgs command arguments.
      * @return StringMatchResult.
+     * @deprecated since 6.6 in favor of {@link #lcs(LcsArgs)}.
      * @since 6.0
      */
+    @Deprecated
     AsyncExecutions<StringMatchResult> stralgoLcs(StrAlgoArgs strAlgoArgs);
 
+    /**
+     * The LCS command implements the longest common subsequence algorithm.
+     *
+     * <ul>
+     * <li>Without modifiers, the string representing the longest common substring is returned.</li>
+     * <li>When {@link LcsArgs#justLen() LEN} is given the command returns the length of the longest common substring.</li>
+     * <li>When {@link LcsArgs#withIdx() IDX} is given the command returns an array with the LCS length and all the ranges in
+     * both the strings, start and end offset for each string, where there are matches. When {@link LcsArgs#withMatchLen()
+     * WITHMATCHLEN} is given each array representing a match will also have the length of the match.</li>
+     * </ul>
+     *
+     * @param lcsArgs command arguments supplied by the {@link LcsArgs}.
+     * @return StringMatchResult
+     * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
+     * @since 6.6
+     */
+    AsyncExecutions<StringMatchResult> lcs(LcsArgs lcsArgs);
+
     /**
      * Get the length of the value stored in a key.
      *
diff --git a/src/main/java/io/lettuce/core/cluster/api/sync/NodeSelectionStringCommands.java b/src/main/java/io/lettuce/core/cluster/api/sync/NodeSelectionStringCommands.java
index 47c80b004d..dcf3f27acc 100644
--- a/src/main/java/io/lettuce/core/cluster/api/sync/NodeSelectionStringCommands.java
+++ b/src/main/java/io/lettuce/core/cluster/api/sync/NodeSelectionStringCommands.java
@@ -28,6 +28,7 @@
 import io.lettuce.core.SetArgs;
 import io.lettuce.core.StrAlgoArgs;
 import io.lettuce.core.StringMatchResult;
+import io.lettuce.core.LcsArgs;
 import io.lettuce.core.output.KeyValueStreamingChannel;
 
 /**
@@ -409,6 +410,8 @@ public interface NodeSelectionStringCommands<K, V> {
     /**
      * The STRALGO command implements complex algorithms that operate on strings. This method uses the LCS algorithm (longest
      * common substring).
+     * <p>
+     * Command is no longer available in Redis server versions 7.0.x and later.
      *
      * <ul>
      * <li>Without modifiers the string representing the longest common substring is returned.</li>
@@ -421,10 +424,30 @@ public interface NodeSelectionStringCommands<K, V> {
      *
      * @param strAlgoArgs command arguments.
      * @return StringMatchResult.
+     * @deprecated since 6.6 in favor of {@link #lcs(LcsArgs)}.
      * @since 6.0
      */
+    @Deprecated
     Executions<StringMatchResult> stralgoLcs(StrAlgoArgs strAlgoArgs);
 
+    /**
+     * The LCS command implements the longest common subsequence algorithm.
+     *
+     * <ul>
+     * <li>Without modifiers, the string representing the longest common substring is returned.</li>
+     * <li>When {@link LcsArgs#justLen() LEN} is given the command returns the length of the longest common substring.</li>
+     * <li>When {@link LcsArgs#withIdx() IDX} is given the command returns an array with the LCS length and all the ranges in
+     * both the strings, start and end offset for each string, where there are matches. When {@link LcsArgs#withMatchLen()
+     * WITHMATCHLEN} is given each array representing a match will also have the length of the match.</li>
+     * </ul>
+     *
+     * @param lcsArgs command arguments supplied by the {@link LcsArgs}.
+     * @return StringMatchResult
+     * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
+     * @since 6.6
+     */
+    Executions<StringMatchResult> lcs(LcsArgs lcsArgs);
+
     /**
      * Get the length of the value stored in a key.
      *
diff --git a/src/main/java/io/lettuce/core/output/StringMatchResultOutput.java b/src/main/java/io/lettuce/core/output/StringMatchResultOutput.java
index 2217217139..62c6f35aaa 100644
--- a/src/main/java/io/lettuce/core/output/StringMatchResultOutput.java
+++ b/src/main/java/io/lettuce/core/output/StringMatchResultOutput.java
@@ -21,6 +21,7 @@
 
 import io.lettuce.core.StringMatchResult;
 import io.lettuce.core.codec.RedisCodec;
+import io.lettuce.core.protocol.CommandKeyword;
 
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
@@ -38,7 +39,7 @@
  */
 public class StringMatchResultOutput<K, V> extends CommandOutput<K, V, StringMatchResult> {
 
-    private static final ByteBuffer LEN = StandardCharsets.US_ASCII.encode("len");
+    private static final ByteBuffer LEN = StandardCharsets.US_ASCII.encode(CommandKeyword.LEN.toString().toLowerCase());
 
     private String matchString;
 
diff --git a/src/main/java/io/lettuce/core/protocol/CommandKeyword.java b/src/main/java/io/lettuce/core/protocol/CommandKeyword.java
index 8cd1f0f9d3..597816edfe 100644
--- a/src/main/java/io/lettuce/core/protocol/CommandKeyword.java
+++ b/src/main/java/io/lettuce/core/protocol/CommandKeyword.java
@@ -37,11 +37,11 @@ public enum CommandKeyword implements ProtocolKeyword {
 
     BY, BYLEX, BYSCORE, CACHING, CAT, CH, CHANNELS, COPY, COUNT, COUNTKEYSINSLOT, CONSUMERS, CREATE, DB, DELSLOTS, DELSLOTSRANGE, DELUSER, DESC, DRYRUN, SOFT, HARD, ENCODING,
 
-    FAILOVER, FORGET, FIELDS, FLAGS, FLUSH, FORCE, FREQ, FLUSHSLOTS, GENPASS, GETNAME, GETUSER, GETKEYSINSLOT, GETREDIR, GROUP, GROUPS, HTSTATS, ID, IDLE, INFO,
+    FAILOVER, FORGET, FIELDS, FLAGS, FLUSH, FORCE, FREQ, FLUSHSLOTS, GENPASS, GETNAME, GETUSER, GETKEYSINSLOT, GETREDIR, GROUP, GROUPS, HTSTATS, ID, IDLE, IDX, INFO,
 
     IDLETIME, JUSTID, KILL, KEYSLOT, LEFT, LEN, LIMIT, LINKS, LIST, LOAD, LOG, MATCH,
 
-    MAX, MAXLEN, MEET, MIN, MINID, MOVED, NO, NOACK, NOCOMMANDS, NODE, NODES, NOMKSTREAM, NOPASS, NOSAVE, NOT, NOVALUES, NUMSUB, SHARDCHANNELS, SHARDNUMSUB, NUMPAT, NX, OFF, ON, ONE, OR, PAUSE, PREFIXES,
+    MAX, MAXLEN, MEET, MIN, MINID, MINMATCHLEN, MOVED, NO, NOACK, NOCOMMANDS, NODE, NODES, NOMKSTREAM, NOPASS, NOSAVE, NOT, NOVALUES, NUMSUB, SHARDCHANNELS, SHARDNUMSUB, NUMPAT, NX, OFF, ON, ONE, OR, PAUSE, PREFIXES,
 
     REFCOUNT, REMOVE, RELOAD, REPLACE, REDIRECT, REPLICATE, REPLICAS, REV, RESET, RESETCHANNELS, RESETKEYS, RESETPASS,
 
@@ -49,7 +49,7 @@ public enum CommandKeyword implements ProtocolKeyword {
 
     MIGRATING, IMPORTING, SAVE, SKIPME, SLAVES, STREAM, STORE, SUM, SEGFAULT, SETUSER, TAKEOVER, TRACKING, TRACKINGINFO, TYPE, UNBLOCK, USERS, USAGE, WEIGHTS, WHOAMI,
 
-    WITHSCORE, WITHSCORES, WITHVALUES, XOR, XX, YES, INDENT, NEWLINE, SPACE;
+    WITHMATCHLEN, WITHSCORE, WITHSCORES, WITHVALUES, XOR, XX, YES, INDENT, NEWLINE, SPACE;
 
     public final byte[] bytes;
 
diff --git a/src/main/java/io/lettuce/core/protocol/CommandType.java b/src/main/java/io/lettuce/core/protocol/CommandType.java
index 7eb949e5d3..9a2fcf83f6 100644
--- a/src/main/java/io/lettuce/core/protocol/CommandType.java
+++ b/src/main/java/io/lettuce/core/protocol/CommandType.java
@@ -50,7 +50,7 @@ public enum CommandType implements ProtocolKeyword {
 
     // String
 
-    APPEND, GET, GETDEL, GETEX, GETRANGE, GETSET, MGET, MSET, MSETNX, SET, SETEX, PSETEX, SETNX, SETRANGE, STRLEN, STRALGO,
+    APPEND, GET, GETDEL, GETEX, GETRANGE, GETSET, MGET, MSET, MSETNX, SET, SETEX, PSETEX, SETNX, SETRANGE, STRLEN, STRALGO, LCS,
 
     // Numeric
 
diff --git a/src/main/kotlin/io/lettuce/core/api/coroutines/RedisStringCoroutinesCommands.kt b/src/main/kotlin/io/lettuce/core/api/coroutines/RedisStringCoroutinesCommands.kt
index 72df1f67fb..f6500da836 100644
--- a/src/main/kotlin/io/lettuce/core/api/coroutines/RedisStringCoroutinesCommands.kt
+++ b/src/main/kotlin/io/lettuce/core/api/coroutines/RedisStringCoroutinesCommands.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020-Present, Redis Ltd. and Contributors
+ * Copyright 2017-Present, Redis Ltd. and Contributors
  * All rights reserved.
  *
  * Licensed under the MIT License.
@@ -392,23 +392,22 @@ interface RedisStringCoroutinesCommands<K : Any, V : Any> {
     suspend fun setrange(key: K, offset: Long, value: V): Long?
 
     /**
-     * The STRALGO command implements complex algorithms that operate on strings. This method uses the LCS algorithm (longest
-     * common substring).
+     * The LCS command implements the longest common subsequence algorithm.
      *
      * <ul>
-     * <li>Without modifiers the string representing the longest common substring is returned.</li>
-     * <li>When [StrAlgoArgs#justLen LEN] is given the command returns the length of the longest common substring.</li>
-     * <li>When [StrAlgoArgs#withIdx IDX] is given the command returns an array with the LCS length and all the ranges
-     * in both the strings, start and end offset for each string, where there are matches. When
-     * [StrAlgoArgs#withMatchLen WITHMATCHLEN] is given each array representing a match will also have the length of the
-     * match.</li>
+     * <li>Without modifiers, the string representing the longest common substring is returned.</li>
+     * <li>When [LcsArgs#justLen LEN] is given the command returns the length of the longest common substring.</li>
+     * <li>When [LcsArgs#withIdx IDX] is given the command returns an array with the LCS length and all the ranges in
+     * both the strings, start and end offset for each string, where there are matches. When [LcsArgs#withMatchLen
+     * WITHMATCHLEN] is given each array representing a match will also have the length of the match.</li>
      * </ul>
      *
-     * @param strAlgoArgs command arguments.
-     * @return StringMatchResult.
-     * @since 6.0
+     * @param lcsArgs command arguments supplied by the [LcsArgs].
+     * @return StringMatchResult
+     * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
+     * @since 6.6
      */
-    suspend fun stralgoLcs(strAlgoArgs: StrAlgoArgs): StringMatchResult?
+    suspend fun lcs(lcsArgs: LcsArgs): StringMatchResult?
 
     /**
      * Get the length of the value stored in a key.
diff --git a/src/main/kotlin/io/lettuce/core/api/coroutines/RedisStringCoroutinesCommandsImpl.kt b/src/main/kotlin/io/lettuce/core/api/coroutines/RedisStringCoroutinesCommandsImpl.kt
index 86586c6899..8bfbb56d4d 100644
--- a/src/main/kotlin/io/lettuce/core/api/coroutines/RedisStringCoroutinesCommandsImpl.kt
+++ b/src/main/kotlin/io/lettuce/core/api/coroutines/RedisStringCoroutinesCommandsImpl.kt
@@ -116,7 +116,7 @@ internal class RedisStringCoroutinesCommandsImpl<K : Any, V : Any>(internal val
 
     override suspend fun setrange(key: K, offset: Long, value: V): Long? = ops.setrange(key, offset, value).awaitFirstOrNull()
 
-    override suspend fun stralgoLcs(strAlgoArgs: StrAlgoArgs): StringMatchResult? = ops.stralgoLcs(strAlgoArgs).awaitFirstOrNull()
+    override suspend fun lcs(lcsArgs: LcsArgs): StringMatchResult? = ops.lcs(lcsArgs).awaitFirstOrNull()
 
     override suspend fun strlen(key: K): Long? = ops.strlen(key).awaitFirstOrNull()
 
diff --git a/src/main/templates/io/lettuce/core/api/RedisStringCommands.java b/src/main/templates/io/lettuce/core/api/RedisStringCommands.java
index 05f6264228..02a8a2562a 100644
--- a/src/main/templates/io/lettuce/core/api/RedisStringCommands.java
+++ b/src/main/templates/io/lettuce/core/api/RedisStringCommands.java
@@ -403,6 +403,8 @@ public interface RedisStringCommands<K, V> {
     /**
      * The STRALGO command implements complex algorithms that operate on strings. This method uses the LCS algorithm (longest
      * common substring).
+     * <p>
+     * Command is no longer available in Redis server versions 7.0.x and later.
      *
      * <ul>
      * <li>Without modifiers the string representing the longest common substring is returned.</li>
@@ -415,10 +417,30 @@ public interface RedisStringCommands<K, V> {
      *
      * @param strAlgoArgs command arguments.
      * @return StringMatchResult.
+     * @deprecated since 6.6 in favor of {@link #lcs(LcsArgs)}.
      * @since 6.0
      */
+    @Deprecated
     StringMatchResult stralgoLcs(StrAlgoArgs strAlgoArgs);
 
+    /**
+     * The LCS command implements the longest common subsequence algorithm.
+     *
+     * <ul>
+     * <li>Without modifiers, the string representing the longest common substring is returned.</li>
+     * <li>When {@link LcsArgs#justLen() LEN} is given the command returns the length of the longest common substring.</li>
+     * <li>When {@link LcsArgs#withIdx() IDX} is given the command returns an array with the LCS length and all the ranges in
+     * both the strings, start and end offset for each string, where there are matches. When {@link LcsArgs#withMatchLen()
+     * WITHMATCHLEN} is given each array representing a match will also have the length of the match.</li>
+     * </ul>
+     *
+     * @param lcsArgs command arguments supplied by the {@link LcsArgs}.
+     * @return StringMatchResult
+     * @see <a href="https://redis.io/commands/lcs">LCS command refference</a>
+     * @since 6.6
+     */
+    StringMatchResult lcs(LcsArgs lcsArgs);
+
     /**
      * Get the length of the value stored in a key.
      *
diff --git a/src/test/java/io/lettuce/core/commands/StringCommandIntegrationTests.java b/src/test/java/io/lettuce/core/commands/StringCommandIntegrationTests.java
index b32a9beb86..a90c3c27ad 100644
--- a/src/test/java/io/lettuce/core/commands/StringCommandIntegrationTests.java
+++ b/src/test/java/io/lettuce/core/commands/StringCommandIntegrationTests.java
@@ -68,6 +68,10 @@ public class StringCommandIntegrationTests extends TestSupport {
 
     private final RedisCommands<String, String> redis;
 
+    protected final String KEY_1 = "key1{k}";
+
+    protected final String KEY_2 = "key2{k}";
+
     @Inject
     protected StringCommandIntegrationTests(RedisCommands<String, String> redis) {
         this.redis = redis;
@@ -328,10 +332,10 @@ void strAlgo() {
     @EnabledOnCommand("STRALGO")
     void strAlgoUsingKeys() {
 
-        redis.set("key1{k}", "ohmytext");
-        redis.set("key2{k}", "mynewtext");
+        redis.set(KEY_1, "ohmytext");
+        redis.set(KEY_2, "mynewtext");
 
-        StringMatchResult matchResult = redis.stralgoLcs(StrAlgoArgs.Builder.keys("key1{k}", "key2{k}"));
+        StringMatchResult matchResult = redis.stralgoLcs(StrAlgoArgs.Builder.keys(KEY_1, KEY_2));
         assertThat(matchResult.getMatchString()).isEqualTo("mytext");
 
         // STRALGO LCS STRINGS a b
@@ -382,114 +386,105 @@ void strAlgoWithIdx() {
     @Test
     @EnabledOnCommand("LCS")
     void lcs() {
-        redis.set("key1", "ohmytext");
-        redis.set("key2", "mynewtext");
+        redis.set(KEY_1, "ohmytext");
+        redis.set(KEY_2, "mynewtext");
 
-        // LCS key1 key2
-        CustomStringCommands commands = CustomStringCommands.instance(getConnection());
-        StringMatchResult matchResult = commands.lcs("key1", "key2");
+        // > LCS key1 key2
+        StringMatchResult matchResult = redis.lcs(LcsArgs.Builder.keys(KEY_1, KEY_2));
         assertThat(matchResult.getMatchString()).isEqualTo("mytext");
-
-        // LCS a b IDX MINMATCHLEN 4 WITHMATCHLEN
-        // Keys don't exist.
-        matchResult = commands.lcsMinMatchLenWithMatchLen("a", "b", 4);
-        assertThat(matchResult.getMatchString()).isNullOrEmpty();
+        assertThat(matchResult.getMatches().size()).isEqualTo(0);
         assertThat(matchResult.getLen()).isEqualTo(0);
+
     }
 
     @Test
     @EnabledOnCommand("LCS")
-    void lcsUsingKeys() {
+    void lcsNonExistantKeys() {
 
-        redis.set("key1{k}", "ohmytext");
-        redis.set("key2{k}", "mynewtext");
-
-        CustomStringCommands commands = CustomStringCommands.instance(getConnection());
-
-        StringMatchResult matchResult = commands.lcs("key1{k}", "key2{k}");
-        assertThat(matchResult.getMatchString()).isEqualTo("mytext");
-
-        // STRALGO LCS STRINGS a b
-        matchResult = commands.lcsMinMatchLenWithMatchLen("a", "b", 4);
+        // > LCS a b IDX MINMATCHLEN 4 WITHMATCHLEN
+        // Keys don't exist.
+        StringMatchResult matchResult = redis.lcs(LcsArgs.Builder.keys("a{k}", "b{k}").minMatchLen(4).withMatchLen());
         assertThat(matchResult.getMatchString()).isNullOrEmpty();
+        assertThat(matchResult.getMatches()).isNullOrEmpty();
         assertThat(matchResult.getLen()).isEqualTo(0);
     }
 
     @Test
     @EnabledOnCommand("LCS")
     void lcsJustLen() {
-        redis.set("one", "ohmytext");
-        redis.set("two", "mynewtext");
-
-        CustomStringCommands commands = CustomStringCommands.instance(getConnection());
-
-        StringMatchResult matchResult = commands.lcsLen("one", "two");
+        redis.set(KEY_1, "ohmytext");
+        redis.set(KEY_2, "mynewtext");
 
+        // > LCS key1 key2 LEN
+        StringMatchResult matchResult = redis.lcs(LcsArgs.Builder.keys(KEY_1, KEY_2).justLen());
         assertThat(matchResult.getLen()).isEqualTo(6);
+        assertThat(matchResult.getMatchString()).isNullOrEmpty();
+        assertThat(matchResult.getMatches()).isNullOrEmpty();
     }
 
     @Test
     @EnabledOnCommand("LCS")
-    void lcsWithMinMatchLen() {
-        redis.set("key1", "ohmytext");
-        redis.set("key2", "mynewtext");
+    void lcsIdx() {
+        redis.set(KEY_1, "ohmytext");
+        redis.set(KEY_2, "mynewtext");
 
-        CustomStringCommands commands = CustomStringCommands.instance(getConnection());
+        // > LCS key1 key2 IDX
+        StringMatchResult matchResult = redis.lcs(LcsArgs.Builder.keys(KEY_1, KEY_2).withIdx());
 
-        StringMatchResult matchResult = commands.lcsMinMatchLen("key1", "key2", 4);
+        assertThat(matchResult.getMatches().size()).isEqualTo(2);
+        assertThat(matchResult.getMatches().get(0).getA().getStart()).isEqualTo(4);
+        assertThat(matchResult.getMatches().get(0).getA().getEnd()).isEqualTo(7);
+        assertThat(matchResult.getMatches().get(0).getB().getStart()).isEqualTo(5);
+        assertThat(matchResult.getMatches().get(0).getB().getEnd()).isEqualTo(8);
 
-        assertThat(matchResult.getMatchString()).isEqualTo("mytext");
+        assertThat(matchResult.getMatches().get(1).getA().getStart()).isEqualTo(2);
+        assertThat(matchResult.getMatches().get(1).getA().getEnd()).isEqualTo(3);
+        assertThat(matchResult.getMatches().get(1).getB().getStart()).isEqualTo(0);
+        assertThat(matchResult.getMatches().get(1).getB().getEnd()).isEqualTo(1);
+
+        assertThat(matchResult.getLen()).isEqualTo(6);
+
+        assertThat(matchResult.getMatchString()).isNullOrEmpty();
     }
 
     @Test
     @EnabledOnCommand("LCS")
-    void lcsMinMatchLenIdxMatchLen() {
-        redis.set("key1", "ohmytext");
-        redis.set("key2", "mynewtext");
-
-        CustomStringCommands commands = CustomStringCommands.instance(getConnection());
+    void lcsWithMinMatchLen() {
+        redis.set(KEY_1, "ohmytext");
+        redis.set(KEY_2, "mynewtext");
 
-        // LCS key1 key2 IDX MINMATCHLEN 4 WITHMATCHLEN
-        StringMatchResult matchResult = commands.lcsMinMatchLenWithMatchLen("key1", "key2", 4);
+        // > LCS key1 key2 IDX MINMATCHLEN 4
+        StringMatchResult matchResult = redis.lcs(LcsArgs.Builder.keys(KEY_1, KEY_2).withIdx().minMatchLen(4));
 
-        assertThat(matchResult.getMatches()).hasSize(1);
-        assertThat(matchResult.getMatches().get(0).getMatchLen()).isEqualTo(4);
+        assertThat(matchResult.getMatches().get(0).getA().getStart()).isEqualTo(4);
+        assertThat(matchResult.getMatches().get(0).getA().getEnd()).isEqualTo(7);
+        assertThat(matchResult.getMatches().get(0).getB().getStart()).isEqualTo(5);
+        assertThat(matchResult.getMatches().get(0).getB().getEnd()).isEqualTo(8);
 
-        Position a = matchResult.getMatches().get(0).getA();
-        Position b = matchResult.getMatches().get(0).getB();
-
-        assertThat(a.getStart()).isEqualTo(4);
-        assertThat(a.getEnd()).isEqualTo(7);
-        assertThat(b.getStart()).isEqualTo(5);
-        assertThat(b.getEnd()).isEqualTo(8);
         assertThat(matchResult.getLen()).isEqualTo(6);
-    }
 
-    protected StatefulConnection<String, String> getConnection() {
-        StatefulRedisConnection<String, String> src = redis.getStatefulConnection();
-        Assumptions.assumeFalse(Proxy.isProxyClass(src.getClass()), "Redis connection is proxy, skipping.");
-        return src;
+        assertThat(matchResult.getMatchString()).isNullOrEmpty();
     }
 
-    private interface CustomStringCommands extends Commands {
-
-        @Command("LCS :k1 :k2")
-        StringMatchResult lcs(@Param("k1") String k1, @Param("k2") String k2);
+    @Test
+    @EnabledOnCommand("LCS")
+    void lcsMinMatchLenIdxMatchLen() {
+        redis.set(KEY_1, "ohmytext");
+        redis.set(KEY_2, "mynewtext");
 
-        @Command("LCS :k1 :k2 LEN")
-        StringMatchResult lcsLen(@Param("k1") String k1, @Param("k2") String k2);
+        // > LCS key1 key2 IDX MINMATCHLEN 4 WITHMATCHLEN
+        StringMatchResult matchResult = redis.lcs(LcsArgs.Builder.keys(KEY_1, KEY_2).minMatchLen(4).withMatchLen().withIdx());
 
-        @Command("LCS :k1 :k2 MINMATCHLEN :mml")
-        StringMatchResult lcsMinMatchLen(@Param("k1") String k1, @Param("k2") String k2, @Param("mml") int mml);
+        assertThat(matchResult.getMatches().get(0).getA().getStart()).isEqualTo(4);
+        assertThat(matchResult.getMatches().get(0).getA().getEnd()).isEqualTo(7);
+        assertThat(matchResult.getMatches().get(0).getB().getStart()).isEqualTo(5);
+        assertThat(matchResult.getMatches().get(0).getB().getEnd()).isEqualTo(8);
 
-        @Command("LCS :k1 :k2 IDX MINMATCHLEN :mml WITHMATCHLEN")
-        StringMatchResult lcsMinMatchLenWithMatchLen(@Param("k1") String k1, @Param("k2") String k2, @Param("mml") int mml);
+        assertThat(matchResult.getMatches().get(0).getMatchLen()).isEqualTo(4);
 
-        static CustomStringCommands instance(StatefulConnection<String, String> conn) {
-            RedisCommandFactory factory = new RedisCommandFactory(conn);
-            return factory.getCommands(CustomStringCommands.class);
-        }
+        assertThat(matchResult.getLen()).isEqualTo(6);
 
+        assertThat(matchResult.getMatchString()).isNullOrEmpty();
     }
 
 }