diff --git a/packages/core-kernel/src/contracts/core-kernel/cache.ts b/packages/core-kernel/src/contracts/core-kernel/cache.ts
index 84864f00e5..a6631f099f 100644
--- a/packages/core-kernel/src/contracts/core-kernel/cache.ts
+++ b/packages/core-kernel/src/contracts/core-kernel/cache.ts
@@ -1,51 +1,165 @@
-export interface ICacheStore {
+import { IApplication } from "./application";
+
+export interface ICacheStore<K, T> {
+    /**
+     * Create a new instance of the cache store.
+     *
+     * @param {IApplication} app
+     * @returns {ICacheStore<K, T>}
+     * @memberof ICacheStore
+     */
+    make(app: IApplication): Promise<ICacheStore<K, T>>;
+
+    /**
+     * Get all of the items in the cache.
+     *
+     * @returns {Array<[K, T]>}
+     * @memberof ICacheStore
+     */
+    all(): Promise<Array<[K, T]>>;
+
+    /**
+     * Get the keys of the cache items.
+     *
+     * @returns {K[]}
+     * @memberof ICacheStore
+     */
+    keys(): Promise<K[]>;
+
+    /**
+     * Get the values of the cache items.
+     *
+     * @returns {T[]}
+     * @memberof ICacheStore
+     */
+    values(): Promise<T[]>;
+
     /**
      * Retrieve an item from the cache by key.
+     *
+     * @param {K} key
+     * @returns {(T | undefined)}
+     * @memberof ICacheStore
      */
-    get(key: string): Promise<any>;
+    get(key: K): Promise<T | undefined>;
 
     /**
      * Retrieve multiple items from the cache by key.
+     *
+     * @param {K[]} keys
+     * @returns {(Array<T | undefined>)}
+     * @memberof ICacheStore
      */
-    many(keys: string[]): Promise<Record<string, any>>;
+    getMany(keys: K[]): Promise<Array<T | undefined>>;
 
     /**
-     * Store an item in the cache for a given number of milliseconds.
+     * Store an item in the cache for a given number of seconds.
+     *
+     * @param {K} key
+     * @param {T} value
+     * @param {number} seconds
+     * @returns {boolean}
+     * @memberof ICacheStore
      */
-    put(key: string, value: any, ttl?: number): Promise<void>;
+    put(key: K, value: T, seconds: number): Promise<boolean>;
 
     /**
-     * Store multiple items in the cache for a given number of milliseconds.
+     * Store multiple items in the cache for a given number of seconds.
+     *
+     * @param {Array<[K, T]>} values
+     * @param {number} seconds
+     * @returns {boolean[]}
+     * @memberof ICacheStore
      */
-    putMany(values: string[], ttl?: number): Promise<void>;
+    putMany(values: Array<[K, T]>, seconds: number): Promise<boolean[]>;
 
     /**
-     * Increment the value of an item in the cache.
+     * Determine if an item exists in the cache.
+     *
+     * @param {K} key
+     * @returns {boolean}
+     * @memberof ICacheStore
      */
-    increment(key: string, value: number): Promise<void>;
+    has(key: K): Promise<boolean>;
 
     /**
-     * Decrement the value of an item in the cache.
+     * Determine multiple items exist in the cache.
+     *
+     * @param {K[]} keys
+     * @returns {boolean[]}
+     * @memberof ICacheStore
      */
-    decrement(key: string, value: number): Promise<void>;
+    hasMany(keys: K[]): Promise<boolean[]>;
 
     /**
-     * Check if an item exists in the cache by key.
+     * Determine if an item doesn't exist in the cache.
+     *
+     * @param {K} key
+     * @returns {boolean}
+     * @memberof ICacheStore
      */
-    has(key: string): Promise<boolean>;
+    missing(key: K): Promise<boolean>;
+
+    /**
+     * Determine multiple items don't exist in the cache.
+     *
+     * @param {K[]} keys
+     * @returns {boolean[]}
+     * @memberof ICacheStore
+     */
+    missingMany(keys: K[]): Promise<boolean[]>;
 
     /**
      * Store an item in the cache indefinitely.
+     *
+     * @param {K} key
+     * @param {T} value
+     * @returns {boolean}
+     * @memberof ICacheStore
+     */
+    forever(key: K, value: T): Promise<boolean>;
+
+    /**
+     * Store multiple items in the cache indefinitely.
+     *
+     * @param {Array<[K, T]>} values
+     * @param {T} value
+     * @returns {boolean[]}
+     * @memberof ICacheStore
      */
-    forever(key: string, value: string): Promise<void>;
+    foreverMany(values: Array<[K, T]>, value: T): Promise<boolean[]>;
 
     /**
      * Remove an item from the cache.
+     *
+     * @param {K} key
+     * @returns {boolean}
+     * @memberof ICacheStore
      */
-    forget(key: string): Promise<void>;
+    forget(key: K): Promise<boolean>;
+
+    /**
+     * Remove multiple items from the cache.
+     *
+     * @param {K[]} keys
+     * @returns {boolean[]}
+     * @memberof ICacheStore
+     */
+    forgetMany(keys: K[]): Promise<boolean[]>;
 
     /**
      * Remove all items from the cache.
+     *
+     * @returns {boolean}
+     * @memberof ICacheStore
+     */
+    flush(): Promise<boolean>;
+
+    /**
+     * Get the cache key prefix.
+     *
+     * @returns {string}
+     * @memberof ICacheStore
      */
-    flush(): Promise<void>;
+    getPrefix(): Promise<string>;
 }
diff --git a/packages/core-kernel/src/errors.ts b/packages/core-kernel/src/errors.ts
index f495898fe7..3c99f7e22e 100644
--- a/packages/core-kernel/src/errors.ts
+++ b/packages/core-kernel/src/errors.ts
@@ -225,3 +225,19 @@ export class FailedDependencySatisfaction extends KernelError {
         super(`Expected "${dep}" to satisfy "${expected}" but received "${given}".`);
     }
 }
