diff --git a/lib/types/sqlite-types.js b/lib/types/sqlite-types.js
index 8d65b44f4..423d2ab75 100644
--- a/lib/types/sqlite-types.js
+++ b/lib/types/sqlite-types.js
@@ -1,59 +1,61 @@
 // @flow
 
+import type { ClientDBMessageInfo } from './message-types.js';
 import type { StoreOperations } from './store-ops-types.js';
 
 export const outboundP2PMessageStatuses = Object.freeze({
   // The message was prepared to be sent to other peers, but it's not encrypted.
   // It was inserted into DB in the same transaction as making changes to
   // the store.
   persisted: 'persisted',
   // Encryption is done in the same transaction as persisting the CryptoModule,
   // and message order is also tracked on the client side,
   // which means the message can be sent.
   encrypted: 'encrypted',
   // The message was sent to another peer (Tunnelbroker owns it),
   // waiting for the confirmation (handled in `peerToPeerMessageHandler`).
   sent: 'sent',
 });
 export type OutboundP2PMessageStatuses = $Values<
   typeof outboundP2PMessageStatuses,
 >;
 
 export type InboundP2PMessage = {
   +messageID: string,
   +senderDeviceID: string,
   +plaintext: string,
   +status: string,
 };
 
 export type OutboundP2PMessage = {
   +messageID: string,
   +deviceID: string,
   +userID: string,
   +timestamp: string,
   +plaintext: string,
   +ciphertext: string,
   +status: OutboundP2PMessageStatuses,
 };
 
 export type SQLiteAPI = {
   // read operations
   +getAllInboundP2PMessage: () => Promise<InboundP2PMessage[]>,
   +getAllOutboundP2PMessage: () => Promise<OutboundP2PMessage[]>,
+  +getRelatedMessages: (messageID: string) => Promise<ClientDBMessageInfo[]>,
 
   // write operations
   +removeInboundP2PMessages: (ids: $ReadOnlyArray<string>) => Promise<void>,
   +markOutboundP2PMessageAsSent: (
     messageID: string,
     deviceID: string,
   ) => Promise<void>,
   +removeOutboundP2PMessagesOlderThan: (
     messageID: string,
     deviceID: string,
   ) => Promise<void>,
 
   +processDBStoreOperations: (
     operations: StoreOperations,
     userID?: ?string,
   ) => Promise<void>,
 };
diff --git a/lib/utils/__mocks__/config.js b/lib/utils/__mocks__/config.js
index 8f1b2d8eb..2de245d37 100644
--- a/lib/utils/__mocks__/config.js
+++ b/lib/utils/__mocks__/config.js
@@ -1,43 +1,44 @@
 // @flow
 
 import { type Config } from '../config.js';
 
 const getConfig = (): Config => ({
   resolveKeyserverSessionInvalidationUsingNativeCredentials: null,
   setSessionIDOnRequest: true,
   calendarRangeInactivityLimit: null,
   platformDetails: {
     platform: 'web',
     codeVersion: 70,
     stateVersion: 50,
   },
   authoritativeKeyserverID: '123',
   olmAPI: {
     initializeCryptoAccount: jest.fn(),
     getUserPublicKey: jest.fn(),
     encrypt: jest.fn(),
     encryptAndPersist: jest.fn(),
     decrypt: jest.fn(),
     decryptSequentialAndPersist: jest.fn(),
     contentInboundSessionCreator: jest.fn(),
     contentOutboundSessionCreator: jest.fn(),
     notificationsSessionCreator: jest.fn(),
     getOneTimeKeys: jest.fn(),
     validateAndUploadPrekeys: jest.fn(),
     signMessage: jest.fn(),
     verifyMessage: jest.fn(),
     markPrekeysAsPublished: jest.fn(),
   },
   sqliteAPI: {
     getAllInboundP2PMessage: jest.fn(),
     removeInboundP2PMessages: jest.fn(),
     processDBStoreOperations: jest.fn(),
     getAllOutboundP2PMessage: jest.fn(),
     markOutboundP2PMessageAsSent: jest.fn(),
     removeOutboundP2PMessagesOlderThan: jest.fn(),
+    getRelatedMessages: jest.fn(),
   },
 });
 
 const hasConfig = (): boolean => true;
 
 export { getConfig, hasConfig };
