diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3062fba..01b1643 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -5,11 +5,39 @@ on:
     branches:
       - master
       - develop
+      - testing
 
 jobs:
-  build:
+  unit_tests:
     runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: 17
+      - name: Run Unit Tests
+        run: ./gradlew testDebugUnitTest
+
+  android_tests:
+    runs-on: macos-12
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: 17
+      - name: Start Emulator and Run Instrumented Tests
+        uses: reactivecircus/android-emulator-runner@v2
+        with:
+          api-level: 29
+          script: ./gradlew connectedDebugAndroidTest
 
+  build_and_release:
+    runs-on: ubuntu-latest
+    needs: [unit_tests, android_tests]
     steps:
       - uses: actions/checkout@v3
 
@@ -26,9 +54,6 @@ jobs:
       - name: Setup Gradle
         uses: gradle/gradle-build-action@v2
 
-      - name: Run Unit Tests
-        run: ./gradlew test
-
       - name: Build app
         run: ./gradlew assembleRelease
         env:
@@ -42,7 +67,7 @@ jobs:
 
       - name: Create Release on GitHub
         uses: softprops/action-gh-release@v1
-        if: github.ref == 'refs/heads/master' # Solo crea releases para commits en master
+        if: github.ref == 'refs/heads/master'
         env:
           GITHUB_TOKEN: ${{ secrets.SHIORI_TOKEN }}
         with:
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 44ca2d9..6c6e34e 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -1,6 +1,7 @@
 <component name="InspectionProjectProfileManager">
   <profile version="1.0">
     <option name="myName" value="Project Default" />
+    <inspection_tool class="AndroidLintUnsafeImplicitIntentLaunch" enabled="false" level="ERROR" enabled_by_default="false" />
     <inspection_tool class="PreviewAnnotationInFunctionWithParameters" enabled="true" level="ERROR" enabled_by_default="true">
       <option name="composableFile" value="true" />
       <option name="previewFile" value="true" />
diff --git a/build.gradle b/build.gradle
index 00f54f8..945576f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -8,8 +8,8 @@ buildscript {
     }
 }// Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id 'com.android.application' version '8.3.1' apply false
-    id 'com.android.library' version '8.3.1' apply false
+    id 'com.android.application' version '8.5.0' apply false
+    id 'com.android.library' version '8.5.0' apply false
     id 'org.jetbrains.kotlin.android' version '2.0.0' apply false
     id 'org.jetbrains.kotlin.plugin.compose' version '2.0.0' apply false
 }