+
+/**
+ * @export
+ * @class NotImplementedError
+ * @extends {KernelError}
+ */
+export class NotImplementedError extends KernelError {
+    /**
+     * @param {string} klass
+     * @param {string} method
+     * @memberof NotImplementedError
+     */
+    constructor(klass: string, method: string) {
+        super(`Method [${method}] is not implemented in [${klass}].`);
+    }
+}
diff --git a/packages/core-kernel/src/services/cache/adapters/memory.ts b/packages/core-kernel/src/services/cache/adapters/memory.ts
new file mode 100644
index 0000000000..41f2be8496
--- /dev/null
+++ b/packages/core-kernel/src/services/cache/adapters/memory.ts
@@ -0,0 +1,225 @@
+import { IApplication } from "../../../contracts/core-kernel";
+import { ICacheStore } from "../../../contracts/core-kernel/cache";
+import { NotImplementedError } from "../../../errors";
+
+/**
+ * @export
+ * @class MemoryStore
+ * @implements {ICacheStore}
+ */
+export class MemoryStore<K, T> implements ICacheStore<K, T> {
+    /**
+     * @private
+     * @type {Map<K, T>}
+     * @memberof MemoryStore
+     */
+    private readonly store: Map<K, T> = new Map<K, T>();
+
+    /**
+     * Create a new instance of the cache store.
+     *
+     * @param {IApplication} app
+     * @returns {ICacheStore<K, T>}
+     * @memberof ICacheStore
+     */
+    public async make(app: IApplication): Promise<ICacheStore<K, T>> {
+        return this;
+    }
+
+    /**
+     * Get all of the items in the cache.
+     *
+     * @returns {Array<[K, T]>}
+     * @memberof MemoryStore
+     */
+    public async all(): Promise<Array<[K, T]>> {
+        return Array.from(this.store.entries());
+    }
+
+    /**
+     * Get the keys of the cache items.
+     *
+     * @returns {K[]}
+     * @memberof MemoryStore
+     */
+    public async keys(): Promise<K[]> {
+        return Array.from(this.store.keys());
+    }
+
+    /**
+     * Get the values of the cache items.
+     *
+     * @returns {T[]}
+     * @memberof MemoryStore
+     */
+    public async values(): Promise<T[]> {
+        return Array.from(this.store.values());
+    }
+
+    /**
+     * Retrieve an item from the cache by key.
+     *
+     * @param {K} key
+     * @returns {(T | undefined)}
+     * @memberof MemoryStore
+     */
+    public async get(key: K): Promise<T | undefined> {
+        return this.store.get(key);
+    }
+
+    /**
+     * Retrieve multiple items from the cache by key.
+     *
+     * @param {K[]} keys
+     * @returns {(Array<T | undefined>)}
+     * @memberof MemoryStore
+     */
+    public async getMany(keys: K[]): Promise<Array<T | undefined>> {
+        return keys.map((key: K) => this.store.get(key));
+    }
+
+    /**
+     * Store an item in the cache for a given number of seconds.
+     *
+     * @param {K} key
+     * @param {T} value
+     * @param {number} seconds
+     * @returns {boolean}
+     * @memberof MemoryStore
+     */
+    public async put(key: K, value: T, seconds: number): Promise<boolean> {
+        this.store.set(key, value);
+
+        return this.has(key);
+    }
+
+    /**
+     * Store multiple items in the cache for a given number of seconds.
+     *
+     * @param {Array<[K, T]>} values
+     * @param {number} seconds
+     * @returns {boolean[]}
+     * @memberof MemoryStore
+     */
+    public async putMany(values: Array<[K, T]>, seconds: number): Promise<boolean[]> {
+        return values.map((value: [K, T]) => {
+            this.store.set(value[0], value[1]);
+
+            return this.has(value[0]);
+        });
+    }
+
+    /**
+     * Determine if an item exists in the cache.
+     *
+     * @param {K} key
+     * @returns {boolean}
+     * @memberof MemoryStore
+     */
+    public async has(key: K): Promise<boolean> {
+        return this.store.has(key);
+    }
+
+    /**
+     * Determine multiple items exist in the cache.
+     *
+     * @param {K[]} keys
+     * @returns {boolean[]}
+     * @memberof MemoryStore
+     */
+    public async hasMany(keys: K[]): Promise<boolean[]> {
+        return keys.map((key: K) => this.has(key));
+    }
+
+    /**
+     * Determine if an item doesn't exist in the cache.
+     *
+     * @param {K} key
+     * @returns {boolean}
+     * @memberof MemoryStore
+     */
+    public async missing(key: K): Promise<boolean> {
+        return !this.has(key);
+    }
+
+    /**
+     * Determine multiple items don't exist in the cache.
+     *
+     * @param {K[]} keys
+     * @returns {boolean[]}
+     * @memberof MemoryStore
+     */
+    public async missingMany(keys: K[]): Promise<boolean[]> {
+        return keys.map((key: K) => this.missing(key));
+    }
+
+    /**
+     * Store an item in the cache indefinitely.
+     *
+     * @param {K} key
+     * @param {T} value
+     * @returns {boolean}
+     * @memberof MemoryStore
+     */
+    public async forever(key: K, value: T): Promise<boolean> {
+        throw new NotImplementedError(this.constructor.name, "forever");
+    }
+
+    /**
+     * Store multiple items in the cache indefinitely.
+     *
+     * @param {Array<[K, T]>} values
+     * @param {T} value
+     * @returns {boolean[]}
+     * @memberof MemoryStore
+     */
+    public async foreverMany(values: Array<[K, T]>, value: T): Promise<boolean[]> {
+        throw new NotImplementedError(this.constructor.name, "foreverMany");
+    }
+
+    /**
+     * Remove an item from the cache.
+     *
+     * @param {K} key
+     * @returns {boolean}
+     * @memberof MemoryStore
+     */
+    public async forget(key: K): Promise<boolean> {
+        this.store.delete(key);
+
+        return this.missing(key);
+    }
+
+    /**
+     * Remove multiple items from the cache.
+     *
+     * @param {K[]} keys
+     * @returns {boolean[]}
+     * @memberof MemoryStore
+     */
+    public async forgetMany(keys: K[]): Promise<boolean[]> {
+        return keys.map((key: K) => this.missing(key));
+    }
+
+    /**
+     * Remove all items from the cache.
+     *
+     * @returns {boolean}
+     * @memberof MemoryStore
+     */
+    public async flush(): Promise<boolean> {
+        this.store.clear();
+
+        return this.store.size === 0;
+    }
+
+    /**
+     * Get the cache key prefix.
+     *
+     * @returns {string}
+     * @memberof MemoryStore
+     */
+    public async getPrefix(): Promise<string> {
+        throw new NotImplementedError(this.constructor.name, "getPrefix");
+    }
+}
diff --git a/packages/core-kernel/src/services/cache/factory.ts b/packages/core-kernel/src/services/cache/factory.ts
index c039681cf9..382cfbac28 100644
--- a/packages/core-kernel/src/services/cache/factory.ts
+++ b/packages/core-kernel/src/services/cache/factory.ts
@@ -1,7 +1,22 @@
+import { Kernel } from "../../contracts";
+
 /**
  * @export
  * @class CacheFactory
  */
 export class CacheFactory {
-    //
+    /**
+     * @param {Kernel.IApplication} app
+     * @memberof CacheFactory
+     */
+    public constructor(private readonly app: Kernel.IApplication) {}
+
+    /**
+     * @param {Kernel.ICacheStore} store
+     * @returns {Kernel.ICacheStore}
+     * @memberof CacheFactory
+     */
+    public async make<K, T>(store: Kernel.ICacheStore<K, T>): Promise<Kernel.ICacheStore<K, T>> {
+        return store.make(this.app);
+    }
 }
