diff --git a/backend/core-api/src/commands/migrateContentType.ts b/backend/core-api/src/commands/migrateContentType.ts
index 6106bead9b..bedb50fef7 100644
--- a/backend/core-api/src/commands/migrateContentType.ts
+++ b/backend/core-api/src/commands/migrateContentType.ts
@@ -60,6 +60,9 @@ const command = async () => {
   }
 
   console.log(`Process finished at: ${new Date().toISOString()}`);
+
+  await client.close();
+  process.exit();
 };
 
 command();
diff --git a/backend/core-api/src/commands/migrateTags.ts b/backend/core-api/src/commands/migrateTags.ts
new file mode 100644
index 0000000000..b5bb83fdf5
--- /dev/null
+++ b/backend/core-api/src/commands/migrateTags.ts
@@ -0,0 +1,44 @@
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+import { Collection, Db, MongoClient } from 'mongodb';
+
+const { MONGO_URL = 'mongodb://localhost:27017/erxes?directConnection=true' } =
+  process.env;
+
+if (!MONGO_URL) {
+  throw new Error(`Environment variable MONGO_URL not set.`);
+}
+
+const client = new MongoClient(MONGO_URL);
+
+let db: Db;
+let Tags: Collection;
+
+const command = async () => {
+  await client.connect();
+  db = client.db() as Db;
+
+  Tags = db.collection('tags');
+
+  try {
+    await Tags.updateMany(
+      {},
+      {
+        $unset: { scopeBrandIds: '' },
+        $set: { isGroup: false, parentId: '', order: '' }, // flatten parentId: no nested parent tags allowed
+      },
+    );
+  } catch (e) {
+    console.log(`Error occurred: ${e.message}`);
+    await client.close();
+  }
+
+  console.log(`Process finished at: ${new Date().toISOString()}`);
+
+  await client.close();
+  process.exit();
+};
+
+command();
diff --git a/backend/core-api/src/modules/contacts/trpc/customer.ts b/backend/core-api/src/modules/contacts/trpc/customer.ts
index 9883abf68b..a181c7e0bc 100644
--- a/backend/core-api/src/modules/contacts/trpc/customer.ts
+++ b/backend/core-api/src/modules/contacts/trpc/customer.ts
@@ -223,5 +223,31 @@ export const customerRouter = t.router({
           data: doc,
         });
       }),
+
+    tag: t.procedure.input(z.any()).mutation(async ({ ctx, input }) => {
+      const { action, _ids, tagIds, targetIds } = input;
+      const { models } = ctx;
+
+      let response = {};
+
+      if (action === 'count') {
+        response = await models.Customers.countDocuments({
+          tagIds: { $in: _ids },
+        });
+      }
+
+      if (action === 'tagObject') {
+        await models.Customers.updateMany(
+          { _id: { $in: targetIds } },
+          { $set: { tagIds } },
+        );
+
+        response = await models.Customers.find({
+          _id: { $in: targetIds },
+        }).lean();
+      }
+
+      return response;
+    }),
   }),
 });
diff --git a/backend/core-api/src/modules/documents/db/definitions/documents.ts b/backend/core-api/src/modules/documents/db/definitions/documents.ts
index bab5d867a1..71bb4a0357 100644
--- a/backend/core-api/src/modules/documents/db/definitions/documents.ts
+++ b/backend/core-api/src/modules/documents/db/definitions/documents.ts
@@ -8,7 +8,7 @@ export const documentSchema = new Schema(
     name: { type: String },
     content: { type: String },
     replacer: { type: String },
-    code: { type: String },
+    code: { type: String, optional: true },
   },
   {
     timestamps: true,
diff --git a/backend/core-api/src/modules/tags/@types/tag.ts b/backend/core-api/src/modules/tags/@types/tag.ts
index 99a6529a96..2c17be78f2 100644
--- a/backend/core-api/src/modules/tags/@types/tag.ts
+++ b/backend/core-api/src/modules/tags/@types/tag.ts
@@ -9,6 +9,7 @@ export interface ITagFilterQueryParams
   type: string;
   tagIds?: string[];
   parentId?: string;
+  isGroup?: boolean;
   ids: string[];
   excludeIds: boolean;
 }