\ No newline at end of file
diff --git a/data/build.gradle.kts b/data/build.gradle.kts
index 230bf9d..a84a63d 100644
--- a/data/build.gradle.kts
+++ b/data/build.gradle.kts
@@ -34,10 +34,15 @@ android {
     kotlinOptions {
         jvmTarget = "17"
     }
-    // JUnit 5 will bundle in files with identical paths, exclude them
     packagingOptions {
-        exclude("META-INF/LICENSE*")
+        jniLibs {
+            excludes += setOf("META-INF/LICENSE*")
+        }
+        resources {
+            excludes += setOf("META-INF/LICENSE*")
+        }
     }
+    // JUnit 5 will bundle in files with identical paths, exclude them
 }
 
 java {
diff --git a/data/src/androidTest/java/com/desarrollodroide/data/local/room/BookmarkHtmlDaoTest.kt b/data/src/androidTest/java/com/desarrollodroide/data/local/room/BookmarkHtmlDaoTest.kt
new file mode 100644
index 0000000..674e51d
--- /dev/null
+++ b/data/src/androidTest/java/com/desarrollodroide/data/local/room/BookmarkHtmlDaoTest.kt
@@ -0,0 +1,59 @@
+package com.desarrollodroide.data.local.room
+
+import androidx.room.Room
+import androidx.test.core.app.ApplicationProvider
+import com.desarrollodroide.data.local.room.dao.BookmarkHtmlDao
+import com.desarrollodroide.data.local.room.database.BookmarksDatabase
+import com.desarrollodroide.data.local.room.entity.BookmarkHtmlEntity
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+class BookmarkHtmlDaoTest {
+
+    private lateinit var database: BookmarksDatabase
+    private lateinit var bookmarkHtmlDao: BookmarkHtmlDao
+
+    private val bookmarkHtml = BookmarkHtmlEntity(
+        id = 1,
+        url = "http://example.com",
+        readableContentHtml = "<html>Test Content</html>"
+    )
+
+    @Before
+    fun setup() {
+        database = Room.inMemoryDatabaseBuilder(
+            ApplicationProvider.getApplicationContext(),
+            BookmarksDatabase::class.java
+        )
+            .allowMainThreadQueries()
+            .build()
+
+        bookmarkHtmlDao = database.bookmarkHtmlDao()
+    }
+
+    @After
+    fun tearDown() {
+        database.close()
+    }
+
+    @Test
+    fun testInsertAndFetchBookmarkHtml(): Unit = runBlocking {
+        bookmarkHtmlDao.insertOrUpdate(bookmarkHtml)
+        val retrievedHtml = bookmarkHtmlDao.getHtmlContent(bookmarkHtml.id)
+        Assert.assertEquals(bookmarkHtml.readableContentHtml, retrievedHtml)
+        bookmarkHtmlDao.getBookmarkHtml(bookmarkHtml.id)?.let {
+            Assert.assertEquals(bookmarkHtml, it)
+        }
+    }
+
+    @Test
+    fun testUpdateBookmarkHtml() = runBlocking {
+        bookmarkHtmlDao.insertOrUpdate(bookmarkHtml)
+        val updatedBookmarkHtml = bookmarkHtml.copy(readableContentHtml = "<html>Updated Content</html>")
+        bookmarkHtmlDao.insertOrUpdate(updatedBookmarkHtml)
+        val retrievedHtml = bookmarkHtmlDao.getHtmlContent(bookmarkHtml.id)
+        Assert.assertEquals(updatedBookmarkHtml.readableContentHtml, retrievedHtml)
+    }
+}
\ No newline at end of file
diff --git a/data/src/androidTest/java/com/desarrollodroide/data/local/room/TagsDaoTest.kt b/data/src/androidTest/java/com/desarrollodroide/data/local/room/TagsDaoTest.kt
new file mode 100644
index 0000000..070bae2
--- /dev/null
+++ b/data/src/androidTest/java/com/desarrollodroide/data/local/room/TagsDaoTest.kt
@@ -0,0 +1,71 @@
+package com.desarrollodroide.data.local.room
+
+import androidx.room.Room
+import androidx.test.core.app.ApplicationProvider
+import com.desarrollodroide.data.local.room.dao.TagDao
+import com.desarrollodroide.data.local.room.database.BookmarksDatabase
+import com.desarrollodroide.data.local.room.entity.TagEntity
+import junit.framework.TestCase.assertFalse
+import junit.framework.TestCase.assertTrue
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+
+class TagDaoTest {
+
+    private lateinit var database: BookmarksDatabase
+    private lateinit var tagDao: TagDao
+
+    private val tag = TagEntity(
+        id = 1,
+        name = "Test Tag",
+        nBookmarks = 5
+    )
+
+    @Before
+    fun setup() {
+        database = Room.inMemoryDatabaseBuilder(
+            ApplicationProvider.getApplicationContext(),
+            BookmarksDatabase::class.java
+        )
+            .allowMainThreadQueries()
+            .build()
+
+        tagDao = database.tagDao()
+    }
+
+    @After
+    fun tearDown() {
+        database.close()
+    }
+
+    @Test
+    fun testInsertAndFetchTags() = runBlocking {
+        tagDao.insertTag(tag)
+        val retrievedTags = tagDao.getAllTags().first()
+        assertTrue(retrievedTags.contains(tag))
+        tagDao.deleteAllTags()
+        assertTrue(tagDao.getAllTags().first().isEmpty())
+    }
+
+    @Test
+    fun testDeleteTag() = runBlocking {
+        tagDao.insertTag(tag)
+        tagDao.deleteTag(tag)
+        val retrievedTags = tagDao.getAllTags().first()
+        assertFalse(retrievedTags.contains(tag))
+    }
+
+    @Test
+    fun testInsertAndFetchMultipleTags() = runBlocking {
+        val tags = listOf(
+            TagEntity(1, "Tag1", 2),
+            TagEntity(2, "Tag2", 3)
+        )
+        tagDao.insertAllTags(tags)
+        val retrievedTags = tagDao.getAllTags().first()
+        assertTrue(retrievedTags.containsAll(tags))
+    }
+}
diff --git a/data/src/main/java/com/desarrollodroide/data/di/DataModule.kt b/data/src/main/java/com/desarrollodroide/data/di/DataModule.kt
index 187c0d0..abcfc82 100644
--- a/data/src/main/java/com/desarrollodroide/data/di/DataModule.kt
+++ b/data/src/main/java/com/desarrollodroide/data/di/DataModule.kt
@@ -6,6 +6,7 @@ import androidx.datastore.preferences.core.PreferenceDataStoreFactory
 import androidx.datastore.preferences.core.emptyPreferences
 import androidx.datastore.preferences.preferencesDataStoreFile
 import com.desarrollodroide.common.result.ErrorHandler
+import com.desarrollodroide.data.local.datastore.HideTagSerializer
 import com.desarrollodroide.data.local.datastore.RememberUserPreferencesSerializer
 import com.desarrollodroide.data.local.datastore.UserPreferencesSerializer
 import com.desarrollodroide.data.local.preferences.SettingsPreferenceDataSource
@@ -33,6 +34,7 @@ fun dataModule() = module {
     val preferencesDataStoreQualifier = named("preferencesDataStore")
     val protoDataStoreQualifier = named("protoDataStore")
     val protoRememberUserDataStoreQualifier = named("protoRememberUserDataStore")
+    val protoHideTagDataStoreQualifier = named("protoHideTagDataStore")
 
     single(preferencesDataStoreQualifier) {
         PreferenceDataStoreFactory.create(
@@ -59,10 +61,19 @@ fun dataModule() = module {
         )
     }
 
+    single(protoHideTagDataStoreQualifier) {
+        DataStoreFactory.create(
+            serializer = HideTagSerializer,
+            produceFile = { androidContext().preferencesDataStoreFile("hide_tag_data")},
+            corruptionHandler = null,
+        )
+    }
+
     single { SettingsPreferencesDataSourceImpl(
         dataStore = get(preferencesDataStoreQualifier),
         protoDataStore = get(protoDataStoreQualifier),
-        rememberUserProtoDataStore = get(protoRememberUserDataStoreQualifier)
+        rememberUserProtoDataStore = get(protoRememberUserDataStoreQualifier),
+        hideTagDataStore = get(protoHideTagDataStoreQualifier)
     ) as SettingsPreferenceDataSource }
 
     single { AuthRepositoryImpl(
@@ -102,8 +113,6 @@ fun dataModule() = module {
         ) as TagsRepository
     }
 
-
-
     single { FileRemoteDataSource() }
     single { ErrorHandlerImpl() as ErrorHandler }
 
diff --git a/data/src/main/java/com/desarrollodroide/data/local/datastore/HideTagSerializer.kt b/data/src/main/java/com/desarrollodroide/data/local/datastore/HideTagSerializer.kt
new file mode 100644
index 0000000..5dcd68c
--- /dev/null
+++ b/data/src/main/java/com/desarrollodroide/data/local/datastore/HideTagSerializer.kt
@@ -0,0 +1,25 @@
+package com.desarrollodroide.data.local.datastore
+
+import androidx.datastore.core.CorruptionException
+import androidx.datastore.core.Serializer
+import com.desarrollodroide.data.HideTag
+import com.google.protobuf.InvalidProtocolBufferException
+import java.io.InputStream
+import java.io.OutputStream
+
+/**
+ * Serializer for the [HideTag] object defined in your .proto file.
+ */
+object HideTagSerializer : Serializer<HideTag> {
+    override val defaultValue: HideTag = HideTag.getDefaultInstance()
+
+    override suspend fun readFrom(input: InputStream): HideTag {
+        try {
+            return HideTag.parseFrom(input)
+        } catch (exception: InvalidProtocolBufferException) {
+            throw CorruptionException("Cannot read proto.", exception)
+        }
+    }
+
+    override suspend fun writeTo(t: HideTag, output: OutputStream) = t.writeTo(output)
+}
\ No newline at end of file
diff --git a/data/src/main/java/com/desarrollodroide/data/local/preferences/SettingsPreferenceDataSource.kt b/data/src/main/java/com/desarrollodroide/data/local/preferences/SettingsPreferenceDataSource.kt
index 44f2b18..ae3e4b6 100644
--- a/data/src/main/java/com/desarrollodroide/data/local/preferences/SettingsPreferenceDataSource.kt
+++ b/data/src/main/java/com/desarrollodroide/data/local/preferences/SettingsPreferenceDataSource.kt
@@ -3,6 +3,7 @@ package com.desarrollodroide.data.local.preferences
 import com.desarrollodroide.data.UserPreferences
 import com.desarrollodroide.data.helpers.ThemeMode
 import com.desarrollodroide.model.Account
+import com.desarrollodroide.model.Tag
 import com.desarrollodroide.model.User
 import kotlinx.coroutines.flow.Flow
 
@@ -46,4 +47,6 @@ interface SettingsPreferenceDataSource {
 
     fun getUseDynamicColors(): Boolean
     fun setUseDynamicColors(newValue: Boolean)
+    suspend fun getHideTag(): Tag?
+    suspend fun setHideTag(tag: Tag?)
 }
\ No newline at end of file
diff --git a/data/src/main/java/com/desarrollodroide/data/local/preferences/SettingsPreferencesDataSourceImpl.kt b/data/src/main/java/com/desarrollodroide/data/local/preferences/SettingsPreferencesDataSourceImpl.kt
index de58170..50c8e74 100644
--- a/data/src/main/java/com/desarrollodroide/data/local/preferences/SettingsPreferencesDataSourceImpl.kt
+++ b/data/src/main/java/com/desarrollodroide/data/local/preferences/SettingsPreferencesDataSourceImpl.kt
@@ -15,17 +15,20 @@ import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
+import com.desarrollodroide.data.HideTag
 import com.desarrollodroide.data.RememberUserPreferences
 import com.desarrollodroide.data.helpers.ThemeMode
+import com.desarrollodroide.model.Tag
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.runBlocking
 
 class SettingsPreferencesDataSourceImpl(
     private val dataStore: DataStore<Preferences>,
     private val protoDataStore: DataStore<UserPreferences>,
-    private val rememberUserProtoDataStore: DataStore<RememberUserPreferences>
+    private val rememberUserProtoDataStore: DataStore<RememberUserPreferences>,
+    private val hideTagDataStore: DataStore<HideTag>,
 
-) : SettingsPreferenceDataSource {
+    ) : SettingsPreferenceDataSource {
 
     val THEME_MODE_KEY = stringPreferencesKey("theme_mode")
     val COMPACT_VIEW = booleanPreferencesKey("compact_view")
@@ -249,4 +252,23 @@ class SettingsPreferencesDataSourceImpl(
         }
     }
 
+    override suspend fun setHideTag(tag: Tag?) {
+        hideTagDataStore.updateData { currentHideTag ->
+            when (tag) {
+                null -> HideTag.getDefaultInstance()
+                else -> currentHideTag.toBuilder()
+                    .setId(tag.id)
+                    .setName(tag.name)
+                    .build()
+            }
+        }
+    }
+
+    override suspend fun getHideTag(): Tag? {
+        return hideTagDataStore.data.first().let { hideTag ->
+            if (hideTag == HideTag.getDefaultInstance()) null
+            else Tag(id = hideTag.id, name = hideTag.name, selected = false, nBookmarks = 0)
+        }
+    }
+
 }
diff --git a/data/src/main/proto/prefs.proto b/data/src/main/proto/prefs.proto
index 1fac33a..2b4aeb9 100644
--- a/data/src/main/proto/prefs.proto
+++ b/data/src/main/proto/prefs.proto
@@ -28,3 +28,11 @@ message RememberUserPreferences {
   bool createArchive = 7;
 
 }
+
+
+message HideTag {
+
+  int32 id = 1;
+  string name = 2;
+
+}
\ No newline at end of file
diff --git a/data/src/test/java/com/desarrollodroide/data/local/datastore/HideTagSerializerTest.kt b/data/src/test/java/com/desarrollodroide/data/local/datastore/HideTagSerializerTest.kt
new file mode 100644
index 0000000..2c564c6
--- /dev/null
+++ b/data/src/test/java/com/desarrollodroide/data/local/datastore/HideTagSerializerTest.kt
@@ -0,0 +1,47 @@
+package com.desarrollodroide.data.local.datastore
+
+import androidx.datastore.core.CorruptionException
+import com.desarrollodroide.data.HideTag
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class HideTagSerializerTest {
+
+    private val testHideTag = HideTag.newBuilder()
+        .setId(1)
+        .setName("TestTag")
+        .build()
+
+    @Test
+    fun `test writeTo serializes object correctly`() = runBlocking {
+        val testOutputStream = ByteArrayOutputStream()
+        HideTagSerializer.writeTo(testHideTag, testOutputStream)
+        val serializedData = testOutputStream.toByteArray()
+        assertTrue(serializedData.isNotEmpty())
+    }
+
+    @Test
+    fun `test readFrom deserializes object correctly`() = runBlocking {
+        val testOutputStream = ByteArrayOutputStream()
+        HideTagSerializer.writeTo(testHideTag, testOutputStream)
+        val serializedData = testOutputStream.toByteArray()
+        val testInputStream = ByteArrayInputStream(serializedData)
+        val deserializedObject = HideTagSerializer.readFrom(testInputStream)
+        assertEquals(testHideTag.id, deserializedObject.id)
+        assertEquals(testHideTag.name, deserializedObject.name)
+    }
+
+    @Test
+    fun `test readFrom throws CorruptionException on corrupted data`(): Unit = runBlocking {
+        val corruptedData = "corruptedData".toByteArray()
+        val testInputStream = ByteArrayInputStream(corruptedData)
+        assertThrows<CorruptionException> {
+            HideTagSerializer.readFrom(testInputStream)
+        }
+    }
+}
\ No newline at end of file
diff --git a/data/src/test/java/com/desarrollodroide/data/local/preferences/RememberUserPreferencesSerializerTest.kt b/data/src/test/java/com/desarrollodroide/data/local/preferences/RememberUserPreferencesSerializerTest.kt
deleted file mode 100644
index 41671f2..0000000
--- a/data/src/test/java/com/desarrollodroide/data/local/preferences/RememberUserPreferencesSerializerTest.kt
+++ /dev/null
@@ -1,73 +0,0 @@
-package com.desarrollodroide.data.local.preferences
-
-import androidx.datastore.core.CorruptionException
-import com.desarrollodroide.data.RememberUserPreferences
-import com.desarrollodroide.data.local.datastore.RememberUserPreferencesSerializer
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import org.junit.jupiter.api.Test
-import kotlinx.coroutines.test.runTest
-import org.junit.jupiter.api.Assertions.assertEquals
-import java.io.ByteArrayInputStream
-import java.io.ByteArrayOutputStream
-import kotlin.test.assertFailsWith
-
-@OptIn(ExperimentalCoroutinesApi::class)
-class RememberUserPreferencesSerializerTest {
-
-    @Test
-    fun `Serializer reads from input stream correctly`() = runTest {
-        // Given a valid RememberUserPreferences protobuf
-        val originalPreferences = RememberUserPreferences.newBuilder()
-            .setId(123)
-            .setUsername("testUser")
-            .setPassword("testPass")
-            .setUrl("https://example.com")
-            .setMakeArchivePublic(true)
-            .setCreateEbook(false)
-            .setCreateArchive(true)
-            .build()
-
-        val inputStream = ByteArrayInputStream(originalPreferences.toByteArray())
-
-        // When reading from the input stream
-        val resultPreferences = RememberUserPreferencesSerializer.readFrom(inputStream)
-
-        // Then the deserialized object should match the original
-        assertEquals(originalPreferences, resultPreferences)
-    }
-
-    @Test
-    fun `Serializer writes to output stream correctly`() = runTest {
-        // Given a valid RememberUserPreferences object
-        val preferences = RememberUserPreferences.newBuilder()
-            .setId(456)
-            .setUsername("anotherUser")
-            .setPassword("anotherPass")
-            .setUrl("https://another-example.com")
-            .setMakeArchivePublic(false)
-            .setCreateEbook(true)
-            .setCreateArchive(false)
-            .build()
-
-        val outputStream = ByteArrayOutputStream()
-
-        // When writing to the output stream
-        RememberUserPreferencesSerializer.writeTo(preferences, outputStream)
-
-        // Then the serialized bytes should match the original object's bytes
-        assertEquals(preferences, RememberUserPreferences.parseFrom(outputStream.toByteArray()))
-    }
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    @Test
-    fun `Serializer throws CorruptionException on invalid input`() = runTest {
-        // Given an invalid byte array (corrupted data)
-        val corruptedData = byteArrayOf(1, 2, 3, 4)
-        val inputStream = ByteArrayInputStream(corruptedData)
-
-        // Then assert that reading from the input stream throws a CorruptionException
-        assertFailsWith<CorruptionException> {
-            RememberUserPreferencesSerializer.readFrom(inputStream)
-        }
-    }
-}
diff --git a/data/src/test/java/com/desarrollodroide/data/local/preferences/SettingsPreferencesDataSourceTest.kt b/data/src/test/java/com/desarrollodroide/data/local/preferences/SettingsPreferencesDataSourceTest.kt
index 587ceaf..06f8881 100644
--- a/data/src/test/java/com/desarrollodroide/data/local/preferences/SettingsPreferencesDataSourceTest.kt
+++ b/data/src/test/java/com/desarrollodroide/data/local/preferences/SettingsPreferencesDataSourceTest.kt
@@ -17,7 +17,11 @@ import org.junit.jupiter.api.Test
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 import androidx.datastore.preferences.core.stringPreferencesKey
+import com.desarrollodroide.data.HideTag
+import com.desarrollodroide.model.Tag
 import kotlinx.coroutines.flow.first
+import org.junit.jupiter.api.Assertions.assertNotNull
+import org.junit.jupiter.api.Assertions.assertNull
 import org.mockito.kotlin.any
 import org.mockito.kotlin.verify
 
@@ -27,6 +31,7 @@ class SettingsPreferencesDataSourceImplTest {
     private lateinit var settingsPreferencesDataSourceImpl: SettingsPreferencesDataSourceImpl
     private var preferencesDataStore: DataStore<Preferences> = mock()
     private val protoDataStoreMock: DataStore<UserPreferences> = mock()
+    private val hideTagDataStoreMock: DataStore<HideTag> = mock()
     private val rememberUserProtoDataStoreMock: DataStore<RememberUserPreferences> = mock()
     private val THEME_MODE_KEY = stringPreferencesKey("theme_mode")
     private val COMPACT_VIEW_KEY = booleanPreferencesKey("compact_view")
@@ -38,7 +43,8 @@ class SettingsPreferencesDataSourceImplTest {
         settingsPreferencesDataSourceImpl = SettingsPreferencesDataSourceImpl(
             dataStore = preferencesDataStore,
             protoDataStore = protoDataStoreMock,
-            rememberUserProtoDataStore = rememberUserProtoDataStoreMock
+            rememberUserProtoDataStore = rememberUserProtoDataStoreMock,
+            hideTagDataStore = hideTagDataStoreMock
             )
     }
 
@@ -270,4 +276,52 @@ class SettingsPreferencesDataSourceImplTest {
         verify(rememberUserProtoDataStoreMock).updateData(any())
     }
 
+    @Test
+    fun `setUseDynamicColors updates preference correctly`() = runTest {
+        val newValue = true
+        settingsPreferencesDataSourceImpl.setUseDynamicColors(newValue)
+        verify(preferencesDataStore).edit(any())
+    }
+
+    @Test
+    fun `getUseDynamicColors retrieves the correct value`() = runTest {
+        val expectedValue = true
+        whenever(preferencesDataStore.data).thenReturn(flowOf(preferencesOf(settingsPreferencesDataSourceImpl.USE_DYNAMIC_COLORS to expectedValue)))
+        val actualValue = settingsPreferencesDataSourceImpl.getUseDynamicColors()
+        assertEquals(expectedValue, actualValue)
+    }
+
+    @Test
+    fun `setHideTag updates HideTag correctly`() = runTest {
+        val tag = Tag(id = 1, name = "TestTag", selected = false, nBookmarks = 0)
+        settingsPreferencesDataSourceImpl.setHideTag(tag)
+        verify(hideTagDataStoreMock).updateData(any())
+    }
+
+    @Test
+    fun `setHideTag with null clears HideTag`() = runTest {
+        settingsPreferencesDataSourceImpl.setHideTag(null)
+        verify(hideTagDataStoreMock).updateData(any())
+    }
+
+    @Test
+    fun `getHideTag retrieves the correct Tag when set`() = runTest {
+        val expectedTag = HideTag.newBuilder()
+            .setId(1)
+            .setName("TestTag")
+            .build()
+        whenever(hideTagDataStoreMock.data).thenReturn(flowOf(expectedTag))
+        val actualTag = settingsPreferencesDataSourceImpl.getHideTag()
+        assertNotNull(actualTag)
+        assertEquals(expectedTag.id, actualTag?.id)
+        assertEquals(expectedTag.name, actualTag?.name)
+    }
+
+    @Test
+    fun `getHideTag returns null when no tag is set`() = runTest {
+        whenever(hideTagDataStoreMock.data).thenReturn(flowOf(HideTag.getDefaultInstance()))
+        val actualTag = settingsPreferencesDataSourceImpl.getHideTag()
+        assertNull(actualTag)
+    }
+
 }
diff --git a/data/src/test/java/com/desarrollodroide/data/mapper/MapperTest.kt b/data/src/test/java/com/desarrollodroide/data/mapper/MapperTest.kt
new file mode 100644
index 0000000..3408f46
--- /dev/null
+++ b/data/src/test/java/com/desarrollodroide/data/mapper/MapperTest.kt
@@ -0,0 +1,669 @@
+package com.desarrollodroide.data.mapper
+
+import com.desarrollodroide.data.local.room.entity.BookmarkEntity
+import com.desarrollodroide.data.local.room.entity.TagEntity
+import com.desarrollodroide.model.Account
+import com.desarrollodroide.model.Tag
+import com.desarrollodroide.model.UpdateCachePayload
+import org.junit.jupiter.api.Assertions.*
+import com.desarrollodroide.network.model.AccountDTO
+import com.desarrollodroide.network.model.BookmarkDTO
+import com.desarrollodroide.network.model.BookmarksDTO
+import com.desarrollodroide.network.model.LivenessResponseDTO
+import com.desarrollodroide.network.model.LoginResponseDTO
+import com.desarrollodroide.network.model.LoginResponseMessageDTO
+import com.desarrollodroide.network.model.ReadableContentResponseDTO
+import com.desarrollodroide.network.model.ReadableMessageDto
+import com.desarrollodroide.network.model.ReleaseInfoDTO
+import com.desarrollodroide.network.model.SessionDTO
+import com.desarrollodroide.network.model.TagDTO
+import org.junit.jupiter.api.Test
+
+class MapperTest {
+
+    @Test
+    fun `SessionDTO toDomainModel maps correctly`() {
+        val accountDTO = AccountDTO(
+            id = 1,
+            userName = "testUser",
+            password = "password",
+            isOwner = true,
+            oldPassword = "oldPass",
+            newPassword = "newPass",
+            isLegacyApi = true
+        )
+        val sessionDTO = SessionDTO(
+            token = "token123",
+            session = "session123",
+            account = accountDTO
+        )
+
+        val user = sessionDTO.toDomainModel()
+
+        assertEquals("token123", user.token)
+        assertEquals("session123", user.session)
+        assertEquals("testUser", user.account.userName)
+        assertEquals("password", user.account.password)
+        assertEquals(true, user.account.owner)
+        assertEquals(true, user.account.isLegacyApi)  // Corrected to match the DTO's isLegacyApi value
+    }
+
+    @Test
+    fun `SessionDTO toProtoEntity maps correctly`() {
+        val accountDTO = AccountDTO(
+            id = 1,
+            userName = "testUser",
+            password = "password",
+            isOwner = true,
+            oldPassword = "oldPass",
+            newPassword = "newPass",
+            isLegacyApi = true
+        )
+        val sessionDTO = SessionDTO(
+            token = "token123",
+            session = "session123",
+            account = accountDTO
+        )
+
+        val userPreferences = sessionDTO.toProtoEntity()
+
+        assertEquals(1, userPreferences.id)
+        assertEquals("testUser", userPreferences.username)
+        assertEquals(true, userPreferences.owner)
+        assertEquals("", userPreferences.password)
+        assertEquals("session123", userPreferences.session)
+        assertEquals("", userPreferences.url)  // Assuming this is not set from DTO
+        assertEquals(false, userPreferences.rememberPassword)  // Assuming default value
+        assertEquals(true, userPreferences.isLegacyApi)
+        assertEquals("", userPreferences.token)
+    }
+
+    @Test
+    fun `AccountDTO toDomainModel maps correctly`() {
+        val accountDTO = AccountDTO(
+            id = 1,
+            userName = "testUser",
+            password = "password",
+            isOwner = true,
+            oldPassword = "oldPass",
+            newPassword = "newPass",
+            isLegacyApi = true
+        )
+
+        val account = accountDTO.toDomainModel()
+
+        assertEquals("testUser", account.userName)
+        assertEquals("password", account.password)
+        assertEquals(true, account.owner)
+        assertEquals(true, account.isLegacyApi)  // Corrected to match the DTO's isLegacyApi value
+    }
+
+    @Test
+    fun `BookmarkDTO toDomainModel maps correctly`() {
+        val tagDTO = TagDTO(
+            id = 1,
+            name = "tag1",
+            nBookmarks = 5
+        )
+
+        val bookmarkDTO = BookmarkDTO(
+            id = 1,
+            url = "http://example.com",
+            title = "Example Title",
+            excerpt = "Example Excerpt",
+            author = "Author Name",
+            public = 1,
+            modified = "2023-06-18",
+            imageURL = "/image.jpg",
+            hasContent = true,
+            hasArchive = true,
+            hasEbook = true,
+            tags = listOf(tagDTO),
+            createArchive = true,
+            createEbook = true
+        )
+
+        val serverUrl = "http://example.com"
+        val bookmark = bookmarkDTO.toDomainModel(serverUrl)
+
+        assertEquals(1, bookmark.id)
+        assertEquals("http://example.com", bookmark.url)
+        assertEquals("Example Title", bookmark.title)
+        assertEquals("Example Excerpt", bookmark.excerpt)
+        assertEquals("Author Name", bookmark.author)
+        assertEquals(1, bookmark.public)
+        assertEquals("2023-06-18", bookmark.modified)
+        assertEquals("http://example.com/image.jpg", bookmark.imageURL)
+        assertEquals(true, bookmark.hasContent)
+        assertEquals(true, bookmark.hasArchive)
+        assertEquals(true, bookmark.hasEbook)
+        assertEquals(1, bookmark.tags.size)
+        assertEquals(1, bookmark.tags[0].id)
+        assertEquals("tag1", bookmark.tags[0].name)
+        assertEquals(5, bookmark.tags[0].nBookmarks)
+        assertEquals(true, bookmark.createArchive)
+        assertEquals(true, bookmark.createEbook)
+    }
+
+
+    @Test
+    fun `BookmarksDTO toDomainModel maps correctly`() {
+        val tagDTO = TagDTO(
+            id = 1,
+            name = "tag1",
+            nBookmarks = 5
+        )
+
+        val bookmarkDTO = BookmarkDTO(
+            id = 1,
+            url = "http://example.com",
+            title = "Example Title",
+            excerpt = "Example Excerpt",
+            author = "Author Name",
+            public = 1,
+            modified = "2023-06-18",
+            imageURL = "/image.jpg",
+            hasContent = true,
+            hasArchive = true,
+            hasEbook = true,
+            tags = listOf(tagDTO),
+            createArchive = true,
+            createEbook = true
+        )
+
+        val bookmarksDTO = BookmarksDTO(
+            page = 1,
+            maxPage = 10,
+            bookmarks = listOf(bookmarkDTO)
+        )
+
+        val serverUrl = "http://example.com"
+        val bookmarks = bookmarksDTO.toDomainModel(serverUrl)
+
+        assertEquals(1, bookmarks.page)
+        assertEquals(10, bookmarks.maxPage)
+        assertEquals(1, bookmarks.bookmarks.size)
+
+        val bookmark = bookmarks.bookmarks[0]
+        assertEquals(1, bookmark.id)
+        assertEquals("http://example.com", bookmark.url)
+        assertEquals("Example Title", bookmark.title)
+        assertEquals("Example Excerpt", bookmark.excerpt)
+        assertEquals("Author Name", bookmark.author)
+        assertEquals(1, bookmark.public)
+        assertEquals("2023-06-18", bookmark.modified)
+        assertEquals("http://example.com/image.jpg", bookmark.imageURL)
+        assertEquals(true, bookmark.hasContent)
+        assertEquals(true, bookmark.hasArchive)
+        assertEquals(true, bookmark.hasEbook)
+        assertEquals(1, bookmark.tags.size)
+        assertEquals(1, bookmark.tags[0].id)
+        assertEquals("tag1", bookmark.tags[0].name)
+        assertEquals(5, bookmark.tags[0].nBookmarks)
+        assertEquals(true, bookmark.createArchive)
+        assertEquals(true, bookmark.createEbook)
+    }
+
+    @Test
+    fun `TagDTO toDomainModel maps correctly`() {
+        val tagDTO = TagDTO(
+            id = 1,
+            name = "tag1",
+            nBookmarks = 5
+        )
+
+        val tag = tagDTO.toDomainModel()
+
+        assertEquals(1, tag.id)
+        assertEquals("tag1", tag.name)
+        assertEquals(false, tag.selected) // Assuming selected is always false in the domain model
+        assertEquals(5, tag.nBookmarks)
+    }
+
+    @Test
+    fun `TagDTO toDomainModel with null fields maps correctly`() {
+        val tagDTO = TagDTO(
+            id = null,
+            name = null,
+            nBookmarks = null
+        )
+
+        val tag = tagDTO.toDomainModel()
+
+        assertEquals(0, tag.id) // Default value for id
+        assertEquals("", tag.name) // Default value for name
+        assertEquals(false, tag.selected) // Assuming selected is always false in the domain model
+        assertEquals(0, tag.nBookmarks) // Default value for nBookmarks
+    }
+
+    @Test
+    fun `TagDTO toEntityModel maps correctly`() {
+        val tagDTO = TagDTO(
+            id = 1,
+            name = "tag1",
+            nBookmarks = 5
+        )
+
+        val tagEntity = tagDTO.toEntityModel()
+
+        assertEquals(1, tagEntity.id)
+        assertEquals("tag1", tagEntity.name)
+        assertEquals(5, tagEntity.nBookmarks)
+    }
+
+    @Test
+    fun `TagDTO toEntityModel with null fields maps correctly`() {
+        val tagDTO = TagDTO(
+            id = null,
+            name = null,
+            nBookmarks = null
+        )
+
+        val tagEntity = tagDTO.toEntityModel()
+
+        assertEquals(0, tagEntity.id) // Default value for id
+        assertEquals("", tagEntity.name) // Default value for name
+        assertEquals(0, tagEntity.nBookmarks) // Default value for nBookmarks
+    }
+
+    @Test
+    fun `TagEntity toDomainModel maps correctly`() {
+        val tagEntity = TagEntity(
+            id = 1,
+            name = "tag1",
+            nBookmarks = 5
+        )
+
+        val tag = tagEntity.toDomainModel()
+
+        assertEquals(1, tag.id)
+        assertEquals("tag1", tag.name)
+        assertEquals(false, tag.selected) // Assuming selected is always false in the domain model
+        assertEquals(5, tag.nBookmarks)
+    }
+
+    @Test
+    fun `Account toRequestBody maps correctly`() {
+        val account = Account(
+            id = 1,
+            userName = "testUser",
+            password = "password",
+            owner = true,
+            serverUrl = "https://example.com",
+            isLegacyApi = false
+        )
+
+        val loginRequestPayload = account.toRequestBody()
+
+        assertEquals("testUser", loginRequestPayload.username)
+        assertEquals("password", loginRequestPayload.password)
+    }
+
+    @Test
+    fun `BookmarkDTO toEntityModel maps correctly`() {
+        val tagDTO = TagDTO(
+            id = 1,
+            name = "tag1",
+            nBookmarks = 5
+        )
+
+        val bookmarkDTO = BookmarkDTO(
+            id = 1,
+            url = "http://example.com",
+            title = "Example Title",
+            excerpt = "Example Excerpt",
+            author = "Author Name",
+            public = 1,
+            modified = "2023-06-18",
+            imageURL = "/image.jpg",
+            hasContent = true,
+            hasArchive = true,
+            hasEbook = true,
+            tags = listOf(tagDTO),
+            createArchive = true,
+            createEbook = true
+        )
+
+        val bookmarkEntity = bookmarkDTO.toEntityModel()
+
+        assertEquals(1, bookmarkEntity.id)
+        assertEquals("http://example.com", bookmarkEntity.url)
+        assertEquals("Example Title", bookmarkEntity.title)
+        assertEquals("Example Excerpt", bookmarkEntity.excerpt)
+        assertEquals("Author Name", bookmarkEntity.author)
+        assertEquals(1, bookmarkEntity.isPublic)
+        assertEquals("2023-06-18", bookmarkEntity.modified)
+        assertEquals("/image.jpg", bookmarkEntity.imageURL)
+        assertEquals(true, bookmarkEntity.hasContent)
+        assertEquals(true, bookmarkEntity.hasArchive)
+        assertEquals(true, bookmarkEntity.hasEbook)
+        assertEquals(1, bookmarkEntity.tags.size)
+        assertEquals(1, bookmarkEntity.tags[0].id)
+        assertEquals("tag1", bookmarkEntity.tags[0].name)
+        assertEquals(5, bookmarkEntity.tags[0].nBookmarks)
+        assertEquals(true, bookmarkEntity.createArchive)
+        assertEquals(true, bookmarkEntity.createEbook)
+    }
+
+    @Test
+    fun `BookmarkDTO toEntityModel with null fields maps correctly`() {
+        val bookmarkDTO = BookmarkDTO(
+            id = null,
+            url = null,
+            title = null,
+            excerpt = null,
+            author = null,
+            public = null,
+            modified = null,
+            imageURL = null,
+            hasContent = null,
+            hasArchive = null,
+            hasEbook = null,
+            tags = null,
+            createArchive = null,
+            createEbook = null
+        )
+
+        val bookmarkEntity = bookmarkDTO.toEntityModel()
+
+        assertEquals(0, bookmarkEntity.id) // Default value for id
+        assertEquals("", bookmarkEntity.url) // Default value for url
+        assertEquals("", bookmarkEntity.title) // Default value for title
+        assertEquals("", bookmarkEntity.excerpt) // Default value for excerpt
+        assertEquals("", bookmarkEntity.author) // Default value for author
+        assertEquals(0, bookmarkEntity.isPublic) // Default value for isPublic
+        assertEquals("", bookmarkEntity.modified) // Default value for modified
+        assertEquals("", bookmarkEntity.imageURL) // Default value for imageURL
+        assertEquals(false, bookmarkEntity.hasContent) // Default value for hasContent
+        assertEquals(false, bookmarkEntity.hasArchive) // Default value for hasArchive
+        assertEquals(false, bookmarkEntity.hasEbook) // Default value for hasEbook
+        assertEquals(0, bookmarkEntity.tags.size) // Default empty list for tags
+        assertEquals(false, bookmarkEntity.createArchive) // Default value for createArchive
+        assertEquals(false, bookmarkEntity.createEbook) // Default value for createEbook
+    }
+
+    @Test
+    fun `BookmarkEntity toDomainModel maps correctly`() {
+        val tag = Tag(
+            id = 1,
+            name = "tag1",
+            selected = false,
+            nBookmarks = 5
+        )
+
+        val bookmarkEntity = BookmarkEntity(
+            id = 1,
+            url = "http://example.com",
+            title = "Example Title",
+            excerpt = "Example Excerpt",
+            author = "Author Name",
+            isPublic = 1,
+            modified = "2023-06-18",
+            imageURL = "/image.jpg",
+            hasContent = true,
+            hasArchive = true,
+            hasEbook = true,
+            tags = listOf(tag),
+            createArchive = true,
+            createEbook = true
+        )
+
+        val bookmark = bookmarkEntity.toDomainModel()
+
+        assertEquals(1, bookmark.id)
+        assertEquals("http://example.com", bookmark.url)
+        assertEquals("Example Title", bookmark.title)
+        assertEquals("Example Excerpt", bookmark.excerpt)
+        assertEquals("Author Name", bookmark.author)
+        assertEquals(1, bookmark.public)
+        assertEquals("2023-06-18", bookmark.modified)
+        assertEquals("/image.jpg", bookmark.imageURL)
+        assertEquals(true, bookmark.hasContent)
+        assertEquals(true, bookmark.hasArchive)
+        assertEquals(true, bookmark.hasEbook)
+        assertEquals(1, bookmark.tags.size)
+        assertEquals(1, bookmark.tags[0].id)
+        assertEquals("tag1", bookmark.tags[0].name)
+        assertEquals(5, bookmark.tags[0].nBookmarks)
+        assertEquals(true, bookmark.createArchive)
+        assertEquals(true, bookmark.createEbook)
+    }
+
+    @Test
+    fun `BookmarkEntity toDomainModel with empty tags maps correctly`() {
+        val bookmarkEntity = BookmarkEntity(
+            id = 1,
+            url = "http://example.com",
+            title = "Example Title",
+            excerpt = "Example Excerpt",
+            author = "Author Name",
+            isPublic = 1,
+            modified = "2023-06-18",
+            imageURL = "/image.jpg",
+            hasContent = true,
+            hasArchive = true,
+            hasEbook = true,
+            tags = emptyList(),
+            createArchive = true,
+            createEbook = true
+        )
+
+        val bookmark = bookmarkEntity.toDomainModel()
+
+        assertEquals(1, bookmark.id)
+        assertEquals("http://example.com", bookmark.url)
+        assertEquals("Example Title", bookmark.title)
+        assertEquals("Example Excerpt", bookmark.excerpt)
+        assertEquals("Author Name", bookmark.author)
+        assertEquals(1, bookmark.public)
+        assertEquals("2023-06-18", bookmark.modified)
+        assertEquals("/image.jpg", bookmark.imageURL)
+        assertEquals(true, bookmark.hasContent)
+        assertEquals(true, bookmark.hasArchive)
+        assertEquals(true, bookmark.hasEbook)
+        assertEquals(0, bookmark.tags.size) // Ensure tags are empty
+        assertEquals(true, bookmark.createArchive)
+        assertEquals(true, bookmark.createEbook)
+    }
+
+    @Test
+    fun `UpdateCachePayload toDTO maps correctly`() {
+        val updateCachePayload = UpdateCachePayload(
+            createArchive = true,
+            createEbook = false,
+            ids = listOf(1, 2, 3),
+            keepMetadata = true,
+            skipExist = false
+        )
+
+        val updateCachePayloadDTO = updateCachePayload.toDTO()
+
+        assertEquals(true, updateCachePayloadDTO.createArchive)
+        assertEquals(false, updateCachePayloadDTO.createEbook)
+        assertEquals(listOf(1, 2, 3), updateCachePayloadDTO.ids)
+        assertEquals(true, updateCachePayloadDTO.keepMetadata)
+    }
+
+    @Test
+    fun `LivenessResponseDTO toDomainModel maps correctly`() {
+        val releaseInfoDTO = ReleaseInfoDTO(
+            version = "1.0.0",
+            date = "2023-06-18",
+            commit = "abc123"
+        )
+
+        val livenessResponseDTO = LivenessResponseDTO(
+            ok = true,
+            message = releaseInfoDTO
+        )
+
+        val livenessResponse = livenessResponseDTO.toDomainModel()
+
+        assertEquals(true, livenessResponse.ok)
+        assertEquals("1.0.0", livenessResponse.message?.version)
+        assertEquals("2023-06-18", livenessResponse.message?.date)
+        assertEquals("abc123", livenessResponse.message?.commit)
+    }
+
+    @Test
+    fun `LivenessResponseDTO toDomainModel with null message maps correctly`() {
+        val livenessResponseDTO = LivenessResponseDTO(
+            ok = true,
+            message = null
+        )
+
+        val livenessResponse = livenessResponseDTO.toDomainModel()
+
+        assertEquals(true, livenessResponse.ok)
+        assertEquals(null, livenessResponse.message)
+    }
+
+    @Test
+    fun `LivenessResponseDTO toDomainModel with null ok maps correctly`() {
+        val releaseInfoDTO = ReleaseInfoDTO(
+            version = "1.0.0",
+            date = "2023-06-18",
+            commit = "abc123"
+        )
+
+        val livenessResponseDTO = LivenessResponseDTO(
+            ok = null,
+            message = releaseInfoDTO
+        )
+
+        val livenessResponse = livenessResponseDTO.toDomainModel()
+
+        assertEquals(false, livenessResponse.ok)
+        assertEquals("1.0.0", livenessResponse.message?.version)
+        assertEquals("2023-06-18", livenessResponse.message?.date)
+        assertEquals("abc123", livenessResponse.message?.commit)
+    }
+
+    @Test
+    fun `ReleaseInfoDTO toDomainModel maps correctly`() {
+        val releaseInfoDTO = ReleaseInfoDTO(
+            version = "1.0.0",
+            date = "2023-06-18",
+            commit = "abc123"
+        )
+
+        val releaseInfo = releaseInfoDTO.toDomainModel()
+
+        assertEquals("1.0.0", releaseInfo.version)
+        assertEquals("2023-06-18", releaseInfo.date)
+        assertEquals("abc123", releaseInfo.commit)
+    }
+
+    @Test
+    fun `ReleaseInfoDTO toDomainModel with null fields maps correctly`() {
+        val releaseInfoDTO = ReleaseInfoDTO(
+            version = null,
+            date = null,
+            commit = null
+        )
+
+        val releaseInfo = releaseInfoDTO.toDomainModel()
+
+        assertEquals("", releaseInfo.version) // Default value for version
+        assertEquals("", releaseInfo.date) // Default value for date
+        assertEquals("", releaseInfo.commit) // Default value for commit
+    }
+
+    @Test
+    fun `LoginResponseDTO toProtoEntity maps correctly`() {
+        val loginResponseMessageDTO = LoginResponseMessageDTO(
+            expires = 3600,
+            session = "session123",
+            token = "token123"
+        )
+
+        val loginResponseDTO = LoginResponseDTO(
+            ok = true,
+            message = loginResponseMessageDTO,
+            error = null
+        )
+
+        val userPreferences = loginResponseDTO.toProtoEntity(userName = "testUser")
+
+        assertEquals("session123", userPreferences.session)
+        assertEquals("testUser", userPreferences.username)
+        assertEquals("token123", userPreferences.token)
+        assertEquals(false, userPreferences.isLegacyApi)
+    }
+
+    @Test
+    fun `LoginResponseDTO toProtoEntity with null message maps correctly`() {
+        val loginResponseDTO = LoginResponseDTO(
+            ok = true,
+            message = null,
+            error = null
+        )
+
+        val userPreferences = loginResponseDTO.toProtoEntity(userName = "testUser")
+
+        assertEquals("", userPreferences.session) // Default value for session
+        assertEquals("testUser", userPreferences.username)
+        assertEquals("", userPreferences.token) // Default value for token
+        assertEquals(false, userPreferences.isLegacyApi)
+    }
+
+    @Test
+    fun `ReadableContentResponseDTO toDomainModel maps correctly`() {
+        val readableMessageDto = ReadableMessageDto(
+            content = "Sample Content",
+            html = "<p>Sample HTML</p>"
+        )
+
+        val readableContentResponseDTO = ReadableContentResponseDTO(
+            ok = true,
+            message = readableMessageDto
+        )
+
+        val readableContent = readableContentResponseDTO.toDomainModel()
+
+        assertEquals(true, readableContent.ok)
+        assertEquals("Sample Content", readableContent.message.content)
+        assertEquals("<p>Sample HTML</p>", readableContent.message.html)
+    }
+
+    @Test
+    fun `ReadableContentResponseDTO toDomainModel with null fields maps correctly`() {
+        val readableContentResponseDTO = ReadableContentResponseDTO(
+            ok = null,
+            message = null
+        )
+
+        val readableContent = readableContentResponseDTO.toDomainModel()
+
+        assertEquals(false, readableContent.ok) // Default value for ok
+        assertEquals("", readableContent.message.content) // Default value for content
+        assertEquals("", readableContent.message.html) // Default value for html
+    }
+
+    @Test
+    fun `ReadableMessageDto toDomainModel maps correctly`() {
+        val readableMessageDto = ReadableMessageDto(
+            content = "Sample Content",
+            html = "<p>Sample HTML</p>"
+        )
+
+        val readableMessage = readableMessageDto.toDomainModel()
+
+        assertEquals("Sample Content", readableMessage.content)
+        assertEquals("<p>Sample HTML</p>", readableMessage.html)
+    }
+
+    @Test
+    fun `ReadableMessageDto toDomainModel with null fields maps correctly`() {
+        val readableMessageDto = ReadableMessageDto(
+            content = null,
+            html = null
+        )
+
+        val readableMessage = readableMessageDto.toDomainModel()
+
+        assertEquals("", readableMessage.content) // Default value for content
+        assertEquals("", readableMessage.html) // Default value for html
+    }
+
+}
\ No newline at end of file
diff --git a/domain/src/main/java/com/desarrollodroide/domain/usecase/UseCase.kt b/domain/src/main/java/com/desarrollodroide/domain/usecase/UseCase.kt
deleted file mode 100644
index edebefb..0000000
--- a/domain/src/main/java/com/desarrollodroide/domain/usecase/UseCase.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package com.desarrollodroide.domain.usecase
-
-interface UseCase<in Params, out T> {
-    fun execute(params: Params): T
-}
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
index e2e4700..f380923 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -25,8 +25,8 @@ android.nonTransitiveRClass=true
 compileSdkVersion=34
 minSdkVersion=21
 targetSdkVersion=34
-versionCode=43
-versionName=1.33.01
+versionCode=44
+versionName=1.34
 
 android.defaults.buildfeatures.buildconfig=true
 android.nonFinalResIds=false
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index bfe94aa..7603627 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 #Mon Mar 25 12:51:42 CET 2024
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/network/src/main/java/com/desarrollodroide/network/retrofit/FileRemoteDataSource.kt b/network/src/main/java/com/desarrollodroide/network/retrofit/FileRemoteDataSource.kt
index 9e7618c..7a11191 100644
--- a/network/src/main/java/com/desarrollodroide/network/retrofit/FileRemoteDataSource.kt
+++ b/network/src/main/java/com/desarrollodroide/network/retrofit/FileRemoteDataSource.kt
@@ -4,10 +4,9 @@ import android.content.Context
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import java.io.File
-import android.os.Environment
 
 class FileRemoteDataSource {
-    suspend fun downloadFile(
+    fun downloadFile(
         context: Context,
         url: String,
         fileName: String,
@@ -32,7 +31,7 @@ class FileRemoteDataSource {
     }
 
     private fun cleanFileName(fileName: String): String {
-        return fileName.replace(Regex("[^a-zA-Z0-9.,\\-\\s_]"), "_")
+        return fileName.replace(Regex("[^a-zA-Z0-9.,\\-\\s_\u0600-\u06FF]"), "_")
     }
 }
 
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/di/PresenterModule.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/di/PresenterModule.kt
index c7b18fd..53b2148 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/di/PresenterModule.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/di/PresenterModule.kt
@@ -37,6 +37,7 @@ fun presenterModule() = module {
             bookmarksRepository = get(),
             sendLogoutUseCase = get(),
             themeManager = get(),
+            getTagsUseCase = get(),
         )
     }
 
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/bookmarkeditor/BookmarkEditorActivity.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/bookmarkeditor/BookmarkEditorActivity.kt
index c3adb9b..93860ad 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/bookmarkeditor/BookmarkEditorActivity.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/bookmarkeditor/BookmarkEditorActivity.kt
@@ -3,6 +3,7 @@ package com.desarrollodroide.pagekeeper.ui.bookmarkeditor
 import android.content.Intent
 import android.os.Bundle
 import android.util.Log
+import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.compose.foundation.background
@@ -48,7 +49,10 @@ class BookmarkEditorActivity : ComponentActivity() {
                                 createArchive = bookmarkViewModel.getCreateArchive(),
                                 createEbook = bookmarkViewModel.getCreateEbook()
                             ),
-                            onBackClick = { finish() },
+                            onBackClick = {
+                                Toast.makeText(this@BookmarkEditorActivity, "Bookmark saved", Toast.LENGTH_LONG).show()
+                                finish()
+                            },
                             updateBookmark = { },
                             startMainActivity = { startMainActivity() }
                         )
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/bookmarkeditor/BookmarkEditorScreen.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/bookmarkeditor/BookmarkEditorScreen.kt
index f6adbc8..1280250 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/bookmarkeditor/BookmarkEditorScreen.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/bookmarkeditor/BookmarkEditorScreen.kt
@@ -11,7 +11,6 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import com.desarrollodroide.pagekeeper.ui.components.ConfirmDialog
 import com.desarrollodroide.pagekeeper.ui.components.InfiniteProgressDialog
-import com.desarrollodroide.pagekeeper.ui.components.SimpleDialog
 import com.desarrollodroide.model.Bookmark
 import com.desarrollodroide.model.Tag
 import org.koin.androidx.compose.get
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/components/CategoriesView.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/components/CategoriesView.kt
index 6d79f50..e67c14e 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/components/CategoriesView.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/components/CategoriesView.kt
@@ -1,5 +1,6 @@
 package com.desarrollodroide.pagekeeper.ui.components
 
+import android.util.Log
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
@@ -32,13 +33,15 @@ fun Categories(
     showCategories: Boolean,
     uniqueCategories: MutableState<List<Tag>>,
     selectedTags: MutableState<List<Tag>> = mutableStateOf(emptyList<Tag>()),
-    onCategoriesSelectedChanged: (List<Tag>) -> Unit
+    onCategoriesSelectedChanged: (List<Tag>) -> Unit,
+    singleSelection: Boolean = false
 ) {
+    Log.v("selectedTags", "selectedTags: $selectedTags")
     AnimatedVisibility(showCategories) {
-        Column() {
-            FlowRow() {
+        Column {
+            FlowRow {
                 uniqueCategories.value.forEach { category ->
-                    val selected = category in selectedTags.value
+                    val selected = selectedTags.value.any { it.id == category.id }
                     FilterChip(
                         colors = FilterChipDefaults.filterChipColors(
                             containerColor = MaterialTheme.colorScheme.surface,
@@ -58,10 +61,14 @@ fun Categories(
                         onClick = {
                             when (categoriesType) {
                                 CategoriesType.SELECTABLES -> {
-                                    if (selected) {
-                                        selectedTags.value = selectedTags.value - category
+                                    if (singleSelection) {
+                                        selectedTags.value = if (selected) emptyList() else listOf(category)
                                     } else {
-                                        selectedTags.value = selectedTags.value + category
+                                        if (selected) {
+                                            selectedTags.value = selectedTags.value - category
+                                        } else {
+                                            selectedTags.value = selectedTags.value + category
+                                        }
                                     }
                                 }
                                 CategoriesType.REMOVEABLES -> {
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/CategoriesView.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/CategoriesView.kt
index 34df559..ba07b09 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/CategoriesView.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/CategoriesView.kt
@@ -7,9 +7,13 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Sell
 import androidx.compose.material3.Button
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
@@ -61,15 +65,36 @@ fun CategoriesView(
 
         Text("Categories", style = MaterialTheme.typography.headlineSmall)
         Spacer(Modifier.height(8.dp))
-        Categories(
-            categoriesType = CategoriesType.SELECTABLES,
-            showCategories = true,
-            uniqueCategories = uniqueCategories,
-            selectedTags = selectedTags,
-            onCategoriesSelectedChanged = { tags ->
-                selectedTags.value = tags
+        if (uniqueCategories.value.isEmpty()) {
+            Row(
+                horizontalArrangement = Arrangement.Center,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier
+                    .padding(vertical = 16.dp)
+                    .fillMaxWidth()
+            ) {
+                Icon(
+                    imageVector = Icons.Outlined.Sell,
+                    contentDescription = "No categories available",
+                    modifier = Modifier.size(24.dp)
+                )
+                Spacer(Modifier.width(8.dp))
+                Text(
+                    "No categories available",
+                    style = MaterialTheme.typography.bodyLarge
+                )
             }
-        )
+        } else {
+            Categories(
+                categoriesType = CategoriesType.SELECTABLES,
+                showCategories = true,
+                uniqueCategories = uniqueCategories,
+                selectedTags = selectedTags,
+                onCategoriesSelectedChanged = { tags ->
+                    selectedTags.value = tags
+                }
+            )
+        }
 
         Spacer(Modifier.height(24.dp))
 
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedContent.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedContent.kt
index 311b669..649c795 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedContent.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedContent.kt
@@ -1,5 +1,6 @@
 package com.desarrollodroide.pagekeeper.ui.feed
 
+import android.util.Log
 import androidx.compose.animation.animateContentSize
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
@@ -32,6 +33,7 @@ import com.desarrollodroide.pagekeeper.ui.components.pulltorefresh.PullRefreshIn
 import com.desarrollodroide.pagekeeper.ui.components.pulltorefresh.pullRefresh
 import com.desarrollodroide.pagekeeper.ui.components.pulltorefresh.rememberPullRefreshState
 import com.desarrollodroide.model.Bookmark
+import com.desarrollodroide.model.Tag
 import com.desarrollodroide.pagekeeper.ui.feed.item.BookmarkActions
 import com.desarrollodroide.pagekeeper.ui.feed.item.BookmarkItem
 import kotlinx.coroutines.delay
@@ -46,6 +48,7 @@ fun FeedContent(
     isLegacyApi: Boolean,
     token: String,
     bookmarksPagingItems: LazyPagingItems<Bookmark>,
+    tagToHide: Tag?,
 ) {
     val refreshCoroutineScope = rememberCoroutineScope()
     var isRefreshing by remember { mutableStateOf(false) }
@@ -69,7 +72,8 @@ fun FeedContent(
         ) {
             items(bookmarksPagingItems.itemCount) { index ->
                 val bookmark = bookmarksPagingItems[index]
-                if (bookmark != null) {
+                Log.v("TagToHide", "$tagToHide")
+                if (bookmark != null && bookmark.tags.none { it.id == tagToHide?.id }) {
                     BookmarkItem(
                         bookmark = bookmark,
                         serverURL = serverURL,
@@ -84,15 +88,7 @@ fun FeedContent(
                             onClickBookmark = { actions.onBookmarkSelect(bookmark) },
                             onClickEpub = { actions.onBookmarkEpub(bookmark) },
                             onClickSync = { actions.onClickSync(bookmark) },
-                            onClickCategory = { category ->
-//                                bookmark.tags.firstOrNull() { it.name == category.name }?.apply {
-//                                    if (selectedTags.value.contains(category)) {
-//                                        selectedTags.value = selectedTags.value - category
-//                                    } else {
-//                                        selectedTags.value = selectedTags.value + category
-//                                    }
-//                                }
-                            }),
+                            onClickCategory = { category -> }),
                     )
                     if (index < bookmarksPagingItems.itemCount) {
                         HorizontalDivider(
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedScreen.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedScreen.kt
index 0234b41..671ce76 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedScreen.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedScreen.kt
@@ -60,6 +60,8 @@ fun FeedScreen(
 ) {
     val context = LocalContext.current
     val tagsState by feedViewModel.tagsState.collectAsState()
+    val tagToHide by feedViewModel.tagToHide.collectAsState()
+
     LaunchedEffect(Unit) {
         feedViewModel.loadInitialData()
         feedViewModel.getPagingBookmarks()
@@ -112,9 +114,7 @@ fun FeedScreen(
         onClearError = {
             feedViewModel.resetData()
         },
-        onCategoriesSelectedChanged = { categories ->
-            //feedViewModel.saveSelectedCategories(categories)
-        },
+        onCategoriesSelectedChanged = { categories -> },
     )
 
     LaunchedEffect(bookmarksPagingItems.loadState) {
@@ -137,6 +137,7 @@ fun FeedScreen(
             if (isCompactView) BookmarkViewType.SMALL else BookmarkViewType.FULL
         },
         bookmarksPagingItems = bookmarksPagingItems,
+        tagToHide = tagToHide
     )
     if (feedViewModel.showBookmarkEditorScreen.value && feedViewModel.bookmarkSelected.value != null) {
         Box(
@@ -313,6 +314,7 @@ private fun FeedView(
     isLegacyApi: Boolean,
     token: String,
     bookmarksPagingItems: LazyPagingItems<Bookmark>,
+    tagToHide: Tag?,
     ) {
     if (bookmarksPagingItems.itemCount > 0) {
         Column {
@@ -329,6 +331,7 @@ private fun FeedView(
                     token = token,
                     viewType = viewType,
                     bookmarksPagingItems = bookmarksPagingItems,
+                    tagToHide = tagToHide
                 )
             }
         }
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedViewModel.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedViewModel.kt
index d59f4ab..2be8991 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedViewModel.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/feed/FeedViewModel.kt
@@ -77,6 +77,7 @@ class FeedViewModel(
     val bookmarkToDelete = mutableStateOf<Bookmark?>(null)
     val bookmarkToUpdateCache = mutableStateOf<Bookmark?>(null)
     val isCompactView = MutableStateFlow<Boolean>(false)
+    val tagToHide = MutableStateFlow<Tag?>(null)
 
     val availableTags: StateFlow<List<Tag>> = bookmarkDatabase.getAll()
         .map { bookmarks ->
@@ -111,6 +112,7 @@ class FeedViewModel(
             xSessionId = settingsPreferenceDataSource.getSession()
             isLegacyApi = settingsPreferenceDataSource.getIsLegacyApi()
             isCompactView.value = settingsPreferenceDataSource.getCompactView()
+            tagToHide.value = settingsPreferenceDataSource.getHideTag()
         }
     }
 
@@ -285,4 +287,5 @@ class FeedViewModel(
     fun isLegacyApi(): Boolean = runBlocking {
         settingsPreferenceDataSource.getIsLegacyApi()
     }
+
 }
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/home/HomeScreen.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/home/HomeScreen.kt
index f180fed..86f8bd1 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/home/HomeScreen.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/home/HomeScreen.kt
@@ -15,9 +15,9 @@ import org.koin.androidx.compose.get
 import androidx.compose.runtime.*
 import androidx.compose.material3.Text
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.FilterList
 import androidx.compose.material.icons.filled.Search
 import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material.icons.outlined.Sell
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -223,7 +223,7 @@ fun TopBar(
                 }
                 IconButton(onClick = { toggleCategoryVisibility() }) {
                     Icon(
-                        imageVector = Icons.Filled.FilterList,
+                        imageVector = Icons.Outlined.Sell,
                         contentDescription = "Filter",
                         tint =  MaterialTheme.colorScheme.secondary,
                        )
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/LoginScreen.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/LoginScreen.kt
index 7cf68e8..3a8568f 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/LoginScreen.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/LoginScreen.kt
@@ -31,9 +31,10 @@ import com.desarrollodroide.pagekeeper.ui.settings.LinkableText
 fun LoginScreen(
     loginViewModel: LoginViewModel,
     onSuccess: (User) -> Unit,
-    ) {
+) {
     val loginUiState: UiState<User> by loginViewModel.userUiState.collectAsStateWithLifecycle()
     val livenessUiState: UiState<LivenessResponse> by loginViewModel.livenessUiState.collectAsStateWithLifecycle()
+    val serverAvailabilityUiState: UiState<LivenessResponse> by loginViewModel.serverAvailabilityUiState.collectAsStateWithLifecycle()
     Box(
         modifier = Modifier
             .fillMaxSize()
@@ -53,14 +54,21 @@ fun LoginScreen(
             onSuccess = {
                 loginViewModel.clearState()
                 onSuccess.invoke(it)
-                        },
+            },
             user = loginViewModel.userName,
             password = loginViewModel.password,
             serverUrl = loginViewModel.serverUrl,
             onClearError = {
                 loginViewModel.clearState()
             },
-            livenessUiState = livenessUiState
+            livenessUiState = livenessUiState,
+            serverAvailabilityUiState = serverAvailabilityUiState,
+            onClickTestButton = {
+                loginViewModel.checkServerAvailability()
+            },
+            resetServerAvailabilityState = {
+                loginViewModel.resetServerAvailabilityUiState()
+            }
         )
     }
 }
@@ -76,10 +84,13 @@ fun LoginContent(
     passwordErrorState: MutableState<Boolean>,
     onSuccess: (User) -> Unit,
     onClickLoginButton: () -> Unit,
+    onClickTestButton: () -> Unit,
     onClearError: () -> Unit,
     onCheckedRememberSessionChange: (Boolean) -> Unit,
     loginUiState: UiState<User>,
     livenessUiState: UiState<LivenessResponse>,
+    serverAvailabilityUiState: UiState<LivenessResponse>,
+    resetServerAvailabilityState: () -> Unit
 ) {
     if (loginUiState.isLoading || livenessUiState.isLoading) {
         InfiniteProgressDialog(onDismissRequest = {})
@@ -111,16 +122,21 @@ fun LoginContent(
         ContentViews(
             serverUrl = serverUrl,
             urlErrorState = urlErrorState,
-            user =user,
+            user = user,
             userErrorState = userErrorState,
             password = password,
             passwordErrorState = passwordErrorState,
             onClickLoginButton = onClickLoginButton,
             checked = checked,
             onCheckedRememberSessionChange = onCheckedRememberSessionChange,
+            isTestingServer = serverAvailabilityUiState.isLoading,
+            onClickTestButton = onClickTestButton,
+            serverAvailabilityUiState = serverAvailabilityUiState,
+            serverVersion = serverAvailabilityUiState.data?.message?.version ?: "",
+            resetServerAvailabilityState = resetServerAvailabilityState
         )
-    } else if (loginUiState.data != null){
-        LaunchedEffect(Unit){
+    } else if (loginUiState.data != null) {
+        LaunchedEffect(Unit) {
             onSuccess.invoke(loginUiState.data)
         }
     }
@@ -134,21 +150,16 @@ private fun ContentViews(
     userErrorState: MutableState<Boolean>,
     password: MutableState<String>,
     passwordErrorState: MutableState<Boolean>,
+    isTestingServer: Boolean,
     onClickLoginButton: () -> Unit,
+    onClickTestButton: () -> Unit,
     checked: MutableState<Boolean>,
     onCheckedRememberSessionChange: (Boolean) -> Unit,
+    serverAvailabilityUiState: UiState<LivenessResponse>,
+    serverVersion: String,
+    resetServerAvailabilityState: () -> Unit
 ) {
     Box(modifier = Modifier.fillMaxSize()) {
-//        Image(
-//            painter = painterResource(id = R.drawable.curved_wave_top),
-//            contentDescription = null,
-//            colorFilter = ColorFilter.tint(MaterialTheme.colorScheme.primary.copy(alpha = 0.5f)),
-//            contentScale = ContentScale.Crop,
-//            modifier = Modifier
-//                .fillMaxWidth()
-//                .height(150.dp)
-//        )
-
         Image(
             painter = painterResource(id = R.drawable.ic_logo),
             contentDescription = null,
@@ -177,16 +188,25 @@ private fun ContentViews(
             verticalArrangement = Arrangement.Bottom,
         ) {
             ServerUrlTextField(
+                modifier = Modifier,
                 serverUrl = serverUrl,
-                serverErrorState = urlErrorState)
+                serverErrorState = urlErrorState,
+                serverAvailabilityUiState = serverAvailabilityUiState,
+                serverVersion = serverVersion,
+                resetServerAvailabilityState = resetServerAvailabilityState,
+                onClick = onClickTestButton,
+                isTestingServer = isTestingServer
+            )
             Spacer(modifier = Modifier.height(10.dp))
             UserTextField(
                 user = user,
-                userErrorState = userErrorState)
+                userErrorState = userErrorState
+            )
             Spacer(modifier = Modifier.height(10.dp))
             PasswordTextField(
                 password = password,
-                passwordErrorState = passwordErrorState)
+                passwordErrorState = passwordErrorState
+            )
             Spacer(Modifier.size(14.dp))
             LoginButton(
                 user = user,
@@ -194,7 +214,8 @@ private fun ContentViews(
                 password = password,
                 passwordErrorState = passwordErrorState,
                 onClickLoginButton = onClickLoginButton,
-                serverErrorState = urlErrorState)
+                serverErrorState = urlErrorState
+            )
             RememberSessionSection(
                 checked = checked,
                 onCheckedChange = onCheckedRememberSessionChange
@@ -202,10 +223,9 @@ private fun ContentViews(
             Box(
                 modifier = Modifier
                     .fillMaxWidth()
-                    .padding(10.dp)
-                ,
+                    .padding(10.dp),
                 contentAlignment = Alignment.Center
-            ){
+            ) {
                 LinkableText(
                     text = "Server Setup Guide",
                     url = SHIORI_GITHUB_URL
@@ -235,7 +255,10 @@ fun DefaultPreview() {
             onCheckedRememberSessionChange = {},
             onClearError = {},
             loginUiState = UiState(data = null, idle = false),
-            livenessUiState = UiState(false)
+            livenessUiState = UiState(false),
+            serverAvailabilityUiState = UiState(data = null, idle = false),
+            onClickTestButton = {},
+            resetServerAvailabilityState = {}
         )
     }
 }
\ No newline at end of file
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/LoginViewModel.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/LoginViewModel.kt
index b33e277..9864869 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/LoginViewModel.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/LoginViewModel.kt
@@ -16,6 +16,8 @@ import kotlinx.coroutines.launch
 import com.desarrollodroide.common.result.Result
 import com.desarrollodroide.domain.usecase.SystemLivenessUseCase
 import com.desarrollodroide.model.LivenessResponse
+import com.desarrollodroide.pagekeeper.ui.components.idle
+import kotlinx.coroutines.delay
 
 class LoginViewModel(
     private val settingsPreferenceDataSource: SettingsPreferenceDataSource,
@@ -53,6 +55,9 @@ class LoginViewModel(
     private val _livenessUiState = MutableStateFlow(UiState<LivenessResponse>(idle = true))
     val livenessUiState = _livenessUiState.asStateFlow()
 
+    private val _serverAvailabilityUiState = MutableStateFlow(UiState<LivenessResponse>(idle = true))
+    val serverAvailabilityUiState = _serverAvailabilityUiState.asStateFlow()
+
     init {
         viewModelScope.launch {
             getUser()
@@ -132,9 +137,6 @@ class LoginViewModel(
                         is Result.Success -> {
                             Log.v("LoginViewModel", "Liveness: ${result.data}")
                             _livenessUiState.success(result.data)
-//                            if (result.data != null) {
-//                                _livenessUiState.success(result.data)
-//                            }
                             sendLogin()
                         }
                     }
@@ -142,6 +144,30 @@ class LoginViewModel(
         }
     }
 
+    fun checkServerAvailability(){
+        viewModelScope.launch {
+            livenessUseCase.invoke(serverUrl.value)
+                .collect { result ->
+                    when (result) {
+                        is Result.Error -> {
+                            Log.v("LoginViewModel", "Server Availability error")
+                            val error = result.error?.throwable?.message?:result.error?.message?:"Unknown error"
+                            _serverAvailabilityUiState.error(errorMessage = error)
+                        }
+                        is Result.Loading -> {
+                            _serverAvailabilityUiState.isLoading(true)
+                        }
+
+                        is Result.Success -> {
+                            Log.v("LoginViewModel", "Server Availability: ${result.data}")
+                            delay(1000)
+                            _serverAvailabilityUiState.success(result.data)
+                        }
+                    }
+                }
+        }
+    }
+
     fun clearState() {
         _userUiState.success(null)
         _livenessUiState.success(null)
@@ -165,4 +191,8 @@ class LoginViewModel(
             rememberSession.value = true
         }
     }
+
+    fun resetServerAvailabilityUiState() {
+        _serverAvailabilityUiState.idle(true)
+    }
 }
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/ServerUrlTextField.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/ServerUrlTextField.kt
index cb53fb4..8273874 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/ServerUrlTextField.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/login/ServerUrlTextField.kt
@@ -1,46 +1,116 @@
 package com.desarrollodroide.pagekeeper.ui.login
 
 import android.webkit.URLUtil
+import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.size
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.CheckCircle
 import androidx.compose.material.icons.filled.Link
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LocalContentColor
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import com.desarrollodroide.model.LivenessResponse
+import com.desarrollodroide.pagekeeper.ui.components.UiState
 
 @Composable
 fun ServerUrlTextField(
+    modifier: Modifier,
+    serverAvailabilityUiState: UiState<LivenessResponse>,
     serverUrl: MutableState<String>,
-    serverErrorState: MutableState<Boolean>
+    serverErrorState: MutableState<Boolean>,
+    serverVersion: String,
+    resetServerAvailabilityState: () -> Unit,
+    onClick: () -> Unit,
+    isTestingServer: Boolean
 ) {
-    Column() {
+    val serverUrlAvailable = serverAvailabilityUiState.data?.ok == true
+    var isFocused by remember { mutableStateOf(false) }
+
+    Column(
+        modifier = modifier
+    ) {
         OutlinedTextField(
             value = serverUrl.value,
             leadingIcon = {
-                Icon(imageVector = Icons.Filled.Link, contentDescription = null)
+                Icon(
+                    imageVector = Icons.Filled.Link,
+                    contentDescription = null
+                )
+            },
+            trailingIcon = {
+                if (isTestingServer) {
+                    CircularProgressIndicator(
+                        modifier = Modifier.size(24.dp),
+                        strokeWidth = 2.dp
+                    )
+                } else if (serverUrlAvailable) {
+                    Icon(
+                        imageVector = Icons.Default.CheckCircle,
+                        contentDescription = "visibility",
+                    )
+                }
             },
             onValueChange = {
                 serverErrorState.value = !URLUtil.isValidUrl(it)
                 serverUrl.value = it
+                if (serverUrlAvailable || serverAvailabilityUiState.error != null) {
+                    resetServerAvailabilityState()
+                }
             },
             isError = serverErrorState.value,
-            modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier
+                .fillMaxWidth()
+                .onFocusChanged { focusState ->
+                    if (isFocused && !focusState.isFocused && URLUtil.isValidUrl(serverUrl.value)) {
+                        onClick()
+                    }
+                    isFocused = focusState.isFocused
+                },
             label = {
                 Text(text = "Server url")
             },
+            singleLine = true,
+            maxLines = 1
         )
-        if (serverErrorState.value) {
+
+        AnimatedVisibility(visible = serverErrorState.value) {
             Text(
                 modifier = Modifier.align(Alignment.End),
                 color = Color.Red,
                 text = "Invalid url"
             )
         }
+
+        AnimatedVisibility(visible = serverUrlAvailable && serverVersion.isNotEmpty()) {
+            Text(
+                modifier = Modifier.align(Alignment.Start),
+                text = "Server v$serverVersion"
+            )
+        }
+
+        AnimatedVisibility(visible = serverAvailabilityUiState.error != null) {
+            Text(
+                modifier = Modifier.align(Alignment.End),
+                color = Color.Red,
+                text = serverAvailabilityUiState.error ?: ""
+            )
+        }
     }
 }
\ No newline at end of file
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/AccountSection.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/AccountSection.kt
index 121c129..4ba5b74 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/AccountSection.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/AccountSection.kt
@@ -16,7 +16,6 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
 
 @Composable
@@ -39,6 +38,13 @@ fun AccountSection(
             style = MaterialTheme.typography.titleSmall
         )
         Spacer(modifier = Modifier.height(5.dp))
+        ClickableOption(
+            Item(
+                "Logout",
+                icon = Icons.AutoMirrored.Filled.Logout,
+                onClick = onLogout
+            ),
+        )
         ClickableOption(
             Item(
                 title = "Server Settings Guide",
@@ -49,7 +55,7 @@ fun AccountSection(
         ClickableOption(
             item = Item(
                 title = "Source Code",
-                icon = Icons.Filled.Code, // Icono que representa código fuente
+                icon = Icons.Filled.Code,
                 onClick = onNavigateToSourceCode
             )
         )
@@ -74,13 +80,5 @@ fun AccountSection(
                 onClick = onNavigateToPrivacyPolicy
             )
         )
-        ClickableOption(
-            Item(
-                "Logout",
-                icon = Icons.AutoMirrored.Filled.Logout,
-                onClick = onLogout
-            ),
-            color = Color.Red
-        )
     }
 }
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/ClickableOption.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/ClickableOption.kt
index 87b418a..97643bc 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/ClickableOption.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/ClickableOption.kt
@@ -2,19 +2,27 @@ package com.desarrollodroide.pagekeeper.ui.settings
 
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Person
+import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 
 @Composable
-fun ClickableOption(item: Item, color: Color = Color.Black) {
+fun ClickableOption(
+    item: Item,
+) {
     Row(
         modifier = Modifier
             .fillMaxWidth()
@@ -23,9 +31,89 @@ fun ClickableOption(item: Item, color: Color = Color.Black) {
         horizontalArrangement = Arrangement.Start
     ) {
         Icon(item.icon, contentDescription = item.title)
-        Text(
-            modifier = Modifier.padding(10.dp),
-            text = item.title
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(vertical = 10.dp)
+        ) {
+            Text(
+                modifier = Modifier
+                    .padding(horizontal = 10.dp),
+                text = item.title
+            )
+            if (item.subtitle.isNotEmpty()){
+                Text(
+                    modifier = Modifier
+                        .padding(horizontal = 10.dp),
+                    text = item.subtitle,
+                    style = MaterialTheme.typography.labelSmall)
+            }
+        }
+    }
+}
+
+@Composable
+fun ClickableOption(
+    title: String,
+    icon: ImageVector,
+    subtitle: String = "",
+    onClick: () -> Unit
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.Start
+    ) {
+        Icon(icon, contentDescription = title)
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(vertical = 10.dp)
+        ) {
+            Text(
+                modifier = Modifier
+                    .padding(horizontal = 10.dp),
+                text = title
+            )
+            if (subtitle.isNotEmpty()) {
+                Text(
+                    modifier = Modifier
+                        .padding(horizontal = 10.dp),
+                    text = subtitle,
+                    style = MaterialTheme.typography.labelSmall
+                )
+            }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun ClickableOptionPreviewWithSubtitle() {
+    MaterialTheme {
+        ClickableOption(
+            item = Item(
+                title = "Settings",
+                subtitle = "Set your preferences",
+                icon = Icons.Default.Settings,
+                onClick = {}
+            )
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun ClickableOptionPreviewWithoutSubtitle() {
+    MaterialTheme {
+        ClickableOption(
+            item = Item(
+                title = "Profile",
+                icon = Icons.Default.Person,
+                onClick = {}
+            )
         )
     }
 }
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/FeedSection.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/FeedSection.kt
new file mode 100644
index 0000000..55ae075
--- /dev/null
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/FeedSection.kt
@@ -0,0 +1,110 @@
+package com.desarrollodroide.pagekeeper.ui.settings
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Sell
+import androidx.compose.material.icons.filled.ViewCompactAlt
+import androidx.compose.material3.BottomSheetDefaults
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.Text
+import androidx.compose.material3.rememberModalBottomSheetState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.desarrollodroide.model.Tag
+import com.desarrollodroide.pagekeeper.ui.components.InfiniteProgressDialog
+import com.desarrollodroide.pagekeeper.ui.components.UiState
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.launch
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun FeedSection(
+    compactView: MutableStateFlow<Boolean>,
+    onClickHideDialogOption: () -> Unit,
+    onSelectHideDialogOption: (Tag?) -> Unit,
+    tagsUiState: UiState<List<Tag>>,
+    hideTag: Tag?,
+    ) {
+    val isCategoriesVisible = remember { mutableStateOf(false) }
+
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp)
+            .padding(top = 12.dp, bottom = 5.dp)
+    ) {
+        Text(
+            text = "Bookmark list",
+            style = MaterialTheme.typography.titleSmall
+        )
+        Spacer(modifier = Modifier.height(5.dp))
+
+        val compatViewItem = Item(
+            title = "Compact view",
+            icon = Icons.Filled.ViewCompactAlt,
+            switchState = compactView
+        )
+
+        SwitchOption(
+            item = compatViewItem,
+            switchState = compactView
+        )
+
+        ClickableOption(
+            title = "Hide tag",
+            icon = Icons.Filled.Sell,
+            subtitle = hideTag?.name ?: "None",
+            onClick = onClickHideDialogOption
+        )
+
+        if (tagsUiState.isLoading) {
+            InfiniteProgressDialog(onDismissRequest = {})
+        }
+
+        val sheetStateCategories = rememberModalBottomSheetState(
+            skipPartiallyExpanded = false
+        )
+
+        LaunchedEffect(tagsUiState) {
+            if (tagsUiState.data != null) {
+                isCategoriesVisible.value = true
+            }
+        }
+
+        if (isCategoriesVisible.value) {
+            val scope = rememberCoroutineScope()
+            ModalBottomSheet(
+                shape = BottomSheetDefaults.ExpandedShape,
+                onDismissRequest = {
+                    isCategoriesVisible.value = false
+                },
+                sheetState = sheetStateCategories,
+            ) {
+                val categories: List<Tag> = tagsUiState.data ?: emptyList()
+                val categoriesState = remember { mutableStateOf(categories) }
+                HideCategoryOptionView(
+                    hideTag = hideTag,
+                    uniqueCategories = categoriesState,
+                    onApply = { selectedTag ->
+                        scope.launch {
+                            sheetStateCategories.hide()
+                            isCategoriesVisible.value = false
+                            onSelectHideDialogOption(selectedTag)
+                        }
+                    },
+                )
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/HideCategoryOptionView.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/HideCategoryOptionView.kt
new file mode 100644
index 0000000..4080ced
--- /dev/null
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/HideCategoryOptionView.kt
@@ -0,0 +1,122 @@
+package com.desarrollodroide.pagekeeper.ui.settings
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Sell
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import com.desarrollodroide.model.Tag
+import com.desarrollodroide.pagekeeper.ui.components.Categories
+import com.desarrollodroide.pagekeeper.ui.components.CategoriesType
+
+@Composable
+fun HideCategoryOptionView(
+    onApply: (Tag?) -> Unit,
+    uniqueCategories: MutableState<List<Tag>>,
+    hideTag: Tag?,
+) {
+    val selectedTags = remember { mutableStateOf(hideTag?.let { listOf(it) } ?: listOf()) }
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(16.dp),
+        horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+        Text("Select category to hide", style = MaterialTheme.typography.headlineSmall)
+        Spacer(Modifier.height(8.dp))
+        if (uniqueCategories.value.isEmpty()) {
+            Row(
+                horizontalArrangement = Arrangement.Center,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier
+                    .padding(vertical = 16.dp)
+                    .fillMaxWidth()
+            ) {
+                Icon(
+                    imageVector = Icons.Outlined.Sell,
+                    contentDescription = "No categories available",
+                    modifier = Modifier.size(24.dp)
+                )
+                Spacer(Modifier.width(8.dp))
+                Text(
+                    "No categories available",
+                    style = MaterialTheme.typography.bodyLarge
+                )
+            }
+        } else {
+            Categories(
+                categoriesType = CategoriesType.SELECTABLES,
+                showCategories = true,
+                uniqueCategories = uniqueCategories,
+                selectedTags = selectedTags,
+                onCategoriesSelectedChanged = { tags ->
+                    selectedTags.value = tags
+                },
+                singleSelection = true
+            )
+        }
+
+        Spacer(Modifier.height(24.dp))
+        Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
+            Button(
+                onClick = {
+                    selectedTags.value = listOf()
+                    onApply(null)
+                },
+                modifier = Modifier.weight(1f)
+            ) {
+                Text("None")
+            }
+            Spacer(Modifier.width(8.dp))
+            Button(
+                onClick = {
+                    onApply(selectedTags.value.firstOrNull())
+                },
+                modifier = Modifier.weight(1f),
+                enabled = uniqueCategories.value.isNotEmpty()
+            ) {
+                Text("Apply")
+            }
+        }
+        Spacer(modifier = Modifier.height(20.dp))
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun SortAndFilterScreenPreview() {
+    val regionOptions = remember {
+        mutableStateOf(
+            listOf(
+                Tag("Northern Europe"), Tag("Western Europe"),
+                Tag("Southern Europe"), Tag("Southeast Europe"),
+                Tag("Central Europe"), Tag("Eastern Europe")
+            )
+        )
+    }
+    MaterialTheme {
+        HideCategoryOptionView(
+            onApply = {},
+            uniqueCategories = regionOptions,
+            hideTag = null
+        )
+    }
+}
\ No newline at end of file
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/SettingsScreen.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/SettingsScreen.kt
index 3a78b1a..4caa616 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/SettingsScreen.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/SettingsScreen.kt
@@ -32,6 +32,7 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import com.desarrollodroide.data.helpers.SHIORI_GITHUB_URL
 import com.desarrollodroide.data.helpers.ThemeMode
+import com.desarrollodroide.model.Tag
 import com.desarrollodroide.pagekeeper.extensions.openUrlInBrowser
 import com.desarrollodroide.pagekeeper.ui.components.ErrorDialog
 import com.desarrollodroide.pagekeeper.ui.components.InfiniteProgressDialog
@@ -54,6 +55,9 @@ fun SettingsScreen(
         onBack()
     }
     val settingsUiState = settingsViewModel.settingsUiState.collectAsState().value
+    val tagsUiState = settingsViewModel.tagsState.collectAsState().value
+    val tagToHide = settingsViewModel.tagToHide.collectAsState().value
+
     Scaffold(
         topBar = {
             CenterAlignedTopAppBar(
@@ -80,6 +84,7 @@ fun SettingsScreen(
         ) {
             SettingsContent(
                 settingsUiState = settingsUiState,
+                tagsUiState = tagsUiState,
                 onLogout = { settingsViewModel.logout() },
                 goToLogin = goToLogin,
                 themeMode = settingsViewModel.themeMode,
@@ -90,7 +95,10 @@ fun SettingsScreen(
                 onNavigateToTermsOfUse = onNavigateToTermsOfUse,
                 onNavigateToPrivacyPolicy = onNavigateToPrivacyPolicy,
                 onNavigateToSourceCode = onNavigateToSourceCode,
-                useDynamicColors = settingsViewModel.useDynamicColors
+                useDynamicColors = settingsViewModel.useDynamicColors,
+                onClickHideDialogOption = settingsViewModel::getTags,
+                onSelectHideDialogOption = settingsViewModel::setHideTag,
+                hideTag = tagToHide
             )
         }
     }
@@ -104,13 +112,17 @@ fun SettingsContent(
     createArchive: MutableStateFlow<Boolean>,
     compatView: MutableStateFlow<Boolean>,
     onLogout: () -> Unit,
-    onNavigateToSourceCode: () -> Unit ,
+    onNavigateToSourceCode: () -> Unit,
     onNavigateToTermsOfUse: () -> Unit,
     onNavigateToPrivacyPolicy: () -> Unit,
     themeMode: MutableStateFlow<ThemeMode>,
     goToLogin: () -> Unit,
     useDynamicColors: MutableStateFlow<Boolean>,
-) {
+    tagsUiState: UiState<List<Tag>>,
+    onClickHideDialogOption: () -> Unit,
+    onSelectHideDialogOption: (Tag?) -> Unit,
+    hideTag: Tag?,
+    ) {
     val context = LocalContext.current
     if (settingsUiState.isLoading) {
         InfiniteProgressDialog(onDismissRequest = {})
@@ -141,11 +153,19 @@ fun SettingsContent(
             Spacer(modifier = Modifier.height(8.dp))
             VisualSection(
                 themeMode = themeMode,
-                compactView = compatView,
                 dynamicColors = useDynamicColors
             )
             HorizontalDivider()
             Spacer(modifier = Modifier.height(18.dp))
+            FeedSection(
+                compactView = compatView,
+                tagsUiState = tagsUiState,
+                onSelectHideDialogOption = onSelectHideDialogOption,
+                onClickHideDialogOption = onClickHideDialogOption,
+                hideTag = hideTag
+            )
+            HorizontalDivider()
+            Spacer(modifier = Modifier.height(18.dp))
             DefaultsSection(
                 makeArchivePublic = makeArchivePublic,
                 createEbook = createEbook,
@@ -190,6 +210,7 @@ private fun HorizontalDivider(){
 data class Item(
     val title: String,
     val icon: ImageVector,
+    val subtitle: String = "",
     val onClick: () -> Unit = {},
     val switchState: MutableStateFlow<Boolean> = MutableStateFlow(false)
 )
@@ -198,18 +219,21 @@ data class Item(
 @Composable
 fun SettingsScreenPreview() {
     SettingsContent(
-        onLogout = {},
-        goToLogin = {},
         settingsUiState = UiState(isLoading = false),
-        themeMode = remember { MutableStateFlow(ThemeMode.AUTO)},
         makeArchivePublic = remember { MutableStateFlow(false) },
-        createArchive = remember { MutableStateFlow(false) },
         createEbook = remember { MutableStateFlow(false) },
-        onNavigateToTermsOfUse = {},
-        onNavigateToPrivacyPolicy = {},
-        //onCompactViewChanged = remember { MutableStateFlow(false) },
+        createArchive = remember { MutableStateFlow(false) },
         compatView = remember { MutableStateFlow(false) },
+        onLogout = {},
         onNavigateToSourceCode = {},
-        useDynamicColors = remember { MutableStateFlow(false) }
+        onNavigateToTermsOfUse = {},
+        onNavigateToPrivacyPolicy = {},
+        themeMode = remember { MutableStateFlow(ThemeMode.AUTO)},
+        goToLogin = {},
+        useDynamicColors = remember { MutableStateFlow(false) },
+        tagsUiState = UiState(isLoading = false),
+        onClickHideDialogOption = {},
+        onSelectHideDialogOption = {},
+        hideTag = null,
     )
 }
\ No newline at end of file
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/SettingsViewModel.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/SettingsViewModel.kt
index c773353..f95ea5a 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/SettingsViewModel.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/SettingsViewModel.kt
@@ -12,27 +12,38 @@ import com.desarrollodroide.common.result.Result
 import com.desarrollodroide.data.helpers.ThemeMode
 import com.desarrollodroide.data.local.preferences.SettingsPreferenceDataSource
 import com.desarrollodroide.data.repository.BookmarksRepository
+import com.desarrollodroide.domain.usecase.GetTagsUseCase
 import com.desarrollodroide.domain.usecase.SendLogoutUseCase
+import com.desarrollodroide.model.Tag
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
 
 class SettingsViewModel(
     private val sendLogoutUseCase: SendLogoutUseCase,
     private val bookmarksRepository: BookmarksRepository,
     private val settingsPreferenceDataSource: SettingsPreferenceDataSource,
-    private val themeManager: ThemeManager
+    private val themeManager: ThemeManager,
+    private val getTagsUseCase: GetTagsUseCase
 ) : ViewModel() {
 
     private val _settingsUiState = MutableStateFlow(UiState<String>(isLoading = false))
     val settingsUiState = _settingsUiState.asStateFlow()
 
+    private val _tagsState = MutableStateFlow(UiState<List<Tag>>(idle = true))
+    val tagsState = _tagsState.asStateFlow()
+
+    private val _tagToHide = MutableStateFlow<Tag?>(null)
+    val tagToHide = _tagToHide.asStateFlow()
+
     val makeArchivePublic = MutableStateFlow<Boolean>(false)
     val createEbook = MutableStateFlow<Boolean>(false)
     val createArchive = MutableStateFlow<Boolean>(false)
     val compactView = MutableStateFlow<Boolean>(false)
     val useDynamicColors = MutableStateFlow<Boolean>(false)
     val themeMode = MutableStateFlow<ThemeMode>(ThemeMode.AUTO)
+    private var token = ""
 
     init {
         loadSettings()
@@ -74,6 +85,40 @@ class SettingsViewModel(
             compactView.value = settingsPreferenceDataSource.getCompactView()
             useDynamicColors.value = settingsPreferenceDataSource.getUseDynamicColors()
             themeMode.value = settingsPreferenceDataSource.getThemeMode()
+            token = settingsPreferenceDataSource.getToken()
+            _tagToHide.value = settingsPreferenceDataSource.getHideTag()
+        }
+    }
+
+    fun getTags() {
+      viewModelScope.launch {
+            getTagsUseCase.invoke(
+                serverUrl = settingsPreferenceDataSource.getUrl(),
+                token = token,
+            )
+                .distinctUntilChanged()
+                .collect() { result ->
+                    when (result) {
+                        is Result.Error -> {
+                            Log.v("FeedViewModel", "Error getting tags: ${result.error?.message}")
+                        }
+                        is Result.Loading -> {
+                            Log.v("FeedViewModel", "Loading, updating tags from cache...")
+                            _tagsState.isLoading(true)
+                        }
+                        is Result.Success -> {
+                            Log.v("FeedViewModel", "Tags loaded successfully.")
+                            _tagsState.success(result.data)
+                        }
+                    }
+                }
+        }
+    }
+
+    fun setHideTag(tag: Tag?) {
+        viewModelScope.launch {
+            settingsPreferenceDataSource.setHideTag(tag)
+            _tagToHide.value = tag
         }
     }
 
diff --git a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/VisualSection.kt b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/VisualSection.kt
index 73191f3..9d78bd7 100644
--- a/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/VisualSection.kt
+++ b/presentation/src/main/java/com/desarrollodroide/pagekeeper/ui/settings/VisualSection.kt
@@ -11,10 +11,10 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.DarkMode
+import androidx.compose.material.icons.filled.FormatColorFill
 import androidx.compose.material.icons.filled.HdrAuto
 import androidx.compose.material.icons.filled.LightMode
 import androidx.compose.material.icons.filled.Palette
-import androidx.compose.material.icons.filled.ViewCompactAlt
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -30,7 +30,6 @@ import kotlinx.coroutines.flow.MutableStateFlow
 @Composable
 fun VisualSection(
     themeMode: MutableStateFlow<ThemeMode>,
-    compactView: MutableStateFlow<Boolean>,
     dynamicColors: MutableStateFlow<Boolean>,
 ) {
     Column(
@@ -42,29 +41,14 @@ fun VisualSection(
         Text(text = "Visual", style = MaterialTheme.typography.titleSmall)
         Spacer(modifier = Modifier.height(5.dp))
         ThemeOption(
-            item = Item("Theme", Icons.Filled.Palette, onClick = {
-                val newMode = when (themeMode.value) {
-                    ThemeMode.DARK -> ThemeMode.LIGHT
-                    ThemeMode.LIGHT -> ThemeMode.AUTO
-                    ThemeMode.AUTO -> ThemeMode.DARK
-                }
-            }),
+            item = Item("Theme", Icons.Filled.Palette, onClick = {}),
             initialThemeMode = themeMode
         )
-        val compatViewItem = Item(
-            title = "Compact view",
-            icon = Icons.Filled.ViewCompactAlt,
-            switchState = compactView
-        )
         val dynamicColorItem = Item(
             title = "Use dynamic colors",
-            icon = Icons.Filled.Palette,
+            icon = Icons.Filled.FormatColorFill,
             switchState = dynamicColors
         )
-        SwitchOption(
-            item = compatViewItem,
-            switchState = compactView
-        )
         SwitchOption(
             item = dynamicColorItem,
             switchState = dynamicColors