Valkey GLIDE

https://glide.valkey.io
Admin
Valkey GLIDE is an open-source, high-performance, multi-language client library for the Valkey...
Tokens:3,632,342
Snippets:26,035
Trust Score:9.8
Update:1 week ago
Show doc for...
Tokens:
Raw
### JsonBatch usage example with set and get

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/servermodules/JsonBatch.html

Shows how to create a Batch, add JSON commands (set and get) to it, execute the batch, and verify the results. The example asserts that the set command returns "OK" and the get command returns the stored JSON document.

```java
Batch batch = new Batch(true);
JsonBatch.set(batch, "doc", ".", "{\"a\": 1.0, \"b\": 2}");
JsonBatch.get(batch, "doc");
Object[] result = client.exec(batch, false).get();
assert result[0].equals("OK"); // result of JsonBatch.set()
assert result[1].equals("{\"a\": 1.0, \"b\": 2}"); // result of JsonBatch.get()
```

--------------------------------

### Install Valkey GLIDE for Go with go get

Source: https://glide.valkey.io/getting-started/quickstart?lang=go

Initializes a Go module if needed and installs the GLIDE Go client. Requires Go 1.22+.

```bash
# Initialize a new Go module (if needed)
go mod init your-project-name


# Install GLIDE
go get github.com/valkey-io/valkey-glide/go/v2
go mod tidy

```

--------------------------------

### Java: Full example

Source: https://glide.valkey.io/how-to/load-and-execute-functions

Complete Java example that defines, loads, and calls a Valkey Function using GLIDE. It includes imports, client setup, and the full workflow.

```java
import glide.api.GlideClient;
import glide.api.models.configuration.GlideClientConfiguration;
import glide.api.models.configuration.NodeAddress;


public class Example {
    public static void main(String[] args) {
        GlideClientConfiguration config = GlideClientConfiguration.builder()
            .address(NodeAddress.builder()
                .host("localhost")
                .port(6379)
                .build())
            .build();


        try (GlideClient client = GlideClient.createClient(config).get()) {
            // lua code that updates a key and returns its new value
            String luaCode = """
            #!lua name=page_visits
            server.register_function('update_visits', function(visits)
                server.call('INCR', visits[1])
                return server.call('GET', visits[1])
            end)
            """;


            // loading the function to valkey
            client.functionLoad(luaCode, true).get();


            client.set("page:home:visits", "0").get();
            // calling the previously loaded function
            Object result = client.fcall("update_visits",
                new String[]{"page:home:visits"}, new String[]{}).get();
            System.out.println(result);  // 1
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Python: Full example

Source: https://glide.valkey.io/how-to/load-and-execute-functions

Complete Python example that defines, loads, and calls a Valkey Function using GLIDE. It includes imports, client setup, and the full workflow.

```python
import asyncio
from glide import Script, GlideClient, GlideClientConfiguration, NodeAddress


async def main():
    config = GlideClientConfiguration(addresses=[NodeAddress("localhost", 6379)])
    client = await GlideClient.create(config)


    # lua code that updates a key and returns its new value
    lua_code = """#!lua name=page_visits
    server.register_function('update_visits', function(visits)
        server.call('INCR', visits[1])
        return server.call('GET', visits[1])
    end)
    """


    # loading the function to valkey
    await client.function_load(lua_code, replace=True)


    await client.set("page:home:visits", "0")
    # calling the previously loaded function
    result = await client.fcall("update_visits", keys=["page:home:visits"])
    print(result)  # b'1'


if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Create helloworld.py

Source: https://glide.valkey.io/tutorials/pubsub/pubsub-basics

Initial setup for the tutorial. Imports asyncio and GLIDE client classes, defines the main coroutine, and runs it.

```python
import asyncio
from glide import GlideClient, NodeAddress, GlideClientConfiguration


async def main():
    print("Starting Pub/Sub tutorial...")
    # Our code will go here


if __name__ == "__main__":
    asyncio.run(main())

```

--------------------------------

