diff --git a/docs/.vitepress/config.js b/docs/.vitepress/config.js
index f535db2..a601d10 100644
--- a/docs/.vitepress/config.js
+++ b/docs/.vitepress/config.js
@@ -70,7 +70,7 @@ export default defineConfig({
         collapsed: false,
         items: [
           {
-            text: 'mule-chunking-connector',
+            text: 'Chunking Connector',
             collapsed: false,
             items: [
               { text: 'Overview', link: '/connectors/mule-chunking-connector/' },
@@ -86,7 +86,7 @@ export default defineConfig({
             ]
           },
           {
-            text: 'mule-idp-connector',
+            text: 'IDP Connector',
             collapsed: false,
             items: [
               { text: 'Overview', link: '/connectors/mule-idp-connector/' },
@@ -111,6 +111,33 @@ export default defineConfig({
               { text: 'Universal REST Smart Connector', link: '/connectors/mule-idp-connector/mulesoft-idp-universal-rest-smart-connector' },
               { text: 'Dataweave', link: '/connectors/mule-idp-connector/dataweave' }
             ]
+          },
+          {
+            text: 'Lettuce Redis Connector',
+            collapsed: false,
+            items: [
+              { text: 'Overview', link: '/connectors/mule-lettuce-redis-connector/' },
+              { text: 'Set Up', link: '/connectors/mule-lettuce-redis-connector/set-up' },
+              {
+                text: 'Operations',
+                collapsed: true,
+                items: [
+                  { text: 'Operations Overview', link: '/connectors/mule-lettuce-redis-connector/operations/' },
+                  { text: 'Server', link: '/connectors/mule-lettuce-redis-connector/operations/server' },
+                  { text: 'Key / Value', link: '/connectors/mule-lettuce-redis-connector/operations/key-value' },
+                  { text: 'Hash', link: '/connectors/mule-lettuce-redis-connector/operations/hash' },
+                  { text: 'List', link: '/connectors/mule-lettuce-redis-connector/operations/list' },
+                  { text: 'Set', link: '/connectors/mule-lettuce-redis-connector/operations/set' },
+                  { text: 'Sorted Set', link: '/connectors/mule-lettuce-redis-connector/operations/sorted-set' },
+                  { text: 'Geospatial', link: '/connectors/mule-lettuce-redis-connector/operations/geospatial' },
+                  { text: 'Stream', link: '/connectors/mule-lettuce-redis-connector/operations/stream' },
+                  { text: 'Channel', link: '/connectors/mule-lettuce-redis-connector/operations/channel' },
+                  { text: 'Send Command', link: '/connectors/mule-lettuce-redis-connector/operations/send-command' },
+                  { text: 'Search Operations', link: '/connectors/mule-lettuce-redis-connector/operations/search-operations' }
+                ]
+              },
+              { text: 'Sources (Listeners)', link: '/connectors/mule-lettuce-redis-connector/sources' }
+            ]
           }
         ]
       },
@@ -121,7 +148,7 @@ export default defineConfig({
         collapsed: false,
         items: [
           {
-            text: 'mule-pdfbox-module',
+            text: 'PDFBox Module',
             collapsed: false,
             items: [
               { text: 'Overview', link: '/modules/mule-pdfbox-module/' },
diff --git a/docs/connectors/mule-lettuce-redis-connector/index.md b/docs/connectors/mule-lettuce-redis-connector/index.md
new file mode 100644
index 0000000..be1d381
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/index.md
@@ -0,0 +1,70 @@
+---
+title: Mule Lettuce Redis Connector
+description: Direct access to Redis commands from Mule applications, built on the Lettuce reactive Redis client.
+---
+
+# Lettuce Redis Connector
+
+A low-level connector providing Mule applications with direct access to Redis commands, built on the [Lettuce](https://lettuce.io/) reactive Redis client library. Published on Maven Central under `cloud.anypoint`.
+
+The connector's goal is to provide full coverage of all documented Redis commands, organized by Redis data structure. For commands not yet implemented as dedicated operations, the [Send Command](./operations/send-command) operation lets you execute any arbitrary Redis command.
+
+## Features
+
+- **Broad command coverage**: Dedicated operations for strings, hashes, lists, sets, sorted sets, geospatial indexes, and streams
+- **Pub/Sub event sources**: Trigger Mule flows in real time from Redis channels using SUBSCRIBE and PSUBSCRIBE
+- **Dynamic command execution**: [Send Command](./operations/send-command) executes any Redis command not yet available as a dedicated operation
+- **Automated SCAN iteration**: [Search Operations](./operations/search-operations) handle Redis cursor management internally, streaming full result sets without manual loop logic
+- **Maven Central**: Install with a single Maven dependency — no local builds required
+
+## Quick Example
+
+```xml
+<!-- Standard Redis configuration -->
+<lettuce-redis:config name="Redis_Config">
+    <lettuce-redis:connection
+        host="localhost"
+        port="6379"
+        tls="false"
+        password="${secure::redis.password}"/>
+</lettuce-redis:config>
+
+<!-- Store a value -->
+<lettuce-redis:set config-ref="Redis_Config" key="greeting" value="hello"/>
+
+<!-- Retrieve it -->
+<lettuce-redis:get config-ref="Redis_Config" key="greeting"/>
+
+<!-- payload is now "hello" -->
+<logger level="INFO" message="#[payload]"/>
+```
+
+## Supported Command Categories
+
+| Category | Operations | Page |
+|----------|-----------|------|
+| Server | PING | [Server](./operations/server) |
+| Key / Value | APPEND, COPY, DECR, DEL, EXPIRE, GET, GETDEL, GETEX, GETRANGE, GETSET, INCR, MGET, MSET, PERSIST, PEXPIRE, PTTL, SCAN, SET, TOUCH, TTL | [Key / Value](./operations/key-value) |
+| Hash | HEXISTS, HGET, HGETALL, HINCRBY, HLEN, HMGET, HSCAN, HSET | [Hash](./operations/hash) |
+| List | BLMOVE, BLPOP, BRPOP, LMOVE, LPOP, LPUSH, LSET, RPOP, RPUSH | [List](./operations/list) |
+| Set | SADD, SCARD, SDIFF, SISMEMBER, SMEMBERS, SMISMEMBER, SPOP, SRANDMEMBER, SREM, SSCAN | [Set](./operations/set) |
+| Sorted Set | ZADD, ZINCRBY, ZRANK, ZSCAN, ZSCORE | [Sorted Set](./operations/sorted-set) |
+| Geospatial | GEOADD, GEODIST, GEOPOS, GEOSEARCH | [Geospatial](./operations/geospatial) |
+| Stream | XACK, XADD, XDEL, XGROUP CREATE, XGROUP DESTROY, XINFO GROUPS, XRANGE, XREAD, XREADGROUP, XTRIM | [Stream](./operations/stream) |
+| Channel | PUBLISH | [Channel](./operations/channel) |
+| Send Command | Any Redis command (dynamic) | [Send Command](./operations/send-command) |
+| Search Operations | Automated SCAN, HSCAN, SSCAN, ZSCAN iteration | [Search Operations](./operations/search-operations) |
+| Sources (Listeners) | SUBSCRIBE, PSUBSCRIBE | [Sources](./sources) |
+
+## Requirements
+
+- **Mule Runtime**: 4.6.0 or later
+- **Java**: 8, 11, or 17
+- **Redis**: Any version supporting the commands you use
+
+## Learn More
+
+- [Set Up Guide](./set-up) — Installation and connection configuration
+- [Operations Reference](./operations/) — All operations by category
+- [Sources (Listeners)](./sources) — Pub/Sub event-driven flows
+- [GitHub Repository](https://github.com/anypointcloud/mule-lettuce-redis-connector) — Source code and issues
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/channel.md b/docs/connectors/mule-lettuce-redis-connector/operations/channel.md
new file mode 100644
index 0000000..17b617c
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/channel.md
@@ -0,0 +1,110 @@
+---
+title: Channel Commands — Lettuce Redis Connector
+description: Reference for channel (Pub/Sub) Redis commands in the Mule Lettuce Redis Connector
+---
+
+# Channel Commands
+
+Channel commands are used to send messages to Redis Pub/Sub channels. To receive messages, see [Sources (Listeners)](../sources).
+
+This page covers: **PUBLISH**
+
+---
+
+## PUBLISH
+
+Publish a message to a Redis Pub/Sub channel.
+
+> 📘 **Redis Reference**: [PUBLISH](https://redis.io/docs/latest/commands/publish/)
+
+### XML Example
+
+```xml
+<lettuce-redis:publish doc:name="Publish notification"
+    config-ref="Redis_Config"
+    channel="order-events"
+    message='{"orderId": "12345", "status": "shipped"}'/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `channel` | String | Yes | — | The name of the channel to publish to |
+| `message` | String | Yes | — | The message content to publish |
+
+### Output
+
+**Type**: `Long`
+
+The number of subscribers that received the message. A return value of `0` means no clients were subscribed to the channel when the message was published.
+
+::: warning Message Delivery
+Redis Pub/Sub is fire-and-forget. If no subscriber is listening when PUBLISH is called, the message is lost. For durable messaging, consider using [Redis Streams](./stream) instead.
+:::
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | Connection failure or server error |
+
+### Usage
+
+::: info Configuration
+PUBLISH uses the **standard configuration** (`lettuce-redis:config`), not the pub/sub configuration. Only the SUBSCRIBE and PSUBSCRIBE sources require the pub/sub configuration.
+:::
+
+**Common pattern: Publish and subscribe in the same application**
+
+```xml
+<!-- Standard config for PUBLISH -->
+<lettuce-redis:config name="Redis_Config">
+    <lettuce-redis:connection
+        host="${redis.host}"
+        port="${redis.port}"
+        tls="false"
+        password="${secure::redis.password}"/>
+</lettuce-redis:config>
+
+<!-- Pub/Sub config for SUBSCRIBE sources -->
+<lettuce-redis:pubsub-config name="Redis_PubSub_Config">
+    <lettuce-redis:pubsub-connection
+        host="${redis.host}"
+        port="${redis.port}"
+        tls="false"
+        password="${secure::redis.password}"/>
+</lettuce-redis:pubsub-config>
+
+<!-- Publish messages when orders are placed -->
+<flow name="order-publisher">
+    <http:listener config-ref="HTTP_Config" path="/orders"/>
+
+    <lettuce-redis:publish
+        config-ref="Redis_Config"
+        channel="order-events"
+        message="#[payload]"/>
+
+    <set-variable variableName="subscriberCount" value="#[payload]"/>
+
+    <logger level="INFO"
+        message="Published to #[vars.subscriberCount] subscribers"/>
+</flow>
+
+<!-- Subscribe to order events and process them -->
+<flow name="order-subscriber">
+    <lettuce-redis:subscribe-channel
+        config-ref="Redis_PubSub_Config"
+        channels="#[['order-events']]"/>
+
+    <logger level="INFO"
+        message="Received order event: #[payload]"/>
+
+    <flow-ref name="process-order-event"/>
+</flow>
+```
+
+### See Also
+
+- [Sources (Listeners)](../sources) — SUBSCRIBE and PSUBSCRIBE for receiving messages
+- [Redis Streams](./stream) — Durable, persistent messaging with consumer groups
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/geospatial.md b/docs/connectors/mule-lettuce-redis-connector/operations/geospatial.md
new file mode 100644
index 0000000..dbbd296
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/geospatial.md
@@ -0,0 +1,347 @@
+---
+title: Geospatial Commands — Lettuce Redis Connector
+description: Reference for geospatial Redis commands in the Mule Lettuce Redis Connector
+---
+
+# Geospatial Commands
+
+Geospatial commands operate on Redis geospatial indexes — sorted sets where each member represents a location with longitude and latitude coordinates. Useful for location-based queries like "find nearby points" or "calculate distance between locations".
+
+This page covers: **GEOADD**, **GEODIST**, **GEOPOS**, **GEOSEARCH**
+
+---
+
+## GEOADD
+
+Add one or more geospatial items (longitude, latitude, name) to a geospatial index.
+
+> 📘 **Redis Reference**: [GEOADD](https://redis.io/docs/latest/commands/geoadd/)
+
+### XML Example
+
+```xml
+<lettuce-redis:geoadd doc:name="Add store locations"
+    config-ref="Redis_Config"
+    key="stores:locations"
+    items="#[[
+        {name: 'store-downtown', longitude: -122.4194, latitude: 37.7749},
+        {name: 'store-airport', longitude: -122.3750, latitude: 37.6213},
+        {name: 'store-suburbs', longitude: -122.0842, latitude: 37.3861}
+    ]]"
+    nx="false"
+    xx="false"
+    ch="false"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The geospatial index key |
+| `items` | List\<GeospatialItem\> | Yes | — | Locations to add. At least one required. Each item has: `name` (String), `longitude` (double), `latitude` (double). |
+| `nx` | boolean | No | `false` | Only add new members (do not update existing) |
+| `xx` | boolean | No | `false` | Only update existing members (do not add new) |
+| `ch` | boolean | No | `false` | Change the return value to count **changed** members instead of **added** members |
+
+**GeospatialItem structure**:
+```dataweave
+{
+  name: "location-name",       // String
+  longitude: -122.4194,         // double
+  latitude: 37.7749             // double
+}
+```
+
+### Output
+
+**Type**: `Long`
+
+The number of elements added to the index. When `ch=true`, returns the number of elements added or updated.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No items provided, or invalid coordinates |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a sorted set (geospatial index) |
+
+---
+
+## GEOPOS
+
+Get the longitude and latitude coordinates of one or more members in a geospatial index.
+
+> 📘 **Redis Reference**: [GEOPOS](https://redis.io/docs/latest/commands/geopos/)
+
+### XML Example
+
+```xml
+<lettuce-redis:geopos doc:name="Get store positions"
+    config-ref="Redis_Config"
+    key="stores:locations"
+    members="#[['store-downtown', 'store-airport']]"/>
+
+<!-- payload is a List<GeoLocation> -->
+<foreach collection="#[payload]">
+    <logger level="INFO"
+        message="Location: lon=#[payload.longitude], lat=#[payload.latitude]"/>
+</foreach>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The geospatial index key |
+| `members` | List\<String\> | Yes | — | Member names to look up. At least one required. Payload by default via `@Content`. |
+
+### Output
+
+**Type**: `List<GeoLocation>`
+
+A list of locations, one for each input member. If a member does not exist, its entry in the list is `null`.
+
+**GeoLocation structure**:
+```dataweave
+{
+  longitude: -122.4194,   // double
+  latitude: 37.7749        // double
+}
+```
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No members provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a geospatial index |
+
+---
+
+## GEODIST
+
+Calculate the distance between two members in a geospatial index.
+
+> 📘 **Redis Reference**: [GEODIST](https://redis.io/docs/latest/commands/geodist/)
+
+### XML Example
+
+```xml
+<lettuce-redis:geodist doc:name="Calculate distance between stores"
+    config-ref="Redis_Config"
+    key="stores:locations"
+    member1="store-downtown"
+    member2="store-airport"
+    unit="KM"/>
+
+<!-- payload is now the distance in kilometers as a Double -->
+<logger level="INFO" message="Distance: #[payload] km"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The geospatial index key |
+| `member1` | String | Yes | — | First member |
+| `member2` | String | Yes | — | Second member |
+| `unit` | DistanceUnit | No | `M` | Unit for the returned distance: `M` (meters), `KM` (kilometers), `FT` (feet), `MI` (miles) |
+
+**DistanceUnit values**: `M`, `KM`, `FT`, `MI`
+
+### Output
+
+**Type**: `Double`
+
+The distance between the two members in the specified unit.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a geospatial index |
+
+---
+
+## GEOSEARCH
+
+Search for members in a geospatial index within a specified area.
+
+> 📘 **Redis Reference**: [GEOSEARCH](https://redis.io/docs/latest/commands/geosearch/)
+
+GEOSEARCH is the most complex operation in the connector due to its many configuration options. It supports searching by radius or by box, from a member location or from explicit coordinates, with optional result options (coordinates, distance, geohash).
+
+::: warning Static Configuration Required
+The `searchCenter` and `searchBy` parameters are `@Expression(NOT_SUPPORTED)` — they **must** be configured statically in XML. DataWeave expressions cannot be used for these parameters.
+:::
+
+### XML Examples
+
+**Search by radius from a member:**
+
+```xml
+<lettuce-redis:geosearch doc:name="Find stores near downtown"
+    config-ref="Redis_Config"
+    key="stores:locations"
+    searchCenter="#[{fromMember: 'store-downtown'}]"
+    searchBy="#[{byRadius: {radius: 10.0, unit: 'KM'}}]"
+    sortOrder="ASC"
+    count="5"
+    countAny="false">
+    <lettuce-redis:search-result-options
+        withCoord="false"
+        withDist="false"
+        withHash="false"/>
+</lettuce-redis:geosearch>
+
+<!-- payload is a List<String> of member names -->
+```
+
+**Search by radius from coordinates:**
+
+```xml
+<lettuce-redis:geosearch doc:name="Find stores near coordinates"
+    config-ref="Redis_Config"
+    key="stores:locations"
+    searchCenter="#[{fromLatLong: {latitude: 37.7749, longitude: -122.4194}}]"
+    searchBy="#[{byRadius: {radius: 5.0, unit: 'MI'}}]"
+    sortOrder="ASC">
+    <lettuce-redis:search-result-options
+        withCoord="true"
+        withDist="true"
+        withHash="false"/>
+</lettuce-redis:geosearch>
+
+<!-- payload is a List<Map> with detailed results -->
+<foreach collection="#[payload]">
+    <logger level="INFO"
+        message="Store: #[payload.member], Distance: #[payload.distance] mi, Lat: #[payload.latitude], Lon: #[payload.longitude]"/>
+</foreach>
+```
+
+**Search by box:**
+
+```xml
+<lettuce-redis:geosearch doc:name="Find stores in rectangular area"
+    config-ref="Redis_Config"
+    key="stores:locations"
+    searchCenter="#[{fromLatLong: {latitude: 37.7749, longitude: -122.4194}}]"
+    searchBy="#[{byBox: {width: 20.0, height: 15.0, unit: 'KM'}}]"
+    sortOrder="NONE">
+    <lettuce-redis:search-result-options
+        withCoord="false"
+        withDist="false"
+        withHash="false"/>
+</lettuce-redis:geosearch>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The geospatial index key |
+| `searchCenter` | GeoSearchCenter | Yes | — | Origin of the search. See structures below. |
+| `searchBy` | GeoSearchBy | Yes | — | Search shape (radius or box). See structures below. |
+| `sortOrder` | SortOrder | Yes | — | Sort results by distance: `NONE`, `ASC`, or `DESC` |
+| `count` | Integer | No | — | Maximum number of results to return |
+| `countAny` | boolean | No | `false` | If true, return any `count` results (not necessarily the closest) |
+| `searchResultOptions` | GeoSearchResultOption | Yes | — | What to include in results: `withCoord`, `withDist`, `withHash` |
+
+**GeoSearchCenter** (choose one):
+
+| Type | Structure |
+|------|-----------|
+| `fromMember` | `{fromMember: "member-name"}` |
+| `fromLatLong` | `{fromLatLong: {latitude: 37.7749, longitude: -122.4194}}` |
+
+**GeoSearchBy** (choose one):
+
+| Type | Structure |
+|------|-----------|
+| `byRadius` | `{byRadius: {radius: 10.0, unit: 'KM'}}` |
+| `byBox` | `{byBox: {width: 20.0, height: 15.0, unit: 'KM'}}` |
+
+**GeoSearchResultOption** (parameter group):
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `withCoord` | boolean | `false` | Include coordinates in results |
+| `withDist` | boolean | `false` | Include distance from search center in results |
+| `withHash` | boolean | `false` | Include geohash integer in results |
+
+**SortOrder values**: `NONE`, `ASC`, `DESC`
+
+**DistanceUnit values** (for radius and box): `M`, `KM`, `FT`, `MI`
+
+### Output
+
+**Type**: `List` (dynamic, resolved by metadata based on `searchResultOptions`)
+
+**When no result options are enabled** (`withCoord=false`, `withDist=false`, `withHash=false`):
+- **Type**: `List<String>` — Member names only
+
+**When one or more result options are enabled**:
+- **Type**: `List<Map>` — Each element is a map with the following fields:
+  - `"member"` → String (always present) — The member name
+  - `"latitude"` → Number (if `withCoord=true`) — Latitude coordinate
+  - `"longitude"` → Number (if `withCoord=true`) — Longitude coordinate
+  - `"distance"` → Number (if `withDist=true`) — Distance from search center
+  - `"hash"` → Number (if `withHash=true`) — Geohash value
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | Invalid search parameters |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a geospatial index |
+
+### Complete Example: Nearby Store Finder
+
+```xml
+<flow name="find-nearby-stores">
+    <http:listener config-ref="HTTP_Config" path="/stores/nearby"/>
+
+    <!-- Input: lat, lon, radiusKm from query params -->
+    <lettuce-redis:geosearch doc:name="Search nearby stores"
+        config-ref="Redis_Config"
+        key="stores:locations"
+        searchCenter="#[{fromLatLong: {
+            latitude: attributes.queryParams.lat,
+            longitude: attributes.queryParams.lon
+        }}]"
+        searchBy="#[{byRadius: {
+            radius: attributes.queryParams.radiusKm,
+            unit: 'KM'
+        }}]"
+        sortOrder="ASC"
+        count="10">
+        <lettuce-redis:search-result-options
+            withCoord="true"
+            withDist="true"
+            withHash="false"/>
+    </lettuce-redis:geosearch>
+
+    <!-- Transform results to JSON API response -->
+    <ee:transform>
+        <ee:message>
+            <ee:set-payload><![CDATA[%dw 2.0
+output application/json
+---
+{
+    stores: payload map {
+        id: $.member,
+        distance_km: $.distance,
+        coordinates: {
+            lat: $.latitude,
+            lon: $.longitude
+        }
+    }
+}]]></ee:set-payload>
+        </ee:message>
+    </ee:transform>
+</flow>
+```
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/hash.md b/docs/connectors/mule-lettuce-redis-connector/operations/hash.md
new file mode 100644
index 0000000..fcb005b
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/hash.md
@@ -0,0 +1,354 @@
+---
+title: Hash Commands — Lettuce Redis Connector
+description: Reference for hash Redis commands in the Mule Lettuce Redis Connector
+---
+
+# Hash Commands
+
+Hash commands operate on Redis hashes — maps between string fields and string values. Hashes are ideal for representing objects with multiple fields.
+
+This page covers: **HEXISTS**, **HGET**, **HGETALL**, **HINCRBY**, **HLEN**, **HMGET**, **HSCAN**, **HSET**
+
+---
+
+## HSET
+
+Set one or more fields in a hash.
+
+> 📘 **Redis Reference**: [HSET](https://redis.io/docs/latest/commands/hset/)
+
+### XML Example
+
+```xml
+<!-- Set multiple fields in a user hash -->
+<lettuce-redis:hset doc:name="Set user fields"
+    config-ref="Redis_Config"
+    key="user:123"
+    fields="#[{'name': 'Alice Johnson', 'email': 'alice@example.com', 'role': 'admin', 'status': 'active'}]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The hash key |
+| `fields` | Map\<String, String\> | Yes | — | Field-value pairs to set. Map must not be empty. Payload by default via `@Content`. |
+
+### Output
+
+**Type**: `Long`
+
+The number of **new** fields added. Updates to existing fields are not counted.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | Fields map is empty |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a hash |
+
+---
+
+## HGET
+
+Get the value of a hash field.
+
+> 📘 **Redis Reference**: [HGET](https://redis.io/docs/latest/commands/hget/)
+
+### XML Example
+
+```xml
+<lettuce-redis:hget doc:name="Get user email"
+    config-ref="Redis_Config"
+    key="user:123"
+    field="email"/>
+
+<!-- payload now contains the email address -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The hash key |
+| `field` | String | Yes | — | The field name to retrieve |
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The value of the field.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:NIL` | Field does not exist in the hash |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a hash |
+
+---
+
+## HGETALL
+
+Get all fields and values in a hash.
+
+> 📘 **Redis Reference**: [HGETALL](https://redis.io/docs/latest/commands/hgetall/)
+
+### XML Example
+
+```xml
+<lettuce-redis:hgetall doc:name="Get all user fields"
+    config-ref="Redis_Config"
+    key="user:123"/>
+
+<!-- payload is now a Map<String, String> with all fields and values -->
+<logger level="INFO" message="User name: #[payload.name]"/>
+<logger level="INFO" message="User email: #[payload.email]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The hash key |
+
+### Output
+
+**Type**: `Map<String, String>`
+
+A map of all field-value pairs in the hash. Returns an empty map if the hash does not exist.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a hash |
+
+---
+
+## HMGET
+
+Get the values of multiple hash fields.
+
+> 📘 **Redis Reference**: [HMGET](https://redis.io/docs/latest/commands/hmget/)
+
+### XML Example
+
+```xml
+<lettuce-redis:hmget doc:name="Get multiple user fields"
+    config-ref="Redis_Config"
+    key="user:123"
+    fieldNames="#[['name', 'email', 'status']]"/>
+
+<!-- payload is now a Map<String, String> with the requested fields -->
+<!-- Missing fields appear with null values in the map -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The hash key |
+| `fieldNames` | List\<String\> | Yes | — | Field names to retrieve. At least one required. Fields must be defined inline (`allowInlineDefinition=true, allowReferences=false`). |
+
+### Output
+
+**Type**: `Map<String, String>`
+
+A map of field names to values. If a field does not exist in the hash, its value in the map is `null`.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No field names provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a hash |
+
+---
+
+## HEXISTS
+
+Check if a field exists in a hash.
+
+> 📘 **Redis Reference**: [HEXISTS](https://redis.io/docs/latest/commands/hexists/)
+
+### XML Example
+
+```xml
+<lettuce-redis:hexists doc:name="Check if user has phone"
+    config-ref="Redis_Config"
+    key="user:123"
+    field="phone"/>
+
+<choice>
+    <when expression="#[payload == true]">
+        <logger level="INFO" message="User has a phone number on file"/>
+    </when>
+    <otherwise>
+        <logger level="INFO" message="No phone number for user"/>
+    </otherwise>
+</choice>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The hash key |
+| `field` | String | Yes | — | The field to check |
+
+### Output
+
+**Type**: `Boolean`
+
+- `true` if the field exists in the hash
+- `false` if the field does not exist or the hash does not exist
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a hash |
+
+---
+
+## HLEN
+
+Get the number of fields in a hash.
+
+> 📘 **Redis Reference**: [HLEN](https://redis.io/docs/latest/commands/hlen/)
+
+### XML Example
+
+```xml
+<lettuce-redis:hlen doc:name="Count user fields"
+    config-ref="Redis_Config"
+    key="user:123"/>
+
+<logger level="INFO" message="User has #[payload] fields"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The hash key |
+
+### Output
+
+**Type**: `Long`
+
+The number of fields in the hash. Returns `0` if the hash does not exist.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a hash |
+
+---
+
+## HINCRBY
+
+Increment the integer value of a hash field by the specified amount.
+
+> 📘 **Redis Reference**: [HINCRBY](https://redis.io/docs/latest/commands/hincrby/)
+
+### XML Example
+
+```xml
+<lettuce-redis:hincrby doc:name="Increment user login count"
+    config-ref="Redis_Config"
+    key="user:123:stats"
+    field="loginCount"
+    increment="1"/>
+
+<!-- payload is now the new value after increment -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The hash key |
+| `field` | String | Yes | — | The field to increment |
+| `increment` | Long | Yes | — | The amount to add (can be negative for decrement) |
+
+### Output
+
+**Type**: `Long`
+
+The new value of the field after the increment.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a hash, or field does not hold an integer value |
+
+---
+
+## HSCAN
+
+Incrementally iterate hash fields using a cursor.
+
+> 📘 **Redis Reference**: [HSCAN](https://redis.io/docs/latest/commands/hscan/)
+
+::: tip Automated Cursor Management
+For most use cases, consider using [Search Hash Fields](./search-operations#search-hash-fields) instead, which handles cursor iteration automatically and streams all field-value pairs. Use HSCAN directly only when you need fine-grained control over pagination.
+:::
+
+### XML Example
+
+```xml
+<!-- Start a new scan (cursor 0) -->
+<lettuce-redis:hscan doc:name="Scan hash fields"
+    config-ref="Redis_Config"
+    key="user:123"
+    cursor="0"
+    match="setting:*"
+    count="50"/>
+
+<!-- payload contains a Map<String, String> of fields from this page -->
+<!-- attributes.cursor contains the next cursor value -->
+<logger level="INFO" message="Next cursor: #[attributes.cursor]"/>
+
+<!-- Continue scanning with the next cursor -->
+<lettuce-redis:hscan doc:name="Scan next page"
+    config-ref="Redis_Config"
+    key="user:123"
+    cursor="#[attributes.cursor]"
+    match="setting:*"
+    count="50"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The hash key to scan |
+| `cursor` | Integer | Yes | — | Cursor position. Use `0` to start a new scan. |
+| `match` | String | No | — | Glob-style pattern to filter field names |
+| `count` | Integer | No | — | Hint for the number of elements to return per iteration |
+
+### Output
+
+**Type**: `Map<String, String>`
+
+A map of field-value pairs matching the pattern for this scan iteration.
+
+**Attributes**: `ScanAttributes` — Contains the `cursor` field with the next cursor value. When `cursor` is `0`, the scan is complete.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a hash |
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/index.md b/docs/connectors/mule-lettuce-redis-connector/operations/index.md
new file mode 100644
index 0000000..2957085
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/index.md
@@ -0,0 +1,146 @@
+---
+title: Operations
+description: Complete reference of all operations in the Mule Lettuce Redis Connector, organized by Redis command category.
+---
+
+# Operations
+
+The Mule Lettuce Redis Connector provides operations in two categories:
+
+- **Category A — Redis Command Mirrors**: Operations that map directly to a single Redis command. These are reference-style: if you know the Redis command, the operation works the same way.
+- **Category B — Value-Add Features**: Operations that go beyond a single command, providing automation or capabilities not available in raw Redis.
+
+---
+
+## Category A: Redis Command Operations
+
+### Server
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| PING | [PING](https://redis.io/docs/latest/commands/ping/) | [Server](./server#ping) |
+
+### Key / Value
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| APPEND | [APPEND](https://redis.io/docs/latest/commands/append/) | [Key / Value](./key-value#append) |
+| COPY | [COPY](https://redis.io/docs/latest/commands/copy/) | [Key / Value](./key-value#copy) |
+| DECR | [DECR](https://redis.io/docs/latest/commands/decr/) | [Key / Value](./key-value#decr) |
+| DEL | [DEL](https://redis.io/docs/latest/commands/del/) | [Key / Value](./key-value#del) |
+| EXPIRE | [EXPIRE](https://redis.io/docs/latest/commands/expire/) | [Key / Value](./key-value#expire) |
+| GET | [GET](https://redis.io/docs/latest/commands/get/) | [Key / Value](./key-value#get) |
+| GETDEL | [GETDEL](https://redis.io/docs/latest/commands/getdel/) | [Key / Value](./key-value#getdel) |
+| GETEX | [GETEX](https://redis.io/docs/latest/commands/getex/) | [Key / Value](./key-value#getex) |
+| GETRANGE | [GETRANGE](https://redis.io/docs/latest/commands/getrange/) | [Key / Value](./key-value#getrange) |
+| GETSET | [GETSET](https://redis.io/docs/latest/commands/getset/) | [Key / Value](./key-value#getset) |
+| INCR | [INCR](https://redis.io/docs/latest/commands/incr/) | [Key / Value](./key-value#incr) |
+| MGET | [MGET](https://redis.io/docs/latest/commands/mget/) | [Key / Value](./key-value#mget) |
+| MSET | [MSET](https://redis.io/docs/latest/commands/mset/) | [Key / Value](./key-value#mset) |
+| PERSIST | [PERSIST](https://redis.io/docs/latest/commands/persist/) | [Key / Value](./key-value#persist) |
+| PEXPIRE | [PEXPIRE](https://redis.io/docs/latest/commands/pexpire/) | [Key / Value](./key-value#pexpire) |
+| PTTL | [PTTL](https://redis.io/docs/latest/commands/pttl/) | [Key / Value](./key-value#pttl) |
+| SCAN | [SCAN](https://redis.io/docs/latest/commands/scan/) | [Key / Value](./key-value#scan) |
+| SET | [SET](https://redis.io/docs/latest/commands/set/) | [Key / Value](./key-value#set) |
+| TOUCH | [TOUCH](https://redis.io/docs/latest/commands/touch/) | [Key / Value](./key-value#touch) |
+| TTL | [TTL](https://redis.io/docs/latest/commands/ttl/) | [Key / Value](./key-value#ttl) |
+
+### Hash
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| HEXISTS | [HEXISTS](https://redis.io/docs/latest/commands/hexists/) | [Hash](./hash#hexists) |
+| HGET | [HGET](https://redis.io/docs/latest/commands/hget/) | [Hash](./hash#hget) |
+| HGETALL | [HGETALL](https://redis.io/docs/latest/commands/hgetall/) | [Hash](./hash#hgetall) |
+| HINCRBY | [HINCRBY](https://redis.io/docs/latest/commands/hincrby/) | [Hash](./hash#hincrby) |
+| HLEN | [HLEN](https://redis.io/docs/latest/commands/hlen/) | [Hash](./hash#hlen) |
+| HMGET | [HMGET](https://redis.io/docs/latest/commands/hmget/) | [Hash](./hash#hmget) |
+| HSCAN | [HSCAN](https://redis.io/docs/latest/commands/hscan/) | [Hash](./hash#hscan) |
+| HSET | [HSET](https://redis.io/docs/latest/commands/hset/) | [Hash](./hash#hset) |
+
+### List
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| BLMOVE | [BLMOVE](https://redis.io/docs/latest/commands/blmove/) | [List](./list#blmove) |
+| BLPOP | [BLPOP](https://redis.io/docs/latest/commands/blpop/) | [List](./list#blpop) |
+| BRPOP | [BRPOP](https://redis.io/docs/latest/commands/brpop/) | [List](./list#brpop) |
+| LMOVE | [LMOVE](https://redis.io/docs/latest/commands/lmove/) | [List](./list#lmove) |
+| LPOP | [LPOP](https://redis.io/docs/latest/commands/lpop/) | [List](./list#lpop) |
+| LPUSH | [LPUSH](https://redis.io/docs/latest/commands/lpush/) | [List](./list#lpush) |
+| LSET | [LSET](https://redis.io/docs/latest/commands/lset/) | [List](./list#lset) |
+| RPOP | [RPOP](https://redis.io/docs/latest/commands/rpop/) | [List](./list#rpop) |
+| RPUSH | [RPUSH](https://redis.io/docs/latest/commands/rpush/) | [List](./list#rpush) |
+
+### Set
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| SADD | [SADD](https://redis.io/docs/latest/commands/sadd/) | [Set](./set#sadd) |
+| SCARD | [SCARD](https://redis.io/docs/latest/commands/scard/) | [Set](./set#scard) |
+| SDIFF | [SDIFF](https://redis.io/docs/latest/commands/sdiff/) | [Set](./set#sdiff) |
+| SISMEMBER | [SISMEMBER](https://redis.io/docs/latest/commands/sismember/) | [Set](./set#sismember) |
+| SMEMBERS | [SMEMBERS](https://redis.io/docs/latest/commands/smembers/) | [Set](./set#smembers) |
+| SMISMEMBER | [SMISMEMBER](https://redis.io/docs/latest/commands/smismember/) | [Set](./set#smismember) |
+| SPOP | [SPOP](https://redis.io/docs/latest/commands/spop/) | [Set](./set#spop) |
+| SRANDMEMBER | [SRANDMEMBER](https://redis.io/docs/latest/commands/srandmember/) | [Set](./set#srandmember) |
+| SREM | [SREM](https://redis.io/docs/latest/commands/srem/) | [Set](./set#srem) |
+| SSCAN | [SSCAN](https://redis.io/docs/latest/commands/sscan/) | [Set](./set#sscan) |
+
+### Sorted Set
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| ZADD | [ZADD](https://redis.io/docs/latest/commands/zadd/) | [Sorted Set](./sorted-set#zadd) |
+| ZINCRBY | [ZINCRBY](https://redis.io/docs/latest/commands/zincrby/) | [Sorted Set](./sorted-set#zincrby) |
+| ZRANK | [ZRANK](https://redis.io/docs/latest/commands/zrank/) | [Sorted Set](./sorted-set#zrank) |
+| ZSCAN | [ZSCAN](https://redis.io/docs/latest/commands/zscan/) | [Sorted Set](./sorted-set#zscan) |
+| ZSCORE | [ZSCORE](https://redis.io/docs/latest/commands/zscore/) | [Sorted Set](./sorted-set#zscore) |
+
+### Geospatial
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| GEOADD | [GEOADD](https://redis.io/docs/latest/commands/geoadd/) | [Geospatial](./geospatial#geoadd) |
+| GEODIST | [GEODIST](https://redis.io/docs/latest/commands/geodist/) | [Geospatial](./geospatial#geodist) |
+| GEOPOS | [GEOPOS](https://redis.io/docs/latest/commands/geopos/) | [Geospatial](./geospatial#geopos) |
+| GEOSEARCH | [GEOSEARCH](https://redis.io/docs/latest/commands/geosearch/) | [Geospatial](./geospatial#geosearch) |
+
+### Stream
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| XACK | [XACK](https://redis.io/docs/latest/commands/xack/) | [Stream](./stream#xack) |
+| XADD | [XADD](https://redis.io/docs/latest/commands/xadd/) | [Stream](./stream#xadd) |
+| XDEL | [XDEL](https://redis.io/docs/latest/commands/xdel/) | [Stream](./stream#xdel) |
+| XGROUP CREATE | [XGROUP CREATE](https://redis.io/docs/latest/commands/xgroup-create/) | [Stream](./stream#xgroup-create) |
+| XGROUP DESTROY | [XGROUP DESTROY](https://redis.io/docs/latest/commands/xgroup-destroy/) | [Stream](./stream#xgroup-destroy) |
+| XINFO GROUPS | [XINFO GROUPS](https://redis.io/docs/latest/commands/xinfo-groups/) | [Stream](./stream#xinfo-groups) |
+| XRANGE | [XRANGE](https://redis.io/docs/latest/commands/xrange/) | [Stream](./stream#xrange) |
+| XREAD | [XREAD](https://redis.io/docs/latest/commands/xread/) | [Stream](./stream#xread) |
+| XREADGROUP | [XREADGROUP](https://redis.io/docs/latest/commands/xreadgroup/) | [Stream](./stream#xreadgroup) |
+| XTRIM | [XTRIM](https://redis.io/docs/latest/commands/xtrim/) | [Stream](./stream#xtrim) |
+
+### Channel
+
+| Operation | Redis Command | Page |
+|-----------|--------------|------|
+| PUBLISH | [PUBLISH](https://redis.io/docs/latest/commands/publish/) | [Channel](./channel#publish) |
+
+---
+
+## Category B: Value-Add Operations
+
+| Operation | Description | Page |
+|-----------|-------------|------|
+| Send Command | Execute any Redis command dynamically by name. Use for commands not yet available as dedicated operations. | [Send Command](./send-command) |
+| Search Keys | Stream all keys matching a pattern via automated SCAN cursor iteration | [Search Operations](./search-operations#search-keys) |
+| Search Hash Fields | Stream all fields in a hash via automated HSCAN cursor iteration | [Search Operations](./search-operations#search-hash-fields) |
+| Search Set Members | Stream all members in a set via automated SSCAN cursor iteration | [Search Operations](./search-operations#search-set-members) |
+| Search Sorted Set Members | Stream all members and scores in a sorted set via automated ZSCAN cursor iteration | [Search Operations](./search-operations#search-sorted-set-members) |
+
+---
+
+## Sources (Event Listeners)
+
+Sources are not operations — they are Mule event listeners that trigger flows when Redis delivers a message. See the [Sources](../sources) page for SUBSCRIBE and PSUBSCRIBE.
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/key-value.md b/docs/connectors/mule-lettuce-redis-connector/operations/key-value.md
new file mode 100644
index 0000000..daad9b7
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/key-value.md
@@ -0,0 +1,903 @@
+---
+title: Key / Value Commands — Lettuce Redis Connector
+description: Reference for key/value Redis commands in the Mule Lettuce Redis Connector
+---
+
+# Key / Value Commands
+
+Key/Value commands operate on Redis string values — the most basic Redis data type. Strings can hold any kind of data: text, JSON, serialized objects, or binary data.
+
+This page covers: **APPEND**, **COPY**, **DECR**, **DEL**, **EXPIRE**, **GET**, **GETDEL**, **GETEX**, **GETRANGE**, **GETSET**, **INCR**, **MGET**, **MSET**, **PERSIST**, **PEXPIRE**, **PTTL**, **SCAN**, **SET**, **TOUCH**, **TTL**
+
+---
+
+## SET
+
+Set a key to hold a string value, with optional expiry and conditional flags.
+
+> 📘 **Redis Reference**: [SET](https://redis.io/docs/latest/commands/set/)
+
+### XML Example
+
+```xml
+<!-- Simple SET -->
+<lettuce-redis:set doc:name="Set greeting"
+    config-ref="Redis_Config"
+    key="greeting"
+    value="Hello, world!"/>
+
+<!-- SET with expiry and conditional flags -->
+<lettuce-redis:set doc:name="Set session with TTL"
+    config-ref="Redis_Config"
+    key="session:12345"
+    value='{"userId": "user123", "loginTime": "2024-01-15T10:30:00Z"}'
+    ex="3600"
+    nx="true"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to set |
+| `value` | String | Yes | — | The value to store (payload by default via `@Content`) |
+| `xx` | boolean | No | `false` | Only set if key already exists |
+| `nx` | boolean | No | `false` | Only set if key does NOT exist (use for "create if not exists" semantics) |
+| `get` | boolean | No | `false` | Return the old value before setting the new one |
+| `ex` | Integer | No | — | Expiry time in seconds |
+| `px` | Integer | No | — | Expiry time in milliseconds |
+| `exat` | Integer | No | — | Expiry as Unix timestamp in seconds |
+| `pxat` | Integer | No | — | Expiry as Unix timestamp in milliseconds |
+| `keepttl` | boolean | No | `false` | Retain the existing TTL (if key already exists with a TTL) |
+
+::: info Mutually Exclusive TTL Options
+Only one of `ex`, `px`, `exat`, `pxat`, or `keepttl` should be specified. The Redis server enforces this constraint.
+:::
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+- Returns `"OK"` when the operation succeeds
+- Returns the old value if `get="true"` was specified
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## GET
+
+Retrieve the string value of a key.
+
+> 📘 **Redis Reference**: [GET](https://redis.io/docs/latest/commands/get/)
+
+### XML Example
+
+```xml
+<lettuce-redis:get doc:name="Get user session"
+    config-ref="Redis_Config"
+    key="session:12345"/>
+
+<!-- payload now contains the session JSON string -->
+<logger level="INFO" message="Session: #[payload]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to retrieve |
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The value stored at the key.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:NIL` | Key does not exist |
+| `REDIS:COMMAND` | General command execution error |
+
+::: warning GET Throws on Missing Keys
+If the key does not exist, GET throws a `REDIS:NIL` error rather than returning `null`. Use error handling to manage missing keys gracefully.
+:::
+
+**Error handling pattern:**
+
+```xml
+<try>
+    <lettuce-redis:get config-ref="Redis_Config" key="user:profile"/>
+    <logger level="INFO" message="Profile found: #[payload]"/>
+
+    <error-handler>
+        <on-error-continue type="REDIS:NIL">
+            <logger level="WARN" message="User profile not found"/>
+            <set-payload value="#[null]"/>
+        </on-error-continue>
+    </error-handler>
+</try>
+```
+
+---
+
+## MGET
+
+Retrieve the values of multiple keys in a single operation.
+
+> 📘 **Redis Reference**: [MGET](https://redis.io/docs/latest/commands/mget/)
+
+::: tip MGET Implementation Note
+This operation is fully implemented and working, but is not listed in the connector's README. It is safe to use in production.
+:::
+
+### XML Example
+
+```xml
+<lettuce-redis:mget doc:name="Get multiple user fields"
+    config-ref="Redis_Config"
+    keys="#[['user:123:name', 'user:123:email', 'user:123:status']]"/>
+
+<!-- payload is now a List<String> with values in the same order as keys -->
+<!-- Missing keys appear as null in the list -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `keys` | List\<String\> | Yes | — | One or more keys to retrieve. At least one required. |
+
+### Output
+
+**Type**: `List<String>`
+
+A list of values in the same order as the input keys. If a key does not exist or holds the wrong type, the corresponding list entry is `null`.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No keys provided |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## MSET
+
+Set multiple key-value pairs atomically.
+
+> 📘 **Redis Reference**: [MSET](https://redis.io/docs/latest/commands/mset/)
+
+### XML Example
+
+```xml
+<lettuce-redis:mset doc:name="Set multiple user fields"
+    config-ref="Redis_Config"
+    keyValues="#[{'user:123:name': 'Alice', 'user:123:email': 'alice@example.com', 'user:123:status': 'active'}]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `keyValues` | Map\<String, String\> | Yes | — | Map of key-value pairs to set. Payload by default via `@Content`. |
+
+### Output
+
+**Type**: `Void`
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## APPEND
+
+Append a string to the value of a key. If the key does not exist, it is created with the appended string as its value.
+
+> 📘 **Redis Reference**: [APPEND](https://redis.io/docs/latest/commands/append/)
+
+### XML Example
+
+```xml
+<lettuce-redis:append doc:name="Append to log"
+    config-ref="Redis_Config"
+    key="system:log"
+    value="#['\n' ++ now() ++ ': User logged in']"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to append to |
+| `value` | String | Yes | — | The string to append (payload by default via `@Content`) |
+
+### Output
+
+**Type**: `Long`
+
+The new total length of the string after appending.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:WRONG_TYPE` | Key exists but holds a non-string value |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## INCR
+
+Increment the integer value of a key by 1.
+
+> 📘 **Redis Reference**: [INCR](https://redis.io/docs/latest/commands/incr/)
+
+### XML Example
+
+```xml
+<lettuce-redis:incr doc:name="Increment page views"
+    config-ref="Redis_Config"
+    key="page:views:home"/>
+
+<!-- payload is now the new value after increment -->
+<logger level="INFO" message="Page views: #[payload]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key whose value to increment |
+
+### Output
+
+**Type**: `Long`
+
+The value of the key after incrementing.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:WRONG_TYPE` | Key exists but does not hold a string representation of an integer |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## DECR
+
+Decrement the integer value of a key by 1.
+
+> 📘 **Redis Reference**: [DECR](https://redis.io/docs/latest/commands/decr/)
+
+### XML Example
+
+```xml
+<lettuce-redis:decr doc:name="Decrement rate limit"
+    config-ref="Redis_Config"
+    key="ratelimit:user:123"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key whose value to decrement |
+
+### Output
+
+**Type**: `Long`
+
+The value of the key after decrementing.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:WRONG_TYPE` | Key exists but does not hold an integer value |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## DEL
+
+Delete one or more keys.
+
+> 📘 **Redis Reference**: [DEL](https://redis.io/docs/latest/commands/del/)
+
+### XML Example
+
+```xml
+<lettuce-redis:del doc:name="Delete session keys"
+    config-ref="Redis_Config"
+    keys="#[['session:12345', 'session:12346', 'session:12347']]"/>
+
+<!-- payload is the number of keys actually deleted -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `keys` | List\<String\> | Yes | — | One or more keys to delete |
+
+### Output
+
+**Type**: `Long`
+
+The number of keys that were deleted. Keys that did not exist are not counted.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## EXPIRE
+
+Set a key's time to live (TTL) in seconds, with optional conditional flags.
+
+> 📘 **Redis Reference**: [EXPIRE](https://redis.io/docs/latest/commands/expire/)
+
+### XML Example
+
+```xml
+<!-- Set 1-hour expiry on a cache key -->
+<lettuce-redis:expire doc:name="Expire cache"
+    config-ref="Redis_Config"
+    key="cache:product:123"
+    seconds="3600"/>
+
+<!-- Only set expiry if no TTL currently exists -->
+<lettuce-redis:expire doc:name="Expire if no TTL"
+    config-ref="Redis_Config"
+    key="cache:product:123"
+    seconds="3600"
+    nx="true"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to set expiry on |
+| `seconds` | Integer | Yes | — | TTL in seconds |
+| `nx` | boolean | No | `false` | Only set expiry if key currently has no TTL |
+| `xx` | boolean | No | `false` | Only set expiry if key already has a TTL |
+| `gt` | boolean | No | `false` | Only set expiry if new TTL is greater than current TTL |
+| `lt` | boolean | No | `false` | Only set expiry if new TTL is less than current TTL |
+
+### Output
+
+**Type**: `Boolean`
+
+- `true` if the expiry was set
+- `false` if the expiry was not set (key doesn't exist or conditional flag prevented the operation)
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | Invalid combination of conditional flags |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## PEXPIRE
+
+Set a key's time to live (TTL) in milliseconds.
+
+> 📘 **Redis Reference**: [PEXPIRE](https://redis.io/docs/latest/commands/pexpire/)
+
+### XML Example
+
+```xml
+<lettuce-redis:pexpire doc:name="Expire in 500ms"
+    config-ref="Redis_Config"
+    key="temp:token:xyz"
+    milliseconds="500"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to set expiry on |
+| `milliseconds` | Integer | Yes | — | TTL in milliseconds |
+| `nx` | boolean | No | `false` | Only set expiry if key currently has no TTL |
+| `xx` | boolean | No | `false` | Only set expiry if key already has a TTL |
+| `gt` | boolean | No | `false` | Only set expiry if new TTL > current TTL |
+| `lt` | boolean | No | `false` | Only set expiry if new TTL < current TTL |
+
+### Output
+
+**Type**: `Boolean`
+
+- `true` if the expiry was set
+- `false` otherwise
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | Invalid combination of conditional flags |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## PERSIST
+
+Remove the expiration from a key, making it persistent.
+
+> 📘 **Redis Reference**: [PERSIST](https://redis.io/docs/latest/commands/persist/)
+
+### XML Example
+
+```xml
+<lettuce-redis:persist doc:name="Make session persistent"
+    config-ref="Redis_Config"
+    key="session:12345"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to remove expiry from |
+
+### Output
+
+**Type**: `Boolean`
+
+- `true` if the TTL was removed
+- `false` if the key does not exist or had no TTL
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## TTL
+
+Get the remaining time to live (TTL) of a key in seconds.
+
+> 📘 **Redis Reference**: [TTL](https://redis.io/docs/latest/commands/ttl/)
+
+### XML Example
+
+```xml
+<lettuce-redis:ttl doc:name="Check session TTL"
+    config-ref="Redis_Config"
+    key="session:12345"/>
+
+<choice>
+    <when expression="#[payload &gt; 300]">
+        <logger level="INFO" message="Session has plenty of time remaining"/>
+    </when>
+    <when expression="#[payload == -1]">
+        <logger level="WARN" message="Session has no expiry set"/>
+    </when>
+    <when expression="#[payload == -2]">
+        <logger level="ERROR" message="Session key does not exist"/>
+    </when>
+    <otherwise>
+        <logger level="WARN" message="Session expires soon: #[payload] seconds"/>
+    </otherwise>
+</choice>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to inspect |
+
+### Output
+
+**Type**: `Long`
+
+- Remaining TTL in seconds (positive value)
+- `-1` if the key exists but has no associated expiry
+- `-2` if the key does not exist
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## PTTL
+
+Get the remaining time to live (TTL) of a key in milliseconds.
+
+> 📘 **Redis Reference**: [PTTL](https://redis.io/docs/latest/commands/pttl/)
+
+### XML Example
+
+```xml
+<lettuce-redis:pttl doc:name="Check rate limit TTL"
+    config-ref="Redis_Config"
+    key="ratelimit:user:123"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to inspect |
+
+### Output
+
+**Type**: `Long`
+
+- Remaining TTL in milliseconds (positive value)
+- `-1` if the key exists but has no TTL
+- `-2` if the key does not exist
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## GETRANGE
+
+Get a substring of the value stored at a key.
+
+> 📘 **Redis Reference**: [GETRANGE](https://redis.io/docs/latest/commands/getrange/)
+
+### XML Example
+
+```xml
+<!-- Get first 10 characters -->
+<lettuce-redis:getrange doc:name="Get prefix"
+    config-ref="Redis_Config"
+    key="document:text"
+    start="0"
+    end="9"/>
+
+<!-- Get last 5 characters (negative indices count from end) -->
+<lettuce-redis:getrange doc:name="Get suffix"
+    config-ref="Redis_Config"
+    key="document:text"
+    start="-5"
+    end="-1"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to read from |
+| `start` | Integer | Yes | — | Start index (inclusive, 0-based). Negative values count from the end. |
+| `end` | Integer | Yes | — | End index (inclusive). Negative values count from the end. |
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The substring of the stored value.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:NIL` | Key does not exist |
+| `REDIS:WRONG_TYPE` | Key exists but holds a non-string value |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## GETDEL
+
+Atomically get the value of a key and delete it.
+
+> 📘 **Redis Reference**: [GETDEL](https://redis.io/docs/latest/commands/getdel/)
+
+### XML Example
+
+```xml
+<lettuce-redis:getdel doc:name="Get and delete OTP"
+    config-ref="Redis_Config"
+    key="otp:user:123"/>
+
+<!-- payload now contains the OTP value, and the key is deleted -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to get and delete |
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The value before deletion.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:NIL` | Key does not exist |
+| `REDIS:WRONG_TYPE` | Key exists but holds a non-string value |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## GETEX
+
+Get the value of a key and optionally set or update its expiration.
+
+> 📘 **Redis Reference**: [GETEX](https://redis.io/docs/latest/commands/getex/)
+
+### XML Example
+
+```xml
+<!-- Get value and set 10-minute expiry -->
+<lettuce-redis:getex doc:name="Get and refresh TTL"
+    config-ref="Redis_Config"
+    key="session:12345"
+    ex="600"/>
+
+<!-- Get value and remove expiry -->
+<lettuce-redis:getex doc:name="Get and persist"
+    config-ref="Redis_Config"
+    key="session:12345"
+    persist="true"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to get |
+| `ex` | Long | No | — | Set expiry in seconds |
+| `px` | Long | No | — | Set expiry in milliseconds |
+| `exat` | Long | No | — | Set expiry as Unix timestamp in seconds |
+| `pxat` | Long | No | — | Set expiry as Unix timestamp in milliseconds |
+| `persist` | boolean | No | `false` | Remove the TTL |
+
+::: info Mutually Exclusive Parameters
+Only one of `ex`, `px`, `exat`, `pxat`, or `persist` should be specified. The Redis server enforces this constraint.
+:::
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The current value of the key.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:NIL` | Key does not exist |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## GETSET
+
+Set a key to a new value and return the old value.
+
+> 📘 **Redis Reference**: [GETSET](https://redis.io/docs/latest/commands/getset/)
+
+### XML Example
+
+```xml
+<lettuce-redis:getset doc:name="Swap value"
+    config-ref="Redis_Config"
+    key="current:leader"
+    value="node-02"/>
+
+<!-- payload now contains the previous leader ID -->
+<logger level="INFO" message="Previous leader: #[payload]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The key to set |
+| `value` | String | Yes | — | The new value to store (payload by default via `@Content`) |
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The old value before the SET operation. Returns `null` if the key did not exist.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:WRONG_TYPE` | Key exists but holds a non-string value |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## COPY
+
+Copy a key to a new key, optionally to a different database.
+
+> 📘 **Redis Reference**: [COPY](https://redis.io/docs/latest/commands/copy/)
+
+### XML Example
+
+```xml
+<lettuce-redis:copy doc:name="Backup user data"
+    config-ref="Redis_Config"
+    source="user:123"
+    destination="user:123:backup"
+    replace="true"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `source` | String | Yes | — | Source key to copy from |
+| `destination` | String | Yes | — | Destination key to copy to |
+| `destinationDb` | Integer | No | — | Target database index (if copying to a different database) |
+| `replace` | boolean | No | `false` | Overwrite destination if it already exists |
+
+### Output
+
+**Type**: `Boolean`
+
+- `true` if the key was copied
+- `false` if the source key does not exist or destination exists and `replace=false`
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## TOUCH
+
+Update the last access time of one or more keys without changing their values.
+
+> 📘 **Redis Reference**: [TOUCH](https://redis.io/docs/latest/commands/touch/)
+
+### XML Example
+
+```xml
+<lettuce-redis:touch doc:name="Touch session keys"
+    config-ref="Redis_Config"
+    keys="#[['session:12345', 'session:12346']]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `keys` | List\<String\> | Yes | — | One or more keys to touch |
+
+### Output
+
+**Type**: `Void`
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No keys provided |
+| `REDIS:COMMAND` | General command execution error |
+
+---
+
+## SCAN
+
+Incrementally iterate the keyspace using a cursor.
+
+> 📘 **Redis Reference**: [SCAN](https://redis.io/docs/latest/commands/scan/)
+
+::: tip Automated Cursor Management
+For most use cases, consider using [Search Keys](./search-operations#search-keys) instead, which handles cursor iteration automatically and streams all matching keys. Use SCAN directly only when you need fine-grained control over pagination.
+:::
+
+### XML Example
+
+```xml
+<!-- Start a new scan (cursor 0) -->
+<lettuce-redis:scan doc:name="Scan for user keys"
+    config-ref="Redis_Config"
+    cursor="0"
+    match="user:*"
+    count="100"/>
+
+<!-- payload contains keys from this page -->
+<!-- attributes.cursor contains the next cursor value -->
+<logger level="INFO" message="Next cursor: #[attributes.cursor]"/>
+
+<!-- Continue scanning with the next cursor -->
+<lettuce-redis:scan doc:name="Scan next page"
+    config-ref="Redis_Config"
+    cursor="#[attributes.cursor]"
+    match="user:*"
+    count="100"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `cursor` | Integer | Yes | — | Cursor position. Use `0` to start a new scan. |
+| `match` | String | No | — | Glob-style pattern to filter keys (e.g., `user:*`, `product:*:cache`) |
+| `count` | Integer | No | — | Hint for the number of elements to return. Redis may return more or fewer. |
+| `type` | String | No | — | Filter by Redis type (`string`, `list`, `set`, `zset`, `hash`, `stream`) |
+
+### Output
+
+**Type**: `List<String>`
+
+A list of keys matching the pattern for this scan iteration.
+
+**Attributes**: `ScanAttributes` — Contains the `cursor` field with the next cursor value. When `cursor` is `0`, the scan is complete.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+
+### Manual Cursor Iteration Pattern
+
+```xml
+<flow name="manual-scan-iteration">
+    <set-variable variableName="cursor" value="#[0]"/>
+    <set-variable variableName="allKeys" value="#[[]]"/>
+
+    <until-successful maxRetries="1000">
+        <lettuce-redis:scan
+            config-ref="Redis_Config"
+            cursor="#[vars.cursor]"
+            match="session:*"
+            count="100"/>
+
+        <!-- Collect keys from this page -->
+        <set-variable variableName="allKeys"
+            value="#[vars.allKeys ++ payload]"/>
+
+        <!-- Update cursor for next iteration -->
+        <set-variable variableName="cursor"
+            value="#[attributes.cursor]"/>
+
+        <!-- Stop when cursor returns to 0 -->
+        <choice>
+            <when expression="#[vars.cursor == 0]">
+                <raise-error type="SCAN:COMPLETE"/>
+            </when>
+        </choice>
+    </until-successful>
+
+    <logger level="INFO"
+        message="Scanned #[sizeOf(vars.allKeys)] keys"/>
+</flow>
+```
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/list.md b/docs/connectors/mule-lettuce-redis-connector/operations/list.md
new file mode 100644
index 0000000..6e89804
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/list.md
@@ -0,0 +1,450 @@
+---
+title: List Commands — Lettuce Redis Connector
+description: Reference for list Redis commands in the Mule Lettuce Redis Connector
+---
+
+# List Commands
+
+List commands operate on Redis lists — ordered collections of strings. Lists are doubly-linked, so adding elements to the head or tail is very fast.
+
+This page covers: **BLMOVE**, **BLPOP**, **BRPOP**, **LMOVE**, **LPOP**, **LPUSH**, **LSET**, **RPOP**, **RPUSH**
+
+---
+
+## LPUSH
+
+Prepend one or more values to a list.
+
+> 📘 **Redis Reference**: [LPUSH](https://redis.io/docs/latest/commands/lpush/)
+
+### XML Example
+
+```xml
+<lettuce-redis:lpush doc:name="Push to queue"
+    config-ref="Redis_Config"
+    key="queue:tasks"
+    members="#[['task-1', 'task-2', 'task-3']]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The list key |
+| `members` | List\<String\> | Yes | — | Values to prepend. At least one required. Payload by default via `@Content`. |
+
+### Output
+
+**Type**: `Long`
+
+The length of the list after the operation.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No members provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a list |
+
+---
+
+## RPUSH
+
+Append one or more values to a list.
+
+> 📘 **Redis Reference**: [RPUSH](https://redis.io/docs/latest/commands/rpush/)
+
+### XML Example
+
+```xml
+<lettuce-redis:rpush doc:name="Append to log"
+    config-ref="Redis_Config"
+    key="log:events"
+    members="#[['event-1', 'event-2']]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The list key |
+| `members` | List\<String\> | Yes | — | Values to append. At least one required. Payload by default via `@Content`. |
+
+### Output
+
+**Type**: `Long`
+
+The length of the list after the operation.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No members provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a list |
+
+---
+
+## LPOP
+
+Remove and return the first element(s) from a list.
+
+> 📘 **Redis Reference**: [LPOP](https://redis.io/docs/latest/commands/lpop/)
+
+### XML Example
+
+```xml
+<!-- Pop a single element -->
+<lettuce-redis:lpop doc:name="Pop one"
+    config-ref="Redis_Config"
+    key="queue:tasks"/>
+<!-- payload is a List<String> with one element -->
+
+<!-- Pop multiple elements -->
+<lettuce-redis:lpop doc:name="Pop three"
+    config-ref="Redis_Config"
+    key="queue:tasks"
+    count="3"/>
+<!-- payload is a List<String> with up to three elements -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The list key |
+| `count` | Integer | No | — | Number of elements to pop. When omitted, pops one element. |
+
+### Output
+
+**Type**: `List<String>`
+
+The operation always returns a `List<String>` regardless of whether `count` is provided:
+- When `count` is **not** specified: list contains a single element (the popped element)
+- When `count` **is** specified: list contains up to `count` popped elements
+
+::: warning Metadata Mismatch
+Anypoint Studio's design-time metadata indicates this operation returns a `String` when `count` is not provided. At runtime, the operation always returns a `List<String>`. When writing DataWeave expressions, treat the output as a list. This mismatch is tracked in [issue #4](https://github.com/MuleSoft-Forge/mule-lettuce-redis-connector/issues/4).
+:::
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a list |
+
+---
+
+## RPOP
+
+Remove and return the last element(s) from a list.
+
+> 📘 **Redis Reference**: [RPOP](https://redis.io/docs/latest/commands/rpop/)
+
+### XML Example
+
+```xml
+<!-- Pop a single element -->
+<lettuce-redis:rpop doc:name="Pop last"
+    config-ref="Redis_Config"
+    key="stack:items"/>
+<!-- payload is a List<String> with one element -->
+
+<!-- Pop multiple elements -->
+<lettuce-redis:rpop doc:name="Pop last three"
+    config-ref="Redis_Config"
+    key="stack:items"
+    count="3"/>
+<!-- payload is a List<String> with up to three elements -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The list key |
+| `count` | Integer | No | — | Number of elements to pop |
+
+### Output
+
+**Type**: `List<String>`
+
+The operation always returns a `List<String>` regardless of whether `count` is provided:
+- When `count` is **not** specified: list contains a single element (the popped element)
+- When `count` **is** specified: list contains up to `count` popped elements
+
+::: warning Metadata Mismatch
+Anypoint Studio's design-time metadata indicates this operation returns a `String` when `count` is not provided. At runtime, the operation always returns a `List<String>`. When writing DataWeave expressions, treat the output as a list. This mismatch is tracked in [issue #4](https://github.com/MuleSoft-Forge/mule-lettuce-redis-connector/issues/4).
+:::
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a list |
+
+---
+
+## BLPOP
+
+Remove and return the first element from one of multiple lists, blocking until an element is available or timeout occurs.
+
+> 📘 **Redis Reference**: [BLPOP](https://redis.io/docs/latest/commands/blpop/)
+
+### XML Example
+
+```xml
+<!-- Block for up to 5 seconds waiting for a task -->
+<lettuce-redis:blpop doc:name="Wait for task"
+    config-ref="Redis_Config"
+    keys="#[['queue:high-priority', 'queue:normal', 'queue:low']]"
+    timeoutSeconds="5"/>
+
+<!-- payload is a Map<String, String> with one entry: the key and the popped value -->
+<logger level="INFO"
+    message="Popped from #[payload.keys()[0]]: #[payload[payload.keys()[0]]]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `keys` | List\<String\> | Yes | — | One or more list keys to wait on. At least one required. The first list to have an element available is popped. |
+| `timeoutSeconds` | Double | Yes | — | Seconds to wait. Use `0` to block indefinitely. |
+
+### Output
+
+**Type**: `Map<String, String>`
+
+A single-entry map where:
+- **Key**: The list key that had an element
+- **Value**: The popped element
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No keys provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | One of the keys is not a list |
+| `REDIS:TIMEOUT` | Timeout reached with no element available |
+
+---
+
+## BRPOP
+
+Remove and return the last element from one of multiple lists, blocking until an element is available or timeout occurs.
+
+> 📘 **Redis Reference**: [BRPOP](https://redis.io/docs/latest/commands/brpop/)
+
+### XML Example
+
+```xml
+<lettuce-redis:brpop doc:name="Wait for message"
+    config-ref="Redis_Config"
+    keys="#[['messages:inbox']]"
+    timeoutSeconds="10"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `keys` | List\<String\> | Yes | — | One or more list keys. At least one required. |
+| `timeoutSeconds` | Double | Yes | — | Seconds to wait. Use `0` to block indefinitely. |
+
+### Output
+
+**Type**: `Map<String, String>`
+
+A single-entry map: the key that had an element and the popped value.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No keys provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | One of the keys is not a list |
+| `REDIS:TIMEOUT` | Timeout reached with no element available |
+
+---
+
+## LMOVE
+
+Atomically move an element from one list to another.
+
+> 📘 **Redis Reference**: [LMOVE](https://redis.io/docs/latest/commands/lmove/)
+
+### XML Example
+
+```xml
+<!-- Move task from pending to in-progress queue -->
+<lettuce-redis:lmove doc:name="Move task to processing"
+    config-ref="Redis_Config"
+    source="queue:pending"
+    destination="queue:in-progress"
+    whereFrom="LEFT"
+    whereTo="RIGHT"/>
+
+<!-- payload now contains the moved element -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `source` | String | Yes | — | Source list key |
+| `destination` | String | Yes | — | Destination list key |
+| `whereFrom` | ListEnd | Yes | — | Which end to pop from the source list: `LEFT` or `RIGHT` |
+| `whereTo` | ListEnd | Yes | — | Which end to push to the destination list: `LEFT` or `RIGHT` |
+
+**ListEnd values**: `LEFT`, `RIGHT`
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The element that was moved.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Source or destination is not a list |
+
+### Queue Transfer Pattern
+
+```xml
+<!-- Implement a reliable queue: move tasks from "pending" to "in-progress" -->
+<flow name="process-tasks">
+    <scheduler>
+        <scheduling-strategy>
+            <fixed-frequency frequency="1" timeUnit="SECONDS"/>
+        </scheduling-strategy>
+    </scheduler>
+
+    <try>
+        <lettuce-redis:lmove
+            config-ref="Redis_Config"
+            source="queue:pending"
+            destination="queue:in-progress"
+            whereFrom="LEFT"
+            whereTo="RIGHT"/>
+
+        <!-- Process the task -->
+        <flow-ref name="process-task"/>
+
+        <!-- On success, remove from in-progress -->
+        <lettuce-redis:rpop
+            config-ref="Redis_Config"
+            key="queue:in-progress"/>
+
+        <error-handler>
+            <on-error-continue>
+                <!-- On failure, move back to pending -->
+                <lettuce-redis:lmove
+                    config-ref="Redis_Config"
+                    source="queue:in-progress"
+                    destination="queue:pending"
+                    whereFrom="RIGHT"
+                    whereTo="LEFT"/>
+            </on-error-continue>
+        </error-handler>
+    </try>
+</flow>
+```
+
+---
+
+## BLMOVE
+
+Atomically move an element from one list to another, blocking until an element is available or timeout occurs.
+
+> 📘 **Redis Reference**: [BLMOVE](https://redis.io/docs/latest/commands/blmove/)
+
+### XML Example
+
+```xml
+<lettuce-redis:blmove doc:name="Wait and move task"
+    config-ref="Redis_Config"
+    source="queue:pending"
+    destination="queue:in-progress"
+    whereFrom="LEFT"
+    whereTo="RIGHT"
+    timeout="5.0"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `source` | String | Yes | — | Source list key |
+| `destination` | String | Yes | — | Destination list key |
+| `whereFrom` | ListEnd | Yes | — | Which end to pop from: `LEFT` or `RIGHT` |
+| `whereTo` | ListEnd | Yes | — | Which end to push to: `LEFT` or `RIGHT` |
+| `timeout` | Double | Yes | — | Seconds to wait for an element. Use `0.0` to block indefinitely. |
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The element that was moved.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Source or destination is not a list |
+
+---
+
+## LSET
+
+Set the value of an element in a list by its index.
+
+> 📘 **Redis Reference**: [LSET](https://redis.io/docs/latest/commands/lset/)
+
+### XML Example
+
+```xml
+<!-- Update the first element (index 0) -->
+<lettuce-redis:lset doc:name="Update first item"
+    config-ref="Redis_Config"
+    key="todo:items"
+    index="0"
+    element="Buy groceries (URGENT)"/>
+
+<!-- Update the last element (index -1) -->
+<lettuce-redis:lset doc:name="Update last item"
+    config-ref="Redis_Config"
+    key="todo:items"
+    index="-1"
+    element="Call mom"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The list key |
+| `index` | Long | Yes | — | Index of the element to set (0-based). Negative indices count from the end (-1 is last element). |
+| `element` | String | Yes | — | The new value (payload by default via `@Content`) |
+
+### Output
+
+**Type**: `Void`
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:OUT_OF_RANGE` | Index is out of range for the list |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a list |
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/search-operations.md b/docs/connectors/mule-lettuce-redis-connector/operations/search-operations.md
new file mode 100644
index 0000000..27e6da4
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/search-operations.md
@@ -0,0 +1,350 @@
+---
+title: Search Operations — Lettuce Redis Connector
+description: Automated SCAN-based iteration for keys, hash fields, set members, and sorted set members
+---
+
+# Search Operations
+
+## The Problem with Manual SCAN
+
+When you need to iterate over large keyspaces or collections in Redis, you can't just ask for "all keys" or "all set members" — that would lock the server for too long. Instead, Redis uses cursor-based iteration commands: SCAN, HSCAN, SSCAN, and ZSCAN.
+
+Here's what manual cursor iteration looks like:
+
+1. Call SCAN with cursor `0`
+2. Process the returned keys
+3. Read the new cursor value from the response
+4. Call SCAN again with the new cursor
+5. Repeat steps 2-4 until the cursor returns to `0`
+6. Handle the edge case where a page returns 0 results but the cursor is not yet `0`
+
+In Mule XML, this requires flow-ref recursion, choice routers, and careful state management — verbose, error-prone, and cluttered with iteration logic instead of business logic.
+
+**Search Operations solve this problem.** They handle all the cursor management automatically and integrate natively with `<foreach>` and batch processing. You just write a simple loop — the connector takes care of the rest.
+
+---
+
+## How Search Operations Work
+
+Search Operations are implemented as Mule SDK `PagingProvider`s. This means:
+
+- They stream results in pages, making repeated SCAN calls under the hood
+- The connector maintains cursor state automatically until the full result set is returned
+- You use them with `<foreach>`, batch jobs, or any component that consumes iterables
+- You never see or manage the cursor — it's completely transparent
+
+Under the hood, the connector:
+1. Starts a SCAN loop with cursor `0`
+2. Calls the Redis SCAN command and retrieves a page of results
+3. Passes that page to your flow
+4. Stores the new cursor value internally
+5. Repeats until cursor returns to `0`, indicating the scan is complete
+
+---
+
+## The Four Search Operations
+
+### Search Keys
+
+**Automates:** [SCAN](./key-value#scan)
+
+**When to use:** Iterating over all keys in the database, optionally filtered by pattern or type.
+
+#### Example
+
+```xml
+<flow name="cleanup-expired-sessions">
+    <scheduler>
+        <scheduling-strategy>
+            <cron expression="0 0 2 * * ?"/>
+        </scheduling-strategy>
+    </scheduler>
+
+    <!-- Find all session keys -->
+    <lettuce-redis:search-keys
+        config-ref="Redis_Config"
+        match="session:*"
+        type="string"
+        pageSizeHint="100"/>
+
+    <!-- Process each key -->
+    <foreach>
+        <set-variable variableName="currentKey" value="#[payload]"/>
+        <logger level="DEBUG" message="Checking session key: #[vars.currentKey]"/>
+
+        <!-- Check TTL and delete if no expiration is set -->
+        <lettuce-redis:ttl config-ref="Redis_Config" key="#[vars.currentKey]"/>
+
+        <choice>
+            <when expression="#[payload == -1]">
+                <logger level="INFO" message="Deleting session with no TTL: #[vars.currentKey]"/>
+                <lettuce-redis:del config-ref="Redis_Config" keys="#[[vars.currentKey]]"/>
+            </when>
+        </choice>
+    </foreach>
+</flow>
+```
+
+#### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `match` | String | No | — | Glob-style pattern filter (e.g., `"user:*"`, `"cache:???"`). Only keys matching this pattern are returned. |
+| `type` | String | No | — | Redis type filter: `"string"`, `"hash"`, `"list"`, `"set"`, `"zset"`, or `"stream"`. Only keys of this type are returned. |
+| `pageSizeHint` | Integer | No | — | Hint to Redis for number of elements per SCAN call. Redis may return more or fewer elements. |
+
+#### Output
+
+**Type (per iteration):** `String`
+
+Each iteration of `<foreach>` receives a single key name as a String.
+
+---
+
+### Search Hash Fields
+
+**Automates:** [HSCAN](./hash#hscan)
+
+**When to use:** Iterating over all field-value pairs in a hash, optionally filtered by field name pattern.
+
+#### Example
+
+```xml
+<flow name="export-user-preferences">
+    <http:listener config-ref="HTTP_Config" path="/user/{userId}/preferences"/>
+
+    <!-- Get all preference fields for the user -->
+    <lettuce-redis:search-hash-fields
+        config-ref="Redis_Config"
+        key="#['user:' ++ attributes.uriParams.userId ++ ':prefs']"
+        pageSizeHint="50"/>
+
+    <!-- Each iteration gets a Map<String, String> with field-value pairs from this page -->
+    <foreach>
+        <logger level="DEBUG" message="Preference batch: #[payload]"/>
+
+        <!-- Transform to an array of preference objects -->
+        <ee:transform>
+            <ee:message>
+                <ee:set-payload><![CDATA[%dw 2.0
+output application/json
+---
+payload pluck (value, key) -> {
+    name: key,
+    value: value
+}]]></ee:set-payload>
+            </ee:message>
+        </ee:transform>
+    </foreach>
+</flow>
+```
+
+#### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | Hash key to scan |
+| `match` | String | No | — | Pattern filter on field names (e.g., `"email_*"`, `"theme_*"`) |
+| `pageSizeHint` | Integer | No | — | Elements per HSCAN call hint |
+
+#### Output
+
+**Type (per iteration):** `Map<String, String>`
+
+Each iteration receives a map of field-value pairs from one page of the HSCAN result. The map may contain multiple fields depending on how Redis batched the results.
+
+---
+
+### Search Set Members
+
+**Automates:** [SSCAN](./set#sscan)
+
+**When to use:** Iterating over all members of a set, optionally filtered by pattern.
+
+#### Example
+
+```xml
+<flow name="process-active-users">
+    <!-- Get all members from the "active-users" set -->
+    <lettuce-redis:search-set-members
+        config-ref="Redis_Config"
+        key="active-users"
+        pageSizeHint="100"/>
+
+    <!-- Each iteration gets a single member (user ID) -->
+    <foreach>
+        <logger message="Processing active user: #[payload]"/>
+
+        <!-- Fetch user details from another Redis key -->
+        <lettuce-redis:hgetall
+            config-ref="Redis_Config"
+            key="#['user:' ++ payload]"/>
+
+        <!-- Send notification or update stats -->
+        <flow-ref name="send-user-notification"/>
+    </foreach>
+</flow>
+```
+
+#### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | Set key to scan |
+| `match` | String | No | — | Pattern filter on member values |
+| `pageSizeHint` | Integer | No | — | Elements per SSCAN call hint |
+
+#### Output
+
+**Type (per iteration):** `String`
+
+Each iteration receives a single set member as a String.
+
+---
+
+### Search Sorted Set Members
+
+**Automates:** [ZSCAN](./sorted-set#zscan)
+
+**When to use:** Iterating over all members and scores in a sorted set, optionally filtered by member name pattern.
+
+#### Example
+
+```xml
+<flow name="export-leaderboard">
+    <http:listener config-ref="HTTP_Config" path="/leaderboard/export"/>
+
+    <!-- Get all player scores from the leaderboard -->
+    <lettuce-redis:search-sorted-set-members
+        config-ref="Redis_Config"
+        key="leaderboard:global"
+        pageSizeHint="500"/>
+
+    <!-- Each iteration gets a Map<String, Double> with member-score pairs -->
+    <foreach>
+        <logger message="Leaderboard page: #[payload]"/>
+    </foreach>
+
+    <!-- Aggregate all results into a final JSON response -->
+    <ee:transform>
+        <ee:message>
+            <ee:set-payload><![CDATA[%dw 2.0
+output application/json
+---
+{
+    players: payload flatMap (page) ->
+        page pluck (score, member) -> {
+            playerId: member,
+            score: score
+        }
+}]]></ee:set-payload>
+        </ee:message>
+    </ee:transform>
+</flow>
+```
+
+#### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | Sorted set key to scan |
+| `match` | String | No | — | Pattern filter on member names |
+| `pageSizeHint` | Integer | No | — | Elements per ZSCAN call hint |
+
+#### Output
+
+**Type (per iteration):** `Map<String, Double>`
+
+Each iteration receives a map where keys are member names (Strings) and values are scores (Doubles). The map contains member-score pairs from one page of the ZSCAN result.
+
+---
+
+## When to Use Search Operations vs Manual SCAN
+
+| Scenario | Use |
+|----------|-----|
+| Iterate over all matches and process them | **Search Operations** — automatic, clean, works with `<foreach>` and batch |
+| Stop early after finding N results | **Manual SCAN** — you control the loop and can break out |
+| Need access to the raw cursor value | **Manual SCAN** — Search Operations hide the cursor |
+| Need to resume a scan from a saved cursor | **Manual SCAN** — Search Operations always start from cursor `0` |
+| Production iteration over large keyspaces | **Search Operations** — handles edge cases automatically |
+| Filter results with complex logic during iteration | **Search Operations** — iterate with `<foreach>`, filter with `<choice>` |
+
+---
+
+## Important Notes
+
+### SCAN Is Not Atomic
+
+Redis SCAN commands are not snapshots — data can change during iteration. If keys are added or removed while you're scanning, they may or may not appear in your results. This is a Redis behavior, not a connector limitation.
+
+If you need a consistent view of data at a point in time, consider:
+- Using Redis transactions (MULTI/EXEC) with smaller, known key sets
+- Snapshoting data to a temporary key first, then scanning that
+- Accepting eventual consistency and designing your logic to be idempotent
+
+### `pageSizeHint` Is a Hint, Not a Guarantee
+
+The `pageSizeHint` parameter maps to Redis's `COUNT` option. Redis uses it as a hint for how many elements to scan per iteration, but the actual number returned can be more or less depending on:
+- The internal representation of the data structure
+- Hash table density and resizing
+- The `match` filter (filtered results may be smaller than the hint)
+
+The connector handles this transparently — you don't need to worry about variable page sizes.
+
+### Performance Tuning
+
+For very large keyspaces (millions of keys), SCAN can take many round trips to Redis. The `pageSizeHint` parameter helps you tune the tradeoff:
+
+- **Smaller hints** (e.g., `10-50`) → More round trips, lower memory usage per call, lower server load per call
+- **Larger hints** (e.g., `500-1000`) → Fewer round trips, higher memory usage per call, higher server load per call
+
+Start with the default (Redis decides) and only tune if you see performance issues.
+
+---
+
+## Example: Batch Processing with Search Operations
+
+Search Operations integrate seamlessly with Mule's batch processing:
+
+```xml
+<flow name="batch-update-user-stats">
+    <scheduler>
+        <scheduling-strategy>
+            <cron expression="0 0 1 * * ?"/>
+        </scheduling-strategy>
+    </scheduler>
+
+    <batch:job jobName="updateUserStatsBatch">
+        <batch:input>
+            <!-- Search Operations work as batch input sources -->
+            <lettuce-redis:search-keys
+                config-ref="Redis_Config"
+                match="user:*:stats"
+                pageSizeHint="100"/>
+        </batch:input>
+
+        <batch:process-records>
+            <batch:step name="updateStats">
+                <logger message="Processing user stats key: #[payload]"/>
+
+                <!-- Fetch, transform, update logic here -->
+                <lettuce-redis:hgetall
+                    config-ref="Redis_Config"
+                    key="#[payload]"/>
+
+                <!-- Update stats based on business logic -->
+            </batch:step>
+        </batch:process-records>
+    </batch:job>
+</flow>
+```
+
+---
+
+## See Also
+
+- [SCAN](./key-value#scan) — Manual key scanning with cursor control
+- [HSCAN](./hash#hscan) — Manual hash field scanning
+- [SSCAN](./set#sscan) — Manual set member scanning
+- [ZSCAN](./sorted-set#zscan) — Manual sorted set member scanning
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/send-command.md b/docs/connectors/mule-lettuce-redis-connector/operations/send-command.md
new file mode 100644
index 0000000..1eb725d
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/send-command.md
@@ -0,0 +1,217 @@
+---
+title: Send Command — Lettuce Redis Connector
+description: Execute any Redis command dynamically when no dedicated operation exists
+---
+
+# Send Command
+
+## When to Use Send Command
+
+The Lettuce Redis Connector implements dedicated operations for the most commonly used Redis commands — SET, GET, LPUSH, ZADD, and dozens more. But Redis has hundreds of commands, and new ones are added in every server release. When you need a command that the connector doesn't have a dedicated operation for, **Send Command** is your escape hatch.
+
+Use Send Command when you need to:
+- Execute a Redis command not yet implemented as a dedicated operation
+- Use new commands added in recent Redis server versions
+- Call commands from Redis modules (RedisJSON, RedisGraph, etc.)
+- Work with custom or experimental commands
+
+**The tradeoff:** You lose type safety and design-time metadata. The connector can't validate your arguments at design time or automatically infer the return type — you're responsible for knowing the command's signature and specifying how to interpret the response.
+
+---
+
+## How It Works
+
+Send Command uses Lettuce's low-level dispatch mechanism to send an arbitrary command string with arguments directly to the Redis server. You specify three things:
+
+1. **Command name** — the Redis command (e.g., `"LLEN"`, `"TYPE"`, `"RANDOMKEY"`)
+2. **Arguments** — an ordered list of strings representing the command's arguments
+3. **Return type** — what kind of response you expect from Redis (`STATUS`, `STRING`, `LONG`, or `ARRAY`)
+
+The connector sends the command, receives the response from Redis, and converts it to a Mule-friendly type based on the `returnType` you specified.
+
+---
+
+## The `returnType` Parameter — Understanding Your Options
+
+The `returnType` parameter is the most important part of using Send Command. It tells the connector how to interpret Redis's response. Choose the wrong type and you'll get a runtime error.
+
+| Return Type | Redis Response Type | Mule Output Type | Use When |
+|-------------|---------------------|-------------------|----------|
+| `STATUS` | Simple status string (e.g., `"OK"`, `"QUEUED"`) | `String` | Commands that return a status message: SET (without GET option), PING, SELECT, FLUSHDB |
+| `STRING` | Bulk string | `String` | Commands that return a string value: GET, HGET, LINDEX, TYPE |
+| `LONG` | Integer | `Long` | Commands that return a number: INCR, DECR, DBSIZE, LLEN, SCARD |
+| `ARRAY` | Array | `List<String>` | Commands that return multiple values: KEYS, MGET, LRANGE, SMEMBERS |
+
+::: tip How to Pick the Right Return Type
+Check the [Redis command documentation](https://redis.io/commands) for the command you're using. Every command page lists its return type — map that to one of the four `returnType` values above.
+:::
+
+::: warning NIL Responses
+If the command returns nil (e.g., GET on a nonexistent key) and you specified `returnType=STRING` or `returnType=ARRAY`, the connector throws a `REDIS:NIL` error. Use an error handler to catch this if nil is a valid outcome for your use case.
+:::
+
+---
+
+## Example: Using a Command Not in the Connector
+
+Let's say you need to check the length of a Redis list using the `LLEN` command. The connector doesn't have a dedicated LLEN operation, so you use Send Command:
+
+```xml
+<flow name="check-queue-length">
+    <http:listener config-ref="HTTP_Config" path="/queue/length"/>
+
+    <!-- Get the length of the "pending-tasks" list -->
+    <lettuce-redis:send-command
+        config-ref="Redis_Config"
+        command="LLEN"
+        arguments="#[['pending-tasks']]"
+        returnType="LONG"/>
+
+    <!-- payload is now a Long — the list length -->
+    <logger level="INFO" message="Queue has #[payload] pending tasks"/>
+
+    <set-payload value="#[output application/json --- {queueLength: payload}]"/>
+</flow>
+```
+
+**What's happening here:**
+- **`command="LLEN"`** — we're calling the Redis LLEN command
+- **`arguments="#[['pending-tasks']]"`** — LLEN takes one argument: the list key
+- **`returnType="LONG"`** — LLEN returns an integer (the list length)
+
+After the operation, `payload` contains the number of items in the list as a `Long`.
+
+---
+
+## Example: Getting a Key's Type
+
+Redis's `TYPE` command returns the data type of a key (`string`, `hash`, `list`, etc.). Since it returns a string status, use `returnType=STRING`:
+
+```xml
+<flow name="inspect-key-type">
+    <lettuce-redis:send-command
+        config-ref="Redis_Config"
+        command="TYPE"
+        arguments="#[['user:1001']]"
+        returnType="STRING"/>
+
+    <!-- payload is now a String like "hash" or "string" -->
+    <choice>
+        <when expression="#[payload == 'hash']">
+            <logger message="Key is a hash — fetching all fields"/>
+            <lettuce-redis:hgetall config-ref="Redis_Config" key="user:1001"/>
+        </when>
+        <when expression="#[payload == 'string']">
+            <logger message="Key is a string — fetching value"/>
+            <lettuce-redis:get config-ref="Redis_Config" key="user:1001"/>
+        </when>
+        <otherwise>
+            <logger level="WARN" message="Unexpected key type: #[payload]"/>
+        </otherwise>
+    </choice>
+</flow>
+```
+
+---
+
+## Example: Combining with DataWeave
+
+When using `returnType=ARRAY`, the result is a `List<String>`. You can transform it with DataWeave just like any other list:
+
+```xml
+<flow name="get-and-transform-range">
+    <!-- Get elements 0-9 from a list -->
+    <lettuce-redis:send-command
+        config-ref="Redis_Config"
+        command="LRANGE"
+        arguments="#[['event-log', '0', '9']]"
+        returnType="ARRAY"/>
+
+    <!-- payload is now a List<String> -->
+    <ee:transform>
+        <ee:message>
+            <ee:set-payload><![CDATA[%dw 2.0
+output application/json
+---
+{
+    events: payload map {
+        timestamp: $ splitBy '|' then [0],
+        message: $ splitBy '|' then [1]
+    }
+}]]></ee:set-payload>
+        </ee:message>
+    </ee:transform>
+</flow>
+```
+
+---
+
+## Error Handling
+
+Send Command can throw several error types depending on what goes wrong:
+
+| Error Type | When It's Thrown | How to Handle |
+|------------|------------------|---------------|
+| `REDIS:NIL` | Redis returned nil and `returnType` is `STRING` or `ARRAY` | Use an error handler to provide a default value or alternate logic |
+| `REDIS:WRONG_TYPE` | The key holds a different data type than the command expects | Check the key type first or catch and handle gracefully |
+| `REDIS:COMMAND` | Redis rejected the command (wrong arguments, unknown command, etc.) | Verify command syntax and argument count |
+| `REDIS:TIMEOUT` | Redis server did not respond in time | Retry or alert on infrastructure issues |
+
+### Example: Handling NIL Gracefully
+
+```xml
+<flow name="safe-get">
+    <try>
+        <lettuce-redis:send-command
+            config-ref="Redis_Config"
+            command="GET"
+            arguments="#[['session:' ++ attributes.queryParams.sessionId]]"
+            returnType="STRING"/>
+
+        <logger message="Session found: #[payload]"/>
+
+        <error-handler>
+            <on-error-continue type="REDIS:NIL">
+                <logger level="WARN" message="Session not found — using default"/>
+                <set-payload value="{}"/>
+            </on-error-continue>
+        </error-handler>
+    </try>
+</flow>
+```
+
+---
+
+## Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `command` | String | Yes | — | Redis command name (e.g., `"LLEN"`, `"TYPE"`, `"RANDOMKEY"`) |
+| `arguments` | List\<String\> | Yes | — | Command arguments in order. Use an empty list `#[[]]` for commands with no arguments. |
+| `returnType` | CommandReturnType | Yes | — | Expected return type: `STATUS`, `STRING`, `LONG`, or `ARRAY` |
+
+### Output
+
+**Type**: `Object` (resolved dynamically based on `returnType`)
+
+- `STATUS` → `String`
+- `STRING` → `String`
+- `LONG` → `Long`
+- `ARRAY` → `List<String>`
+
+---
+
+## Tips
+
+- **Check the Redis docs for return type:** If you're unsure which `returnType` to use, check the official [Redis command reference](https://redis.io/commands) — every command page lists the return type
+- **Arguments are always strings:** Even if a command takes a number (like `LRANGE key 0 10`), pass the arguments as strings: `#[['mylist', '0', '10']]`
+- **Keys go in the arguments list:** Unlike dedicated operations, Send Command doesn't have a separate `key` parameter — the key is just the first (or second, or third) argument depending on the command
+- **Use dedicated operations when available:** Send Command is powerful but less convenient than dedicated operations. If a command has a dedicated operation (like SET, GET, ZADD), prefer that — you get better metadata, validation, and autocomplete
+
+---
+
+## See Also
+
+- [Key-Value Operations](./key-value) — Dedicated operations for common commands like SET, GET, MGET
+- [List Operations](./list) — LPUSH, RPOP, LMOVE, and other list commands
+- [Hash Operations](./hash) — HSET, HGET, HINCRBY, and more
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/server.md b/docs/connectors/mule-lettuce-redis-connector/operations/server.md
new file mode 100644
index 0000000..d3a92c8
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/server.md
@@ -0,0 +1,77 @@
+---
+title: Server Commands — Lettuce Redis Connector
+description: Reference for server Redis commands in the Mule Lettuce Redis Connector
+---
+
+# Server Commands
+
+Server commands are used to check the health and responsiveness of the Redis server.
+
+This page covers: **PING**
+
+---
+
+## PING
+
+Test connectivity to the Redis server and optionally echo a custom message.
+
+> 📘 **Redis Reference**: [PING](https://redis.io/docs/latest/commands/ping/)
+
+### XML Example
+
+```xml
+<!-- Simple ping (returns "PONG") -->
+<lettuce-redis:ping doc:name="Ping" config-ref="Redis_Config"/>
+
+<!-- Ping with custom message (echoes the message back) -->
+<lettuce-redis:ping doc:name="Ping with message"
+    config-ref="Redis_Config"
+    message="health-check"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `message` | String | No | — | If provided, Redis echoes this message back instead of "PONG" |
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+- When no `message` parameter is provided: returns `"PONG"`
+- When a `message` is provided: returns the message string
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | Connection failure or server error |
+
+### Usage
+
+PING is commonly used for:
+- Health checks in monitoring flows
+- Verifying connectivity before executing operations
+- Validating configuration changes
+
+```xml
+<flow name="redis-health-check">
+    <scheduler>
+        <scheduling-strategy>
+            <fixed-frequency frequency="30" timeUnit="SECONDS"/>
+        </scheduling-strategy>
+    </scheduler>
+
+    <try>
+        <lettuce-redis:ping config-ref="Redis_Config"/>
+        <logger level="INFO" message="Redis is healthy: #[payload]"/>
+
+        <error-handler>
+            <on-error-continue>
+                <logger level="ERROR" message="Redis health check failed"/>
+            </on-error-continue>
+        </error-handler>
+    </try>
+</flow>
+```
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/set.md b/docs/connectors/mule-lettuce-redis-connector/operations/set.md
new file mode 100644
index 0000000..0f7e468
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/set.md
@@ -0,0 +1,455 @@
+---
+title: Set Commands — Lettuce Redis Connector
+description: Reference for set Redis commands in the Mule Lettuce Redis Connector
+---
+
+# Set Commands
+
+Set commands operate on Redis sets — unordered collections of unique strings. Sets are useful for membership testing, removing duplicates, and set algebra operations.
+
+This page covers: **SADD**, **SCARD**, **SDIFF**, **SISMEMBER**, **SMEMBERS**, **SMISMEMBER**, **SPOP**, **SRANDMEMBER**, **SREM**, **SSCAN**
+
+---
+
+## SADD
+
+Add one or more members to a set.
+
+> 📘 **Redis Reference**: [SADD](https://redis.io/docs/latest/commands/sadd/)
+
+### XML Example
+
+```xml
+<lettuce-redis:sadd doc:name="Add tags"
+    config-ref="Redis_Config"
+    key="article:123:tags"
+    members="#[['redis', 'mulesoft', 'integration', 'tutorial']]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key |
+| `members` | List\<String\> | Yes | — | Members to add. Payload by default via `@Content`. |
+
+### Output
+
+**Type**: `Long`
+
+The number of members **actually added** to the set. Members that were already in the set are not counted.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
+
+---
+
+## SREM
+
+Remove one or more members from a set.
+
+> 📘 **Redis Reference**: [SREM](https://redis.io/docs/latest/commands/srem/)
+
+### XML Example
+
+```xml
+<lettuce-redis:srem doc:name="Remove tags"
+    config-ref="Redis_Config"
+    key="article:123:tags"
+    members="#[['draft', 'incomplete']]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key |
+| `members` | List\<String\> | Yes | — | Members to remove. Payload by default via `@Content`. |
+
+### Output
+
+**Type**: `Long`
+
+The number of members removed from the set. Members that were not in the set are not counted.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
+
+---
+
+## SMEMBERS
+
+Get all members of a set.
+
+> 📘 **Redis Reference**: [SMEMBERS](https://redis.io/docs/latest/commands/smembers/)
+
+### XML Example
+
+```xml
+<lettuce-redis:smembers doc:name="Get all tags"
+    config-ref="Redis_Config"
+    key="article:123:tags"/>
+
+<!-- payload is now a List<String> of all members -->
+<foreach collection="#[payload]">
+    <logger level="INFO" message="Tag: #[payload]"/>
+</foreach>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key |
+
+### Output
+
+**Type**: `List<String>`
+
+All members of the set. Returns an empty list if the set does not exist.
+
+::: warning Large Sets
+For sets with many members, consider using [Search Set Members](./search-operations#search-set-members) which streams results incrementally via SSCAN.
+:::
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
+
+---
+
+## SISMEMBER
+
+Check if a value is a member of a set.
+
+> 📘 **Redis Reference**: [SISMEMBER](https://redis.io/docs/latest/commands/sismember/)
+
+### XML Example
+
+```xml
+<lettuce-redis:sismember doc:name="Check if user is admin"
+    config-ref="Redis_Config"
+    key="users:admins"
+    member="user:123"/>
+
+<choice>
+    <when expression="#[payload == true]">
+        <flow-ref name="admin-flow"/>
+    </when>
+    <otherwise>
+        <flow-ref name="standard-user-flow"/>
+    </otherwise>
+</choice>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key |
+| `member` | String | Yes | — | The member to test |
+
+### Output
+
+**Type**: `Boolean`
+
+- `true` if the member is in the set
+- `false` if the member is not in the set or the set does not exist
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
+
+---
+
+## SMISMEMBER
+
+Check if multiple values are members of a set.
+
+> 📘 **Redis Reference**: [SMISMEMBER](https://redis.io/docs/latest/commands/smismember/)
+
+### XML Example
+
+```xml
+<lettuce-redis:smismember doc:name="Check multiple permissions"
+    config-ref="Redis_Config"
+    key="user:123:permissions"
+    members="#[['read', 'write', 'delete', 'admin']]"/>
+
+<!-- payload is now a List<Boolean> with results in the same order as the input -->
+<set-variable variableName="permissions"
+    value="#[{read: payload[0], write: payload[1], delete: payload[2], admin: payload[3]}]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key |
+| `members` | List\<String\> | Yes | — | Members to test. Payload by default via `@Content`. |
+
+### Output
+
+**Type**: `List<Boolean>`
+
+A list of boolean values, one for each input member, in the same order. Each value is:
+- `true` if the corresponding member is in the set
+- `false` if the corresponding member is not in the set
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
+
+---
+
+## SCARD
+
+Get the number of members in a set (cardinality).
+
+> 📘 **Redis Reference**: [SCARD](https://redis.io/docs/latest/commands/scard/)
+
+### XML Example
+
+```xml
+<lettuce-redis:scard doc:name="Count active sessions"
+    config-ref="Redis_Config"
+    key="sessions:active"/>
+
+<logger level="INFO" message="Active sessions: #[payload]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key |
+
+### Output
+
+**Type**: `Long`
+
+The number of members in the set. Returns `0` if the set does not exist.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
+
+---
+
+## SDIFF
+
+Compute the difference between the first set and all subsequent sets.
+
+> 📘 **Redis Reference**: [SDIFF](https://redis.io/docs/latest/commands/sdiff/)
+
+### XML Example
+
+```xml
+<!-- Find users who have read permission but not write permission -->
+<lettuce-redis:sdiff doc:name="Find read-only users"
+    config-ref="Redis_Config"
+    key="permissions:read"
+    keys="#[['permissions:write']]"/>
+
+<!-- payload contains members in "read" but not in "write" -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The first set (base set) |
+| `keys` | List\<String\> | Yes | — | Additional sets to subtract from the first set |
+
+### Output
+
+**Type**: `List<String>`
+
+Members that are in the first set but not in any of the other sets.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | One of the keys is not a set |
+
+---
+
+## SPOP
+
+Remove and return one or more random members from a set.
+
+> 📘 **Redis Reference**: [SPOP](https://redis.io/docs/latest/commands/spop/)
+
+### XML Example
+
+```xml
+<!-- Pop a single random member -->
+<lettuce-redis:spop doc:name="Draw winner"
+    config-ref="Redis_Config"
+    key="contest:entries"/>
+<!-- payload is a String -->
+
+<!-- Pop multiple random members -->
+<lettuce-redis:spop doc:name="Draw three winners"
+    config-ref="Redis_Config"
+    key="contest:entries"
+    count="3"/>
+<!-- payload is a List<String> -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key |
+| `count` | Integer | No | — | Number of members to pop. When omitted, pops one member. |
+
+### Output
+
+**Type**: `Object` (dynamic, resolved by metadata)
+
+- When `count` is **not** specified: `String` (the single popped member)
+- When `count` **is** specified: `List<String>` (the popped members)
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
+
+---
+
+## SRANDMEMBER
+
+Get one or more random members from a set without removing them.
+
+> 📘 **Redis Reference**: [SRANDMEMBER](https://redis.io/docs/latest/commands/srandmember/)
+
+### XML Example
+
+```xml
+<!-- Get one random member -->
+<lettuce-redis:srandmember doc:name="Get random item"
+    config-ref="Redis_Config"
+    key="products:featured"/>
+
+<!-- Get 5 unique random members -->
+<lettuce-redis:srandmember doc:name="Get 5 unique items"
+    config-ref="Redis_Config"
+    key="products:featured"
+    count="5"/>
+
+<!-- Get 10 random members (may include duplicates) -->
+<lettuce-redis:srandmember doc:name="Get 10 with duplicates allowed"
+    config-ref="Redis_Config"
+    key="products:featured"
+    count="-10"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key |
+| `count` | Integer | No | — | Number of members to return. **Positive** = unique results; **Negative** = duplicates allowed. |
+
+### Output
+
+**Type**: `List<String>`
+
+Random members from the set. If `count` is not specified, returns a single-element list.
+
+::: info Count Sign Matters
+- **Positive `count`**: Returns up to `count` **unique** members (no duplicates)
+- **Negative `count`**: Returns exactly `abs(count)` members, **duplicates allowed**
+:::
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
+
+---
+
+## SSCAN
+
+Incrementally iterate set members using a cursor.
+
+> 📘 **Redis Reference**: [SSCAN](https://redis.io/docs/latest/commands/sscan/)
+
+::: tip Automated Cursor Management
+For most use cases, consider using [Search Set Members](./search-operations#search-set-members) instead, which handles cursor iteration automatically and streams all members. Use SSCAN directly only when you need fine-grained control over pagination.
+:::
+
+### XML Example
+
+```xml
+<!-- Start a new scan (cursor 0) -->
+<lettuce-redis:sscan doc:name="Scan set members"
+    config-ref="Redis_Config"
+    key="users:active"
+    cursor="0"
+    match="user:*"
+    count="100"/>
+
+<!-- payload contains a List<String> of members from this page -->
+<!-- attributes.cursor contains the next cursor value -->
+<logger level="INFO" message="Next cursor: #[attributes.cursor]"/>
+
+<!-- Continue scanning with the next cursor -->
+<lettuce-redis:sscan doc:name="Scan next page"
+    config-ref="Redis_Config"
+    key="users:active"
+    cursor="#[attributes.cursor]"
+    match="user:*"
+    count="100"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The set key to scan |
+| `cursor` | Integer | Yes | — | Cursor position. Use `0` to start a new scan. |
+| `match` | String | No | — | Glob-style pattern to filter members |
+| `count` | Integer | No | — | Hint for the number of elements to return per iteration |
+
+### Output
+
+**Type**: `List<String>`
+
+A list of members matching the pattern for this scan iteration.
+
+**Attributes**: `ScanAttributes` — Contains the `cursor` field with the next cursor value. When `cursor` is `0`, the scan is complete.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a set |
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/sorted-set.md b/docs/connectors/mule-lettuce-redis-connector/operations/sorted-set.md
new file mode 100644
index 0000000..a63c6f9
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/sorted-set.md
@@ -0,0 +1,269 @@
+---
+title: Sorted Set Commands — Lettuce Redis Connector
+description: Reference for sorted set Redis commands in the Mule Lettuce Redis Connector
+---
+
+# Sorted Set Commands
+
+Sorted set commands operate on Redis sorted sets — collections of unique strings, each associated with a score. Members are ordered by score, making sorted sets useful for leaderboards, priority queues, and range queries.
+
+This page covers: **ZADD**, **ZINCRBY**, **ZRANK**, **ZSCAN**, **ZSCORE**
+
+---
+
+## ZADD
+
+Add one or more members with scores to a sorted set, with optional conditional flags.
+
+> 📘 **Redis Reference**: [ZADD](https://redis.io/docs/latest/commands/zadd/)
+
+### XML Example
+
+```xml
+<!-- Add multiple members with scores -->
+<lettuce-redis:zadd doc:name="Add leaderboard scores"
+    config-ref="Redis_Config"
+    key="leaderboard:global"
+    memberScores="#[{'player:123': 1500.0, 'player:456': 1200.0, 'player:789': 1800.0}]"
+    xx="false"
+    nx="false"
+    gt="false"
+    lt="false"
+    ch="false"/>
+
+<!-- Only update existing members if new score is higher -->
+<lettuce-redis:zadd doc:name="Update high scores"
+    config-ref="Redis_Config"
+    key="leaderboard:global"
+    memberScores="#[{'player:123': 1600.0}]"
+    xx="true"
+    gt="true"
+    ch="true"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The sorted set key |
+| `memberScores` | Map\<String, Double\> | Yes | — | Member-to-score pairs. Payload by default via `@Content`. |
+| `xx` | boolean | No | `false` | Only update existing members (do not add new) |
+| `nx` | boolean | No | `false` | Only add new members (do not update existing) |
+| `gt` | boolean | No | `false` | Only update if the new score is **greater than** the current score |
+| `lt` | boolean | No | `false` | Only update if the new score is **less than** the current score |
+| `ch` | boolean | No | `false` | Change the return value to count **changed** members instead of **added** members |
+
+### Output
+
+**Type**: `Long`
+
+- By default: the number of **new** members added (updates to existing members are not counted)
+- When `ch=true`: the number of members **added or changed**
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a sorted set |
+
+---
+
+## ZSCORE
+
+Get the score of a member in a sorted set.
+
+> 📘 **Redis Reference**: [ZSCORE](https://redis.io/docs/latest/commands/zscore/)
+
+### XML Example
+
+```xml
+<lettuce-redis:zscore doc:name="Get player score"
+    config-ref="Redis_Config"
+    key="leaderboard:global"
+    member="player:123"/>
+
+<!-- payload is now the player's score as a Double -->
+<logger level="INFO" message="Player score: #[payload]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The sorted set key |
+| `member` | String | Yes | — | The member whose score to retrieve |
+
+### Output
+
+**Type**: `Double`
+
+The score of the member.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a sorted set |
+
+---
+
+## ZRANK
+
+Get the rank (index) of a member in a sorted set, optionally with its score.
+
+> 📘 **Redis Reference**: [ZRANK](https://redis.io/docs/latest/commands/zrank/)
+
+### XML Example
+
+```xml
+<!-- Get rank only -->
+<lettuce-redis:zrank doc:name="Get player rank"
+    config-ref="Redis_Config"
+    key="leaderboard:global"
+    member="player:123"
+    withScore="false"/>
+<!-- payload is a Long (the rank, 0-based) -->
+
+<!-- Get rank and score together -->
+<lettuce-redis:zrank doc:name="Get player rank and score"
+    config-ref="Redis_Config"
+    key="leaderboard:global"
+    member="player:123"
+    withScore="true"/>
+<!-- payload is a Map with keys "rank" and "score" -->
+<logger level="INFO" message="Rank: #[payload.rank], Score: #[payload.score]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The sorted set key |
+| `member` | String | Yes | — | The member to get the rank of |
+| `withScore` | boolean | No | `false` | If `true`, return both rank and score together |
+
+### Output
+
+**Type**: `Object` (dynamic, resolved by metadata)
+
+- When `withScore=false`: `Long` — The rank (0-based index in sorted order)
+- When `withScore=true`: `Map<String, Object>` with keys:
+  - `"rank"` → Long
+  - `"score"` → Double
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:NIL` | Member does not exist in the sorted set |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a sorted set |
+
+---
+
+## ZINCRBY
+
+Increment the score of a member in a sorted set.
+
+> 📘 **Redis Reference**: [ZINCRBY](https://redis.io/docs/latest/commands/zincrby/)
+
+### XML Example
+
+```xml
+<lettuce-redis:zincrby doc:name="Award points"
+    config-ref="Redis_Config"
+    key="leaderboard:global"
+    increment="100.0"
+    member="player:123"/>
+
+<!-- payload is now the new score after increment -->
+<logger level="INFO" message="New score: #[payload]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The sorted set key |
+| `increment` | Double | Yes | — | The amount to add to the member's score (can be negative) |
+| `member` | String | Yes | — | The member whose score to increment |
+
+### Output
+
+**Type**: `Double`
+
+The new score of the member after the increment.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a sorted set |
+
+---
+
+## ZSCAN
+
+Incrementally iterate sorted set members and scores using a cursor.
+
+> 📘 **Redis Reference**: [ZSCAN](https://redis.io/docs/latest/commands/zscan/)
+
+::: tip Automated Cursor Management
+For most use cases, consider using [Search Sorted Set Members](./search-operations#search-sorted-set-members) instead, which handles cursor iteration automatically and streams all member-score pairs. Use ZSCAN directly only when you need fine-grained control over pagination.
+:::
+
+### XML Example
+
+```xml
+<!-- Start a new scan (cursor 0) -->
+<lettuce-redis:zscan doc:name="Scan leaderboard"
+    config-ref="Redis_Config"
+    key="leaderboard:global"
+    cursor="0"
+    match="player:*"
+    count="50"/>
+
+<!-- payload is a List<Map<String, Double>> -->
+<!-- Each element is a single-entry map: {member: score} -->
+<foreach collection="#[payload]">
+    <logger level="INFO"
+        message="Member: #[payload.keys()[0]], Score: #[payload[payload.keys()[0]]]"/>
+</foreach>
+
+<!-- attributes.cursor contains the next cursor value -->
+<logger level="INFO" message="Next cursor: #[attributes.cursor]"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The sorted set key to scan |
+| `cursor` | Integer | Yes | — | Cursor position. Use `0` to start a new scan. |
+| `match` | String | No | — | Glob-style pattern to filter member names |
+| `count` | Integer | No | — | Hint for the number of elements to return per iteration |
+
+### Output
+
+**Type**: `List<Map<String, Double>>`
+
+A list where each element is a single-entry map representing one member-score pair:
+```json
+[
+  {"player:123": 1500.0},
+  {"player:456": 1200.0},
+  {"player:789": 1800.0}
+]
+```
+
+**Attributes**: `ScanAttributes` — Contains the `cursor` field with the next cursor value. When `cursor` is `0`, the scan is complete.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a sorted set |
diff --git a/docs/connectors/mule-lettuce-redis-connector/operations/stream.md b/docs/connectors/mule-lettuce-redis-connector/operations/stream.md
new file mode 100644
index 0000000..73f3248
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/operations/stream.md
@@ -0,0 +1,630 @@
+---
+title: Stream Commands — Lettuce Redis Connector
+description: Reference for stream Redis commands in the Mule Lettuce Redis Connector
+---
+
+# Stream Commands
+
+Stream commands operate on Redis streams — append-only log data structures designed for messaging and event sourcing. Streams support consumer groups for distributed processing, making them ideal for building scalable message queues and event-driven architectures.
+
+This page covers: **XACK**, **XADD**, **XDEL**, **XGROUP CREATE**, **XGROUP DESTROY**, **XINFO GROUPS**, **XRANGE**, **XREAD**, **XREADGROUP**, **XTRIM**
+
+---
+
+## XADD
+
+Append a new entry to a stream, optionally with automatic eviction to cap stream size.
+
+> 📘 **Redis Reference**: [XADD](https://redis.io/docs/latest/commands/xadd/)
+
+### XML Example
+
+```xml
+<!-- Add an entry with auto-generated ID -->
+<lettuce-redis:xadd doc:name="Add event"
+    config-ref="Redis_Config"
+    key="events:orders"
+    noMkStream="false"
+    entry="#[{orderId: '12345', status: 'created', timestamp: now()}]"/>
+
+<!-- Add with max length eviction (keep last 1000 entries) -->
+<lettuce-redis:xadd doc:name="Add with eviction"
+    config-ref="Redis_Config"
+    key="events:orders"
+    noMkStream="false"
+    entry="#[{orderId: '12346', status: 'created'}]">
+    <lettuce-redis:eviction-option>
+        <lettuce-redis:max-len-eviction-option
+            maxLength="1000"
+            exactTrimming="false"
+            limit="100"/>
+    </lettuce-redis:eviction-option>
+</lettuce-redis:xadd>
+
+<!-- payload is now the generated entry ID (e.g., "1609459200000-0") -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The stream key |
+| `noMkStream` | boolean | No | `false` | If `true`, do not create the stream if it doesn't exist |
+| `id` | String | No | `"*"` | Entry ID. Use `"*"` for auto-generation (recommended). |
+| `evictionOption` | StreamEvictionOption | No | — | Eviction policy to cap stream size (MaxLenEvictionOption or MinIdEvictionOption) |
+| `entry` | Map\<String, String\> | Yes | — | Field-value pairs for the entry. At least one required. Payload by default via `@Content`. |
+
+**StreamEvictionOption** (choose one):
+
+| Type | Fields |
+|------|--------|
+| `MaxLenEvictionOption` | `maxLength` (long), `exactTrimming` (boolean, default `true`), `limit` (Integer, optional) |
+| `MinIdEvictionOption` | `id` (String), `exactTrimming` (boolean, default `true`), `limit` (Integer, optional) |
+
+**Eviction notes**:
+- `exactTrimming=false` allows approximate trimming for better performance
+- `limit` caps the number of entries deleted in a single trim operation
+
+### Output
+
+**Type**: `String` (media type: `text/plain`)
+
+The ID of the newly added entry (e.g., `"1609459200000-0"`).
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | Entry map is empty, or invalid ID |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a stream |
+
+---
+
+## XRANGE
+
+Retrieve a range of entries from a stream.
+
+> 📘 **Redis Reference**: [XRANGE](https://redis.io/docs/latest/commands/xrange/)
+
+### XML Example
+
+```xml
+<!-- Get all entries -->
+<lettuce-redis:xrange doc:name="Get all entries"
+    config-ref="Redis_Config"
+    key="events:orders"
+    start="-"
+    end="+"/>
+
+<!-- Get entries in a specific time range, limit to 100 -->
+<lettuce-redis:xrange doc:name="Get recent entries"
+    config-ref="Redis_Config"
+    key="events:orders"
+    start="1609459200000"
+    end="1609545600000"
+    count="100"/>
+
+<!-- payload is a Map<String, Map<String, String>> -->
+<!-- Outer map: entry ID -> inner map of field-value pairs -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The stream key |
+| `start` | String | Yes | — | Range start ID. Use `"-"` for the beginning of the stream. |
+| `end` | String | Yes | — | Range end ID. Use `"+"` for the end of the stream. |
+| `count` | Integer | No | — | Maximum number of entries to return |
+
+### Output
+
+**Type**: `Map<String, Map<String, String>>`
+
+A map where:
+- **Key**: Entry ID (e.g., `"1609459200000-0"`)
+- **Value**: Map of field-value pairs for that entry
+
+Example:
+```json
+{
+  "1609459200000-0": {"orderId": "12345", "status": "created"},
+  "1609459200001-0": {"orderId": "12346", "status": "created"}
+}
+```
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | Invalid start or end ID |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key exists but is not a stream |
+
+---
+
+## XREAD
+
+Read entries from one or more streams, optionally blocking until new entries arrive.
+
+> 📘 **Redis Reference**: [XREAD](https://redis.io/docs/latest/commands/xread/)
+
+### XML Example
+
+```xml
+<!-- Read new entries from multiple streams -->
+<lettuce-redis:xread doc:name="Read from streams"
+    config-ref="Redis_Config"
+    count="10"
+    streamWatermarks="#[[
+        {key: 'events:orders', id: '$'},
+        {key: 'events:shipments', id: '$'}
+    ]]"/>
+
+<!-- Block for up to 5 seconds waiting for new entries -->
+<lettuce-redis:xread doc:name="Block and read"
+    config-ref="Redis_Config"
+    count="10"
+    block="5000"
+    streamWatermarks="#[[
+        {key: 'events:orders', id: '$'}
+    ]]"/>
+
+<!-- payload is a Map<String, List<StreamEntry>> -->
+<!-- Stream key -> list of entries -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `count` | Integer | No | — | Maximum entries per stream |
+| `block` | Integer | No | — | Milliseconds to block waiting for new entries. Omit for non-blocking. |
+| `streamWatermarks` | List\<StreamWatermark\> | Yes | — | Stream keys and last-read IDs. At least one required. Use `"0"` to read from the beginning, `"$"` to read only new entries. |
+
+**StreamWatermark structure**:
+```dataweave
+{
+  key: "stream-key",           // String
+  id: "$"                      // String (entry ID or special value)
+}
+```
+
+**Special ID values**:
+- `"0"` — Read from the beginning of the stream
+- `"$"` — Read only entries added **after** this call
+
+### Output
+
+**Type**: `Map<String, List<StreamEntry>>`
+
+A map where:
+- **Key**: Stream key
+- **Value**: List of StreamEntry objects
+
+**StreamEntry structure**:
+```dataweave
+{
+  id: "1609459200000-0",             // String
+  entry: {orderId: "12345", ...}     // Map<String, String>
+}
+```
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No stream watermarks provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | One of the keys is not a stream |
+
+---
+
+## XREADGROUP
+
+Read entries from one or more streams as part of a consumer group.
+
+> 📘 **Redis Reference**: [XREADGROUP](https://redis.io/docs/latest/commands/xreadgroup/)
+
+### XML Example
+
+```xml
+<!-- Read undelivered entries for this consumer -->
+<lettuce-redis:xreadgroup doc:name="Read as consumer"
+    config-ref="Redis_Config"
+    group="order-processors"
+    consumer="worker-01"
+    count="10"
+    noack="false"
+    streamWatermarks="#[[
+        {key: 'events:orders', id: '>'}
+    ]]"/>
+
+<!-- Block for up to 10 seconds waiting for new entries -->
+<lettuce-redis:xreadgroup doc:name="Block and read as consumer"
+    config-ref="Redis_Config"
+    group="order-processors"
+    consumer="worker-01"
+    count="5"
+    block="10000"
+    noack="false"
+    streamWatermarks="#[[
+        {key: 'events:orders', id: '>'}
+    ]]"/>
+
+<!-- payload is a Map<String, List<StreamEntry>> -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `group` | String | Yes | — | Consumer group name |
+| `consumer` | String | Yes | — | Consumer name within the group |
+| `count` | Long | No | — | Maximum entries per stream |
+| `block` | Long | No | — | Milliseconds to block waiting for new entries |
+| `noack` | boolean | No | `false` | If `true`, do not track acknowledgment (auto-acknowledge) |
+| `streamWatermarks` | List\<StreamWatermark\> | Yes | — | Stream keys and IDs. At least one required. Use `">"` to read undelivered entries. |
+
+**Special ID value for consumer groups**:
+- `">"` — Read only entries **not yet delivered** to any consumer in the group
+
+### Output
+
+**Type**: `Map<String, List<StreamEntry>>`
+
+Same structure as XREAD.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No stream watermarks provided, or group/consumer invalid |
+| `REDIS:COMMAND` | General command execution error (e.g., group does not exist) |
+| `REDIS:WRONG_TYPE` | One of the keys is not a stream |
+
+### Consumer Group Processing Pattern
+
+```xml
+<!-- Create consumer group (one-time setup) -->
+<lettuce-redis:xgroup-create
+    config-ref="Redis_Config"
+    key="events:orders"
+    group="order-processors"
+    lastEntryId="$"
+    mkstream="true"/>
+
+<!-- Consumer loop -->
+<flow name="process-orders">
+    <scheduler>
+        <scheduling-strategy>
+            <fixed-frequency frequency="1" timeUnit="SECONDS"/>
+        </scheduling-strategy>
+    </scheduler>
+
+    <!-- Read undelivered entries -->
+    <lettuce-redis:xreadgroup
+        config-ref="Redis_Config"
+        group="order-processors"
+        consumer="worker-01"
+        count="10"
+        block="5000"
+        noack="false"
+        streamWatermarks="#[[{key: 'events:orders', id: '>'}]]"/>
+
+    <!-- Process each entry -->
+    <foreach collection="#[payload['events:orders'] default []]">
+        <set-variable variableName="entryId" value="#[payload.id]"/>
+        <set-variable variableName="orderData" value="#[payload.entry]"/>
+
+        <try>
+            <flow-ref name="process-order"/>
+
+            <!-- Acknowledge successful processing -->
+            <lettuce-redis:xack
+                config-ref="Redis_Config"
+                key="events:orders"
+                group="order-processors"
+                ids="#[[vars.entryId]]"/>
+
+            <error-handler>
+                <on-error-continue>
+                    <logger level="ERROR"
+                        message="Failed to process order #[vars.entryId]"/>
+                    <!-- Entry remains in pending list for retry -->
+                </on-error-continue>
+            </error-handler>
+        </try>
+    </foreach>
+</flow>
+```
+
+---
+
+## XACK
+
+Acknowledge one or more entries as processed by a consumer group.
+
+> 📘 **Redis Reference**: [XACK](https://redis.io/docs/latest/commands/xack/)
+
+### XML Example
+
+```xml
+<lettuce-redis:xack doc:name="Acknowledge entry"
+    config-ref="Redis_Config"
+    key="events:orders"
+    group="order-processors"
+    ids="#[['1609459200000-0', '1609459200001-0']]"/>
+
+<!-- payload is the number of entries acknowledged -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The stream key |
+| `group` | String | Yes | — | Consumer group name |
+| `ids` | List\<String\> | Yes | — | Entry IDs to acknowledge. At least one required. |
+
+### Output
+
+**Type**: `Long`
+
+The number of entries successfully acknowledged.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No IDs provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key is not a stream |
+
+---
+
+## XDEL
+
+Delete one or more entries from a stream.
+
+> 📘 **Redis Reference**: [XDEL](https://redis.io/docs/latest/commands/xdel/)
+
+### XML Example
+
+```xml
+<lettuce-redis:xdel doc:name="Delete processed entries"
+    config-ref="Redis_Config"
+    key="events:orders"
+    ids="#[['1609459200000-0', '1609459200001-0']]"/>
+
+<!-- payload is the number of entries deleted -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The stream key |
+| `ids` | List\<String\> | Yes | — | Entry IDs to delete. At least one required. |
+
+### Output
+
+**Type**: `Long`
+
+The number of entries deleted.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:ARGUMENT` | No IDs provided |
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key is not a stream |
+
+---
+
+## XTRIM
+
+Trim a stream to a specified length or minimum ID.
+
+> 📘 **Redis Reference**: [XTRIM](https://redis.io/docs/latest/commands/xtrim/)
+
+::: warning Static Configuration Required
+The `evictionOption` parameter is `@Expression(NOT_SUPPORTED)` — it **must** be configured statically in XML. DataWeave expressions cannot be used for this parameter.
+:::
+
+### XML Example
+
+```xml
+<!-- Trim to keep last 1000 entries (approximate) -->
+<lettuce-redis:xtrim doc:name="Trim stream"
+    config-ref="Redis_Config"
+    key="events:orders">
+    <lettuce-redis:eviction-option>
+        <lettuce-redis:max-len-eviction-option
+            maxLength="1000"
+            exactTrimming="false"
+            limit="100"/>
+    </lettuce-redis:eviction-option>
+</lettuce-redis:xtrim>
+
+<!-- Trim entries older than a specific ID -->
+<lettuce-redis:xtrim doc:name="Trim old entries"
+    config-ref="Redis_Config"
+    key="events:orders">
+    <lettuce-redis:eviction-option>
+        <lettuce-redis:min-id-eviction-option
+            id="1609459200000-0"
+            exactTrimming="true"/>
+    </lettuce-redis:eviction-option>
+</lettuce-redis:xtrim>
+
+<!-- payload is the number of entries deleted -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The stream key |
+| `evictionOption` | StreamEvictionOption | Yes | — | Eviction policy (MaxLenEvictionOption or MinIdEvictionOption). Must be static XML. |
+
+**StreamEvictionOption** (same as XADD):
+
+| Type | Fields |
+|------|--------|
+| `MaxLenEvictionOption` | `maxLength` (long), `exactTrimming` (boolean), `limit` (Integer, optional) |
+| `MinIdEvictionOption` | `id` (String), `exactTrimming` (boolean), `limit` (Integer, optional) |
+
+### Output
+
+**Type**: `Long`
+
+The number of entries deleted.
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key is not a stream |
+
+---
+
+## XGROUP CREATE
+
+Create a new consumer group for a stream.
+
+> 📘 **Redis Reference**: [XGROUP CREATE](https://redis.io/docs/latest/commands/xgroup-create/)
+
+### XML Example
+
+```xml
+<!-- Create group starting from current end of stream -->
+<lettuce-redis:xgroup-create doc:name="Create consumer group"
+    config-ref="Redis_Config"
+    key="events:orders"
+    group="order-processors"
+    lastEntryId="$"
+    mkstream="true"/>
+
+<!-- Create group to process all existing and future entries -->
+<lettuce-redis:xgroup-create doc:name="Create group from beginning"
+    config-ref="Redis_Config"
+    key="events:orders"
+    group="archive-processors"
+    lastEntryId="0"
+    mkstream="false"/>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The stream key |
+| `group` | String | Yes | — | Consumer group name to create |
+| `lastEntryId` | String | No | `"$"` | ID of the last entry the group has seen. Use `"$"` to start from the current end, `"0"` to process all existing entries. |
+| `mkstream` | boolean | Yes | — | If `true`, create the stream if it does not exist |
+| `entriesRead` | Long | No | — | Number of entries already read (for accurate lag tracking) |
+
+### Output
+
+**Type**: `Void`
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error (e.g., group already exists) |
+| `REDIS:WRONG_TYPE` | Key exists but is not a stream |
+
+---
+
+## XGROUP DESTROY
+
+Destroy a consumer group.
+
+> 📘 **Redis Reference**: [XGROUP DESTROY](https://redis.io/docs/latest/commands/xgroup-destroy/)
+
+### XML Example
+
+```xml
+<lettuce-redis:xgroup-destroy doc:name="Destroy consumer group"
+    config-ref="Redis_Config"
+    key="events:orders"
+    group="old-processors"/>
+
+<!-- payload is true if group was destroyed, false if it didn't exist -->
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The stream key |
+| `group` | String | Yes | — | Consumer group name to destroy |
+
+### Output
+
+**Type**: `Boolean`
+
+- `true` if the group was destroyed
+- `false` if the group did not exist
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key is not a stream |
+
+---
+
+## XINFO GROUPS
+
+Get information about all consumer groups for a stream.
+
+> 📘 **Redis Reference**: [XINFO GROUPS](https://redis.io/docs/latest/commands/xinfo-groups/)
+
+### XML Example
+
+```xml
+<lettuce-redis:xinfo-groups doc:name="Get consumer groups"
+    config-ref="Redis_Config"
+    key="events:orders"/>
+
+<!-- payload is a List<Map<String, Object>> with one map per group -->
+<foreach collection="#[payload]">
+    <logger level="INFO"
+        message="Group: #[payload.name], Consumers: #[payload.consumers], Pending: #[payload.pending]"/>
+</foreach>
+```
+
+### Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `key` | String | Yes | — | The stream key |
+
+### Output
+
+**Type**: `List<Map<String, Object>>`
+
+A list of maps, one for each consumer group. Each map contains:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | String | Consumer group name |
+| `consumers` | Long | Number of consumers in the group |
+| `pending` | Long | Number of entries pending acknowledgment |
+| `last-delivered-id` | String | ID of the last entry delivered to a consumer |
+| `entries-read` | Long | Number of entries read by the group |
+| `lag` | Long | Number of entries in the stream not yet delivered |
+
+### Errors
+
+| Error Type | Condition |
+|------------|-----------|
+| `REDIS:COMMAND` | General command execution error |
+| `REDIS:WRONG_TYPE` | Key is not a stream |
diff --git a/docs/connectors/mule-lettuce-redis-connector/set-up.md b/docs/connectors/mule-lettuce-redis-connector/set-up.md
new file mode 100644
index 0000000..908e0a9
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/set-up.md
@@ -0,0 +1,206 @@
+---
+title: Set Up
+description: Installation and configuration guide for the Mule Lettuce Redis Connector.
+---
+
+# Set Up
+
+| Version | Min runtime version | Compatible Java versions | Description |
+| ------- | ------------------- | ------------------------ | ----------- |
+| [0.1.24](https://central.sonatype.com/artifact/cloud.anypoint/mule-lettuce-redis-connector/0.1.24) | 4.6.0 | Java 8, Java 11, Java 17 | Latest release |
+
+## Requirements
+
+- **Mule Runtime**: 4.6.0 or later
+- **Java**: 8, 11, or 17
+- **Maven**: 3.9.8 or later
+- **Redis server**: Any version supporting the commands you use
+
+## Installation
+
+### Step 1: Add Maven Dependency
+
+Add the following dependency to your Mule application's `pom.xml`:
+
+```xml
+<dependency>
+    <groupId>cloud.anypoint</groupId>
+    <artifactId>mule-lettuce-redis-connector</artifactId>
+    <version>0.1.24</version>
+    <classifier>mule-plugin</classifier>
+</dependency>
+```
+
+### Step 2: Choose Your Configuration Type
+
+The connector provides two configuration elements. Use the one that matches your use case:
+
+| Configuration | XML element | Use for |
+|--------------|-------------|---------|
+| Standard | `lettuce-redis:config` | All operations (GET, SET, HSET, LPUSH, XADD, PUBLISH, Send Command, Search Operations, etc.) |
+| Pub/Sub | `lettuce-redis:pubsub-config` | Sources only (SUBSCRIBE and PSUBSCRIBE event listeners) |
+
+## Standard Configuration
+
+Use `lettuce-redis:config` for all regular operations. This covers every command in the Key/Value, Hash, List, Set, Sorted Set, Geospatial, Stream, and Channel categories, as well as Send Command and Search Operations.
+
+```xml
+<lettuce-redis:config name="Redis_Config">
+    <lettuce-redis:connection
+        host="redis.example.com"
+        port="6379"
+        tls="false"
+        password="${secure::redis.password}"/>
+</lettuce-redis:config>
+```
+
+### Connection Parameters
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `host` | String | Yes | — | Redis server hostname or IP address |
+| `tls` | boolean | Yes | — | Enable TLS/SSL encryption for the connection |
+| `port` | int | Yes | — | Redis server port (Redis default is 6379) |
+| `password` | String | Yes | — | Redis AUTH password. See note below about credential management. |
+| `commandTimeout` | Integer | No | — | Fixed timeout for all commands. Used together with `commandTimeoutUnit`. |
+| `commandTimeoutUnit` | TimeUnit | No | — | Time unit for `commandTimeout` (e.g., `MILLISECONDS`, `SECONDS`). Required when `commandTimeout` is set. |
+
+::: warning Password Is Required and Does Not Support DataWeave Expressions
+The `password` parameter currently accepts only a literal string or a Mule property placeholder. DataWeave expressions are not supported. Use Mule's secure configuration properties to keep credentials out of your flow XML.
+:::
+
+### Credential Management
+
+Always store the Redis password in a secure properties file rather than hardcoding it in your flow XML:
+
+**`src/main/resources/secure-config.yaml`** (encrypted, add to `.gitignore`):
+```yaml
+redis:
+  password: "your-redis-password"
+```
+
+**Global configuration** (or `src/main/mule/global.xml`):
+```xml
+<!-- Secure properties loader -->
+<secure-properties:config
+    name="Secure_Properties"
+    file="secure-config.yaml"
+    key="${encryption.key}"/>
+
+<!-- Redis configuration using secure property -->
+<lettuce-redis:config name="Redis_Config">
+    <lettuce-redis:connection
+        host="${redis.host}"
+        port="${redis.port}"
+        tls="${redis.tls}"
+        password="${secure::redis.password}"/>
+</lettuce-redis:config>
+```
+
+### Command Timeout Configuration
+
+To configure a fixed command timeout, provide both `commandTimeout` and `commandTimeoutUnit`:
+
+```xml
+<lettuce-redis:config name="Redis_Config">
+    <lettuce-redis:connection
+        host="redis.example.com"
+        port="6379"
+        tls="false"
+        password="${secure::redis.password}"
+        commandTimeout="5000"
+        commandTimeoutUnit="MILLISECONDS"/>
+</lettuce-redis:config>
+```
+
+Valid `commandTimeoutUnit` values: `NANOSECONDS`, `MICROSECONDS`, `MILLISECONDS`, `SECONDS`, `MINUTES`, `HOURS`, `DAYS`.
+
+### TLS Configuration
+
+To connect to a Redis server with TLS enabled, set `tls="true"`:
+
+```xml
+<lettuce-redis:config name="Redis_Config_TLS">
+    <lettuce-redis:connection
+        host="redis.example.com"
+        port="6380"
+        tls="true"
+        password="${secure::redis.password}"/>
+</lettuce-redis:config>
+```
+
+---
+
+## Pub/Sub Configuration
+
+Use `lettuce-redis:pubsub-config` **only** for the SUBSCRIBE and PSUBSCRIBE sources (event listeners). This is a separate configuration element from the standard one.
+
+```xml
+<lettuce-redis:pubsub-config name="Redis_PubSub_Config">
+    <lettuce-redis:pubsub-connection
+        host="redis.example.com"
+        port="6379"
+        tls="false"
+        password="${secure::redis.password}"/>
+</lettuce-redis:pubsub-config>
+```
+
+::: tip Why a Separate Configuration?
+Redis Pub/Sub requires a different underlying connection type than regular commands. In the Lettuce client, these are `StatefulRedisConnection` (standard) and `StatefulRedisPubSubConnection` (pub/sub) — they are not interchangeable. The connector uses separate config elements to make this distinction explicit and prevent misconfiguration.
+:::
+
+**Connection parameters are identical** to the standard configuration — same host, port, tls, password, and timeout options.
+
+### PUBLISH vs SUBSCRIBE
+
+| Operation | Configuration to use |
+|-----------|---------------------|
+| `PUBLISH` (sending messages) | `lettuce-redis:config` (standard) |
+| `SUBSCRIBE` source (receiving messages) | `lettuce-redis:pubsub-config` |
+| `PSUBSCRIBE` source (pattern listening) | `lettuce-redis:pubsub-config` |
+
+---
+
+## Using Both Configurations in the Same Application
+
+Applications that both publish and subscribe to Redis channels need both configurations:
+
+```xml
+<!-- Standard config — used by PUBLISH, GET, SET, and all other operations -->
+<lettuce-redis:config name="Redis_Config">
+    <lettuce-redis:connection
+        host="${redis.host}"
+        port="${redis.port}"
+        tls="${redis.tls}"
+        password="${secure::redis.password}"/>
+</lettuce-redis:config>
+
+<!-- Pub/Sub config — used only by SUBSCRIBE and PSUBSCRIBE sources -->
+<lettuce-redis:pubsub-config name="Redis_PubSub_Config">
+    <lettuce-redis:pubsub-connection
+        host="${redis.host}"
+        port="${redis.port}"
+        tls="${redis.tls}"
+        password="${secure::redis.password}"/>
+</lettuce-redis:pubsub-config>
+
+<!-- Flow that subscribes and re-publishes to another channel -->
+<flow name="message-relay">
+    <lettuce-redis:subscribe-channel
+        config-ref="Redis_PubSub_Config"
+        channels="#[['input-channel']]"/>
+
+    <logger level="INFO" message="Received: #[payload] on #[attributes.channel]"/>
+
+    <lettuce-redis:publish
+        config-ref="Redis_Config"
+        channel="output-channel"
+        message="#[payload]"/>
+</flow>
+```
+
+## Next Steps
+
+- [Operations Reference](./operations/) — All available operations by category
+- [Sources (Listeners)](./sources) — Setting up Pub/Sub event-driven flows
+- [GitHub Repository](https://github.com/anypointcloud/mule-lettuce-redis-connector) — Source code and issues
diff --git a/docs/connectors/mule-lettuce-redis-connector/sources.md b/docs/connectors/mule-lettuce-redis-connector/sources.md
new file mode 100644
index 0000000..21bde13
--- /dev/null
+++ b/docs/connectors/mule-lettuce-redis-connector/sources.md
@@ -0,0 +1,242 @@
+---
+title: Sources (Listeners)
+description: Real-time Redis Pub/Sub event listeners for Mule flows using SUBSCRIBE and PSUBSCRIBE.
+---
+
+# Sources (Listeners)
+
+## What Are Sources?
+
+In the Mule SDK, a *source* is an event listener — a component that sits at the beginning of a flow and triggers it when something happens externally. Unlike operations (which your flow calls), sources wait and react.
+
+Redis Pub/Sub lets applications publish messages to channels and receive them in real time. The connector exposes two sources:
+
+| Source | Redis Command | Use when |
+|--------|--------------|----------|
+| SUBSCRIBE | SUBSCRIBE | You know the exact channel names to listen on |
+| PSUBSCRIBE | PSUBSCRIBE | You want to match channels by glob pattern (e.g., `user:*:events`) |
+
+Each message published to a subscribed channel or matching pattern triggers one Mule event through the connected flow.
+
+::: tip Pub/Sub Is Fire-and-Forget
+If no subscriber is listening when a message is published, the message is lost. Redis Pub/Sub is not a message queue — it does not persist messages. For durable messaging, consider Redis Streams (XADD/XREADGROUP) instead.
+:::
+
+## Prerequisites
+
+Sources require the **Pub/Sub configuration** (`lettuce-redis:pubsub-config`), not the standard configuration. See [Set Up](./set-up#pub-sub-configuration) for how to create it and why it must be separate.
+
+```xml
+<lettuce-redis:pubsub-config name="Redis_PubSub_Config">
+    <lettuce-redis:pubsub-connection
+        host="${redis.host}"
+        port="${redis.port}"
+        tls="${redis.tls}"
+        password="${secure::redis.password}"/>
+</lettuce-redis:pubsub-config>
+```
+
+---
+
+## SUBSCRIBE
+
+### What It Does
+
+SUBSCRIBE listens on one or more **exact** channel names. Every message published to any of those channels triggers one Mule event with the message as the payload.
+
+### Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `channels` | List\<String\> | Yes | One or more exact channel names to subscribe to |
+
+### Output
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `payload` | String | The message content |
+| `attributes.channel` | String | The channel the message was received on |
+
+### Example
+
+```xml
+<flow name="handle-notifications">
+    <!-- Listen for messages on the "notifications" channel -->
+    <lettuce-redis:subscribe-channel
+        config-ref="Redis_PubSub_Config"
+        channels="#[['notifications']]"/>
+
+    <!-- Log which channel the message came from -->
+    <logger
+        level="INFO"
+        message="Message on #[attributes.channel]: #[payload]"/>
+
+    <!-- Process the message -->
+    <flow-ref name="process-notification"/>
+</flow>
+```
+
+### Subscribing to Multiple Channels
+
+A single SUBSCRIBE source can listen on multiple channels at once:
+
+```xml
+<lettuce-redis:subscribe-channel
+    config-ref="Redis_PubSub_Config"
+    channels="#[['orders', 'inventory', 'pricing']]"/>
+```
+
+Use `attributes.channel` in a `<choice>` router to handle each channel differently:
+
+```xml
+<flow name="multi-channel-handler">
+    <lettuce-redis:subscribe-channel
+        config-ref="Redis_PubSub_Config"
+        channels="#[['orders', 'inventory', 'pricing']]"/>
+
+    <choice>
+        <when expression="#[attributes.channel == 'orders']">
+            <flow-ref name="handle-order"/>
+        </when>
+        <when expression="#[attributes.channel == 'inventory']">
+            <flow-ref name="handle-inventory-update"/>
+        </when>
+        <otherwise>
+            <flow-ref name="handle-pricing-update"/>
+        </otherwise>
+    </choice>
+</flow>
+```
+
+---
+
+## PSUBSCRIBE
+
+### What It Does
+
+PSUBSCRIBE subscribes to channels by **glob pattern** rather than exact name. Any channel whose name matches the pattern will deliver messages to the flow.
+
+Use PSUBSCRIBE when you need to listen on a family of related channels whose names are not known at design time, or when you want to avoid maintaining a large list of exact channel names.
+
+### Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `patterns` | List\<String\> | Yes | One or more glob patterns. Channels matching any pattern trigger the flow. |
+
+### Output
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `payload` | String | The message content |
+| `attributes.channel` | String | The actual channel name the message was received on (not the pattern) |
+
+### Pattern Matching Examples
+
+| Pattern | Matches | Does Not Match |
+|---------|---------|----------------|
+| `user:*` | `user:123`, `user:abc` | `order:123`, `users:123` |
+| `user:*:events` | `user:123:events`, `user:abc:events` | `user:events`, `user:123:logs` |
+| `*:updated` | `order:updated`, `product:updated` | `order:update`, `updated` |
+| `[io]*` | `orders`, `inventory` | `pricing`, `users` |
+| `h?llo` | `hello`, `hallo` | `heello`, `hllo` |
+
+::: tip Pattern Syntax
+Redis pattern matching supports `*` (any sequence of characters), `?` (any single character), and `[...]` (character classes), same as shell globbing.
+:::
+
+### Example
+
+```xml
+<flow name="handle-user-events">
+    <!-- Listen on any channel matching "user:*:events" -->
+    <lettuce-redis:subscribe-channel-pattern
+        config-ref="Redis_PubSub_Config"
+        patterns="#[['user:*:events']]"/>
+
+    <!-- attributes.channel contains the actual channel, e.g. "user:42:events" -->
+    <logger
+        level="INFO"
+        message="Event on #[attributes.channel]: #[payload]"/>
+
+    <!-- Extract user ID from the channel name -->
+    <set-variable
+        variableName="userId"
+        value="#[attributes.channel splitBy ':' then [1]]"/>
+
+    <flow-ref name="process-user-event"/>
+</flow>
+```
+
+### PSUBSCRIBE vs SUBSCRIBE
+
+| | SUBSCRIBE | PSUBSCRIBE |
+|--|-----------|------------|
+| Channel matching | Exact name | Glob pattern |
+| `attributes.channel` | The subscribed channel | The actual channel that matched |
+| Best for | Known, fixed channel names | Dynamic or family-of-channels scenarios |
+| Multiple channels? | Yes — list multiple names | Yes — list multiple patterns |
+
+---
+
+## Common Patterns
+
+### Publish and Subscribe in the Same Application
+
+PUBLISH uses the **standard** config; SUBSCRIBE/PSUBSCRIBE use the **pub/sub** config. Both can coexist in the same application:
+
+```xml
+<!-- Standard config for PUBLISH and all other operations -->
+<lettuce-redis:config name="Redis_Config">
+    <lettuce-redis:connection
+        host="${redis.host}"
+        port="${redis.port}"
+        tls="${redis.tls}"
+        password="${secure::redis.password}"/>
+</lettuce-redis:config>
+
+<!-- Pub/Sub config for listening -->
+<lettuce-redis:pubsub-config name="Redis_PubSub_Config">
+    <lettuce-redis:pubsub-connection
+        host="${redis.host}"
+        port="${redis.port}"
+        tls="${redis.tls}"
+        password="${secure::redis.password}"/>
+</lettuce-redis:pubsub-config>
+
+<!-- Flow that RECEIVES messages -->
+<flow name="message-receiver">
+    <lettuce-redis:subscribe-channel
+        config-ref="Redis_PubSub_Config"
+        channels="#[['incoming']]"/>
+    <logger level="INFO" message="Received: #[payload]"/>
+    <!-- Transform and re-publish -->
+    <lettuce-redis:publish
+        config-ref="Redis_Config"
+        channel="processed"
+        message="#[upper(payload)]"/>
+</flow>
+
+<!-- Flow that SENDS messages (triggered by HTTP, scheduler, etc.) -->
+<flow name="message-sender">
+    <http:listener config-ref="HTTP_Config" path="/send"/>
+    <lettuce-redis:publish
+        config-ref="Redis_Config"
+        channel="incoming"
+        message="#[payload]"/>
+</flow>
+```
+
+---
+
+## Important Notes
+
+- **Each source instance maintains its own dedicated Redis connection.** A Pub/Sub connection cannot be shared with regular operations — this is why the separate `lettuce-redis:pubsub-config` is required.
+- **Messages are fire-and-forget.** If the subscriber's flow is not running when a message is published, that message is lost.
+- **PUBLISH returns the subscriber count.** The output of the PUBLISH operation is a `Long` indicating how many subscribers received the message. A return value of `0` means no one was listening.
+- **Pattern subscription delivers the actual channel name**, not the pattern, in `attributes.channel`. If you subscribed with `user:*:events` and a message arrived on `user:42:events`, `attributes.channel` is `"user:42:events"`.
+
+## See Also
+
+- [Set Up — Pub/Sub Configuration](./set-up#pub-sub-configuration)
+- [Channel Operations — PUBLISH](./operations/channel#publish)