diff --git a/frontend/components/text-classifier/labeling-rules/RuleDefinition.vue b/frontend/components/text-classifier/labeling-rules/RuleDefinition.vue
index 5412121d88e..b57abaf0e61 100644
--- a/frontend/components/text-classifier/labeling-rules/RuleDefinition.vue
+++ b/frontend/components/text-classifier/labeling-rules/RuleDefinition.vue
@@ -5,25 +5,16 @@
         <rule-empty-query :dataset="dataset" v-if="!query" />
         <rule-labels-definition
           v-else
-          :current-rule="currentRule"
           :dataset="dataset"
-          @update-rule="updateRule"
-          @update-labels="updateLabels"
+          @save-rule="saveRule"
+          @update-rule="updateCurrentRule"
         >
-          <template v-if="recordsMetric" #records-metric>
-            Records
-            <strong>
-              {{ recordsMetric.value }}
-            </strong>
-          </template>
         </rule-labels-definition>
       </div>
       <div class="rule__metrics">
         <rules-metrics
-          @records-metric="onUpdateRecordsMetric"
           title="Rule Metrics"
           metrics-type="all"
-          :activeLabel="activeLabel"
           :key="refresh"
           :rules="rules"
           :dataset="dataset"
@@ -31,6 +22,7 @@
           <template #button-bottom>
             <re-button
               class="rule__button button-quaternary--outline"
+              :disabled="isLoading"
               @click="showRulesList"
               >Manage rules</re-button
             >
@@ -44,66 +36,87 @@
   </div>
 </template>
 <script>