### Python: Full example

Source: https://glide.valkey.io/how-to/execute-custom-scripts

Complete Python example that connects to Valkey, defines a Lua script, and executes it.

```python
import asyncio
from glide import Script, GlideClient, GlideClientConfiguration, NodeAddress


async def main():
    config = GlideClientConfiguration(addresses=[NodeAddress("localhost", 6379)])
    client = await GlideClient.create(config)


    lua = """
    server.call('SET', KEYS[1], ARGV[1])
    return KEYS[1] .. ': ' .. server.call('GET', KEYS[1])
    """


    script = Script(lua)


    keys = ["username"]
    args = ["John Doe"]
    result = await client.invoke_script(script, keys=keys, args=args)
    print(result)


if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### sunion example

Source: https://glide.valkey.io/languages/nodejs/api/classes/GlideClient.GlideClient.html

Gets the union of all given sets. In cluster mode, all keys must map to the same hash slot. The example shows adding members to two sets, then getting the union and handling a non-existing set.

```javascript
await client.sadd("my_set1", ["member1", "member2"]);  
await client.sadd("my_set2", ["member2", "member3"]);  
const result1 = await client.sunion(["my_set1", "my_set2"]);  
console.log(result1);  
// Output: Set(3) {'member1', 'member2', 'member3'}  
// Sets `my_set1` and `my_set2` have three unique members.  
  
const result2 = await client.sunion(["my_set1", "non_existing_set"]);  
console.log(result2);  
// Output: Set(2) {'member1', 'member2'}
```

--------------------------------

### Java: Full example

Source: https://glide.valkey.io/how-to/execute-custom-scripts

Complete Java example that connects to Valkey, defines a Lua script, and executes it.

```java
import glide.api.GlideClient;
import glide.api.models.configuration.GlideClientConfiguration;
import glide.api.models.configuration.NodeAddress;
import glide.api.models.Script;
import glide.api.models.commands.ScriptOptions;