diff --git a/backend/core-api/src/modules/tags/db/definitions/tags.ts b/backend/core-api/src/modules/tags/db/definitions/tags.ts
index 0efc713887..a68c823129 100644
--- a/backend/core-api/src/modules/tags/db/definitions/tags.ts
+++ b/backend/core-api/src/modules/tags/db/definitions/tags.ts
@@ -5,26 +5,15 @@ export const tagSchema = schemaWrapper(
   new Schema(
     {
       _id: mongooseStringRandomId,
-      name: { type: String, label: 'Name' },
-      type: {
-        type: String,
-        label: 'Type',
-        index: true,
-      },
+      name: { type: String, label: 'Name', unique: true },
       colorCode: { type: String, label: 'Color code' },
+      parentId: { type: String, label: 'Parent' },
+      relatedIds: { type: [String], label: 'Children tag ids' },
+      isGroup: { type: Boolean, label: 'Is group', default: false },
+      type: { type: String, label: 'Content type' },
+      description: { type: String, label: 'Description' },
       objectCount: { type: Number, label: 'Object count' },
-      order: { type: String, label: 'Order', index: true },
-      parentId: {
-        type: String,
-        optional: true,
-        index: true,
-        label: 'Parent',
-      },
-      relatedIds: {
-        type: [String],
-        optional: true,
-        label: 'Children tag ids',
-      },
+      order: { type: String, label: 'Order' },
     },
     {
       timestamps: true,
@@ -32,5 +21,4 @@ export const tagSchema = schemaWrapper(
   ),
 );
 
-// for tags query. increases search speed, avoids in-memory sorting
-tagSchema.index({ _id: 1, type: 1, order: 1, name: 1, createdAt: 1 });
+tagSchema.index({ _id: 1, name: 1, parentId: 1, type: 1 });
diff --git a/backend/core-api/src/modules/tags/db/models/Tags.ts b/backend/core-api/src/modules/tags/db/models/Tags.ts
index 3503765656..5ad2f69eca 100644
--- a/backend/core-api/src/modules/tags/db/models/Tags.ts
+++ b/backend/core-api/src/modules/tags/db/models/Tags.ts
@@ -1,9 +1,9 @@
-import { escapeRegExp } from 'erxes-api-shared/utils';
+import { tagSchema } from '@/tags/db/definitions/tags';
+import { removeRelatedTagIds, setRelatedTagIds } from '@/tags/utils';
 import { ITag, ITagDocument } from 'erxes-api-shared/core-types';
+import { escapeRegExp } from 'erxes-api-shared/utils';
 import { Model } from 'mongoose';
 import { IModels } from '~/connectionResolvers';
-import { removeRelatedTagIds, setRelatedTagIds } from '@/tags/utils';
-import { tagSchema } from '@/tags/db/definitions/tags';
 export interface ITagModel extends Model<ITagDocument> {
   getTag(_id: string): Promise<ITagDocument>;
   createTag(doc: ITag): Promise<ITagDocument>;
@@ -13,9 +13,57 @@ export interface ITagModel extends Model<ITagDocument> {
 
 export const loadTagClass = (models: IModels) => {
   class Tag {
-    /*
-     * Get a tag
-     */
+    public static async validate(_id: string | null, doc: ITag) {
+      const { name, parentId, isGroup } = doc;
+
+      const existingTag = await models.Tags.findOne({
+        name,
+        _id: { $ne: _id },
+      }).lean();
+
+      if (existingTag) {
+        throw new Error(`A tag named ${name} already exists`);
+      }
+
+      const tag = _id ? await models.Tags.findOne({ _id }).lean() : null;
+
+      if (String(_id) === String(parentId)) {
+        throw new Error('Group cannot be itself');
+      }
+
+      if (parentId) {
+        const parentTag = await models.Tags.findOne({ _id: parentId }).lean();
+
+        if (!parentTag) {
+          throw new Error('Group not found');
+        }
+
+        if (!parentTag.isGroup) {
+          throw new Error('Parent tag must be a group');
+        }
+
+        if ((isGroup || tag?.isGroup) && parentTag?.isGroup) {
+          throw new Error('Nested group is not allowed 2 ');
+        }
+      }
+
+      if (tag) {
+        const parentTag = await models.Tags.findOne({
+          _id: tag.parentId,
+        }).lean();
+
+        const childTags = await models.Tags.find({ parentId: tag._id }).lean();
+
+        if (parentTag?.isGroup && isGroup) {
+          throw new Error('Nested group is not allowed 3');
+        }
+
+        if (!isGroup && childTags.length) {
+          throw new Error('Group has tags');
+        }
+      }
+    }
+
     public static async getTag(_id: string) {
       const tag = await models.Tags.findOne({ _id });
 
@@ -26,25 +74,14 @@ export const loadTagClass = (models: IModels) => {
       return tag;
     }
 
-    /**
-     * Create a tag
-     */
     public static async createTag(doc: ITag) {
-      const isUnique = await this.validateUniqueness(null, doc.name, doc.type);
+      await this.validate(null, doc);
 
-      if (!isUnique) {
-        throw new Error('Tag duplicated');
-      }
-
-      const parentTag = await this.getParentTag(doc);
-
-      // Generatingg order
-      const order = await this.generateOrder(parentTag, doc);
+      const order = await this.generateOrder(doc);
 
       const tag = await models.Tags.create({
         ...doc,
         order,
-        createdAt: new Date(),
       });
 
       await setRelatedTagIds(models, tag);
@@ -52,39 +89,21 @@ export const loadTagClass = (models: IModels) => {
       return tag;
     }
 
-    /**
-     * Update Tag
-     */
     public static async updateTag(_id: string, doc: ITag) {
-      const isUnique = await this.validateUniqueness(
-        { _id },
-        doc.name,
-        doc.type,
-      );
-
-      if (!isUnique) {
-        throw new Error('Tag duplicated');
-      }
-
-      const parentTag = await this.getParentTag(doc);
-
-      if (parentTag && parentTag.parentId === _id) {
-        throw new Error('Cannot change tag');
-      }
+      await this.validate(_id, doc);
 
       const tag = await models.Tags.getTag(_id);
 
-      // Generatingg  order
-      const order = await this.generateOrder(parentTag, doc);
+      const order = await this.generateOrder(doc);
 
       const childTags = await models.Tags.find({
         $and: [
-          { order: { $regex: new RegExp(escapeRegExp(tag.order || ''), 'i') } },
           { _id: { $ne: _id } },
+          { order: { $regex: new RegExp(escapeRegExp(tag.order || ''), 'i') } },
         ],
       });
 
-      if (childTags.length > 0) {
+      if (childTags.length) {
         const bulkDoc: Array<{
           updateOne: {
             filter: { _id: string };
@@ -92,8 +111,8 @@ export const loadTagClass = (models: IModels) => {
           };
         }> = [];
 
-        // updating child tag order
-        childTags.forEach((childTag) => {
+        // updating child categories order
+        childTags.forEach(async (childTag) => {
           let childOrder = childTag.order || '';
 
           childOrder = childOrder.replace(tag.order || '', order);
@@ -111,9 +130,16 @@ export const loadTagClass = (models: IModels) => {
         await removeRelatedTagIds(models, tag);
       }
 
-      await models.Tags.updateOne({ _id }, { $set: { ...doc, order } });
-
-      const updated = await models.Tags.findOne({ _id });
+      const updated = await models.Tags.findOneAndUpdate(
+        { _id: tag._id },
+        {
+          ...doc,
+          order,
+        },
+        {
+          new: true,
+        },
+      );
 
       if (updated) {
         await setRelatedTagIds(models, updated);
@@ -122,79 +148,27 @@ export const loadTagClass = (models: IModels) => {
       return updated;
     }
 
-    /**
-     * Remove Tag
-     */
     public static async removeTag(_id: string) {
       const tag = await models.Tags.getTag(_id);
 
-      const childCount = await models.Tags.countDocuments({
-        parentId: _id,
-      });
+      const childTagIds = await models.Tags.find({ parentId: _id }).distinct(
+        '_id',
+      );
 
-      if (childCount > 0) {
-        throw new Error('Please remove child tags first');
-      }
+      await models.Tags.updateMany(
+        { _id: { $in: childTagIds } },
+        { $unset: { parentId: 1 } },
+      );
 
       await removeRelatedTagIds(models, tag);
 
       return models.Tags.deleteOne({ _id });
     }
 
-    /*
-     * Validates tag uniquness
-     */
-    public static async validateUniqueness(
-      selector: any,
-      name: string,
-      type: string,
-    ): Promise<boolean> {
-      // required name and type
-      if (!name || !type) {
-        return true;
-      }
-
-      // can't update name & type same time more than one tags.
-      const count = await models.Tags.countDocuments(selector);
-
-      if (selector && count > 1) {
-        return false;
-      }
-
-      const obj = selector && (await models.Tags.findOne(selector));
-
-      const filter: any = { name, type };
-
-      if (obj) {
-        filter._id = { $ne: obj._id };
-      }
-
-      const existing = await models.Tags.findOne(filter);
-
-      if (existing) {
-        return false;
-      }
-
-      return true;
-    }
-
-    /*
-     * Get a parent tag
-     */
-    static async getParentTag(doc: ITag) {
-      return models.Tags.findOne({
-        _id: doc.parentId,
-      }).lean();
-    }
+    public static async generateOrder({ name, parentId }: ITag) {
+      const tag = await models.Tags.findOne({ _id: parentId }).lean();
 
-    /**
-     * Generating order
-     */
-    public static async generateOrder(
-      parentTag: ITagDocument | null,
-      { name }: { name: string },
-    ) {
-      const order = parentTag ? `${parentTag.order}${name}/` : `${name}/`;
+      const order = tag?.order ? `${tag.order}${name}/` : `${name}/`;
 
       return order;
     }
diff --git a/backend/core-api/src/modules/tags/graphql/customResolvers/tag.ts b/backend/core-api/src/modules/tags/graphql/customResolvers/tag.ts
index b32449202d..d8eb3d0832 100644
--- a/backend/core-api/src/modules/tags/graphql/customResolvers/tag.ts
+++ b/backend/core-api/src/modules/tags/graphql/customResolvers/tag.ts
@@ -1,7 +1,38 @@
+import { ITagDocument } from 'erxes-api-shared/core-types';
 import { IContext } from '~/connectionResolvers';
+import { countDocuments } from '~/modules/tags/utils';
 
 export default {
-  async __resolveReference({ _id }, { models }: IContext) {
+  async __resolveReference({ _id }: { _id: string }, { models }: IContext) {
     return models.Tags.findOne({ _id });
   },
+
+  async totalObjectCount(
+    tag: ITagDocument,
+    _args: undefined,
+    { subdomain }: IContext,
+  ) {
+
+    if(!tag.type) {
+      return 0;
+    }
+
+    if (tag.relatedIds && tag.relatedIds.length > 0) {
+      const tagIds = tag.relatedIds.concat(tag._id);
+
+      return countDocuments(subdomain, tag.type, tagIds);
+    }
+  },
+
+  async objectCount(
+    tag: ITagDocument,
+    _args: undefined,
+    { subdomain }: IContext,
+  ) {
+    if(!tag.type) {
+      return 0;
+    }
+
+    return countDocuments(subdomain, tag.type, [tag._id]);
+  },
 };
diff --git a/backend/core-api/src/modules/tags/graphql/mutations.ts b/backend/core-api/src/modules/tags/graphql/mutations.ts
index 7b837ad8fe..9c1080273c 100644
--- a/backend/core-api/src/modules/tags/graphql/mutations.ts
+++ b/backend/core-api/src/modules/tags/graphql/mutations.ts
@@ -41,12 +41,13 @@ export const tagMutations = {
       );
     }
 
-    const existingTagsCount = await models.Tags.countDocuments({
-      _id: { $in: tagIds },
+    const tags = await models.Tags.find({
       type,
+      _id: { $in: tagIds },
+      isGroup: { $ne: true },
     });
 
-    if (existingTagsCount !== tagIds.length) {
+    if (tags.length !== tagIds.length) {
       throw new Error('Tag not found.');
     }
 
@@ -68,7 +69,7 @@ export const tagMutations = {
 
       return await model.updateMany(
         { _id: { $in: targetIds } },
-        { $set: { tagIds } },
+        { $set: { tagIds: tags.map((tag) => tag._id) } },
       );
     }
 
@@ -78,7 +79,7 @@ export const tagMutations = {
       module: moduleName,
       action: 'tag',
       input: {
-        tagIds,
+        tagIds: tags.map((tag) => tag._id),
         targetIds,
         type: moduleName,
         action: 'tagObject',
@@ -96,18 +97,4 @@ export const tagMutations = {
   ) {
     return models.Tags.removeTag(_id);
   },
-
-  /**
-   * Merge tags
-   */
-  async tagsMerge(
-    _parent: undefined,
-    { sourceId, destId }: { sourceId: string; destId: string },
-    { models }: IContext,
-  ) {
-    // remove old tag
-    await models.Tags.removeTag(sourceId);
-
-    return models.Tags.getTag(destId);
-  },
 };
diff --git a/backend/core-api/src/modules/tags/graphql/queries.ts b/backend/core-api/src/modules/tags/graphql/queries.ts
index 35fc787769..2ab681e619 100644
--- a/backend/core-api/src/modules/tags/graphql/queries.ts
+++ b/backend/core-api/src/modules/tags/graphql/queries.ts
@@ -2,38 +2,42 @@ import { ITagFilterQueryParams } from '@/tags/@types/tag';
 import { cursorPaginate, getPlugin, getPlugins } from 'erxes-api-shared/utils';
 import { FilterQuery } from 'mongoose';
 import { IContext } from '~/connectionResolvers';
-import { getContentTypes } from '../utils';
 
 const generateFilter = async ({ params, commonQuerySelector, models }) => {
-  const { type, searchValue, tagIds, parentId, ids, excludeIds } = params;
+  const { searchValue, parentId, ids, excludeIds, isGroup, type } = params;
 
-  const filter: FilterQuery<ITagFilterQueryParams> = { ...commonQuerySelector };
+  const filter: FilterQuery<ITagFilterQueryParams> = {
+    ...commonQuerySelector,
+    type: { $in: [null, ''] },
+  };
 
   if (type) {
-    const [serviceName, contentType] = type.split(':');
+    let contentType = type;
 
-    if (contentType === 'all') {
-      const contentTypes: string[] = await getContentTypes(serviceName);
-      filter.type = { $in: contentTypes };
-    } else {
-      filter.type = type;
+    const [_pluginName, _moduleName, instanceId] = contentType.split(':');
+
+    if (!instanceId && params.instanceId) {
+      contentType = `${contentType}:${params.instanceId}`;
     }
+
+    filter.type = contentType;
   }
 
   if (searchValue) {
     filter.name = new RegExp(`.*${searchValue}.*`, 'i');
   }
 
-  if (tagIds) {
-    filter._id = { $in: tagIds };
+  if (ids?.length) {
+    filter._id = { [excludeIds ? '$nin' : '$in']: ids };
   }
 
-  if (ids && ids.length > 0) {
-    filter._id = { [excludeIds ? '$nin' : '$in']: ids };
+  if (isGroup) {
+    filter.isGroup = isGroup;
   }
 
   if (parentId) {
     const parentTag = await models.Tags.find({ parentId }).distinct('_id');
+
     let ids = [parentId, ...parentTag];
 
     const getChildTags = async (parentTagIds: string[]) => {
@@ -57,18 +61,15 @@ const generateFilter = async ({ params, commonQuerySelector, models }) => {
 
 export const tagQueries = {
   /**
-   * Get tag types
+   * Get tags types
    */
   async tagsGetTypes() {
     const services = await getPlugins();
-
     const fieldTypes: Array<{ description: string; contentType: string }> = [];
-
     for (const serviceName of services) {
       const service = await getPlugin(serviceName);
       const meta = service.config.meta || {};
-
-      if (meta.tags) {
+      if (meta && meta.tags) {
         const types = meta.tags.types || [];
 
         for (const type of types) {
@@ -82,7 +83,6 @@ export const tagQueries = {
 
     return fieldTypes;
   },
-
   /**
    * Get tags
    */
@@ -99,7 +99,10 @@ export const tagQueries = {
 
     const { list, totalCount, pageInfo } = await cursorPaginate({
       model: models.Tags,
-      params,
+      params: {
+        orderBy: { order: 1 },
+        ...params,
+      },
       query: filter,
     });
 
@@ -130,14 +133,11 @@ export const tagQueries = {
     return models.Tags.countDocuments(selector);
   },
 
-  /**
-   * Get one tag
-   */
   async tagDetail(
     _parent: undefined,
     { _id }: { _id: string },
     { models }: IContext,
   ) {
-    return models.Tags.findOne({ _id });
+    return models.Tags.getTag(_id);
   },
 };
diff --git a/backend/core-api/src/modules/tags/graphql/schemas.ts b/backend/core-api/src/modules/tags/graphql/schemas.ts
index ec1b467f4e..c745a4ed4a 100644
--- a/backend/core-api/src/modules/tags/graphql/schemas.ts
+++ b/backend/core-api/src/modules/tags/graphql/schemas.ts
@@ -1,19 +1,21 @@
 import { GQL_CURSOR_PARAM_DEFS } from 'erxes-api-shared/utils';
 
 export const types = `
- type Tag @key(fields: "_id") @cacheControl(maxAge: 3) {
+  type Tag @key(fields: "_id") @cacheControl(maxAge: 3) {
     _id: String
     name: String
-    type: String
     colorCode: String
-    createdAt: Date
-    objectCount: Int
-    totalObjectCount: Int
     parentId: String
-    order: String
     relatedIds: [String]
-
-    cursor: String
+    isGroup: Boolean
+    description: String
+    type: String
+    
+    order: String
+    objectCount: Int
+    totalObjectCount: Int
+    
+    createdAt: Date
   }
 
   type TagsListResponse {
@@ -26,10 +28,11 @@ export const types = `
 const queryParams = `
   type: String,
   searchValue: String,
-  tagIds: [String],
   parentId: String,
   ids: [String],
   excludeIds: Boolean,
+  isGroup: Boolean,
+  instanceId: String,
 
   sortField: String,
 
@@ -44,16 +47,16 @@ export const queries = `
 `;
 
 const mutationParams = `
-  name: String!,
-  type: String!,
+  type: String,
   colorCode: String,
   parentId: String,
+  isGroup: Boolean,
+  description: String,
 `;
 
 export const mutations = `
-  tagsAdd(${mutationParams}): Tag
-  tagsEdit(_id: String!, ${mutationParams}): Tag
-  tagsRemove(_id: String!): JSON
+  tagsAdd(name: String!, ${mutationParams}): Tag
+  tagsEdit(_id: String!, name: String, ${mutationParams}): Tag
   tagsTag(type: String!, targetIds: [String!]!, tagIds: [String!]!): JSON
-  tagsMerge(sourceId: String!, destId: String!): Tag
+  tagsRemove(_id: String!): JSON
 `;
diff --git a/backend/core-api/src/modules/tags/utils.ts b/backend/core-api/src/modules/tags/utils.ts
index 5d4090b98b..ac4b49c917 100644
--- a/backend/core-api/src/modules/tags/utils.ts
+++ b/backend/core-api/src/modules/tags/utils.ts
@@ -1,33 +1,36 @@
 import { ITagDocument } from 'erxes-api-shared/core-types';
-import { getPlugin } from 'erxes-api-shared/utils';
+import { sendTRPCMessage } from 'erxes-api-shared/utils';
 import { IModels } from '~/connectionResolvers';
 
 // set related tags
 export const setRelatedTagIds = async (models: IModels, tag: ITagDocument) => {
-  if (tag.parentId) {
-    const parentTag = await models.Tags.findOne({ _id: tag.parentId });
+  if (!tag.parentId) {
+    return;
+  }
 
-    if (parentTag) {
-      let relatedIds: string[];
+  const parentTag = await models.Tags.findOne({ _id: tag.parentId });
 
-      relatedIds = tag.relatedIds || [];
-      relatedIds.push(tag._id);
+  if (!parentTag) {
+    return;
+  }
 
-      relatedIds = [
-        ...new Set([...relatedIds, ...(parentTag.relatedIds || [])]),
-      ];
+  const relatedIds: string[] = [tag._id, ...(tag.relatedIds || [])];
 
-      await models.Tags.updateOne(
-        { _id: parentTag._id },
-        { $set: { relatedIds } },
-      );
+  await models.Tags.updateOne(
+    { _id: parentTag._id },
+    {
+      $set: {
+        relatedIds: [
+          ...new Set([...relatedIds, ...(parentTag.relatedIds || [])]),
+        ],
+      },
+    },
+  );
 
-      const updated = await models.Tags.findOne({ _id: tag.parentId });
+  const updated = await models.Tags.findOne({ _id: tag.parentId });
 
-      if (updated) {
-        await setRelatedTagIds(models, updated);
-      }
-    }
+  if (updated) {
+    await setRelatedTagIds(models, updated);
   }
 };
 
@@ -67,9 +70,30 @@ export const removeRelatedTagIds = async (
   await models.Tags.bulkWrite(doc);
 };
 
-export const getContentTypes = async (serviceName) => {
-  const service = await getPlugin(serviceName);
-  const meta = service.config.meta || {};
-  const types = (meta.tags && meta.tags.types) || [];
-  return types.map((type) => `${serviceName}:${type.type}`);
+export const countDocuments = async (
+  subdomain: string,
+  type: string,
+  _ids: string[],
+) => {
+  const [pluginName, moduleName] = type.split(':');
+
+  const MODULE_NAMES = {
+    customer: 'customers',
+  };
+
+  if (!MODULE_NAMES[moduleName]) {
+    return 0;
+  }
+
+  return await sendTRPCMessage({
+    pluginName,
+    method: 'mutation',
+    module: MODULE_NAMES[moduleName] || moduleName,
+    action: 'tag',
+    input: {
+      type,
+      _ids,
+      action: 'count',
+    },
+  });
 };
diff --git a/backend/erxes-api-shared/src/core-types/modules/tags/tag.ts b/backend/erxes-api-shared/src/core-types/modules/tags/tag.ts
index fee6b11e46..f084d23f46 100644
--- a/backend/erxes-api-shared/src/core-types/modules/tags/tag.ts
+++ b/backend/erxes-api-shared/src/core-types/modules/tags/tag.ts
@@ -2,15 +2,16 @@ import { Document } from 'mongoose';
 
 export interface ITag {
   name: string;
-  type: string;
   colorCode?: string;
-  objectCount?: number;
   parentId?: string;
+  relatedIds?: string[];
+  isGroup?: boolean;
+  type: string;
+  objectCount?: number;
+  order?: string;
 }
 
 export interface ITagDocument extends ITag, Document {
   _id: string;
   createdAt: Date;
-  order?: string;
-  relatedIds?: string[];
 }
diff --git a/frontend/core-ui/src/modules/settings/tags/components/TagsColumns.tsx b/frontend/core-ui/src/modules/settings/tags/components/TagsColumns.tsx
new file mode 100644
index 0000000000..cd40a61f4d
--- /dev/null
+++ b/frontend/core-ui/src/modules/settings/tags/components/TagsColumns.tsx
@@ -0,0 +1,472 @@
+import { useRemoveTag } from '@/settings/tags/hooks/useRemoveTag';
+import { useTagsEdit } from '@/settings/tags/hooks/useTagsEdit';
+import { useTagContext } from '@/settings/tags/providers/TagProvider';
+import {
+  IconEdit,
+  IconTrash,
+  IconArrowRight,
+  IconX,
+  IconDropletsFilled,
+  IconPlus,
+  IconTransform,
+} from '@tabler/icons-react';
+import { Cell, ColumnDef } from '@tanstack/table-core';
+import {
+  toast,
+  Input,
+  Command,
+  RecordTableInlineCell,
+  RecordTableTree,
+  TextOverflowTooltip,
+  Textarea,
+  useConfirm,
+  useQueryState,
+  RecordTable,
+  Combobox,
+  Popover,
+} from 'erxes-ui';
+import React, { useState } from 'react';
+import { ITag, ITagQueryResponse, useTags } from 'ui-modules';
+import { useTagsAdd } from '@/settings/tags/hooks/useTagsAdd';
+
+const MoveTagPopover: React.FC<{
+  tagId: string;
+  currentParentId?: string;
+  onMove: (tagId: string, newParentId: string | null) => void;
+  trigger: React.ReactNode;
+}> = ({ tagId, currentParentId, onMove, trigger }) => {
+  const [open, setOpen] = React.useState(false);
+
+  const { tags: tagsGroup } = useTags({
+    variables: {
+      isGroup: true,
+    },
+    skip: !open,
+  });
+
+  const handleMove = (newParentId: string | null) => {
+    onMove(tagId, newParentId);
+    setOpen(false);
+  };
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <Popover.Trigger asChild>{trigger}</Popover.Trigger>
+      <Popover.Content side="right" className="w-64 p-0" align="start">
+        <Command>
+          <Command.Input placeholder="Search groups..." className="h-9" />
+          <Command.List>
+            <Command.Empty>No groups found.</Command.Empty>
+
+            {currentParentId && (
+              <>
+                <Command.Item onSelect={() => handleMove(null)}>
+                  <div className="flex items-center gap-1">
+                    <IconX size={16} />
+                    <span>Remove from group</span>
+                  </div>
+                </Command.Item>
+                <Command.Separator />
+              </>
+            )}
+
+            <Command.Group heading="Move to group">
+              {tagsGroup
+                ?.filter((group) => group._id !== currentParentId)
+                .map((group) => (
+                  <Command.Item
+                    key={group._id}
+                    onSelect={() => handleMove(group._id)}
+                  >
+                    <div className="flex items-center gap-2">
+                      {group.colorCode ? (
+                        <div
+                          className="w-3 h-3 rounded"
+                          style={{ backgroundColor: group.colorCode }}
+                        ></div>
+                      ) : (
+                        <IconDropletsFilled
+                          size={12}
+                          className="text-blue-600"
+                        />
+                      )}
+
+                      <span>{group.name}</span>
+                    </div>
+                  </Command.Item>
+                ))}
+            </Command.Group>
+          </Command.List>
+        </Command>
+      </Popover.Content>
+    </Popover>
+  );
+};
+
+const NewItemCell: React.FC = () => {
+  const { mode, targetGroupId, cancel } = useTagContext();
+  const [value, setValue] = React.useState('');
+  const { addTag } = useTagsAdd();
+  React.useEffect(() => {
+    if (
+      mode === 'adding-tag' ||
+      mode === 'adding-group' ||
+      mode === 'adding-tag-to-group'
+    ) {
+      setValue('');
+    }
+  }, [mode]);
+
+  const handleSave = () => {
+    if (value.trim()) {
+      const newTag: ITagQueryResponse = {
+        name: value,
+        isGroup: mode === 'adding-group',
+        parentId: mode === 'adding-tag-to-group' ? targetGroupId : undefined,
+      };
+
+      addTag({
+        variables: newTag,
+        onCompleted: () => {
+          toast({ title: 'Tag added successfully.' });
+        },
+        onError: (error) => {
+          console.log('error', error);
+          toast({
+            title: error.message,
+            variant: 'destructive',
+          });
+        },
+      });
+
+      cancel();
+      setValue('');
+    }
+  };
+
+  const handleCancel = () => {
+    cancel();
+    setValue('');
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter') {
+      e.preventDefault();
+      handleSave();
+    } else if (e.key === 'Escape') {
+      e.preventDefault();
+      handleCancel();
+    }
+  };
+
+  if (mode === 'idle') {
+    return null;
+  }
+
+  return (
+    <Input
+      autoFocus
+      placeholder={
+        mode === 'adding-group'
+          ? 'Enter group name...'
+          : mode === 'adding-tag-to-group'
+          ? 'Enter tag name for this group...'
+          : 'Enter tag name...'
+      }
+      value={value}
+      onChange={(e) => setValue(e.target.value)}
+      onKeyDown={handleKeyDown}
+      onBlur={handleCancel}
+      className="p-2 focus:ring-0"
+    />
+  );
+};
+
+export const TagMoreColumnCell = ({ cell }: { cell: Cell<ITag, unknown> }) => {
+  const confirmOptions = { confirmationValue: 'delete' };
+  const { confirm } = useConfirm();
+  const [, setEditingTagId] = useQueryState('editingTagId');
+  const { removeTag, loading } = useRemoveTag();
+  const { tagsEdit } = useTagsEdit();
+  const { startAddingTagToGroup } = useTagContext();
+
+  const { _id, name, isGroup, parentId, hasChildren } = cell.row.original;
+
+  const handleMoveTag = (tagId: string, newParentId: string | null) => {
+    tagsEdit({
+      variables: { id: tagId, name: name, parentId: newParentId },
+    });
+  };
+
+  const onRemove = () => {
+    confirm({
+      message: 'Are you sure you want to remove the selected?',
+      options: confirmOptions,
+    }).then(async () => {
+      try {
+        removeTag(_id);
+      } catch (e) {
+        console.error(e.message);
+      }
+    });
+  };
+
+  return (
+    <Popover>
+      <Popover.Trigger asChild>
+        <RecordTable.MoreButton className="w-full h-full" />
+      </Popover.Trigger>
+      <Combobox.Content>
+        <Command shouldFilter={false}>
+          <Command.List>
+            <Command.Item
+              value="edit"
+              onSelect={() => {
+                setEditingTagId(_id);
+              }}
+            >
+              <IconEdit /> Edit
+            </Command.Item>
+            {!isGroup && (
+              <MoveTagPopover
+                tagId={_id}
+                currentParentId={parentId}
+                onMove={handleMoveTag}
+                trigger={
+                  <div className="flex items-center gap-2 p-2 text-sm">
+                    <IconArrowRight className="h-4 w-4" />
+                    Move
+                  </div>
+                }
+              />
+            )}
+            {isGroup && (
+              <Command.Item
+                onSelect={() => {
+                  startAddingTagToGroup(_id);
+                }}
+              >
+                <IconPlus /> Add tag to group
+              </Command.Item>
+            )}
+            {isGroup && !hasChildren && (
+              <Command.Item
+                onSelect={() => {
+                  tagsEdit({
+                    variables: {
+                      id: _id,
+                      name: name,
+                      parentId: null,
+                      isGroup: false,
+                    },
+                  });
+                }}
+              >
+                <IconTransform /> Convert to tag
+              </Command.Item>
+            )}
+            {!isGroup && (!parentId || parentId === '') && (
+              <Command.Item
+                onSelect={() => {
+                  tagsEdit({
+                    variables: {
+                      id: _id,
+                      name: name,
+                      isGroup: true,
+                    },
+                  });
+                }}
+              >
+                <IconTransform /> Convert to tag group
+              </Command.Item>
+            )}
+            <Command.Item disabled={loading} value="remove" onSelect={onRemove}>
+              <IconTrash /> Delete
+            </Command.Item>
+          </Command.List>
+        </Command>
+      </Combobox.Content>
+    </Popover>
+  );
+};
+
+export const tagsColumns: ColumnDef<ITag>[] = [
+  {
+    id: 'name',
+    header: 'Name',
+    accessorKey: 'name',
+    cell: ({ cell }) => {
+      const { mode } = useTagContext();
+      const row = cell.row.original;
+
+      if (
+        (mode === 'adding-tag' ||
+          mode === 'adding-group' ||
+          mode === 'adding-tag-to-group') &&
+        row._id === 'new-item-temp'
+      ) {
+        return <NewItemCell />;
+      }
+
+      const { tagsEdit, loading } = useTagsEdit();
+      const { _id, name, isGroup, order } = row;
+      const [editingTagId, setEditingTagId] = useQueryState('editingTagId');
+      const [open, setOpen] = React.useState<boolean>(false);
+      const [_name, setName] = React.useState<string>(name);
+
+      React.useEffect(() => {
+        setName(name);
+      }, [name]);
+
+      React.useEffect(() => {
+        if (editingTagId === _id) {
+          setName(name);
+          setOpen(true);
+          setEditingTagId(null);
+        }
+      }, [editingTagId, _id, name, setEditingTagId]);
+
+      const onSave = () => {
+        if (name !== _name) {
+          tagsEdit({
+            variables: {
+              id: _id,
+              name: _name,
+              isGroup: isGroup,
+            },
+          });
+        }
+      };
+
+      const onChange = (el: React.ChangeEvent<HTMLInputElement>) => {
+        setName(el.currentTarget.value);
+      };
+
+      return (
+        <Popover
+          open={open}
+          onOpenChange={(open) => {
+            setOpen(open);
+            if (!open) {
+              onSave();
+            }
+          }}
+        >
+          <RecordTableInlineCell.Trigger>
+            <RecordTableTree.Trigger
+              order={order || ''}
+              name={cell.getValue() as string}
+              hasChildren={isGroup}
+            >
+              <div className="flex items-center gap-2 min-w-0">
+                <span
+                  className={`truncate ${
+                    isGroup
+                      ? 'font-semibold text-foreground'
+                      : 'text-muted-foreground'
+                  }`}
+                >
+                  {cell.getValue() as string}
+                </span>
+              </div>
+            </RecordTableTree.Trigger>
+          </RecordTableInlineCell.Trigger>
+          <RecordTableInlineCell.Content>
+            <Input value={_name} onChange={onChange} disabled={loading} />
+          </RecordTableInlineCell.Content>
+        </Popover>
+      );
+    },
+    minSize: 200,
+    size: 300,
+  },
+
+  {
+    id: 'description',
+    accessorKey: 'description',
+    cell: ({ cell }) => {
+      const { _id, description, name, isGroup } = cell.row.original;
+      const [open, setOpen] = useState<boolean>(false);
+      const [_description, setDescription] = useState<string>(
+        description ?? '',
+      );
+      const { tagsEdit, loading } = useTagsEdit();
+
+      React.useEffect(() => {
+        setDescription(description ?? '');
+      }, [description]);
+
+      const onSave = () => {
+        if (_description !== description) {
+          tagsEdit({
+            variables: {
+              id: _id,
+              name: name,
+              description: _description,
+              isGroup: isGroup,
+            },
+          });
+        }
+      };
+      const onChange = (el: React.ChangeEvent<HTMLTextAreaElement>) => {
+        setDescription(el.currentTarget.value);
+      };
+      return (
+        <Popover
+          open={open}
+          onOpenChange={(open) => {
+            setOpen(open);
+            if (!open) {
+              onSave();
+            }
+          }}
+        >
+          <RecordTableInlineCell.Trigger>
+            <TextOverflowTooltip value={cell.getValue() as string} />
+          </RecordTableInlineCell.Trigger>
+          <RecordTableInlineCell.Content>
+            <Textarea
+              value={_description}
+              onChange={onChange}
+              disabled={loading}
+            />
+          </RecordTableInlineCell.Content>
+        </Popover>
+      );
+    },
+    minSize: 200,
+    size: 400,
+    maxSize: 600,
+  },
+  {
+    header: 'Created',
+    accessorKey: 'createdAt',
+    cell: ({ cell }) => {
+      const formatDate = (dateString: string) => {
+        if (!dateString) return '';
+        const date = new Date(dateString);
+        return date.toLocaleDateString('en-US', {
+          month: 'short',
+          day: 'numeric',
+          year: 'numeric',
+        });
+      };
+      return (
+        <RecordTableInlineCell className="text-muted-foreground">
+          {formatDate(cell.getValue() as string)}
+        </RecordTableInlineCell>
+      );
+    },
+    minSize: 120,
+    size: 150,
+  },
+  {
+    id: 'more',
+    cell: ({ cell }) => (
+      <div className="hover:opacity-100 duration-200 ease-in-out h-8">
+        <TagMoreColumnCell cell={cell} />
+      </div>
+    ),
+    size: 33,
+  },
+];
diff --git a/frontend/core-ui/src/modules/settings/tags/components/TagsGroupsAddButtons.tsx b/frontend/core-ui/src/modules/settings/tags/components/TagsGroupsAddButtons.tsx
new file mode 100644
index 0000000000..09a2b2cd98
--- /dev/null
+++ b/frontend/core-ui/src/modules/settings/tags/components/TagsGroupsAddButtons.tsx
@@ -0,0 +1,14 @@
+import { Button } from 'erxes-ui';
+import { useTagContext } from '@/settings/tags/providers/TagProvider';
+
+export const TagsGroupsAddButtons = () => {
+  const { startAddingTag, startAddingGroup } = useTagContext();
+  return (
+    <div className="flex gap-2">
+      <Button onClick={startAddingGroup} variant="outline">
+        Add Group
+      </Button>
+      <Button onClick={startAddingTag}>Add Tag</Button>
+    </div>
+  );
+};
diff --git a/frontend/core-ui/src/modules/settings/tags/components/TagsRecordTable.tsx b/frontend/core-ui/src/modules/settings/tags/components/TagsRecordTable.tsx
index d09d73200e..5a920ebeed 100644
--- a/frontend/core-ui/src/modules/settings/tags/components/TagsRecordTable.tsx
+++ b/frontend/core-ui/src/modules/settings/tags/components/TagsRecordTable.tsx
@@ -1,221 +1,75 @@
-import { IconEdit, IconTrash } from '@tabler/icons-react';
-import { Cell, ColumnDef } from '@tanstack/react-table';
 import {
-  Badge,
-  Combobox,
-  Command,
-  Input,
-  Popover,
   RecordTable,
-  RecordTableInlineCell,
   RecordTableTree,
-  useConfirm,
   useMultiQueryState,
-  useQueryState,
 } from 'erxes-ui';
-import { ITag, SelectTags, useTags } from 'ui-modules';
-import { useRemoveTag } from '../hooks/useRemoveTag';
-import { useTagsEdit } from '@/settings/tags/hooks/useTagsEdit';
+import { ITag, useTags } from 'ui-modules';
 import React from 'react';
-
-export const TagMoreColumnCell = ({
-  cell,
-}: {
-  cell: Cell<ITag & { hasChildren: boolean }, unknown>;
-}) => {
-  const confirmOptions = { confirmationValue: 'delete' };
-  const { confirm } = useConfirm();
-  const [, setOpen] = useQueryState('tagId');
-  const { removeTag, loading } = useRemoveTag();
-  const { _id } = cell.row.original;
-
-  const onRemove = () => {
-    confirm({
-      message: 'Are you sure you want to remove the selected?',
-      options: confirmOptions,
-    }).then(async () => {
-      try {
-        removeTag(_id);
-      } catch (e) {
-        console.error(e.message);
-      }
-    });
-  };
-  return (
-    <Popover>
-      <Popover.Trigger asChild>
-        <RecordTable.MoreButton className="w-full h-full" />
-      </Popover.Trigger>
-      <Combobox.Content>
-        <Command shouldFilter={false}>
-          <Command.List>
-            <Command.Item
-              value="edit"
-              onSelect={() => {
-                setOpen(_id);
-              }}
-            >
-              <IconEdit /> Edit
-            </Command.Item>
-            <Command.Item disabled={loading} value="remove" onSelect={onRemove}>
-              <IconTrash /> Delete
-            </Command.Item>
-          </Command.List>
-        </Command>
-      </Combobox.Content>
-    </Popover>
-  );
-};
-
-export const tagsColumns: ColumnDef<
-  ITag & { hasChildren: boolean; type?: string }
->[] = [
-  {
-    id: 'more',
-    cell: TagMoreColumnCell,
-    size: 33,
-  },
-  {
-    id: 'name',
-    header: 'Name',
-    accessorKey: 'name',
-    cell: ({ cell }) => {
-      const { tagsEdit, loading } = useTagsEdit();
-      const { _id, name, type } = cell.row.original;
-      const [open, setOpen] = React.useState<boolean>(false);
-      const [_name, setName] = React.useState<string>(name);
-
-      const onSave = () => {
-        if (name !== _name) {
-          tagsEdit({
-            variables: {
-              id: _id,
-              type: type,
-              name: _name,
-            },
-          });
-        }
-      };
-
-      const onChange = (el: React.ChangeEvent<HTMLInputElement>) => {
-        setName(el.currentTarget.value);
-      };
-
-      return (
-        <Popover
-          open={open}
-          onOpenChange={(open) => {
-            setOpen(open);
-            if (!open) {
-              onSave();
-            }
-          }}
-        >
-          <RecordTableInlineCell.Trigger>
-            <RecordTableTree.Trigger
-              order={cell.row.original.order || ''}
-              name={cell.getValue() as string}
-              hasChildren={cell.row.original.hasChildren}
-            >
-              {cell.getValue() as string}
-            </RecordTableTree.Trigger>
-          </RecordTableInlineCell.Trigger>
-          <RecordTableInlineCell.Content>
-            <Input value={_name} onChange={onChange} disabled={loading} />
-          </RecordTableInlineCell.Content>
-        </Popover>
-      );
-    },
-    size: 300,
-  },
-
-  {
-    header: 'Parent',
-    accessorKey: 'parentId',
-    cell: ({ cell }) => {
-      const { _id, name, type, parentId } = cell.row.original;
-      const { tagsEdit } = useTagsEdit();
-      return (
-        <SelectTags.InlineCell
-          scope="tag"
-          mode="single"
-          value={cell.getValue() as string}
-          onValueChange={(value) => {
-            if (value !== parentId) {
-              tagsEdit({
-                variables: {
-                  id: _id,
-                  type: type,
-                  name: name,
-                  parentId: value || undefined,
-                },
-              });
-            }
-          }}
-          tagType=""
-        />
-      );
-    },
-    size: 200,
-  },
-  {
-    header: 'Total item counts',
-    accessorKey: 'totalObjectCount',
-    cell: ({ cell }) => {
-      return (
-        <RecordTableInlineCell className="justify-center">
-          <Badge variant={'secondary'}>
-            {(cell.getValue() as number) || 0}
-          </Badge>
-        </RecordTableInlineCell>
-      );
-    },
-  },
-  {
-    header: 'Item counts',
-    accessorKey: 'objectCount',
-    cell: ({ cell }) => {
-      return (
-        <RecordTableInlineCell className="justify-center">
-          <Badge variant={'secondary'}>
-            {(cell.getValue() as number) || 0}
-          </Badge>
-        </RecordTableInlineCell>
-      );
-    },
-  },
-  {
-    header: 'Type',
-    accessorKey: 'type',
-    cell: ({ cell }) => {
-      return (
-        <RecordTableInlineCell className="justify-center">
-          <Badge>{cell.getValue() as string}</Badge>
-        </RecordTableInlineCell>
-      );
-    },
-    size: 250,
-  },
-];
+import { useTagContext } from '@/settings/tags/providers/TagProvider';
+import { tagsColumns } from './TagsColumns';
 
 export const TagsRecordTable = () => {
+  const { mode, targetGroupId } = useTagContext();
   const [queries] = useMultiQueryState<{
-    contentType: string;
     searchValue: string;
-  }>(['contentType', 'searchValue']);
-  const { contentType, searchValue } = queries;
+  }>([ 'searchValue']);
+  const { searchValue } = queries;
   const { tags, pageInfo, loading, handleFetchMore } = useTags({
     variables: {
-      type: contentType || '',
       searchValue: searchValue ?? undefined,
     },
   });
 
+  const transformedData = React.useMemo(() => {
+    const result: ITag[] = [];
+
+    if (mode === 'adding-tag' || mode === 'adding-group') {
+      result.push({
+        _id: 'new-item-temp',
+        name: '',
+        hasChildren: false,
+        isGroup: mode === 'adding-group',
+        colorCode: '',
+        description: '',
+        order: '',
+      });
+    }
+
+    const existingTags = tags || [];
+    
+    if (existingTags.length === 0) {
+      return result;
+    }
+
+    existingTags.forEach((tag) => {
+      result.push({
+        ...tag,
+        hasChildren: existingTags.some(t => t.parentId === tag._id) && tag.isGroup,
+      });
+
+      if (mode === 'adding-tag-to-group' && targetGroupId === tag._id && tag.isGroup) {
+        result.push({
+          _id: 'new-item-temp',
+          name: '',
+          hasChildren: false,
+          isGroup: false,
+          colorCode: '',
+          description: '',
+          parentId: tag._id,
+          order: `${tag.order}new-item-temp/`,
+        });
+      }
+    });
+
+    return result;
+  }, [tags, mode, targetGroupId]);
+
+
   return (
     <RecordTable.Provider
       columns={tagsColumns}
-      data={tags || []}
-      className="m-3"
+      data={transformedData}
+      className="w-full [&_td:not(:last-child)]:border-r-0 [&_table]:w-full m-3"
       stickyColumns={['more', 'name']}
     >
       <RecordTableTree id="tags-list" ordered>
diff --git a/frontend/core-ui/src/modules/settings/tags/components/TagsSettingBreadcrumb.tsx b/frontend/core-ui/src/modules/settings/tags/components/TagsSettingBreadcrumb.tsx
index 55200fc0ec..458401b813 100644
--- a/frontend/core-ui/src/modules/settings/tags/components/TagsSettingBreadcrumb.tsx
+++ b/frontend/core-ui/src/modules/settings/tags/components/TagsSettingBreadcrumb.tsx
@@ -1,20 +1,8 @@
 import { IconTagsFilled } from '@tabler/icons-react';
 import { Button, Skeleton, useMultiQueryState } from 'erxes-ui';
-import { useTags } from 'ui-modules';
 
 export const TagsSettingBreadcrumb = () => {
-  const [queries] = useMultiQueryState<{
-    contentType: string;
-    searchValue: string;
-  }>(['contentType', 'searchValue']);
-  const { contentType, searchValue } = queries;
 
-  const { totalCount, loading } = useTags({
-    variables: {
-      type: contentType || '',
-      searchValue: searchValue ?? undefined,
-    },
-  });
   return (
     <>
       <Button variant="ghost" className="font-semibold">
diff --git a/frontend/core-ui/src/modules/settings/tags/components/TagsSettingsFilter.tsx b/frontend/core-ui/src/modules/settings/tags/components/TagsSettingsFilter.tsx
index eeb59c0ee9..a05632c86a 100644
--- a/frontend/core-ui/src/modules/settings/tags/components/TagsSettingsFilter.tsx
+++ b/frontend/core-ui/src/modules/settings/tags/components/TagsSettingsFilter.tsx
@@ -22,9 +22,6 @@ export const TagsSettingFilter = () => {
                 <Filter.CommandInput />
                 <Command.List>
                   <Filter.SearchValueTrigger />
-                  <Filter.Item value="contentType">
-                    <IconTagStarred /> Tags type
-                  </Filter.Item>
                 </Command.List>
               </Command>
             </Filter.View>
diff --git a/frontend/core-ui/src/modules/settings/tags/graphql/mutations/tagsMutations.ts b/frontend/core-ui/src/modules/settings/tags/graphql/mutations/tagsMutations.ts
index bf10a1e2fd..e460929a89 100644
--- a/frontend/core-ui/src/modules/settings/tags/graphql/mutations/tagsMutations.ts
+++ b/frontend/core-ui/src/modules/settings/tags/graphql/mutations/tagsMutations.ts
@@ -3,15 +3,19 @@ import { gql } from '@apollo/client';
 export const ADD_TAG = gql`
   mutation TagsAdd(
     $name: String!
-    $type: String!
+    $type: String
     $colorCode: String
     $parentId: String
+    $description: String
+    $isGroup: Boolean
   ) {
     tagsAdd(
       name: $name
       type: $type
       colorCode: $colorCode
       parentId: $parentId
+      description: $description
+      isGroup: $isGroup
     ) {
       _id
     }
@@ -22,9 +26,11 @@ export const EDIT_TAG = gql`
   mutation TagsEdit(
     $id: String!
     $name: String!
-    $type: String!
+    $type: String
     $colorCode: String
     $parentId: String
+    $description: String
+    $isGroup: Boolean
   ) {
     tagsEdit(
       _id: $id
@@ -32,6 +38,8 @@ export const EDIT_TAG = gql`
       type: $type
       colorCode: $colorCode
       parentId: $parentId
+      description: $description
+      isGroup: $isGroup
     ) {
       _id
     }
diff --git a/frontend/core-ui/src/modules/settings/tags/hooks/useTagsAdd.tsx b/frontend/core-ui/src/modules/settings/tags/hooks/useTagsAdd.tsx
index 172e16c627..c5d9f25bd9 100644
--- a/frontend/core-ui/src/modules/settings/tags/hooks/useTagsAdd.tsx
+++ b/frontend/core-ui/src/modules/settings/tags/hooks/useTagsAdd.tsx
@@ -1,4 +1,5 @@
 import { MutationHookOptions, useMutation } from '@apollo/client';
+import { toast } from 'erxes-ui';
 import { ADD_TAG } from '../graphql/mutations/tagsMutations';
 
 export const useTagsAdd = () => {
@@ -10,7 +11,10 @@ export const useTagsAdd = () => {
       variables,
       refetchQueries: ['Tags'],
       onError(error) {
-        console.error(error);
+        toast({
+          title: error?.message || 'Failed to add tag',
+          variant: 'destructive',
+        });
       },
     });
   };
diff --git a/frontend/core-ui/src/modules/settings/tags/providers/TagProvider.tsx b/frontend/core-ui/src/modules/settings/tags/providers/TagProvider.tsx
new file mode 100644
index 0000000000..f4f96da113
--- /dev/null
+++ b/frontend/core-ui/src/modules/settings/tags/providers/TagProvider.tsx
@@ -0,0 +1,48 @@
+import { createContext, useContext, useState } from 'react';
+
+interface ITagContext {
+  mode: 'idle' | 'adding-tag' | 'adding-group' | 'adding-tag-to-group';
+  targetGroupId: string | null;
+  setMode: (mode: ITagContext['mode']) => void;
+  startAddingTag: () => void;
+  startAddingGroup: () => void;
+  startAddingTagToGroup: (groupId: string) => void;
+  cancel: () => void;
+}
+
+export const TagContext = createContext<ITagContext>({} as ITagContext);
+
+export const TagProvider = ({children}: {children: React.ReactNode}) => {
+  const [mode, setMode] = useState<ITagContext['mode']>('idle');
+  const [targetGroupId, setTargetGroupId] = useState<string | null>(null);
+  
+  const startAddingTag = () => setMode('adding-tag');
+  const startAddingGroup = () => setMode('adding-group');
+  const startAddingTagToGroup = (groupId: string) => {
+    setTargetGroupId(groupId);
+    setMode('adding-tag-to-group');
+  };
+  const cancel = () => {
+    setMode('idle');
+    setTargetGroupId(null);
+  };
+
+  return (
+    <TagContext.Provider value={{ 
+      mode, 
+      targetGroupId,
+      setMode,
+      startAddingTag,
+      startAddingGroup,
+      startAddingTagToGroup,
+      cancel
+    }}>
+      {children}
+    </TagContext.Provider>
+  )
+};
+
+export const useTagContext = () => {
+  return useContext(TagContext);
+};
+
diff --git a/frontend/core-ui/src/pages/settings/workspace/tags/TagsSettingPage.tsx b/frontend/core-ui/src/pages/settings/workspace/tags/TagsSettingPage.tsx
index 82d4fc84c1..98a10bdc9c 100644
--- a/frontend/core-ui/src/pages/settings/workspace/tags/TagsSettingPage.tsx
+++ b/frontend/core-ui/src/pages/settings/workspace/tags/TagsSettingPage.tsx
@@ -1,30 +1,31 @@
 import { PageContainer, PageSubHeader, useQueryState } from 'erxes-ui';
 import { SettingsHeader } from 'ui-modules';
 import { TagsSettingBreadcrumb } from '@/settings/tags/components/TagsSettingBreadcrumb';
-import { TagsSidebar } from '@/settings/tags/components/TagsSidebar';
 import { TagsRecordTable } from '@/settings/tags/components/TagsRecordTable';
 import { TagsSettingFilter } from '@/settings/tags/components/TagsSettingsFilter';
-import { TagsAddDialog } from '@/settings/tags/components/TagsAddDialog';
+import { TagsGroupsAddButtons } from '@/settings/tags/components/TagsGroupsAddButtons';
 import { TagsEditDialog } from '@/settings/tags/components/TagsEditDialog';
+import { TagProvider } from '@/settings/tags/providers/TagProvider';
 
 export const TagsSettingPage = () => {
   const [tagId] = useQueryState('tagId');
   return (
     <PageContainer title="Tags">
-      <SettingsHeader breadcrumbs={<TagsSettingBreadcrumb />}>
-        <div className="ml-auto">
-          <TagsAddDialog />
+      <TagProvider>
+        <SettingsHeader breadcrumbs={<TagsSettingBreadcrumb />}>
+          <div className="ml-auto">
+            <TagsGroupsAddButtons />
+          </div>
+        </SettingsHeader>
+        <div className="flex flex-auto overflow-hidden">
+          <div className="flex flex-col h-full overflow-hidden flex-1">
+            <PageSubHeader>
+              <TagsSettingFilter />
+            </PageSubHeader>
+            <TagsRecordTable />
+          </div>
         </div>
-      </SettingsHeader>
-      <div className="flex flex-auto overflow-hidden">
-        <TagsSidebar />
-        <div className="flex flex-col h-full overflow-hidden flex-1">
-          <PageSubHeader>
-            <TagsSettingFilter />
-          </PageSubHeader>
-          <TagsRecordTable />
-        </div>
-      </div>
+      </TagProvider>
       {!!tagId && <TagsEditDialog />}
     </PageContainer>
   );
diff --git a/frontend/libs/erxes-ui/src/modules/filter/components/Filter.tsx b/frontend/libs/erxes-ui/src/modules/filter/components/Filter.tsx
index faa82580b4..322481b8e1 100644
--- a/frontend/libs/erxes-ui/src/modules/filter/components/Filter.tsx
+++ b/frontend/libs/erxes-ui/src/modules/filter/components/Filter.tsx
@@ -30,7 +30,6 @@ import {
 import { getDisplayValue } from '../date-filter/utils/getDisplayValue';
 import { DateFilterCommand } from '../date-filter/components/DateFilterCommand';
 import { usePreviousHotkeyScope } from 'erxes-ui/modules/hotkey/hooks/usePreviousHotkeyScope';
-import { useScopedHotkeys } from 'erxes-ui/modules/hotkey/hooks/useScopedHotkeys';
 import { useFilterQueryState } from '../hooks/useFilterQueryState';
 import { FilterDialogDateView } from '../date-filter/components/DialogDateView';
 
@@ -114,8 +113,6 @@ const FilterPopover = ({
     goBackToPreviousHotkeyScope,
   } = usePreviousHotkeyScope();
 
-  useScopedHotkeys('f', () => setOpen(true), scope);
-
   useEffect(() => {
     if (open) {
       setHotkeyScopeAndMemorizePreviousScope(scope + '.FilterPopover');
diff --git a/frontend/libs/ui-modules/src/modules/tags/components/SelectTags.tsx b/frontend/libs/ui-modules/src/modules/tags/components/SelectTags.tsx
index 7b84adcc24..645797a8b7 100644
--- a/frontend/libs/ui-modules/src/modules/tags/components/SelectTags.tsx
+++ b/frontend/libs/ui-modules/src/modules/tags/components/SelectTags.tsx
@@ -5,8 +5,8 @@ import {
   PopoverScoped,
   RecordTableInlineCell,
   Popover,
-  SelectTree,
   TextOverflowTooltip,
+  SelectTree,
 } from 'erxes-ui';
 import { useTags } from '../hooks/useTags';
 import { useDebounce } from 'use-debounce';
@@ -131,15 +131,39 @@ export const SelectTagsCommand = ({
             show={!disableCreateOption && !loading && !tags?.length}
           />
           <Combobox.Empty loading={loading} error={error} />
-          {tags?.map((tag) => (
-            <SelectTagsItem
-              key={tag._id}
-              tag={{
-                ...tag,
-                hasChildren: tags.some((t) => t.parentId === tag._id),
-              }}
-            />
-          ))}
+          {tags
+            ?.filter((tag) => !tag.parentId && !tag.isGroup)
+            ?.map((tag) => (
+              <SelectTagsItem
+                key={tag._id}
+                tag={{
+                  ...tag,
+                  hasChildren: false,
+                }}
+              />
+            ))}
+          
+          {tags
+            ?.filter(
+              (tag) => tag.isGroup && tags.some((t) => t.parentId === tag._id),
+            )
+            ?.map((tag) => (
+              <Command.Group key={tag._id} heading={tag.name}>
+                {tags
+                  .filter((t) => t.parentId === tag._id)
+                  .map((childTag) => (
+                    <SelectTagsItem
+                      key={childTag._id}
+                      tag={{
+                        ...childTag,
+                        hasChildren: tags.some(
+                          (t) => t.parentId === childTag._id,
+                        ),
+                      }}
+                    />
+                  ))}
+              </Command.Group>
+            ))}
           <Combobox.FetchMore
             fetchMore={handleFetchMore}
             currentLength={tags?.length || 0}
@@ -180,21 +204,15 @@ export const SelectTagsItem = ({
 }) => {
   const { onSelect, selectedTags } = useSelectTagsContext();
   const isSelected = selectedTags.some((t) => t._id === tag._id);
+
   return (
-    <SelectTree.Item
-      key={tag._id}
-      _id={tag._id}
-      name={tag.name}
-      order={tag.order || ''}
-      hasChildren={tag.hasChildren}
-      selected={isSelected}
-      onSelect={() => onSelect(tag)}
-    >
+    <Command.Item onSelect={() => onSelect(tag)}>
       <TextOverflowTooltip
         value={tag.name}
         className="flex-auto w-auto font-medium"
       />
-    </SelectTree.Item>
+      <Combobox.Check checked={isSelected} />
+    </Command.Item>
   );
 };
 
diff --git a/frontend/libs/ui-modules/src/modules/tags/graphql/queries/tagsQueries.tsx b/frontend/libs/ui-modules/src/modules/tags/graphql/queries/tagsQueries.tsx
index 431b3c76df..a3c4f72870 100644
--- a/frontend/libs/ui-modules/src/modules/tags/graphql/queries/tagsQueries.tsx
+++ b/frontend/libs/ui-modules/src/modules/tags/graphql/queries/tagsQueries.tsx
@@ -8,26 +8,33 @@ export const TAGS_QUERY = gql`
     $cursor: String
     $limit: Int
     $direction: CURSOR_DIRECTION
-    $tagIds: [String]
+    $ids: [String]
+    $excludeIds: Boolean
+    $isGroup: Boolean
   ) {
     tags(
       type: $type
       searchValue: $searchValue
       parentId: $parentId
-      tagIds: $tagIds
+      ids: $ids
+      excludeIds: $excludeIds
       cursor: $cursor
       limit: $limit
       direction: $direction
+      isGroup: $isGroup
     ) {
       list {
         _id
         colorCode
         name
-        order
         parentId
         totalObjectCount
         objectCount
         type
+        description
+        isGroup
+        createdAt
+        order
       }
       totalCount
       pageInfo {
diff --git a/frontend/libs/ui-modules/src/modules/tags/types/Tag.ts b/frontend/libs/ui-modules/src/modules/tags/types/Tag.ts
index 10248b4a08..f0c668a085 100644
--- a/frontend/libs/ui-modules/src/modules/tags/types/Tag.ts
+++ b/frontend/libs/ui-modules/src/modules/tags/types/Tag.ts
@@ -3,17 +3,27 @@ import { MutationHookOptions, OperationVariables } from '@apollo/client';
 export interface ITag {
   _id: string;
   name: string;
-  type: string;
+  type?: string;
   colorCode?: string;
   createdAt?: string;
   cursor?: string;
   objectCount?: number;
   parentId?: string;
-  order?: string;
+  isGroup: boolean;
+  order: string;
   relatedIds?: string[];
+  description?: string;
+  hasChildren: boolean;
   totalObjectCount?: number;
 }
 
+export interface ITagQueryResponse {
+  name: string;
+  type?: string;
+  isGroup: boolean;
+  parentId?: string | null;
+}
+
 export type ISelectTagsProviderProps = {
   tagType: string;
   targetIds?: string[];