-import { mapActions } from "vuex";
+import { TextClassificationDataset } from "@/models/TextClassification";
 export default {
   props: {
     dataset: {
-      type: Object,
-      default: () => ({}),
+      type: TextClassificationDataset,
+      required: true,
     },
   },
   data: () => {
     return {
-      rules: [],
-      selectedLabels: [],
-      currentRule: undefined,
-      recordsMetric: undefined,
+      activeLabel: undefined,
       refresh: 0,
     };
   },
   async fetch() {
-    await this.getAllRules();
-    this.currentRule = await this.getRule({
-      dataset: this.dataset,
-      query: this.query,
-    });
+    if (this.rules === undefined) {
+      await this.dataset.refreshRules();
+    }
+    if (!this.hasMetrics) {
+      await this.dataset.refreshRulesMetrics();
+    }
+  },
+  watch: {
+    async activeLabel(newValue) {
+      await this.updateCurrentRule({ query: this.query, label: newValue });
+    },
+    async query(newValue) {
+      await this.updateCurrentRule({
+        query: newValue,
+        label: this.activeLabel,
+      });
+    },
   },
   computed: {
     query() {
       return this.dataset.query.text;
     },
-    activeLabel() {
-      return this.selectedLabels.length ? this.selectedLabels[0] : undefined;
+    isLoading() {
+      return this.$fetchState.pending;
     },
-  },
-  watch: {
-    async query(n, o) {
-      if (o !== n) {
-        this.refresh++;
-        await this.$fetch();
-      }
+    currentRule() {
+      return this.dataset.getCurrentLabelingRule();
+    },
+    hasMetrics() {
+      return this.overalMetrics && this.rulesMetrics;
+    },
+    rules() {
+      return this.dataset.labelingRules;
+    },
+    overalMetrics() {
+      return this.dataset.labelingRulesOveralMetrics;
+    },
+    rulesMetrics() {
+      return this.dataset.labelingRulesMetrics;
     },
   },
   methods: {
-    async getAllRules() {
-      this.rules = await this.getRules({ dataset: this.dataset });
+    async updateCurrentRule({ query, label, description }) {
+      if (!query) {
+        return await this.dataset.clearCurrentLabelingRule();
+      }
+
+      const rule = this.dataset.findRuleByQuery(query, label);
+      if (rule) {
+        await this.dataset.setCurrentLabelingRule(rule);
+      } else if (label) {
+        await this.dataset.setCurrentLabelingRule({
+          query,
+          label,
+          description: description || query,
+        });
+      } else {
+        await this.dataset.clearCurrentLabelingRule();
+      }
     },
     async showRulesList() {
       await this.dataset.viewSettings.enableRulesSummary();
     },
-    async updateRule() {
-      await this.$fetch();
-    },
-    updateLabels(labels) {
-      this.selectedLabels = labels;
-    },
-    onUpdateRecordsMetric(met) {
-      this.recordsMetric = met;
+    async saveRule(rule) {
+      await this.dataset.storeLabelingRule(rule);
     },
-    ...mapActions({
-      getRules: "entities/text_classification/getRules",
-      getRule: "entities/text_classification/getRule",
-    }),
   },
 };
 </script>
diff --git a/frontend/components/text-classifier/labeling-rules/RuleLabelsDefinition.vue b/frontend/components/text-classifier/labeling-rules/RuleLabelsDefinition.vue
index e8b53b9d5a8..9ee6a8a4389 100644
--- a/frontend/components/text-classifier/labeling-rules/RuleLabelsDefinition.vue
+++ b/frontend/components/text-classifier/labeling-rules/RuleLabelsDefinition.vue
@@ -18,9 +18,14 @@
 <template>
   <div class="rule-labels-definition">
     <div class="rule-labels-definition__info">
-      <input v-model="description" class="rule__description" />
+      <input v-model="descriptionVModel" class="rule__description" />
       <p class="rule__records">
-        <slot name="records-metric" />
+        Records:
+        <strong>{{
+          isNaN(currentRuleMetrics.records)
+            ? "-"
+            : $options.filters.formatNumber(currentRuleMetrics.records)
+        }}</strong>
       </p>
     </div>
     <div class="rule__labels" v-if="labels.length">
@@ -33,13 +38,12 @@
         v-for="label in visibleLabels"
         :id="label.class"
         :key="`${label.class}`"
-        v-model="selectedLabels"
-        :allow-multiple="isMultiLabel"
+        v-model="selectedLabelsVModel"
+        :allow-multiple="false"
         :label="label"
         class="label-button"
         :data-title="label.class"
         :value="label.class"
-        @change="updateLabels"
       >
       </ClassifierAnnotationButton>
 
@@ -47,14 +51,14 @@
         v-if="visibleLabels.length < filteredLabels.length"
         href="#"
         class="feedback-interactions__more"
-        @click.prevent="expandLabels()"
+        @click.prevent="expandLabels"
         >+{{ filteredLabels.length - visibleLabels.length }}</a
       >
       <a
         v-else-if="visibleLabels.length > maxVisibleLabels"
         href="#"
         class="feedback-interactions__more"
-        @click.prevent="collapseLabels()"
+        @click.prevent="collapseLabels"
         >Show less</a
       >
     </div>
@@ -69,25 +73,11 @@
         >.
       </p>
     </div>
-    <p
-      class="rule__info"
-      v-if="
-        currentRule &&
-        selectedLabels.includes(currentRule.label) &&
-        currentRule.description === description
-      "
-    >
-      {{
-        saved
-          ? "The rule has been saved"
-          : "This query with this label are already saved as rule"
-      }}.
-    </p>
+    <p class="rule__info" v-if="ruleInfo">{{ ruleInfo }}</p>
     <re-button
-      v-else
-      :disabled="!selectedLabels.length"
+      :disabled="!selectedLabelsVModel.length"
       class="feedback-interactions__button button-primary"
-      @click="createRule()"
+      @click="saveRule"
     >
       Save rule</re-button
     >
@@ -96,59 +86,77 @@
 <script>
 import { mapActions } from "vuex";
 import { DatasetViewSettings } from "@/models/DatasetViewSettings";
+import { TextClassificationDataset } from "@/models/TextClassification";
 
 export default {
   props: {
     dataset: {
-      type: Object,
+      type: TextClassificationDataset,
       required: true,
     },
-    currentRule: {
-      type: Object,
-      default: undefined,
-    },
   },
   data: () => {
     return {
       saved: false,
       searchText: "",
-      selectedLabels: [],
       shownLabels: DatasetViewSettings.MAX_VISIBLE_LABELS,
-      description: undefined,
+      selectedLabelsVModel: [],
+      descriptionVModel: undefined,
     };
   },
   computed: {
+    currentRule() {
+      return this.dataset.getCurrentLabelingRule();
+    },
+
+    currentRuleMetrics() {
+      return this.dataset.getCurrentLabelingRuleMetrics() || {};
+    },
+
+    selectedLabel() {
+      if (this.selectedLabelsVModel !== undefined) {
+        return this.selectedLabelsVModel[0];
+      }
+    },
+
+    ruleInfo() {
+      // TODO: We can improve this
+      if (
+        this.currentRule &&
+        this.dataset.findRuleByQuery(
+          this.currentRule.query,
+          this.currentRule.label
+        )
+      ) {
+        return "This query with this label are already saved as rule";
+      }
+    },
+
     maxVisibleLabels() {
       return DatasetViewSettings.MAX_VISIBLE_LABELS;
     },
-    isMultiLabel() {
-      return this.dataset.isMultiLabel;
-    },
     query() {
       return this.dataset.query.text;
     },
     labels() {
       return this.dataset.labels.map((l) => ({ class: l, selected: false }));
     },
-    sortedLabels() {
-      return this.labels.slice().sort((a, b) => (a.score > b.score ? -1 : 1));
-    },
     filteredLabels() {
-      return this.sortedLabels.filter((label) =>
+      return this.labels.filter((label) =>
         label.class.toLowerCase().match(this.searchText)
       );
     },
     visibleLabels() {
-      const selectedLabels = this.filteredLabels.filter((l) =>
-        this.selectedLabels.includes(l.class)
+      const selectedLabelsVModel = this.filteredLabels.filter((l) =>
+        this.selectedLabelsVModel.includes(l.class)
       ).length;
       const availableNonSelected =
         this.shownLabels < this.filteredLabels.length
-          ? this.shownLabels - selectedLabels
+          ? this.shownLabels - selectedLabelsVModel
           : this.shownLabels;
       let nonSelected = 0;
       return this.filteredLabels.filter((l) => {
-        if (this.selectedLabels.includes(l.class)) {
+        if (this.selectedLabelsVModel.includes(l.class)) {
           return l;
         } else {
           if (nonSelected < availableNonSelected) {
@@ -160,54 +168,42 @@ export default {
     },
   },
   watch: {
-    currentRule(n) {
+    selectedLabel(newValue) {
+      // Here send description too --> update Rule
+      this.$emit("update-rule", {
+        query: this.query,
+        label: newValue,
+        description: this.descriptionVModel,
+      });
+    },
+    currentRule() {
       this.setDescription();
-      if (n) {
-        this.selectedLabels = [n.label];
-        this.$emit("update-labels", [n.label]);
-      }
     },
-    query(n) {
+    query() {
       this.setDescription();
-      this.saved = false;
-      if (!n) {
-        this.selectedLabels = [];
-        this.$emit("update-labels", undefined);
-      }
     },
   },
   mounted() {
     this.setDescription();
-    if (this.currentRule) {
-      this.selectedLabels = this.currentRule ? [this.currentRule.label] : [];
-    }
+    this.selectedLabelsVModel = this.currentRule
+      ? [this.currentRule.label]
+      : [];
   },
   methods: {
     ...mapActions({
       changeViewMode: "entities/datasets/changeViewMode",
-      defineRule: "entities/text_classification/defineRule",
-      updateRule: "entities/text_classification/updateRule",
     }),
-    async createRule() {
-      if (this.currentRule) {
-        await this.updateRule({
-          dataset: this.dataset,
-          label: this.selectedLabels[0],
-          description: this.description,
-        });
-      } else {
-        await this.defineRule({
-          dataset: this.dataset,
-          label: this.selectedLabels[0],
-          description: this.description,
-        });
-      }
+    saveRule() {
       this.saved = true;
       this.collapseLabels();
-      this.$emit("update-rule");
+      this.$emit("save-rule", {
+        query: this.currentRule.query,
+        label: this.currentRule.label,
+        description: this.descriptionVModel,
+      });
     },
     setDescription() {
-      this.description = this.currentRule
+      this.descriptionVModel = this.currentRule
         ? this.currentRule.description
         : this.query;
     },
@@ -220,9 +216,6 @@ export default {
     onSearchLabel(event) {
       this.searchText = event;
     },
-    updateLabels(labels) {
-      this.$emit("update-labels", labels);
-    },
     async changeToAnnotationViewMode() {
       await this.changeViewMode({
         dataset: this.dataset,
diff --git a/frontend/components/text-classifier/labeling-rules/RulesManagement.vue b/frontend/components/text-classifier/labeling-rules/RulesManagement.vue
index 1ff5af592c4..505c5dc38ef 100644
--- a/frontend/components/text-classifier/labeling-rules/RulesManagement.vue
+++ b/frontend/components/text-classifier/labeling-rules/RulesManagement.vue
@@ -11,7 +11,7 @@
         <template #button-top>
           <re-button
             class="rules-management__close button-quaternary--outline"
-            @click="hideList()"
+            @click="hideList"
           >
             <svgicon
               name="chev-left"
@@ -51,7 +51,7 @@
         <re-button
           v-if="formattedRules.length"
           class="button-primary"
-          @click="updateSummary()"
+          @click="updateSummary"
           >Update Summary</re-button
         >
       </div>
@@ -61,18 +61,18 @@
 <script>
 import "assets/icons/empty-rules";
 import { mapActions } from "vuex";
+import { TextClassificationDataset } from "@/models/TextClassification";
 export default {
   props: {
     dataset: {
-      type: Object,
-      default: () => ({}),
+      type: TextClassificationDataset,
+      required: true,
     },
   },
   data: () => {
     return {
       querySearch: undefined,
       visibleModalId: undefined,
-      rules: [],
       metricsByLabel: {},
       tableColumns: [
         {
@@ -112,10 +112,17 @@ export default {
     };
   },
   async fetch() {
-    this.rules = await this.getRules({ dataset: this.dataset });
-    await this.getMetricsByLabel();
+    if (this.dataset.perRuleQueryMetrics === null) {
+      this.dataset.refreshRulesMetrics();
+    }
   },
   computed: {
+    rules() {
+      return this.dataset.labelingRules;
+    },
+    perRuleMetrics() {
+      return this.dataset.perRuleQueryMetrics || {};
+    },
     isVisible() {
       return this.dataset.viewSettings.visibleRulesList;
     },
@@ -126,11 +133,7 @@ export default {
           query: r.query,
           kind: "select",
           label: r.label,
-          coverage: this.metricsByLabel[r.query].coverage,
-          coverage_annotated: this.metricsByLabel[r.query].coverage_annotated,
-          correct: this.metricsByLabel[r.query].correct,
-          incorrect: this.metricsByLabel[r.query].incorrect,
-          precision: this.metricsByLabel[r.query].precision,
+          ...this.metricsForRule(r),
         };
       });
     },
@@ -147,33 +150,24 @@ export default {
   methods: {
     ...mapActions({
       search: "entities/datasets/search",
-      getRules: "entities/text_classification/getRules",
       deleteRule: "entities/text_classification/deleteRule",
-      getRuleMetricsByLabel:
-        "entities/text_classification/getRuleMetricsByLabel",
     }),
+
+    metricsForRule(rule) {
+      return this.perRuleMetrics[rule.query];
+    },
+
     async hideList() {
       await this.dataset.viewSettings.disableRulesSummary();
     },
 
-    async getMetricsByLabel() {
-      const responses = await Promise.all(
-        this.rules.map((rule) => {
-          return this.getRuleMetricsByLabel({
-            dataset: this.dataset,
-            query: rule.query,
-            label: rule.label,
-          });
-        })
-      );
-
-      responses.forEach((response, idx) => {
-        this.metricsByLabel[this.rules[idx].query] = response;
-      });
-    },
-    async onSelectQuery(id) {
-      if (id.query !== this.dataset.query.text) {
-        await this.search({ dataset: this.dataset, query: { text: id.query } });
+    async onSelectQuery(rule) {
+      await this.dataset.setCurrentLabelingRule(rule);
+      if (rule.query !== this.dataset.query.text) {
+        await this.search({
+          dataset: this.dataset,
+          query: { text: rule.query },
+        });
       }
       await this.hideList();
     },
diff --git a/frontend/components/text-classifier/labeling-rules/RulesMetrics.vue b/frontend/components/text-classifier/labeling-rules/RulesMetrics.vue
index b59bbebb709..97bbb8e420d 100644
--- a/frontend/components/text-classifier/labeling-rules/RulesMetrics.vue
+++ b/frontend/components/text-classifier/labeling-rules/RulesMetrics.vue
@@ -3,39 +3,22 @@
     <p class="rule-metrics__title">{{ title }}</p>
     <slot name="button-top" />
     <div class="rule-metrics">
-      <template v-if="$fetchState.pending">
-        <div
-          class="rule-metrics__item"
-          v-for="(field, index) in placeholderFields"
-          :key="index"
-        >
-          <p class="metric__title">{{ field }}</p>
-          <p class="metric__placeholder">-</p>
-        </div>
-      </template>
-      <template v-else-if="!$fetchState.error">
+      <template>
         <div
           :class="[metricsType, 'rule-metrics__item']"
           v-for="metric in metrics"
           :key="metric.name"
         >
-          <p
-            class="metric__title"
-            :data-title="
-              metricsType === 'overall'
-                ? metric.overall.tooltip
-                : metric.rule.tooltip
-            "
-          >
+          <p class="metric__title" :data-title="metricsTitle(metric)">
             {{ metric.name }}
           </p>
-          <p class="metric__rule" v-if="metricsType !== 'overall'">
+          <p class="metric__rule" v-if="!onlyOveralMetrics">
             <transition name="fade" mode="out-in" appear>
               <strong :key="metric.rule.value">{{ metric.rule.value }}</strong>
             </transition>
           </p>
-          <span class="metric__overall" v-if="metricsType !== 'rule'">
-            <template v-if="metricsType === 'all'">{{
+          <span class="metric__overall">
+            <template v-if="!onlyOveralMetrics">{{
               metric.overall.description
             }}</template>
             <transition name="fade" mode="out-in" appear>
@@ -52,48 +35,54 @@
 </template>
 
 <script>
-import { mapActions } from "vuex";
+import { TextClassificationDataset } from "@/models/TextClassification";
 
 export default {
   props: {
-    title: {
-      type: String,
-      default: "Metrics",
-    },
     dataset: {
-      type: Object,
+      type: TextClassificationDataset,
       required: true,
     },
-    rules: {
-      type: Array,
+
+    title: {
+      type: String,
+      required: true,
     },
+
     metricsType: {
       type: String,
       default: "all",
       validator: (value) => {
-        return ["all", "overall", "rule"].includes(value);
+        return ["all", "overall"].includes(value);
       },
     },
-    activeLabel: {
-      type: String,
-    },
   },
   data: () => {
     return {
-      metricsByLabel: {},
       metricsByRules: {},
-      metricsTotal: {},
       refresh: 0,
     };
   },
-  async fetch() {
-    await this.getMetricsByLabel();
-    if (this.rules.length) {
-      await this.getMetrics();
-      await this.getMetricsByRules();
-    }
-  },
   computed: {
+    rules() {
+      return this.dataset.labelingRules;
+    },
+    metricsTotal() {
+      return this.dataset.labelingRulesOveralMetrics || {};
+    },
+
+    currentRule() {
+      return this.dataset.getCurrentLabelingRule();
+    },
+
+    ruleMetrics() {
+      return this.dataset.getCurrentLabelingRuleMetrics() || {};
+    },
+
+    onlyOveralMetrics() {
+      return this.metricsType === "overall";
+    },
+
     placeholderFields() {
       return [
         "Precision",
@@ -113,7 +102,7 @@ export default {
             refresh: this.refresh,
           },
           rule: {
-            value: this.formatNumber(this.metricsByLabel.precision),
+            value: this.formatNumber(this.ruleMetrics.precision),
             tooltip: "Fraction of correct labels given by the rule",
           },
         },
@@ -130,8 +119,8 @@ export default {
           },
           rule: {
             value:
-              this.metricsByLabel.correct !== undefined
-                ? `${this.metricsByLabel.correct}/${this.metricsByLabel.incorrect}`
+              this.ruleMetrics.correct !== undefined
+                ? `${this.ruleMetrics.correct}/${this.ruleMetrics.incorrect}`
                 : "_/_",
             tooltip:
               "Number of records the rule labeled correctly/incorrectly (if annotations are available)",
@@ -145,7 +134,7 @@ export default {
             value: this.formatNumber(this.metricsTotal.coverage),
           },
           rule: {
-            value: this.formatNumber(this.metricsByLabel.coverage),
+            value: this.formatNumber(this.ruleMetrics.coverage),
             tooltip: "Fraction of records labeled by the rule",
           },
         },
@@ -157,87 +146,24 @@ export default {
             value: this.formatNumber(this.metricsTotal.coverage_annotated),
           },
           rule: {
-            value: this.formatNumber(this.metricsByLabel.coverage_annotated),
+            value: this.formatNumber(this.ruleMetrics.coverage_annotated),
             tooltip: "Fraction of annotated records labeled by the rule",
           },
         },
       ];
     },
-    recordsMetric() {
-      return {
-        name: "Records",
-        value: isNaN(this.metricsByLabel.total_records)
-          ? "-"
-          : this.$options.filters.formatNumber(
-              Math.round(
-                this.metricsByLabel.total_records * this.metricsByLabel.coverage
-              )
-            ),
-        tooltip: "Records matching the query",
-      };
-    },
-  },
-  watch: {
-    async activeLabel(n, o) {
-      if (n !== o) {
-        await this.getMetricsByLabel();
-      }
-    },
-    async rules(n, o) {
-      if (n !== o) {
-        if (this.rules.length) {
-          await Promise.all([this.getMetrics(), this.getMetricsByRules()]);
-        }
-        this.refresh++;
-      }
-    },
-    recordsMetric(n) {
-      this.$emit("records-metric", n);
-    },
   },
   methods: {
-    ...mapActions({
-      getRulesMetrics: "entities/text_classification/getRulesMetrics",
-      getRuleMetricsByLabel:
-        "entities/text_classification/getRuleMetricsByLabel",
-    }),
+    metricsTitle(metric) {
+      return this.onlyOveralMetrics
+        ? metric.overall.tooltip
+        : metric.rule.tooltip;
+    },
 
     formatNumber(value) {
       return isNaN(value) ? "-" : this.$options.filters.percent(value);
     },
 
-    async getMetrics() {
-      this.metricsTotal = await this.getRulesMetrics({
-        dataset: this.dataset,
-      });
-    },
-    async getMetricsByRules() {
-      const responses = await Promise.all(
-        this.rules.map((rule) => {
-          return this.getRuleMetricsByLabel({
-            dataset: this.dataset,
-            query: rule.query,
-            label: rule.label,
-          });
-        })
-      );
-
-      responses.forEach((response, idx) => {
-        this.metricsByRules[this.rules[idx].query] = response;
-      });
-    },
-    async getMetricsByLabel() {
-      if (this.activeLabel !== undefined) {
-        const response = await this.getRuleMetricsByLabel({
-          dataset: this.dataset,
-          query: this.dataset.query.text,
-          label: this.activeLabel,
-        });
-        this.metricsByLabel = response;
-      } else {
-        this.metricsByLabel = {};
-      }
-    },
     getValuesByMetricType(type) {
       return Object.keys(this.metricsByRules).map((key) => {
         return this.metricsByRules[key][type];
diff --git a/frontend/components/text-classifier/results/RecordTextClassification.vue b/frontend/components/text-classifier/results/RecordTextClassification.vue
index 4d8cfaf7746..43126eaea63 100644
--- a/frontend/components/text-classifier/results/RecordTextClassification.vue
+++ b/frontend/components/text-classifier/results/RecordTextClassification.vue
@@ -66,12 +66,11 @@
 <script>
 import "assets/icons/predicted-ok";
 import "assets/icons/predicted-ko";
-
+import { mapActions } from "vuex";
 import {
   TextClassificationRecord,
   TextClassificationDataset,
 } from "@/models/TextClassification";
-import { mapActions } from "vuex";
 export default {
   props: {
     dataset: {
diff --git a/frontend/database/modules/datasets.js b/frontend/database/modules/datasets.js
index 016ea5bac1b..979f9758370 100644
--- a/frontend/database/modules/datasets.js
+++ b/frontend/database/modules/datasets.js
@@ -346,7 +346,6 @@ async function _updateDatasetRecords({
   const updatedDataset = await entity.update({
     where: dataset.name,
     data: {
-      ...dataset,
       results: {
         ...dataset.results,
         aggregations: {
diff --git a/frontend/database/modules/text_classification.js b/frontend/database/modules/text_classification.js
index e35468ab980..33d8e5faf4c 100644
--- a/frontend/database/modules/text_classification.js
+++ b/frontend/database/modules/text_classification.js
@@ -16,6 +16,7 @@
  */
 
 import { ObservationDataset } from "@/models/Dataset";
+import { TextClassificationDataset } from "@/models/TextClassification";
 
 const getters = {};
 
@@ -27,14 +28,14 @@ const actions = {
     });
   },
   async getRules(_, { dataset }) {
-    const { response } = await ObservationDataset.api().get(
+    const { response } = await TextClassificationDataset.api().get(
       `/datasets/${dataset.task}/${dataset.name}/labeling/rules`
     );
     return response.data;
   },
 
   async defineRule(_, { dataset, label, description }) {
-    await ObservationDataset.api().post(
+    await TextClassificationDataset.api().post(
       `/datasets/${dataset.task}/${dataset.name}/labeling/rules`,
       {
         query: dataset.query.text,
@@ -45,7 +46,7 @@ const actions = {
   },
 
   async updateRule(_, { dataset, label, description }) {
-    await ObservationDataset.api().patch(
+    await TextClassificationDataset.api().patch(
       `/datasets/${dataset.task}/${dataset.name}/labeling/rules/${dataset.query.text}`,
       {
         label: label,
@@ -55,7 +56,7 @@ const actions = {
   },
 
   async getRule(_, { dataset, query }) {
-    const { response } = await ObservationDataset.api().get(
+    const { response } = await TextClassificationDataset.api().get(
       `/datasets/${dataset.task}/${dataset.name}/labeling/rules/${query}`,
       {
         // Ignore errors related to rule not found
@@ -71,20 +72,20 @@ const actions = {
   },
 
   async deleteRule(_, { dataset, query }) {
-    await ObservationDataset.api().delete(
+    await TextClassificationDataset.api().delete(
       `/datasets/${dataset.task}/${dataset.name}/labeling/rules/${query}`
     );
   },
 
   async getRulesMetrics(_, { dataset }) {
-    const { response } = await ObservationDataset.api().get(
+    const { response } = await TextClassificationDataset.api().get(
       `/datasets/${dataset.task}/${dataset.name}/labeling/rules/metrics`
     );
     return response.data;
   },
 
   async getRuleMetricsByLabel(_, { dataset, query, label }) {
-    const { response } = await ObservationDataset.api().get(
+    const { response } = await TextClassificationDataset.api().get(
       `/datasets/${dataset.task}/${dataset.name}/labeling/rules/${query}/metrics?label=${label}`
     );
     return response.data;
diff --git a/frontend/models/TextClassification.js b/frontend/models/TextClassification.js
index ed496c71033..1cb48800ef2 100644
--- a/frontend/models/TextClassification.js
+++ b/frontend/models/TextClassification.js
@@ -72,30 +72,110 @@ class TextClassificationDataset extends ObservationDataset {
   static fields() {
     return {
       ...super.fields(),
+      _labels: this.attr([]),
+      // Search fields
       query: this.attr({}, (data) => {
         return new TextClassificationSearchQuery(data);
       }),
       sort: this.attr([]),
-      _labels: this.attr([]),
       results: this.attr(
         {},
         (data) => new TextClassificationSearchResults(data)
       ),
+      // Some kind of metrics fields
       globalResults: this.attr({}),
+      // labeling rules fields
+      rules: this.attr(null),
+      rulesOveralMetrics: this.attr(null),
+      perRuleQueryMetrics: this.attr(null),
+      activeRule: this.attr(null),
+      activeRuleMetrics: this.attr(null),
     };
   }
 
+  static apiConfig = {
+    save: false,
+  };
+
   async initialize() {
     const { labels } = await this.fetchMetricSummary("dataset_labels");
     const entity = this.getTaskDatasetClass();
     await entity.insertOrUpdate({
       where: this.name,
+      data: [
+        {
+          owner: this.owner,
+          name: this.name,
+          _labels: labels,
+        },
+      ],
+    });
+    return entity.find(this.name);
+  }
+
+  async _fetchAllRules() {
+    const { response } = await TextClassificationDataset.api().get(
+      `/datasets/${this.task}/${this.name}/labeling/rules`
+    );
+    return response.data;
+  }
+
+  async _fetchOveralMetrics() {
+    const { response } = await TextClassificationDataset.api().get(
+      `/datasets/${this.task}/${this.name}/labeling/rules/metrics`
+    );
+    return response.data;
+  }
+
+  async _fetchRuleMetrics({ query, label }) {
+    const { response } = await TextClassificationDataset.api().get(
+      `/datasets/${this.task}/${this.name}/labeling/rules/${query}/metrics?label=${label}`
+    );
+
+    const metrics = response.data;
+    // Computed extra metrics
+    metrics.records = Math.round(metrics.total_records * metrics.coverage);
+    return metrics;
+  }
+
+  async refreshRulesMetrics() {
+    if (this.rules === null) {
+      // TODO: maybe we can automatically load rules before metrics
+      throw Error("No rules info found");
+    }
+
+    const overalMetrics = await this._fetchOveralMetrics();
+    const responses = await Promise.all(
+      this.rules.map((rule) => {
+        return this._fetchRuleMetrics(rule);
+      })
+    );
+
+    var perRuleQueryMetrics = {};
+    responses.forEach((response, idx) => {
+      perRuleQueryMetrics[this.rules[idx].query] = response;
+    });
+
+    return await TextClassificationDataset.insertOrUpdate({
       data: {
-        ...this,
-        _labels: labels,
+        owner: this.owner,
+        name: this.name,
+        perRuleQueryMetrics,
+        rulesOveralMetrics: overalMetrics,
+      },
+    });
+  }
+
+  async refreshRules() {
+    const rules = await this._fetchAllRules();
+
+    await TextClassificationDataset.insertOrUpdate({
+      data: {
+        owner: this.owner,
+        name: this.name,
+        rules,
       },
     });
-    return entity.find(this.name);
   }
 
   get isMultiLabel() {
@@ -118,6 +198,100 @@ class TextClassificationDataset extends ObservationDataset {
     uniqueLabels.sort();
     return uniqueLabels;
   }
+
+  get labelingRulesMetrics() {
+    return this.perRuleQueryMetrics === null
+      ? undefined
+      : this.perRuleQueryMetrics;
+  }
+
+  get labelingRules() {
+    return this.rules === null ? undefined : this.rules;
+  }
+
+  get labelingRulesOveralMetrics() {
+    return this.rulesOveralMetrics === null
+      ? undefined
+      : this.rulesOveralMetrics;
+  }
+
+  getCurrentLabelingRule() {
+    return this.activeRule === null ? undefined : this.activeRule;
+  }
+
+  getCurrentLabelingRuleMetrics() {
+    return this.activeRuleMetrics === null ? undefined : this.activeRuleMetrics;
+  }
+
+  async setCurrentLabelingRule({ query, label, description }) {
+    if (
+      this.currentLabelingRule &&
+      query === this.currentLabelingRule.query &&
+      label === this.currentLabelingRule.label
+    ) {
+      return;
+    }
+
+    let rule = this.findRuleByQuery(query, label);
+    let ruleMetrics = this.getMetricsByRule(rule);
+
+    await TextClassificationDataset.insertOrUpdate({
+      data: {
+        owner: this.owner,
+        name: this.name,
+        activeRule: rule || {
+          query,
+          label,
+          description: description || query,
+        },
+        activeRuleMetrics:
+          ruleMetrics || (await this._fetchRuleMetrics({ query, label })),
+      },
+    });
+  }
+
+  async storeLabelingRule(newRule) {
+    // await this._persistRule({ query, label, description });
+
+    const newRules = this.rules.filter((rule) => rule.query !== newRule.query);
+    newRules.push(newRule);
+
+    await TextClassificationDataset.insertOrUpdate({
+      data: {
+        owner: this.owner,
+        name: this.name,
+        rules: newRules,
+        activeRule: newRule,
+        perRuleQueryMetrics: {
+          ...this.perRuleQueryMetrics,
+          [newRule.query]: this.activeRuleMetrics,
+        },
+      },
+    });
+  }
+
+  async clearCurrentLabelingRule() {
+    await TextClassificationDataset.insertOrUpdate({
+      data: {
+        owner: this.owner,
+        name: this.name,
+        activeRule: null,
+        activeRuleMetrics: null,
+      },
+    });
+  }
+
+  findRuleByQuery(query, label = undefined) {
+    for (let rule of this.labelingRules || []) {
+      if (rule.query === query && [rule.label, undefined].includes(label)) {
+        return rule;
+      }
+    }
+  }
+
+  getMetricsByRule(rule) {
+    if (rule) return (this.labelingRulesMetrics || {})[rule.query];
+  }
 }
 
 ObservationDataset.registerTaskDataset(