public class Example {
    public static void main(String[] args) {
        GlideClientConfiguration config = GlideClientConfiguration.builder()
            .address(NodeAddress.builder()
                .host("localhost")
                .port(6379)
                .build())
            .build();


        try (GlideClient client = GlideClient.createClient(config).get()) {
            String lua = """
            server.call('SET', KEYS[1], ARGV[1])
            return KEYS[1] .. ': ' .. server.call('GET', KEYS[1])
            """;


            Script script = new Script(lua, false);


            Object result = client.invokeScript(script,
                ScriptOptions.builder()
                    .key("username")
                    .arg("John Doe")
                    .build()).get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Get client name

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/ConnectionManagementCommands.html

Gets the name of the current connection. The example asserts the client name is not null.

```java
String clientName = client.clientGetName().get();
assert clientName != null;
```

--------------------------------

### Get client ID

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/ConnectionManagementCommands.html

Gets the current connection id. The example asserts the id is greater than 0.

```java
Long id = client.clientId().get();
assert id > 0;
```

--------------------------------

### config_set async usage example

Source: https://glide.valkey.io/languages/python/api/reference/glide/async_commands/standalone_commands

Shows how to set configuration parameters using the async config_set command. Passes a dictionary of parameter-value pairs and expects an OK response.

```python
>>> config_set({"timeout": "1000", "maxmemory": "1GB"})
    OK

```

--------------------------------

### Glide SET & GET

Source: https://glide.valkey.io/migration/java/redisson/command-comparison-redisson-glide

Glide example for SET and GET. Uses client.set() and client.get(). The `.get()` is required because Glide's get() returns a CompletableFuture<String>.

```java
// Set a key-value pair
client.set("key", "value");


// Retrieve the value
String value = client.get("key").get();  // value = "value"

```

--------------------------------

### Node: Full example

Source: https://glide.valkey.io/how-to/execute-custom-scripts

Complete Node.js example that connects to Valkey, defines a Lua script, and executes it.

```javascript
import {GlideClient, Script} from "@valkey/valkey-glide";


async function main() {
    const client = await GlideClient.createClient({
        addresses: [{host: "localhost", port: 6379}]
    });


    const lua = `
    server.call('SET', KEYS[1], ARGV[1])
    return KEYS[1] .. ': ' .. server.call('GET', KEYS[1])
    `;


    const script = new Script(lua);


    const keys = ["username"];
    const args = ["John Doe"];
    const result = await client.invokeScript(script, {keys, args});
    console.log(result);


    client.close();
}


main();
```

--------------------------------

### Ruby: Set up Valkey connection

Source: https://glide.valkey.io/getting-started/quickstart?lang=go

Creates a Valkey client in Ruby with host, port, timeout, SSL, and database selection. Use this to connect to Valkey.

```ruby
# Setting up connection configuration
client = Valkey.new(
  host: "localhost",
  port: 6379,
  # Request timeout (seconds)
  timeout: 5.0,
  # TLS configuration (if needed)
  ssl: false,
  # Database selection (0-15 for Redis/Valkey)
  db: 0
)
```

--------------------------------

### getCacheEvictions Example

Source: https://glide.valkey.io/languages/java/api/glide/api/BaseClient.html

Gets the total number of cache evictions. The example shows calling getCacheEvictions and printing the result.

```java
// Get cache evictions
Long evictions = client.getCacheEvictions().get();
System.out.println("Cache evictions: " + evictions);
```

--------------------------------

### getex(String key, GetExOptions options) example

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/StringBaseCommands.html

Retrieves the value of a key with options, using a String key and GetExOptions. The example first sets a key, then retrieves it with a 10-second expiry, and asserts the value.

```java
String response = client.set("key", "value").get();
assert response.equals(OK);
String value = client.getex("key", GetExOptions.Seconds(10L)).get();
assert value.equals("value");
```

--------------------------------

### getCacheMissRate Example

Source: https://glide.valkey.io/languages/java/api/glide/api/BaseClient.html

Gets the cache miss rate metric. The example shows calling getCacheMissRate and printing the result.

```java
// Get cache miss rate
Double missRate = client.getCacheMissRate().get();
System.out.println("Cache miss rate: " + missRate + "%");
```

--------------------------------

### FT.info example with FTInfoOptions

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/servermodules/FT.html

Shows how to call FT.info with a client, index name, and FTInfoOptions to get local index info.

```java
 // Get local index info:
 Map<String, Object> info = FT.info(client, "myIndex",
     new FTInfoOptions(FTInfoOptions.InfoScope.LOCAL)).get();
```

--------------------------------

### getCacheHitRate Example

Source: https://glide.valkey.io/languages/java/api/glide/api/BaseClient.html

Gets the cache hit rate metric. The example shows calling getCacheHitRate and printing the result.

```java
// Get cache hit rate
Double hitRate = client.getCacheHitRate().get();
System.out.println("Cache hit rate: " + hitRate + "%");
```

--------------------------------

### Full runnable example for custom root certificate

Source: https://glide.valkey.io/tutorials/tls

Complete example that loads a certificate, configures TLS and client, creates a GlideClient, and pings the server. Includes error handling and cleanup.

```python
import asyncio
from glide import (
    GlideClient,
    GlideClientConfiguration,
    NodeAddress,
    TlsAdvancedConfiguration,
    AdvancedGlideClientConfiguration
)


async def main_with_custom_cert():
    # Replace with your server's address and TLS port
    addresses = [NodeAddress(host="your-self-signed-server.example.com", port=6379)]


    # 1. Load the certificate as bytes
    cert_file_path = "/path/to/your/ca-cert.pem"
    try:
        with open(cert_file_path, "rb") as f:
            root_cert_bytes = f.read()
    except FileNotFoundError:
        print(f"Error: Certificate file not found at {cert_file_path}")
        return
    except Exception as e:
        print(f"Error reading certificate file: {e}")
        return


    # 2. Create TLS advanced configuration
    tls_config = TlsAdvancedConfiguration(root_pem_cacerts=root_cert_bytes)


    # 3. Create advanced client configuration
    advanced_config = AdvancedGlideClientConfiguration(
        tls_config=tls_config
    )


    # 4. Create main client configuration
    client_config = GlideClientConfiguration(
        addresses,
        use_tls=True,  # Don't forget this!
        advanced_configuration=advanced_config
    )


    try:
        # 5. Create the client
        client = await GlideClient.create(client_config)


        response = await client.ping()
        print(f"Connected successfully with custom cert! Server responded: {response}")


    except Exception as e:
        print(f"Failed to connect with custom cert: {e}")
    finally:
        if 'client' in locals() and client.is_connected():
            await client.close()


if __name__ == "__main__":
    asyncio.run(main_with_custom_cert())

```

--------------------------------

### getCacheEntryCount Example

Source: https://glide.valkey.io/languages/java/api/glide/api/BaseClient.html

Gets the current number of entries in the client-side cache. The example shows calling getCacheEntryCount and printing the result.

```java
// Get cache entry count
Long entryCount = client.getCacheEntryCount().get();
System.out.println("Cache entries: " + entryCount);
```

--------------------------------

### FT.explaincli usage example (String)

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/servermodules/FT.html

Example call to FT.explaincli with String arguments, asserting the returned execution plan as a String array.

```java
String[] result = FT.explaincli(client, "myIndex",  "@price:[0 10]").get();
 assert Arrays.equals(result, new String[]{
   "Field {",
   "  price",
   "  0",
   "  10",
   "}"
 });
```

--------------------------------

### Glide: Authentication during connection setup

Source: https://glide.valkey.io/migration/go/go-redis/command-comparison-go-redis-glide

Authentication is set in the client configuration during connection setup. The example shows creating a client with credentials.

```go
// During connection setup (recommended)
client, err := glide.NewClient(&config.ClientConfiguration{
    Addresses: []config.NodeAddress{
        {Host: "localhost", Port: 6379},
    },
    Credentials: &config.ServerCredentials{
        Username: "user",
        Password: "password",
    },
})


// Authentication is handled automatically during connection
```

--------------------------------

### xautoclaimJustId example with GlideString

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/StreamBaseCommands.html

Example of using xautoclaimJustId with GlideString arguments. The example asserts the returned array contains the next start ID, claimed IDs, and deleted IDs (for Valkey 7.0.0+).

```java
Object[] result = client.xautoclaimJustId(gs("my_stream"), gs("my_group"), gs("my_consumer"), 3_600_000L, gs("0-0"), 1L).get();
 assertEquals(zeroStreamId, result[0]);
 assertDeepEquals(new GlideString[] {streamid_0, streamid_1, streamid_3}, result[1]);
 assertDeepEquals(new Object[] {}, result[2]); // version 7.0.0 or above
```

--------------------------------

### Example Scenario: MGET and SET commands

Source: https://glide.valkey.io/languages/nodejs/api/interfaces/Commands.ClusterBatchRetryStrategy.html

Shows a batch of commands (MGET and SET) and the expected responses when keys are empty and when the slot is migrating, illustrating potential reordering due to retries.

```text
MGET key {key}:1  
SET key "value"
Copy
```

```text
[null, null]  
OK
Copy
```

```text
["value", null]  
OK
Copy
```

--------------------------------

### Start a local Valkey server with Docker

Source: https://glide.valkey.io/getting-started/quickstart?lang=node

Starts a Valkey Docker container named 'valkey-server' and verifies it's running with 'docker ps' before testing connectivity with 'docker exec valkey-server valkey-cli ping', which should output 'PONG'.

```bash
# Pull and run Valkey server
docker run -d --name valkey-server -p 6379:6379 valkey/valkey:latest


# Verify it's running
docker ps

```

```bash
docker exec valkey-server valkey-cli ping
# Expected output: PONG

```

--------------------------------

### Redisson SET & GET

Source: https://glide.valkey.io/migration/java/redisson/command-comparison-redisson-glide

Redisson example for SET and GET using RBucket. Uses `getBucket()` to obtain a bucket, `set()` to store a value, and `get()` to retrieve it. Includes an alternative one-liner approach.

```java
// Set a key-value pair
RBucket<String> bucket = redisson.getBucket("key");
bucket.set("value");


// Retrieve the value
String value = bucket.get(); // value = "value"


// Alternative approach
redisson.getBucket("key").set("value");
String value = redisson.getBucket("key").get(); // value = "value"

```

--------------------------------

### Full example: load and execute function in Ruby

Source: https://glide.valkey.io/how-to/load-and-execute-functions

Complete Ruby example that creates a Valkey client, defines a Lua script that increments a key and returns its new value, loads it, sets an initial value, calls the function, and closes the client.

```ruby
require "valkey"


client = Valkey.new(host: "localhost", port: 6379)


# lua code that updates a key and returns its new value
lua_code = <<~LUA
  #!lua name=page_visits
  server.register_function('update_visits', function(visits)
      server.call('INCR', visits[1])
      return server.call('GET', visits[1])
  end)
LUA


# loading the function to valkey
client.function_load(lua_code, replace: true)


client.set("page:home:visits", "0")
# calling the previously loaded function
result = client.fcall("update_visits", keys: ["page:home:visits"])
puts result  # 1


client.close
```

--------------------------------

### Get and delete key with getdel

Source: https://glide.valkey.io/languages/nodejs/api/classes/BaseClient.BaseClient.html

Example of getting a string value and deleting the key. Returns the value if the key exists, otherwise null.

```typescript
const result = client.getdel("key");  
console.log(result);  
// Output: 'value'  
  
const value = client.getdel("key");  // value is null
```

--------------------------------

### Json.arrtrim example with JSONPath and legacy path

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/servermodules/Json.html

Shows how to use Json.arrtrim with both JSONPath (starting with '$') and legacy path (not starting with '$'). For JSONPath, the result is an Object[] of new array lengths; for legacy path, the result is an integer. The example uses Json.set to initialize the document and asserts the returned lengths.

```java
Json.set(client, "doc", "$", "{[], [\"a\"], [\"a\", \"b\"], [\"a\", \"b\", \"c\"]}").get();
var res = Json.arrtrim(client, "doc", "$[*]", 0, 1).get();
assert Arrays.equals((Object[]) res, new Object[] { 0, 1, 2, 2 }); // New lengths of arrays after trimming

Json.set(client, "doc", "$", "{\"children\": [\"John\", \"Jack\", \"Tom\", \"Bob\", \"Mike\"]}").get();
res = Json.arrtrim(client, "doc", ".children", 0, 1).get();
assert res == 2; // new length after trimming
```

--------------------------------

### PHP: Full example of loading and calling a Valkey function

Source: https://glide.valkey.io/how-to/load-and-execute-functions

Complete PHP example that connects to Valkey, loads a Lua function that increments a key, sets an initial value, and calls the function. Prints the result.

```php
$client = new ValkeyGlide();
$client->connect(addresses: [['host' => 'localhost', 'port' => 6379]]);


// lua code that updates a key and returns its new value
$luaCode = <<<'LUA'
#!lua name=page_visits
server.register_function('update_visits', function(visits)
    server.call('INCR', visits[1])
    return server.call('GET', visits[1])
end)
LUA;


// loading the function to valkey
$client->functionLoad($luaCode, true);


$client->set('page:home:visits', '0');


// calling the previously loaded function
$result = $client->fcall('update_visits', ['page:home:visits']);
echo $result;  // 1
```

--------------------------------

### Start a local Valkey server with Docker

Source: https://glide.valkey.io/getting-started/quickstart?lang=go

Pulls and runs the latest Valkey server Docker image, then verifies it is running with docker ps.

```bash
# Pull and run Valkey server
docker run -d --name valkey-server -p 6379:6379 valkey/valkey:latest


# Verify it's running
docker ps

```

--------------------------------

### Go: Set up client configuration and create client

Source: https://glide.valkey.io/getting-started/quickstart?lang=go

Configures a Glide client in Go using the builder pattern and creates a client, handling errors. Use this to connect to Valkey.

```go
// Setting up connection configuration
host := "localhost"
port := 6379


config := config.NewClientConfiguration().
    WithAddress(&config.NodeAddress{Host: host, Port: port}).
    WithRequestTimeout(5 * time.Second).
    WithUseTLS(false).
    WithDatabaseId(0)


client, err := glide.NewClient(config)
if err != nil {
    fmt.Println("There was an error: ", err)
    return
}
```

--------------------------------

### go-redis: Authentication during connection setup and explicit Auth()

Source: https://glide.valkey.io/migration/go/go-redis/command-comparison-go-redis-glide

Authentication can be set in client options during connection setup or explicitly with rdb.Auth(). The example shows both approaches.

```go
// During connection setup
rdb := redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Username: "user",
    Password: "password",
})


// Or explicitly after connection
result, err := rdb.Auth(ctx, "password").Result()
if err != nil {
    panic(err)
}
fmt.Println(result) // "OK"
```

--------------------------------

### bitcount(String key, long start) example

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/BitmapBaseCommands.html

Counts set bits in the byte interval from the given start offset to the end. Available in Valkey 8.0 and above.

```java
 Long payload = client.bitcount("myKey1", 1).get();
 assert payload == 2L; // From the second to the last bytes of the string stored at "myKey1" are 2 set bits.
```

--------------------------------

### config_get usage example

Source: https://glide.valkey.io/languages/python/api/reference/glide/async_commands/cluster_commands

Shows how to retrieve configuration parameters using the config_get command. The first example uses a RandomNode route, the second uses the default routing. Output is a dictionary of bytes.

```python
>>> await client.config_get(["timeout"] , RandomNode())
    {b'timeout': b'1000'}
>>> await client.config_get(["timeout" , b"maxmemory"])
    {b'timeout': b'1000', b"maxmemory": b"1GB"}
```

--------------------------------

### Get value with expiration using getex

Source: https://glide.valkey.io/languages/nodejs/api/classes/BaseClient.BaseClient.html

Example of getting a key's value and setting its expiration using GETEX-style options. Available since Valkey 6.2.0.

```typescript
const result = await client.getex("key", {expiry: { type: TimeUnit.Seconds, count: 5 }});  
console.log(result);  
// Output: 'value'
```

--------------------------------

### FT.explain example

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/servermodules/FT.html

Parses a query and returns information about how it was parsed. Returns a String representing the execution plan. Example shows the expected result.

```java
String result = FT.explain(client, "myIndex", "@price:[0 10]").get();
 assert result.equals("Field {\n\tprice\n\t0\n\t10\n}");
```

--------------------------------

### FT.info example with default options

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/servermodules/FT.html

Shows how to call FT.info with a client and index name, and the structure of the returned data map.

```java
 // example of using the API:
 Map<String, Object> response = FT.info(client, "myIndex").get();
 // the response contains data in the following format:
 Map<String, Object> data = Map.of(
     "index_name", gs("myIndex"),
     "index_status", gs("AVAILABLE"),
     "key_type", gs("JSON"),
     "creation_timestamp", 1728348101728771L,
     "key_prefixes", new Object[] { gs("json:") },
     "num_indexed_vectors", 0L,
     "space_usage", 653471L,
     "num_docs", 0L,
     "vector_space_usage", 653471L,
     "index_degradation_percentage", 0L,
     "fulltext_space_usage", 0L,
     "current_lag", 0L,
     "fields", new Object [] {
         Map.of(
             gs("identifier"), gs("$.vec"),
             gs("type"), gs("VECTOR"),
             gs("field_name"), gs("VEC"),
             gs("option"), gs(""),
             gs("vector_params", Map.of(
                 gs("data_type", gs("FLOAT32"),
                 gs("initial_capacity", 1000L,
                 gs("current_capacity", 1000L,
                 gs("distance_metric", gs("L2"),
                 gs("dimension", 6L,
                 gs("block_size", 1024L,
                 gs("algorithm", gs("FLAT")
             )
         ),
         Map.of(
             gs("identifier"), gs("name"),
             gs("type"), gs("TEXT"),
             gs("field_name"), gs("name"),
             gs("option"), gs("")
         ),
     }
 );

```

--------------------------------

### xautoclaimJustId example

Source: https://glide.valkey.io/languages/nodejs/api/classes/GlideClient.GlideClient.html

Transfers ownership of pending stream entries. The example claims up to 25 entries with a minimum idle time of 42 milliseconds, starting from ID "0-0". The output shows the next start ID, claimed entry IDs, and (on Valkey 7.0.0+) IDs of deleted messages.

```typescript
const result = await client.xautoclaim("myStream", "myGroup", "myConsumer", 42, "0-0", { count: 25 });  
console.log(result);  
// Output:  
// [  
//     "1609338788321-0",                // value to be used as `start` argument  
//                                       // for the next `xautoclaim` call  
//     [  
//         "1609338752495-0",            // claimed entries  
//         "1609338752495-1",  
//     ],  
//     [  
//         "1594324506465-0",            // array of IDs of deleted messages,  
//         "1594568784150-0"             // included in the response only on valkey 7.0.0 and above  
//     ]  
// ]
```

--------------------------------

### info() example

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/ServerManagementClusterCommands.html

Example of calling info() without arguments, which uses the default InfoOptions.Section.DEFAULT and routes to all primary nodes. The result is a ClusterValue<String> with a multi-value map of node addresses to info strings.

```java
ClusterValue<String> payload = clusterClient.info().get();
 // By default, the command is sent to multiple nodes, expecting a MultiValue result.
 for (Map.Entry<String, String> entry : payload.getMultiValue().entrySet()) {
     System.out.println("Node [" + entry.getKey() + "]: " + entry.getValue());
 }

```

--------------------------------

### go-redis cluster connection setup

Source: https://glide.valkey.io/migration/go/go-redis/connection-setup

Shows how to create a go-redis cluster client, both simple and with options. The simple connection uses redis.NewClusterClient with Addrs, and the options version adds Username and Password.

```go
import (
    "github.com/redis/go-redis/v9"
)


cluster := redis.NewClusterClient(&redis.ClusterOptions{
    Addrs: []string{"127.0.0.1:6379", "127.0.0.1:6380"},
})


// With options
clusterWithOptions := redis.NewClusterClient(&redis.ClusterOptions{
    Addrs:    []string{"127.0.0.1:6379", "127.0.0.1:6380"},
    Username: "user",
    Password: "password",
})
```

--------------------------------

### bitcount(GlideString key, long start) example

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/BitmapBaseCommands.html

Counts set bits in the byte interval from the given start offset using the GlideString overload. Available in Valkey 8.0 and above.

```java
 Long payload = client.bitcount(gs("myKey1"), 1).get();
 assert payload == 2L; // From the second to the last bytes of the string stored at "myKey1" are 2 set bits.
```

--------------------------------

### Run hello_world.py and expected output

Source: https://glide.valkey.io/tutorials/lua-scripting/lua-scripting-basics

Command to run the Python script and the expected output showing a successful connection to Valkey.

```bash
$ python hello_world.py
Starting the GLIDE Lua tutorial...
Successfully connected to Valkey.
Connection closed.

```

--------------------------------

### GlideJson.arrindex example

Source: https://glide.valkey.io/languages/nodejs/api/classes/server-modules_GlideJson.GlideJson.html

Searches for the first occurrence of a scalar value in JSON arrays at a path. The example uses a JSONPath with start and end options, and the output shows the indices found.

```typescript
await GlideJson.set(client, "doc", "$", '{"a": ["value", 3], "b": {"a": [3, ["value", false], 5]}}');  
console.log(await GlideJson.arrindex(client, "doc", "$..a", 3, { start: 3, end: 3 }); // Output: [2, -1]
```

--------------------------------

### Go: Define Lua script, load function, and call it

Source: https://glide.valkey.io/how-to/load-and-execute-functions

Step-by-step Go example: define a Lua script that sets and gets a key, load it with FunctionLoad, then call it with FCallWithKeysAndArgs. Includes error handling.

```go
luaCode := `#!lua name=example_module
server.register_function('set_then_get', function(key, value)
   server.call('SET', key, value)
   return server.call('GET', key)
end)
`
```

```go
_, err := client.FunctionLoad(ctx, luaCode, true)
if err != nil {
    // handle error
}
```

```go
_, err = client.Set(ctx, "page:home:visits", "0")
if err != nil {
    // handle error
}
result, err := client.FCallWithKeysAndArgs(ctx, "set_then_get",
    []string{"page:home:visits"}, []string{"1"})
if err != nil {
    // handle error
}
fmt.Println(result)  // 1
```

--------------------------------

### sinter example

Source: https://glide.valkey.io/languages/python/api/reference/glide_sync/sync_commands

Example usage of the sinter command. It adds members to two sets, then gets their intersection. The output shows the common member and the result when one set does not exist.

```python
>>> client.sadd("my_set1", ["member1", "member2"])
>>> client.sadd("my_set2", ["member2", "member3"])
>>> client.sinter(["my_set1", "my_set2"])
     {b"member2"} # sets "my_set1" and "my_set2" have one commom member
>>> client.sinter([my_set1", "non_existing_set"])
    None

```

--------------------------------

### createClient Example - Connecting to a Standalone Server

Source: https://glide.valkey.io/languages/nodejs/api/classes/GlideClient.GlideClient.html

Shows how to create a GlideClient instance and connect to a standalone Valkey server using the static createClient method. Includes configuration for addresses, database, credentials, TLS, backoff, and pub/sub subscriptions.

```typescript
// Connecting to a Standalone Server  
import { GlideClient, GlideClientConfiguration } from '@valkey/valkey-glide';  
  
const client = await GlideClient.createClient({  
  addresses: [  
    { host: 'primary.example.com', port: 6379 },  
    { host: 'replica1.example.com', port: 6379 },  
  ],  
  databaseId: 1,  
  credentials: {  
    username: 'user1',  
    password: 'passwordA',  
  },  
  useTLS: true,  
  connectionBackoff: {  
    numberOfRetries: 5,  
    factor: 1000,  
    exponentBase: 2,  
    jitter: 20,  
  },  
  pubsubSubscriptions: {  
    channelsAndPatterns: {  
      [GlideClientConfiguration.PubSubChannelModes.Exact]: new Set(['updates']),  
    },  
    callback: (msg) => {  
      console.log(`Received message: ${msg.payload}`);  
    },  
  },  
});
```

--------------------------------

### aclSetUser example

Source: https://glide.valkey.io/languages/java/api/glide/api/commands/ServerManagementCommands.html

Creates or modifies an ACL user with the given rules. The example sets user1 to be on, allow GET, and access all keys. Returns "OK" on success.

```java
String result = client.aclSetUser("user1", new String[] {"on", "+get", "~*"}).get();
assert result.equals("OK");
```

--------------------------------

### redis-py cluster connection setup

Source: https://glide.valkey.io/migration/python/redis-py

Shows how to create a RedisCluster client with startup nodes and optional password and decode_responses.

```python
from redis.cluster import RedisCluster


# Simple connection
rc = RedisCluster(
    startup_nodes=[
        {"host": "127.0.0.1", "port": 6379},
        {"host": "127.0.0.1", "port": 6380}
    ],
    decode_responses=True
)


# With options
rc_with_options = RedisCluster(
    startup_nodes=[
        {"host": "127.0.0.1", "port": 6379},
        {"host": "127.0.0.1", "port": 6380}
    ],
    password="password",
    decode_responses=True
)

```
Tokens:
Raw