diff --git a/app/components/Viewer/Tree/ObjectTree.vue b/app/components/Viewer/Tree/ObjectTree.vue
index ad9c2af5..fafcbb8a 100644
--- a/app/components/Viewer/Tree/ObjectTree.vue
+++ b/app/components/Viewer/Tree/ObjectTree.vue
@@ -42,9 +42,9 @@
 </template>
 
 <script setup>
-  import ViewerBreadCrumb from "@/components/Viewer/BreadCrumb"
-  import ViewerTreeObject from "@/components/Viewer/TreeObject"
-  import ViewerTreeComponent from "@/components/Viewer/TreeComponent"
+  import ViewerBreadCrumb from "@ogw_front/components/Viewer/BreadCrumb"
+  import ViewerTreeObject from "@ogw_front/components/Viewer/TreeObject"
+  import ViewerTreeComponent from "@ogw_front/components/Viewer/TreeComponent"
   import { useTreeviewStore } from "@ogw_front/stores/treeview"
   import { useMenuStore } from "@ogw_front/stores/menu"
 
diff --git a/app/components/Viewer/TreeObject.vue b/app/components/Viewer/TreeObject.vue
index 02d0c9ba..2aaa2c3d 100644
--- a/app/components/Viewer/TreeObject.vue
+++ b/app/components/Viewer/TreeObject.vue
@@ -56,7 +56,7 @@
 
   watch(
     () => treeviewStore.selection,
-    (current, previous) => {
+    async (current, previous) => {
       if (!previous) previous = []
       if (current.value === previous) {
         return
@@ -67,19 +67,16 @@
         dataStyleStore.setVisibility(item.id, true)
       })
 
-      removed.forEach((item) => {
-        dataStyleStore.setVisibility(item.id, false)
+      for (const item of removed) {
+        await dataStyleStore.setVisibility(item.id, false)
 
-        const objectMeta = dataBaseStore.itemMetaDatas(item.id)
-        if (objectMeta.viewer_type === "mesh") {
-          if (dataBaseStore.db[item.id]?.mesh_components_selection) {
-            dataBaseStore.db[item.id].mesh_components_selection = []
-          }
+        const objectMeta = await dataBaseStore.itemMetaDatas(item.id)
+        if (objectMeta?.viewer_type === "mesh") {
           if (dataStyleStore.visibleMeshComponentIds?.[item.id]) {
             dataStyleStore.updateVisibleMeshComponents(item.id, [])
           }
         }
-      })
+      }
       hybridViewerStore.remoteRender()
     },
   )
diff --git a/app/plugins/auto_store_register.js b/app/plugins/auto_store_register.js
index e5dd599c..fba19ebb 100644
--- a/app/plugins/auto_store_register.js
+++ b/app/plugins/auto_store_register.js
@@ -1,4 +1,4 @@
-import { useAppStore } from "../stores/app"
+import { useAppStore } from "@ogw_front/stores/app"
 
 const autoStoreRegister = ({ store }) => {
   if (store.$id === "app") {
diff --git a/app/stores/app.js b/app/stores/app.js
index 4fb94817..94feb875 100644
--- a/app/stores/app.js
+++ b/app/stores/app.js
@@ -15,7 +15,7 @@ export const useAppStore = defineStore("app", () => {
     stores.push(store)
   }
 
-  function exportStores() {
+  function exportStores(params = {}) {
     const snapshot = {}
     let exportCount = 0
 
@@ -23,7 +23,7 @@ export const useAppStore = defineStore("app", () => {
       if (!store.exportStores) continue
       const storeId = store.$id
       try {
-        snapshot[storeId] = store.exportStores()
+        snapshot[storeId] = store.exportStores(params)
         exportCount++
       } catch (error) {
         console.error(`[AppStore] Error exporting store "${storeId}":`, error)
diff --git a/app/stores/data_base.js b/app/stores/data_base.js
index c348c014..65ca71f3 100644
--- a/app/stores/data_base.js
+++ b/app/stores/data_base.js
@@ -1,28 +1,52 @@
 // Third party imports
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
-import { useViewerStore } from "@ogw_front/stores/viewer"
-import { useGeodeStore } from "@ogw_front/stores/geode"
+import { db } from "../../internal/database/db.js"
+import { liveQuery } from "dexie"
 
 // Local constants
 const back_model_schemas = back_schemas.opengeodeweb_back.models
 const viewer_generic_schemas = viewer_schemas.opengeodeweb_viewer.generic
 
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useGeodeStore } from "@ogw_front/stores/geode"
+
 export const useDataBaseStore = defineStore("dataBase", () => {
   const viewerStore = useViewerStore()
 
-  const db = reactive({})
+  const syncCache = reactive({})
+
+  liveQuery(() => db.data.toArray()).subscribe((items) => {
+    Object.keys(syncCache).forEach((key) => delete syncCache[key])
+    items.forEach((item) => {
+      syncCache[item.id] = item
+    })
+  })
+
+  function getAllItemsLive() {
+    return liveQuery(() => db.data.toArray())
+  }
+
+  function getItemLive(id) {
+    return liveQuery(() => db.data.get(id))
+  }
+
+  async function itemMetaDatas(id) {
+    return await db.data.get(id)
+  }
 
-  function itemMetaDatas(id) {
-    return db[id]
+  function itemMetaDatasSync(id) {
+    return syncCache[id]
   }
 
   function formatedMeshComponents(id) {
-    const { mesh_components } = itemMetaDatas(id)
-    const formated_mesh_components = ref([])
+    const item = itemMetaDatasSync(id)
+    if (!item || !item.mesh_components) return []
+    const { mesh_components } = item
+    const formated_mesh_components = []
 
     for (const [category, uuids] of Object.entries(mesh_components)) {
-      formated_mesh_components.value.push({
+      formated_mesh_components.push({
         id: category,
         title: category,
         children: uuids.map((uuid) => ({
@@ -32,11 +56,13 @@ export const useDataBaseStore = defineStore("dataBase", () => {
         })),
       })
     }
-    return formated_mesh_components.value
+    return formated_mesh_components
   }
 
   function meshComponentType(id, uuid) {
-    const { mesh_components } = itemMetaDatas(id)
+    const item = itemMetaDatasSync(id)
+    if (!item || !item.mesh_components) return null
+    const { mesh_components } = item
 
     if (mesh_components["Corner"]?.includes(uuid)) return "corner"
     else if (mesh_components["Line"]?.includes(uuid)) return "line"
@@ -49,18 +75,39 @@ export const useDataBaseStore = defineStore("dataBase", () => {
     return viewerStore.request(viewer_generic_schemas.register, { id })
   }
 
-  async function addItem(
-    id,
-    value = {
-      viewer_type,
-      geode_object_type,
-      native_file,
-      viewable_file,
-      name,
-      binary_light_viewable,
-    },
-  ) {
-    db[id] = value
+  async function deregisterObject(id) {
+    return viewerStore.request(viewer_generic_schemas.deregister, { id })
+  }
+
+  async function addItem(id, value) {
+    const itemData = {
+      id,
+      name: value.name || id,
+      geode_object_type: value.geode_object_type,
+      visible: true,
+      created_at: new Date().toISOString(),
+      ...value,
+    }
+
+    const serializedData = JSON.parse(JSON.stringify(itemData))
+    await db.data.put(serializedData)
+    syncCache[id] = serializedData
+  }
+
+  async function getAllItems() {
+    return await db.data.toArray()
+  }
+
+  async function deleteItem(id) {
+    await db.data.delete(id)
+    delete syncCache[id]
+  }
+
+  async function updateItem(id, changes) {
+    await db.data.update(id, changes)
+    if (syncCache[id]) {
+      Object.assign(syncCache[id], changes)
+    }
   }
 
   async function fetchMeshComponents(id) {
@@ -70,90 +117,107 @@ export const useDataBaseStore = defineStore("dataBase", () => {
       { id },
       {
         response_function: async (response) => {
-          db[id].mesh_components = response._data.uuid_dict
+          const mesh_components = response._data.uuid_dict
+          await updateItem(id, { mesh_components })
         },
       },
     )
   }
 
   async function fetchUuidToFlatIndexDict(id) {
-    console.log("fetchUuidToFlatIndexDict", id)
     const geodeStore = useGeodeStore()
     return geodeStore.request(
       back_model_schemas.vtm_component_indices,
       { id },
       {
         response_function: async (response) => {
-          db[id]["uuid_to_flat_index"] = response._data.uuid_to_flat_index
+          const uuid_to_flat_index = response._data.uuid_to_flat_index
+          await updateItem(id, { uuid_to_flat_index })
         },
       },
     )
   }
 
   function getCornersUuids(id) {
-    const { mesh_components } = itemMetaDatas(id)
-    return Object.values(mesh_components["Corner"])
+    const item = itemMetaDatasSync(id)
+    if (!item || !item.mesh_components) return []
+    const { mesh_components } = item
+    return Object.values(mesh_components["Corner"] || {})
   }
 
   function getLinesUuids(id) {
-    const { mesh_components } = itemMetaDatas(id)
-    return Object.values(mesh_components["Line"])
+    const item = itemMetaDatasSync(id)
+    if (!item || !item.mesh_components) return []
+    const { mesh_components } = item
+    return Object.values(mesh_components["Line"] || {})
   }
   function getSurfacesUuids(id) {
-    const { mesh_components } = itemMetaDatas(id)
-    return Object.values(mesh_components["Surface"])
+    const item = itemMetaDatasSync(id)
+    if (!item || !item.mesh_components) return []
+    const { mesh_components } = item
+    return Object.values(mesh_components["Surface"] || {})
   }
   function getBlocksUuids(id) {
-    const { mesh_components } = itemMetaDatas(id)
-    return Object.values(mesh_components["Block"])
+    const item = itemMetaDatasSync(id)
+    if (!item || !item.mesh_components) return []
+    const { mesh_components } = item
+    return Object.values(mesh_components["Block"] || {})
   }
 
   function getFlatIndexes(id, mesh_component_ids) {
-    const { uuid_to_flat_index } = itemMetaDatas(id)
+    const item = itemMetaDatasSync(id)
+    if (!item || !item.uuid_to_flat_index) return []
+    const { uuid_to_flat_index } = item
     const flat_indexes = []
     for (const mesh_component_id of mesh_component_ids) {
-      flat_indexes.push(uuid_to_flat_index[mesh_component_id])
+      if (uuid_to_flat_index[mesh_component_id] !== undefined) {
+        flat_indexes.push(uuid_to_flat_index[mesh_component_id])
+      }
     }
     return flat_indexes
   }
 
-  function exportStores() {
+  async function exportStores() {
+    const items = await db.data.toArray()
     const snapshotDb = {}
-    for (const [id, item] of Object.entries(db)) {
-      if (!item) continue
-      snapshotDb[id] = {
-        ...item,
-      }
+
+    for (const item of items) {
+      snapshotDb[item.id] = { ...item }
     }
+
     return { db: snapshotDb }
   }
 
   async function importStores(snapshot) {
+    const hybridViewerStore = useHybridViewerStore()
     await hybridViewerStore.initHybridViewer()
     hybridViewerStore.clear()
-    console.log(
-      "[DataBase] importStores entries:",
-      Object.keys(snapshot?.db || {}),
-    )
+
+    await clear()
+
     for (const [id, item] of Object.entries(snapshot?.db || {})) {
       await registerObject(id)
       await addItem(id, item)
     }
   }
 
-  function clear() {
-    for (const id of Object.keys(db)) {
-      delete db[id]
-    }
+  async function clear() {
+    await db.data.clear()
   }
 
   return {
-    db,
+    getAllItemsLive,
+    getItemLive,
     itemMetaDatas,
+    itemMetaDatasSync,
     meshComponentType,
     formatedMeshComponents,
     registerObject,
+    deregisterObject,
     addItem,
+    getAllItems,
+    deleteItem,
+    updateItem,
     fetchUuidToFlatIndexDict,
     fetchMeshComponents,
     getCornersUuids,
diff --git a/app/stores/data_style.js b/app/stores/data_style.js
index ed2a01b5..0b4aa3ff 100644
--- a/app/stores/data_style.js
+++ b/app/stores/data_style.js
@@ -19,7 +19,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
       "dataBaseStore.itemMetaDatas(id)",
       dataBaseStore.itemMetaDatas(id),
     )
-    const { viewer_type } = dataBaseStore.itemMetaDatas(id)
+    const { viewer_type } = dataBaseStore.itemMetaDatasSync(id)
     if (viewer_type === "mesh") {
       return Promise.all([meshStyleStore.setMeshVisibility(id, visibility)])
     } else if (viewer_type === "model") {
@@ -29,7 +29,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   }
 
   function applyDefaultStyle(id) {
-    const { viewer_type } = dataBaseStore.itemMetaDatas(id)
+    const { viewer_type } = dataBaseStore.itemMetaDatasSync(id)
     if (viewer_type === "mesh") {
       return meshStyleStore.applyMeshStyle(id)
     } else if (viewer_type === "model") {
@@ -57,7 +57,7 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
     const ids = Object.keys(dataStyleState.styles || {})
     const promises = []
     for (const id of ids) {
-      const meta = dataBaseStore.itemMetaDatas(id)
+      const meta = dataBaseStore.itemMetaDatasSync(id)
       const viewerType = meta?.viewer_type
       const style = dataStyleState.styles[id]
       if (style && viewerType === "mesh") {
diff --git a/app/stores/hybrid_viewer.js b/app/stores/hybrid_viewer.js
index 3097f454..cbc30613 100644
--- a/app/stores/hybrid_viewer.js
+++ b/app/stores/hybrid_viewer.js
@@ -53,7 +53,7 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     if (!genericRenderWindow.value) {
       return
     }
-    const value = dataBaseStore.db[id]
+    const value = await dataBaseStore.itemMetaDatas(id)
     console.log("hybridViewerStore.addItem", { value })
     const reader = vtkXMLPolyDataReader.newInstance()
     const textEncoder = new TextEncoder()
@@ -74,6 +74,14 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     db[id] = { actor, polydata, mapper }
   }
 
+  async function removeItem(id) {
+    if (!db[id]) return
+    const renderer = genericRenderWindow.value.getRenderer()
+    renderer.removeActor(db[id].actor)
+    genericRenderWindow.value.getRenderWindow().render()
+    delete db[id]
+  }
+
   async function setVisibility(id, visibility) {
     db[id].actor.setVisibility(visibility)
     const renderWindow = genericRenderWindow.value.getRenderWindow()
@@ -281,6 +289,7 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     db,
     genericRenderWindow,
     addItem,
+    removeItem,
     setVisibility,
     setZScaling,
     syncRemoteCamera,
diff --git a/app/stores/treeview.js b/app/stores/treeview.js
index 6d47e5b3..d98f87dd 100644
--- a/app/stores/treeview.js
+++ b/app/stores/treeview.js
@@ -59,13 +59,14 @@ export const useTreeviewStore = defineStore("treeview", () => {
   }
 
   function exportStores() {
+    const selectionIds = selection.value.map((c) => c.id)
     return {
       isAdditionnalTreeDisplayed: isAdditionnalTreeDisplayed.value,
       panelWidth: panelWidth.value,
       model_id: model_id.value,
       isTreeCollection: isTreeCollection.value,
       selectedTree: selectedTree.value,
-      selectionIds: selection.value.map((c) => c.id),
+      selectionIds,
     }
   }
 
@@ -105,6 +106,30 @@ export const useTreeviewStore = defineStore("treeview", () => {
     pendingSelectionIds.value = []
   }
 
+  function removeItem(id) {
+    for (let i = 0; i < items.value.length; i++) {
+      const group = items.value[i]
+      const childIndex = group.children.findIndex((child) => child.id === id)
+
+      if (childIndex !== -1) {
+        group.children.splice(childIndex, 1)
+
+        if (group.children.length === 0) {
+          items.value.splice(i, 1)
+        }
+
+        const selectionIndex = selection.value.findIndex(
+          (item) => item.id === id,
+        )
+        if (selectionIndex !== -1) {
+          selection.value.splice(selectionIndex, 1)
+        }
+
+        return
+      }
+    }
+  }
+
   const clear = () => {
     items.value = []
     selection.value = []
@@ -124,6 +149,7 @@ export const useTreeviewStore = defineStore("treeview", () => {
     selectedTree,
     isImporting,
     addItem,
+    removeItem,
     displayAdditionalTree,
     displayFileTree,
     toggleTreeView,
diff --git a/internal/database/db.js b/internal/database/db.js
new file mode 100644
index 00000000..5d7a99d2
--- /dev/null
+++ b/internal/database/db.js
@@ -0,0 +1,13 @@
+import Dexie from "dexie"
+
+export class DataDB extends Dexie {
+  constructor() {
+    super("DataDB")
+
+    this.version(1).stores({
+      data: "id, name, viewer_type, geode_object_type, visible, created_at",
+    })
+  }
+}
+
+export const db = new DataDB()
diff --git a/package.json b/package.json
index 931ecad3..0fb7b0b8 100644
--- a/package.json
+++ b/package.json
@@ -22,13 +22,16 @@
     "@types/node": "22.15.3",
     "@vueuse/components": "13.1.0",
     "@vueuse/nuxt": "13.1.0",
+    "@vueuse/rxjs": "^14.1.0",
     "ajv": "8.17.1",
+    "dexie": "3.2.4",
     "get-port-please": "3.2.0",
     "is-electron": "2.2.2",
     "js-file-download": "0.4.12",
     "nuxt": "4.2.2",
     "p-timeout": "7.0.1",
     "pinia": "3.0.4",
+    "rxjs": "^7.8.2",
     "sass": "1.87.0",
     "semver": "7.7.1",
     "uuid": "11.1.0",
diff --git a/tests/integration/microservices/back/requirements.txt b/tests/integration/microservices/back/requirements.txt
index c8f45967..bd3a3ef5 100644
--- a/tests/integration/microservices/back/requirements.txt
+++ b/tests/integration/microservices/back/requirements.txt
@@ -5,4 +5,3 @@
 #    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
 
-opengeodeweb-back==5.*,>=5.14.3
diff --git a/tests/integration/microservices/viewer/requirements.txt b/tests/integration/microservices/viewer/requirements.txt
index 147e1750..4d097394 100644
--- a/tests/integration/microservices/viewer/requirements.txt
+++ b/tests/integration/microservices/viewer/requirements.txt
@@ -5,4 +5,3 @@
 #    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements.in
 #
 
-opengeodeweb-viewer==1.*,>=1.13.2