diff --git a/packages/core-kernel/src/services/cache/index.ts b/packages/core-kernel/src/services/cache/index.ts
new file mode 100644
index 0000000000..38f4b1c4d2
--- /dev/null
+++ b/packages/core-kernel/src/services/cache/index.ts
@@ -0,0 +1,3 @@
+export * from "./factory";
+export * from "./manager";
+export * from "./adapters/memory";
diff --git a/packages/core-kernel/src/services/cache/manager.ts b/packages/core-kernel/src/services/cache/manager.ts
index 9cb55f4570..a5c856a684 100644
--- a/packages/core-kernel/src/services/cache/manager.ts
+++ b/packages/core-kernel/src/services/cache/manager.ts
@@ -1,7 +1,67 @@
+import { IApplication, ICacheStore } from "../../contracts/core-kernel";
+import { CacheFactory } from "./factory";
+
 /**
  * @export
  * @class CacheManager
  */
 export class CacheManager {
-    //
+    /**
+     * @private
+     * @type {CacheFactory}
+     * @memberof CacheManager
+     */
+    private readonly factory: CacheFactory;
+
+    /**
+     * @private
+     * @type {Map<string, ICacheStore>}
+     * @memberof CacheManager
+     */
+    private readonly drivers: Map<string, ICacheStore> = new Map<string, ICacheStore>();
+
+    /**
+     * @param {IApplication} app
+     * @memberof CacheManager
+     */
+    public constructor(app: IApplication) {
+        this.factory = new CacheFactory(app);
+    }
+
+    /**
+     * @param {string} [name="default"]
+     * @returns {ICacheStore}
+     * @memberof CacheManager
+     */
+    public driver(name: string = "default"): ICacheStore {
+        return this.drivers.get(name);
+    }
+
+    /**
+     * @param {ICacheStore} driver
+     * @param {string} [name="default"]
+     * @returns {ICacheStore}
+     * @memberof CacheManager
+     */
+    public createDriver(driver: ICacheStore, name: string = "default"): ICacheStore {
+        this.drivers.set(name, this.factory.make(driver));
+
+        return this.driver();
+    }
+
+    /**
+     * @returns {Map<string, ICacheStore>}
+     * @memberof CacheManager
+     */
+    public getDrivers(): Map<string, ICacheStore> {
+        return this.drivers;
+    }
+
+    /**
+     * @returns {CacheFactory}
+     * @memberof CacheManager
+     */
+    public getFactory(): CacheFactory {
+        return this.factory;
+    }
 }