diff --git a/native/database/sqlite-api.js b/native/database/sqlite-api.js
index 0819a7951..d3c67ab63 100644
--- a/native/database/sqlite-api.js
+++ b/native/database/sqlite-api.js
@@ -1,22 +1,23 @@
 // @flow
 
 import type { SQLiteAPI } from 'lib/types/sqlite-types.js';
 
 import { commCoreModule } from '../native-modules.js';
 import { processDBStoreOperations } from '../redux/redux-utils.js';
 
 const sqliteAPI: SQLiteAPI = {
   // read operations
   getAllInboundP2PMessage: commCoreModule.getAllInboundP2PMessage,
   getAllOutboundP2PMessage: commCoreModule.getAllOutboundP2PMessage,
+  getRelatedMessages: commCoreModule.getRelatedMessages,
 
   // write operations
   removeInboundP2PMessages: commCoreModule.removeInboundP2PMessages,
   markOutboundP2PMessageAsSent: commCoreModule.markOutboundP2PMessageAsSent,
   removeOutboundP2PMessagesOlderThan:
     commCoreModule.removeOutboundP2PMessagesOlderThan,
 
   processDBStoreOperations,
 };
 
 export { sqliteAPI };
diff --git a/web/database/sqlite-api.js b/web/database/sqlite-api.js
index 432b554bc..a0a317099 100644
--- a/web/database/sqlite-api.js
+++ b/web/database/sqlite-api.js
@@ -1,76 +1,88 @@
 // @flow
 
+import type { ClientDBMessageInfo } from 'lib/types/message-types.js';
 import type {
   SQLiteAPI,
   InboundP2PMessage,
   OutboundP2PMessage,
 } from 'lib/types/sqlite-types.js';
 
 import { getCommSharedWorker } from '../shared-worker/shared-worker-provider.js';
 import { processDBStoreOperations } from '../shared-worker/utils/store.js';
 import { workerRequestMessageTypes } from '../types/worker-types.js';
 
 const sqliteAPI: SQLiteAPI = {
   // read operations
   async getAllInboundP2PMessage(): Promise<InboundP2PMessage[]> {
     const sharedWorker = await getCommSharedWorker();
 
     const data = await sharedWorker.schedule({
       type: workerRequestMessageTypes.GET_INBOUND_P2P_MESSAGES,
     });
     const messages: ?$ReadOnlyArray<InboundP2PMessage> =
       data?.inboundP2PMessages;
     return messages ? [...messages] : [];
   },
 
   async getAllOutboundP2PMessage(): Promise<OutboundP2PMessage[]> {
     const sharedWorker = await getCommSharedWorker();
 
     const data = await sharedWorker.schedule({
       type: workerRequestMessageTypes.GET_OUTBOUND_P2P_MESSAGES,
     });
     const messages: ?$ReadOnlyArray<OutboundP2PMessage> =
       data?.outboundP2PMessages;
     return messages ? [...messages] : [];
   },
 
+  async getRelatedMessages(messageID: string): Promise<ClientDBMessageInfo[]> {
+    const sharedWorker = await getCommSharedWorker();
+
+    const data = await sharedWorker.schedule({
+      type: workerRequestMessageTypes.GET_RELATED_MESSAGES,
+      messageID,
+    });
+    const messages: ?$ReadOnlyArray<ClientDBMessageInfo> = data?.messages;
+    return messages ? [...messages] : [];
+  },
+
   // write operations
   async removeInboundP2PMessages(ids: $ReadOnlyArray<string>): Promise<void> {
     const sharedWorker = await getCommSharedWorker();
 
     await sharedWorker.schedule({
       type: workerRequestMessageTypes.REMOVE_INBOUND_P2P_MESSAGES,
       ids,
     });
   },
 
   async markOutboundP2PMessageAsSent(
     messageID: string,
     deviceID: string,
   ): Promise<void> {
     const sharedWorker = await getCommSharedWorker();
 
     await sharedWorker.schedule({
       type: workerRequestMessageTypes.MARK_OUTBOUND_P2P_MESSAGE_AS_SENT,
       messageID,
       deviceID,
     });
   },
 
   async removeOutboundP2PMessagesOlderThan(
     messageID: string,
     deviceID: string,
   ): Promise<void> {
     const sharedWorker = await getCommSharedWorker();
 
     await sharedWorker.schedule({
       type: workerRequestMessageTypes.REMOVE_OUTBOUND_P2P_MESSAGES,
       messageID,
       deviceID,
     });
   },
 
   processDBStoreOperations,
 };
 
 export { sqliteAPI };