PHPackages                             turbo124/predis - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Caching](/categories/caching)
4. /
5. turbo124/predis

ActiveLibrary[Caching](/categories/caching)

turbo124/predis
===============

A flexible and feature-complete Redis client for PHP.

v2.0.3(3y ago)095.6k—0%MITPHPPHP ^7.2 || ^8.0

Since Dec 11Pushed 2y agoCompare

[ Source](https://github.com/turbo124/predis)[ Packagist](https://packagist.org/packages/turbo124/predis)[ Docs](http://github.com/predis/predis)[ GitHub Sponsors](https://github.com/sponsors/tillkruss)[ RSS](/packages/turbo124-predis/feed)WikiDiscussions main Synced today

READMEChangelog (1)Dependencies (1)Versions (47)Used By (0)

Predis
======

[](#predis)

[![Software license](https://camo.githubusercontent.com/f02905c4b79bffa5fcb2896bae7a4db6b12e9cf794765eac43f807c1e087d504/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f6c6963656e73652f7072656469732f7072656469732e7376673f7374796c653d666c61742d737175617265)](LICENSE)[![Latest stable](https://camo.githubusercontent.com/c15da8927bcc1f91d8e2e3bf994b1c25628f5b282b5e9c41d4599d23e3abebcc/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f762f7461672f7072656469732f7072656469733f6c6162656c3d737461626c65267374796c653d666c61742d737175617265)](https://github.com/predis/predis/releases)[![Latest development](https://camo.githubusercontent.com/94bd5919545a80c5b95520185476d6e35f1518d59e7db490fe4403921f7ee457/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f762f7461672f7072656469732f7072656469733f696e636c7564655f70726572656c6561736573266c6162656c3d7072652d72656c65617365267374796c653d666c61742d737175617265)](https://github.com/predis/predis/releases)[![Monthly installs](https://camo.githubusercontent.com/972f1b6a8e21969ffc8a2b3b03d0c0b9d1beea532fd20270c87ef1d7e57d1d56/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f646d2f7072656469732f7072656469732e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/predis/predis/stats)[![Build status](https://camo.githubusercontent.com/245d1c29be544492c1e4dd3044338e19f655fde8a6d36ec78e848f7fbf4e00b3/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f7072656469732f7072656469732f74657374732e796d6c3f6272616e63683d6d61696e267374796c653d666c61742d737175617265)](https://github.com/predis/predis/actions)[![Coverage Status](https://camo.githubusercontent.com/e795c7af1242331e1ba5a5a811d984954ce23bc236d2e349dedbf668b0aeae67/68747470733a2f2f696d672e736869656c64732e696f2f636f766572616c6c73436f7665726167652f6769746875622f7072656469732f7072656469733f7374796c653d666c61742d737175617265)](https://coveralls.io/github/predis/predis)

A flexible and feature-complete [Redis](http://redis.io) client for PHP 7.2 and newer.

More details about this project can be found on the [frequently asked questions](FAQ.md).

Main features
-------------

[](#main-features)

- Support for Redis from **3.0** to **7.0**.
- Support for clustering using client-side sharding and pluggable keyspace distributors.
- Support for [redis-cluster](http://redis.io/topics/cluster-tutorial) (Redis &gt;= 3.0).
- Support for master-slave replication setups and [redis-sentinel](http://redis.io/topics/sentinel).
- Transparent key prefixing of keys using a customizable prefix strategy.
- Command pipelining on both single nodes and clusters (client-side sharding only).
- Abstraction for Redis transactions (Redis &gt;= 2.0) and CAS operations (Redis &gt;= 2.2).
- Abstraction for Lua scripting (Redis &gt;= 2.6) and automatic switching between `EVALSHA` or `EVAL`.
- Abstraction for `SCAN`, `SSCAN`, `ZSCAN` and `HSCAN` (Redis &gt;= 2.8) based on PHP iterators.
- Connections are established lazily by the client upon the first command and can be persisted.
- Connections can be established via TCP/IP (also TLS/SSL-encrypted) or UNIX domain sockets.
- Support for custom connection classes for providing different network or protocol backends.
- Flexible system for defining custom commands and override the default ones.

How to *install* and use Predis
-------------------------------

[](#how-to-install-and-use-predis)

This library can be found on [Packagist](http://packagist.org/packages/predis/predis) for an easier management of projects dependencies using [Composer](http://packagist.org/about-composer). Compressed archives of each release are [available on GitHub](https://github.com/predis/predis/releases).

```
composer require predis/predis
```

### Loading the library

[](#loading-the-library)

Predis relies on the autoloading features of PHP to load its files when needed and complies with the [PSR-4 standard](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md). Autoloading is handled automatically when dependencies are managed through Composer, but it is also possible to leverage its own autoloader in projects or scripts lacking any autoload facility:

```
// Prepend a base path if Predis is not available in your "include_path".
require 'Predis/Autoloader.php';

Predis\Autoloader::register();
```

### Connecting to Redis

[](#connecting-to-redis)

When creating a client instance without passing any connection parameter, Predis assumes `127.0.0.1`and `6379` as default host and port. The default timeout for the `connect()` operation is 5 seconds:

```
$client = new Predis\Client();
$client->set('foo', 'bar');
$value = $client->get('foo');
```

Connection parameters can be supplied either in the form of URI strings or named arrays. The latter is the preferred way to supply parameters, but URI strings can be useful when parameters are read from non-structured or partially-structured sources:

```
// Parameters passed using a named array:
$client = new Predis\Client([
    'scheme' => 'tcp',
    'host'   => '10.0.0.1',
    'port'   => 6379,
]);

// Same set of parameters, passed using an URI string:
$client = new Predis\Client('tcp://10.0.0.1:6379');
```

Password protected servers can be accessed by adding `password` to the parameters set. When ACLs are enabled on Redis &gt;= 6.0, both `username` and `password` are required for user authentication.

It is also possible to connect to local instances of Redis using UNIX domain sockets, in this case the parameters must use the `unix` scheme and specify a path for the socket file:

```
$client = new Predis\Client(['scheme' => 'unix', 'path' => '/path/to/redis.sock']);
$client = new Predis\Client('unix:/path/to/redis.sock');
```

The client can leverage TLS/SSL encryption to connect to secured remote Redis instances without the need to configure an SSL proxy like stunnel. This can be useful when connecting to nodes running on various cloud hosting providers. Encryption can be enabled with using the `tls` scheme and an array of suitable [options](http://php.net/manual/context.ssl.php) passed via the `ssl` parameter:

```
// Named array of connection parameters:
$client = new Predis\Client([
  'scheme' => 'tls',
  'ssl'    => ['cafile' => 'private.pem', 'verify_peer' => true],
]);

// Same set of parameters, but using an URI string:
$client = new Predis\Client('tls://127.0.0.1?ssl[cafile]=private.pem&ssl[verify_peer]=1');
```

The connection schemes [`redis`](http://www.iana.org/assignments/uri-schemes/prov/redis) (alias of `tcp`) and [`rediss`](http://www.iana.org/assignments/uri-schemes/prov/rediss) (alias of `tls`) are also supported, with the difference that URI strings containing these schemes are parsed following the rules described on their respective IANA provisional registration documents.

The actual list of supported connection parameters can vary depending on each connection backend so it is recommended to refer to their specific documentation or implementation for details.

Predis can aggregate multiple connections when providing an array of connection parameters and the appropriate option to instruct the client about how to aggregate them (clustering, replication or a custom aggregation logic). Named arrays and URI strings can be mixed when providing configurations for each node:

```
$client = new Predis\Client([
    'tcp://10.0.0.1?alias=first-node', ['host' => '10.0.0.2', 'alias' => 'second-node'],
], [
    'cluster' => 'predis',
]);
```

See the [aggregate connections](#aggregate-connections) section of this document for more details.

Connections to Redis are lazy meaning that the client connects to a server only if and when needed. While it is recommended to let the client do its own stuff under the hood, there may be times when it is still desired to have control of when the connection is opened or closed: this can easily be achieved by invoking `$client->connect()` and `$client->disconnect()`. Please note that the effect of these methods on aggregate connections may differ depending on each specific implementation.

### Client configuration

[](#client-configuration)

Many aspects and behaviors of the client can be configured by passing specific client options to the second argument of `Predis\Client::__construct()`:

```
$client = new Predis\Client($parameters, ['prefix' => 'sample:']);
```

Options are managed using a mini DI-alike container and their values can be lazily initialized only when needed. The client options supported by default in Predis are:

- `prefix`: prefix string applied to every key found in commands.
- `exceptions`: whether the client should throw or return responses upon Redis errors.
- `connections`: list of connection backends or a connection factory instance.
- `cluster`: specifies a cluster backend (`predis`, `redis` or callable).
- `replication`: specifies a replication backend (`predis`, `sentinel` or callable).
- `aggregate`: configures the client with a custom aggregate connection (callable).
- `parameters`: list of default connection parameters for aggregate connections.
- `commands`: specifies a command factory instance to use through the library.

Users can also provide custom options with values or callable objects (for lazy initialization) that are stored in the options container for later use through the library.

### Aggregate connections

[](#aggregate-connections)

Aggregate connections are the foundation upon which Predis implements clustering and replication and they are used to group multiple connections to single Redis nodes and hide the specific logic needed to handle them properly depending on the context. Aggregate connections usually require an array of connection parameters along with the appropriate client option when creating a new client instance.

#### Cluster

[](#cluster)

Predis can be configured to work in clustering mode with a traditional client-side sharding approach to create a cluster of independent nodes and distribute the keyspace among them. This approach needs some sort of external health monitoring of nodes and requires the keyspace to be rebalanced manually when nodes are added or removed:

```
$parameters = ['tcp://10.0.0.1', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
$options    = ['cluster' => 'predis'];

$client = new Predis\Client($parameters);
```

Along with Redis 3.0, a new supervised and coordinated type of clustering was introduced in the form of [redis-cluster](http://redis.io/topics/cluster-tutorial). This kind of approach uses a different algorithm to distribute the keyspaces, with Redis nodes coordinating themselves by communicating via a gossip protocol to handle health status, rebalancing, nodes discovery and request redirection. In order to connect to a cluster managed by redis-cluster, the client requires a list of its nodes (not necessarily complete since it will automatically discover new nodes if necessary) and the `cluster`client options set to `redis`:

```
$parameters = ['tcp://10.0.0.1', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
$options    = ['cluster' => 'redis'];

$client = new Predis\Client($parameters, $options);
```

#### Replication

[](#replication)

The client can be configured to operate in a single master / multiple slaves setup to provide better service availability. When using replication, Predis recognizes read-only commands and sends them to a random slave in order to provide some sort of load-balancing and switches to the master as soon as it detects a command that performs any kind of operation that would end up modifying the keyspace or the value of a key. Instead of raising a connection error when a slave fails, the client attempts to fall back to a different slave among the ones provided in the configuration.

The basic configuration needed to use the client in replication mode requires one Redis server to be identified as the master (this can be done via connection parameters by setting the `role` parameter to `master`) and one or more slaves (in this case setting `role` to `slave` for slaves is optional):

```
$parameters = ['tcp://10.0.0.1?role=master', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
$options    = ['replication' => 'predis'];

$client = new Predis\Client($parameters, $options);
```

The above configuration has a static list of servers and relies entirely on the client's logic, but it is possible to rely on [`redis-sentinel`](http://redis.io/topics/sentinel) for a more robust HA environment with sentinel servers acting as a source of authority for clients for service discovery. The minimum configuration required by the client to work with redis-sentinel is a list of connection parameters pointing to a bunch of sentinel instances, the `replication` option set to `sentinel` and the `service` option set to the name of the service:

```
$sentinels = ['tcp://10.0.0.1', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
$options   = ['replication' => 'sentinel', 'service' => 'mymaster'];

$client = new Predis\Client($sentinels, $options);
```

If the master and slave nodes are configured to require an authentication from clients, a password must be provided via the global `parameters` client option. This option can also be used to specify a different database index. The client options array would then look like this:

```
$options = [
    'replication' => 'sentinel',
    'service' => 'mymaster',
    'parameters' => [
        'password' => $secretpassword,
        'database' => 10,
    ],
];
```

While Predis is able to distinguish commands performing write and read-only operations, `EVAL` and `EVALSHA` represent a corner case in which the client switches to the master node because it cannot tell when a Lua script is safe to be executed on slaves. While this is indeed the default behavior, when certain Lua scripts do not perform write operations it is possible to provide an hint to tell the client to stick with slaves for their execution:

```
$parameters = ['tcp://10.0.0.1?role=master', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
$options    = ['replication' => function () {
    // Set scripts that won't trigger a switch from a slave to the master node.
    $strategy = new Predis\Replication\ReplicationStrategy();
    $strategy->setScriptReadOnly($LUA_SCRIPT);

    return new Predis\Connection\Replication\MasterSlaveReplication($strategy);
}];

$client = new Predis\Client($parameters, $options);
$client->eval($LUA_SCRIPT, 0);             // Sticks to slave using `eval`...
$client->evalsha(sha1($LUA_SCRIPT), 0);    // ... and `evalsha`, too.
```

The [`examples`](examples/) directory contains a few scripts that demonstrate how the client can be configured and used to leverage replication in both basic and complex scenarios.

### Command pipelines

[](#command-pipelines)

Pipelining can help with performances when many commands need to be sent to a server by reducing the latency introduced by network round-trip timings. Pipelining also works with aggregate connections. The client can execute the pipeline inside a callable block or return a pipeline instance with the ability to chain commands thanks to its fluent interface:

```
// Executes a pipeline inside the given callable block:
$responses = $client->pipeline(function ($pipe) {
    for ($i = 0; $i < 1000; $i++) {
        $pipe->set("key:$i", str_pad($i, 4, '0', 0));
        $pipe->get("key:$i");
    }
});

// Returns a pipeline that can be chained thanks to its fluent interface:
$responses = $client->pipeline()->set('foo', 'bar')->get('foo')->execute();
```

### Transactions

[](#transactions)

The client provides an abstraction for Redis transactions based on `MULTI` and `EXEC` with a similar interface to command pipelines:

```
// Executes a transaction inside the given callable block:
$responses = $client->transaction(function ($tx) {
    $tx->set('foo', 'bar');
    $tx->get('foo');
});

// Returns a transaction that can be chained thanks to its fluent interface:
$responses = $client->transaction()->set('foo', 'bar')->get('foo')->execute();
```

This abstraction can perform check-and-set operations thanks to `WATCH` and `UNWATCH` and provides automatic retries of transactions aborted by Redis when `WATCH`ed keys are touched. For an example of a transaction using CAS you can see [the following example](examples/transaction_using_cas.php).

### Adding new commands

[](#adding-new-commands)

While we try to update Predis to stay up to date with all the commands available in Redis, you might prefer to stick with an old version of the library or provide a different way to filter arguments or parse responses for specific commands. To achieve that, Predis provides the ability to implement new command classes to define or override commands in the default command factory used by the client:

```
// Define a new command by extending Predis\Command\Command:
class BrandNewRedisCommand extends Predis\Command\Command
{
    public function getId()
    {
        return 'NEWCMD';
    }
}

// Inject your command in the current command factory:
$client = new Predis\Client($parameters, [
    'commands' => [
        'newcmd' => 'BrandNewRedisCommand',
    ],
]);

$response = $client->newcmd();
```

There is also a method to send raw commands without filtering their arguments or parsing responses. Users must provide the list of arguments for the command as an array, following the signatures as defined by the [Redis documentation for commands](http://redis.io/commands):

```
$response = $client->executeRaw(['SET', 'foo', 'bar']);
```

### Script commands

[](#script-commands)

While it is possible to leverage [Lua scripting](http://redis.io/commands/eval) on Redis 2.6+ using directly [`EVAL`](http://redis.io/commands/eval) and [`EVALSHA`](http://redis.io/commands/evalsha), Predis offers script commands as an higher level abstraction built upon them to make things simple. Script commands can be registered in the command factory used by the client and are accessible as if they were plain Redis commands, but they define Lua scripts that get transmitted to the server for remote execution. Internally they use [`EVALSHA`](http://redis.io/commands/evalsha) by default and identify a script by its SHA1 hash to save bandwidth, but [`EVAL`](http://redis.io/commands/eval)is used as a fall back when needed:

```
// Define a new script command by extending Predis\Command\ScriptCommand:
class ListPushRandomValue extends Predis\Command\ScriptCommand
{
    public function getKeysCount()
    {
        return 1;
    }

    public function getScript()
    {
        return  [
        'lpushrand' => 'ListPushRandomValue',
    ],
]);

$response = $client->lpushrand('random_values', $seed = mt_rand());
```

### Customizable connection backends

[](#customizable-connection-backends)

Predis can use different connection backends to connect to Redis. The builtin Relay integration leverages the [Relay](https://github.com/cachewerk/relay) extension for PHP for major performance gains, by caching a partial replica of the Redis dataset in PHP shared runtime memory.

```
$client = new Predis\Client('tcp://127.0.0.1', [
    'connections' => 'relay',
]);
```

Developers can create their own connection classes to support whole new network backends, extend existing classes or provide completely different implementations. Connection classes must implement `Predis\Connection\NodeConnectionInterface` or extend `Predis\Connection\AbstractConnection`:

```
class MyConnectionClass implements Predis\Connection\NodeConnectionInterface
{
    // Implementation goes here...
}

// Use MyConnectionClass to handle connections for the `tcp` scheme:
$client = new Predis\Client('tcp://127.0.0.1', [
    'connections' => ['tcp' => 'MyConnectionClass'],
]);
```

For a more in-depth insight on how to create new connection backends you can refer to the actual implementation of the standard connection classes available in the `Predis\Connection` namespace.

Development
-----------

[](#development)

### Reporting bugs and contributing code

[](#reporting-bugs-and-contributing-code)

Contributions to Predis are highly appreciated either in the form of pull requests for new features, bug fixes, or just bug reports. We only ask you to adhere to issue and pull request templates.

### Test suite

[](#test-suite)

**ATTENTION**: Do not ever run the test suite shipped with Predis against instances of Redis running in production environments or containing data you are interested in!

Predis has a comprehensive test suite covering every aspect of the library and that can optionally perform integration tests against a running instance of Redis (required &gt;= 2.4.0 in order to verify the correct behavior of the implementation of each command. Integration tests for unsupported Redis commands are automatically skipped. If you do not have Redis up and running, integration tests can be disabled. See [the tests README](tests/README.md) for more details about testing this library.

Predis uses GitHub Actions for continuous integration and the history for past and current builds can be found [on its actions page](https://github.com/predis/predis/actions).

### License

[](#license)

The code for Predis is distributed under the terms of the MIT license (see [LICENSE](LICENSE)).

###  Health Score

41

—

FairBetter than 89% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity28

Limited adoption so far

Community19

Small or concentrated contributor base

Maturity81

Battle-tested with a long release history

 Bus Factor1

Top contributor holds 88.2% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~107 days

Recently: every ~39 days

Total

39

Last Release

1137d ago

Major Versions

v0.8.7 → v1.0.02014-08-01

v0.8.x-dev → v1.0.22015-07-30

v1.1.10 → v2.0.0-beta.12022-05-26

v1.1.x-dev → v2.x-dev2023-02-08

PHP version history (4 changes)v0.7.0PHP &gt;=5.3.0

v0.8.0PHP &gt;=5.3.2

v1.1.0PHP &gt;=5.3.9

v2.0.0-beta.1PHP ^7.2 || ^8.0

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/5827962?v=4)[David Bomba](/maintainers/turbo124)[@turbo124](https://github.com/turbo124)

---

Top Contributors

[![nrk](https://avatars.githubusercontent.com/u/17923?v=4)](https://github.com/nrk "nrk (1957 commits)")[![tillkruss](https://avatars.githubusercontent.com/u/665029?v=4)](https://github.com/tillkruss "tillkruss (130 commits)")[![vladvildanov](https://avatars.githubusercontent.com/u/117659936?v=4)](https://github.com/vladvildanov "vladvildanov (46 commits)")[![srmklive](https://avatars.githubusercontent.com/u/839335?v=4)](https://github.com/srmklive "srmklive (9 commits)")[![GrahamCampbell](https://avatars.githubusercontent.com/u/2829600?v=4)](https://github.com/GrahamCampbell "GrahamCampbell (7 commits)")[![b1rdex](https://avatars.githubusercontent.com/u/312855?v=4)](https://github.com/b1rdex "b1rdex (7 commits)")[![Seldaek](https://avatars.githubusercontent.com/u/183678?v=4)](https://github.com/Seldaek "Seldaek (6 commits)")[![udat](https://avatars.githubusercontent.com/u/437040?v=4)](https://github.com/udat "udat (5 commits)")[![szepeviktor](https://avatars.githubusercontent.com/u/952007?v=4)](https://github.com/szepeviktor "szepeviktor (5 commits)")[![remicollet](https://avatars.githubusercontent.com/u/270445?v=4)](https://github.com/remicollet "remicollet (5 commits)")[![orvice](https://avatars.githubusercontent.com/u/1532235?v=4)](https://github.com/orvice "orvice (4 commits)")[![matthewbaggett](https://avatars.githubusercontent.com/u/943948?v=4)](https://github.com/matthewbaggett "matthewbaggett (4 commits)")[![zaherg](https://avatars.githubusercontent.com/u/27624?v=4)](https://github.com/zaherg "zaherg (3 commits)")[![franmomu](https://avatars.githubusercontent.com/u/720690?v=4)](https://github.com/franmomu "franmomu (3 commits)")[![thbourlove](https://avatars.githubusercontent.com/u/1768066?v=4)](https://github.com/thbourlove "thbourlove (3 commits)")[![Irvyne](https://avatars.githubusercontent.com/u/1851751?v=4)](https://github.com/Irvyne "Irvyne (2 commits)")[![Qusonann](https://avatars.githubusercontent.com/u/58689118?v=4)](https://github.com/Qusonann "Qusonann (2 commits)")[![raphaelstolt](https://avatars.githubusercontent.com/u/48225?v=4)](https://github.com/raphaelstolt "raphaelstolt (2 commits)")[![hannesvdvreken](https://avatars.githubusercontent.com/u/1410358?v=4)](https://github.com/hannesvdvreken "hannesvdvreken (2 commits)")[![abraovic](https://avatars.githubusercontent.com/u/5057523?v=4)](https://github.com/abraovic "abraovic (2 commits)")

---

Tags

redisnosqlpredis

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/turbo124-predis/health.svg)

```
[![Health](https://phpackages.com/badges/turbo124-predis/health.svg)](https://phpackages.com/packages/turbo124-predis)
```

###  Alternatives

[predis/predis

A flexible and feature-complete Redis/Valkey client for PHP.

7.7k299.5M2.1k](/packages/predis-predis)[snc/redis-bundle

A Redis bundle for Symfony

1.0k38.9M64](/packages/snc-redis-bundle)[predis/predis-async

Asynchronous version of Predis

371346.6k](/packages/predis-predis-async)[jamescauwelier/psredis

Sentinel client for the popular php redis client

78390.7k5](/packages/jamescauwelier-psredis)[cache/predis-adapter

A PSR-6 cache implementation using Redis (Predis). This implementation supports tags

242.5M13](/packages/cache-predis-adapter)[symfony-bundles/redis-bundle

Symfony Redis Bundle

271.1M5](/packages/symfony-bundles-redis-bundle)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)
