Contents

• • last_modified_at: “2026-10-04”
• RESP clients {#resp-clients}
  • Key and response contract {#key-and-response-contract}
  • AUTH {#auth}
  • TLS {#tls}
  • redis-cli {#redis-cli}
  • Go {#go}
  • Node.js (redis v4) {#nodejs}
  • Python (redis-py) {#python}
  • Errors and boundaries {#errors}
  • Demo cleanup {#stop-the-demo}

layout: doc lang: en translation_key: resp title: RESP clients description: Connect Redis-compatible clients to pg_local_cache with RESP2 MGET, token authentication, and native TLS. section: RESP permalink: /docs/resp.html redirect_from: - /docs/go.html - /docs/node-postgres.html

last_modified_at: “2026-10-04”

RESP clients {#resp-clients}

Connect Redis-compatible clients to read complete PostgreSQL rows by primary key. This page covers key encoding, authentication, response behavior, errors, and TLS.

CRUD:<db>.<schema>.<table>:<json pk>
CRUD:app.public.items:{"id":42}
CRUD:app.public.orders:{"tenant_id":7,"id":42}

The listener binds to loopback by default. With TLS off, a non-loopback plaintext listener requires pg_local_cache.allow_plaintext_network=on. Use the technical reference for listener and security settings.

redis-cli {#redis-cli}

Set PGLC_RESP_TOKEN to the configured token. The local quickstart also provides a demo token.

export REDISCLI_AUTH="$PGLC_RESP_TOKEN"
redis-cli -2 -h 127.0.0.1 -p 56379 MGET 'CRUD:pglc_demo.public.items:{"id":42}'
redis-cli -2 --tls --cacert ./ca.crt --cert ./client.crt --key ./client.key -h cache.example -p 6380 MGET 'CRUD:app.public.items:{"id":42}'

Go {#go}

Install github.com/redis/go-redis/v9. Set PGLC_RESP_TOKEN; the TLS form uses CA and client certificate files.

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/redis/go-redis/v9"
)

func main() {
    client := redis.NewClient(&redis.Options{
        Addr: "127.0.0.1:56379", Password: os.Getenv("PGLC_RESP_TOKEN"), Protocol: 2,
    })
    defer client.Close()
    rows, err := client.MGet(context.Background(), `CRUD:pglc_demo.public.items:{"id":42}`).Result()
    if err != nil {
        panic(err)
    }
    fmt.Printf("%v\n", rows)
}

TLS variant:

package main

import (
    "context"
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "os"

    "github.com/redis/go-redis/v9"
)

func main() {
    ca, err := os.ReadFile("./ca.crt")
    if err != nil { panic(err) }
    roots := x509.NewCertPool()
    if !roots.AppendCertsFromPEM(ca) { panic("invalid CA") }
    cert, err := tls.LoadX509KeyPair("./client.crt", "./client.key")
    if err != nil { panic(err) }
    client := redis.NewClient(&redis.Options{
        Addr: "cache.example:6380", Password: os.Getenv("PGLC_RESP_TOKEN"), Protocol: 2,
        TLSConfig: &tls.Config{MinVersion: tls.VersionTLS12, ServerName: "cache.example", RootCAs: roots, Certificates: []tls.Certificate{cert}},
    })
    defer client.Close()
    rows, err := client.MGet(context.Background(), `CRUD:app.public.items:{"id":42}`).Result()
    if err != nil { panic(err) }
    fmt.Printf("%v\n", rows)
}

Node.js (redis v4) {#nodejs}

Install with npm install redis@^4. Redis v4 uses RESP2 by default.

import { createClient } from 'redis';

const client = createClient({
  socket: { host: '127.0.0.1', port: 56379 },
  password: process.env.PGLC_RESP_TOKEN,
});
client.on('error', console.error);
await client.connect();
try {
  console.log(await client.mGet(['CRUD:pglc_demo.public.items:{"id":42}']));
} finally {
  await client.quit();
}

TLS variant:

import { readFileSync } from 'node:fs';
import { createClient } from 'redis';

const client = createClient({
  socket: {
    host: 'cache.example', port: 6380, tls: true, servername: 'cache.example',
    ca: [readFileSync('./ca.crt')],
    cert: readFileSync('./client.crt'), key: readFileSync('./client.key'),
  },
  password: process.env.PGLC_RESP_TOKEN,
});
client.on('error', console.error);
await client.connect();
try {
  console.log(await client.mGet(['CRUD:app.public.items:{"id":42}']));
} finally {
  await client.quit();
}

Python (redis-py) {#python}

Install with python -m pip install redis.

import os
import redis

client = redis.Redis(host="127.0.0.1", port=56379,
                     password=os.environ["PGLC_RESP_TOKEN"],
                     decode_responses=True, protocol=2)
print(client.execute_command('MGET', 'CRUD:pglc_demo.public.items:{"id":42}'))
client.close()

TLS variant:

import os
import redis

client = redis.Redis(host="cache.example", port=6380,
                     password=os.environ["PGLC_RESP_TOKEN"],
                     decode_responses=True, protocol=2, ssl=True,
                     ssl_ca_certs="./ca.crt", ssl_certfile="./client.crt",
                     ssl_keyfile="./client.key", ssl_cert_reqs="required",
                     ssl_check_hostname=True)
print(client.execute_command('MGET', 'CRUD:app.public.items:{"id":42}'))
client.close()

Errors and boundaries {#errors}

RESP uses a separate connection and does not participate in the caller’s SQL transaction. For SQL transactions, use PostgreSQL directly; see the invalidation guide.

Demo cleanup {#stop-the-demo}

docker compose -f examples/compose.yaml -f examples/compose.resp.yaml down

2.x SQL local_cache.mget(regclass, anyarray) was removed in 3.0.0; see the upgrade guide.