diff --git a/packages/core-kernel/src/services/cache/store.ts b/packages/core-kernel/src/services/cache/store.ts
deleted file mode 100644
index 3115a38424..0000000000
--- a/packages/core-kernel/src/services/cache/store.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-import Keyv from "keyv";
-import { ICacheStore } from "../../contracts/core-kernel/cache";
-
-/**
- * @export
- * @class CacheStore
- * @implements {ICacheStore}
- */
-export class CacheStore implements ICacheStore {
-    /**
-     * @private
-     * @type {Keyv}
-     * @memberof CacheStore
-     */
-    private store: Keyv;
-
-    /**
-     * @param {Record<string, any>} [opts]
-     * @memberof CacheStore
-     */
-    public constructor(opts?: Record<string, any>) {
-        this.store = new Keyv(opts);
-    }
-
-    /**
-     * @param {string} key
-     * @returns {Promise<any>}
-     * @memberof CacheStore
-     */
-    public async get(key: string): Promise<any> {
-        return this.store.get(key);
-    }
-
-    /**
-     * @param {string[]} keys
-     * @returns {Promise<Record<string, any>>}
-     * @memberof CacheStore
-     */
-    public async many(keys: string[]): Promise<Record<string, any>> {
-        const values: Record<string, any> = {};
-
-        for (const key of Object.keys(keys)) {
-            values[key] = await this.get(key);
-        }
-
-        return values;
-    }
-
-    /**
-     * @param {string} key
-     * @param {*} value
-     * @param {number} [ttl]
-     * @returns {Promise<void>}
-     * @memberof CacheStore
-     */
-    public async put(key: string, value: any, ttl?: number): Promise<void> {
-        await this.store.set(key, value, ttl);
-    }
-
-    /**
-     * @param {string[]} values
-     * @param {number} [ttl]
-     * @returns {Promise<void>}
-     * @memberof CacheStore
-     */
-    public async putMany(values: string[], ttl?: number): Promise<void> {
-        for (const [key, value] of Object.entries(values)) {
-            await this.put(key, value, ttl);
-        }
-    }
-
-    /**
-     * @param {string} key
-     * @param {number} [value=1]
-     * @returns {Promise<void>}
-     * @memberof CacheStore
-     */
-    public async increment(key: string, value: number = 1): Promise<void> {
-        const currentValue: number = await this.get(key);
-
-        await this.put(key, currentValue * 1);
-    }
-
-    /**
-     * @param {string} key
-     * @param {number} [value=1]
-     * @returns {Promise<void>}
-     * @memberof CacheStore
-     */
-    public async decrement(key: string, value: number = 1): Promise<void> {
-        const currentValue: number = await this.get(key);
-
-        await this.put(key, currentValue * -1);
-    }
-
-    /**
-     * @param {string} key
-     * @returns {Promise<boolean>}
-     * @memberof CacheStore
-     */
-    public async has(key: string): Promise<boolean> {
-        const value: any = await this.get(key);
-
-        return value !== undefined;
-    }
-
-    /**
-     * @param {string} key
-     * @param {string} value
-     * @returns {Promise<void>}
-     * @memberof CacheStore
-     */
-    public async forever(key: string, value: string): Promise<void> {
-        await this.store.set(key, value, 5 * 315576e5);
-    }
-
-    /**
-     * @param {string} key
-     * @returns {Promise<void>}
-     * @memberof CacheStore
-     */
-    public async forget(key: string): Promise<void> {
-        await this.store.delete(key);
-    }
-
-    /**
-     * @returns {Promise<void>}
-     * @memberof CacheStore
-     */
-    public async flush(): Promise<void> {
-        await this.store.clear();
-    }
-}