diff --git a/go.mod b/go.mod
index f65315ae8..bca5e95aa 100644
--- a/go.mod
+++ b/go.mod
@@ -16,7 +16,7 @@ require (
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/openimsdk/localcache v0.0.1
 	github.com/openimsdk/protocol v0.0.58-google
-	github.com/openimsdk/tools v0.0.47-alpha.2
+	github.com/openimsdk/tools v0.0.47-alpha.3
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.18.0
 	github.com/sirupsen/logrus v1.9.3 // indirect
diff --git a/pkg/common/db/cache/conversation.go b/pkg/common/db/cache/conversation.go
index 6b0741d55..bef0522c7 100644
--- a/pkg/common/db/cache/conversation.go
+++ b/pkg/common/db/cache/conversation.go
@@ -16,6 +16,8 @@ package cache
 
 import (
 	"context"
+	"github.com/openimsdk/tools/utils/datautil"
+	"github.com/openimsdk/tools/utils/encrypt"
 	"math/big"
 	"strings"
 	"time"
@@ -25,7 +27,6 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/utils"
 	"github.com/redis/go-redis/v9"
 )
 
@@ -188,9 +189,9 @@ func (c *ConversationRedisCache) GetUserConversationIDsHash(ctx context.Context,
 			if err != nil {
 				return 0, err
 			}
-			utils.Sort(conversationIDs, true)
+			datautil.Sort(conversationIDs, true)
 			bi := big.NewInt(0)
-			bi.SetString(utils.Md5(strings.Join(conversationIDs, ";"))[0:8], 16)
+			bi.SetString(encrypt.Md5(strings.Join(conversationIDs, ";"))[0:8], 16)
 			return bi.Uint64(), nil
 		},
 	)
diff --git a/pkg/common/db/cache/friend.go b/pkg/common/db/cache/friend.go
index 2396c5f15..60f347e1b 100644
--- a/pkg/common/db/cache/friend.go
+++ b/pkg/common/db/cache/friend.go
@@ -16,6 +16,7 @@ package cache
 
 import (
 	"context"
+	"github.com/openimsdk/tools/utils/datautil"
 	"time"
 
 	"github.com/dtm-labs/rockscache"
@@ -23,7 +24,6 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/utils"
 	"github.com/redis/go-redis/v9"
 )
 
@@ -129,7 +129,7 @@ func (f *FriendCacheRedis) GetTwoWayFriendIDs(ctx context.Context, ownerUserID s
 		if err != nil {
 			return nil, err
 		}
-		if utils.IsContain(ownerUserID, friendFriendID) {
+		if datautil.Contain(ownerUserID, friendFriendID...) {
 			twoWayFriendIDs = append(twoWayFriendIDs, ownerUserID)
 		}
 	}
diff --git a/pkg/common/db/cache/group.go b/pkg/common/db/cache/group.go
index 0dbb23e1c..dfafd623f 100644
--- a/pkg/common/db/cache/group.go
+++ b/pkg/common/db/cache/group.go
@@ -17,6 +17,7 @@ package cache
 import (
 	"context"
 	"fmt"
+	"github.com/openimsdk/tools/utils/datautil"
 	"time"
 
 	"github.com/dtm-labs/rockscache"
@@ -26,7 +27,6 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/utils"
 	"github.com/redis/go-redis/v9"
 )
 
@@ -330,11 +330,11 @@ func (g *GroupCacheRedis) GetGroupMembersPage(
 		return 0, nil, err
 	}
 	if userIDs != nil {
-		userIDs = utils.BothExist(userIDs, groupMemberIDs)
+		userIDs = datautil.BothExist(userIDs, groupMemberIDs)
 	} else {
 		userIDs = groupMemberIDs
 	}
-	groupMembers, err = g.GetGroupMembersInfo(ctx, groupID, utils.Paginate(userIDs, int(showNumber), int(showNumber)))
+	groupMembers, err = g.GetGroupMembersInfo(ctx, groupID, datautil.Paginate(userIDs, int(showNumber), int(showNumber)))
 
 	return uint32(len(userIDs)), groupMembers, err
 }
diff --git a/pkg/common/db/cache/meta_cache.go b/pkg/common/db/cache/meta_cache.go
index e5c20a019..11911864b 100644
--- a/pkg/common/db/cache/meta_cache.go
+++ b/pkg/common/db/cache/meta_cache.go
@@ -19,13 +19,13 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/openimsdk/tools/utils/datautil"
 	"time"
 
 	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mw/specialerror"
-	"github.com/openimsdk/tools/utils"
 	"github.com/redis/go-redis/v9"
 )
 
@@ -88,7 +88,7 @@ func (m *metaCacheRedis) SetRawRedisClient(cli redis.UniversalClient) {
 
 func (m *metaCacheRedis) ExecDel(ctx context.Context, distinct ...bool) error {
 	if len(distinct) > 0 && distinct[0] {
-		m.keys = utils.Distinct(m.keys)
+		m.keys = datautil.Distinct(m.keys)
 	}
 	if len(m.keys) > 0 {
 		log.ZDebug(ctx, "delete cache", "topic", m.topic, "keys", m.keys)
diff --git a/pkg/common/db/cache/msg.go b/pkg/common/db/cache/msg.go
index ec77fbc68..9d09b255a 100644
--- a/pkg/common/db/cache/msg.go
+++ b/pkg/common/db/cache/msg.go
@@ -17,6 +17,7 @@ package cache
 import (
 	"context"
 	"errors"
+	"github.com/openimsdk/tools/utils/stringutil"
 	"strconv"
 	"time"
 
@@ -27,7 +28,6 @@ import (
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/utils"
 	"github.com/redis/go-redis/v9"
 	"golang.org/x/sync/errgroup"
 )
@@ -162,7 +162,7 @@ func (c *msgCache) getSeqs(ctx context.Context, items []string, getkey func(s st
 		if err != nil && err != redis.Nil {
 			return nil, errs.Wrap(err)
 		}
-		val := utils.StringToInt64(res)
+		val := stringutil.StringToInt64(res)
 		if val != 0 {
 			m[items[i]] = val
 		}
@@ -497,7 +497,7 @@ func (c *msgCache) GetUserDelList(ctx context.Context, userID, conversationID st
 	}
 	seqs = make([]int64, len(result))
 	for i, v := range result {
-		seqs[i] = utils.StringToInt64(v)
+		seqs[i] = stringutil.StringToInt64(v)
 	}
 
 	return seqs, nil
diff --git a/pkg/common/db/cache/token.go b/pkg/common/db/cache/token.go
index 64745d1ca..b4af9b27e 100644
--- a/pkg/common/db/cache/token.go
+++ b/pkg/common/db/cache/token.go
@@ -4,7 +4,7 @@ import (
 	"context"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/cachekey"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/utils"
+	"github.com/openimsdk/tools/utils/stringutil"
 	"github.com/redis/go-redis/v9"
 )
 
@@ -36,7 +36,7 @@ func (c *tokenCache) GetTokensWithoutError(ctx context.Context, userID string, p
 	}
 	mm := make(map[string]int)
 	for k, v := range m {
-		mm[k] = utils.StringToInt(v)
+		mm[k] = stringutil.StringToInt(v)
 	}
 
 	return mm, nil
diff --git a/pkg/common/db/controller/black.go b/pkg/common/db/controller/black.go
index d64a7dcfa..056962837 100644
--- a/pkg/common/db/controller/black.go
+++ b/pkg/common/db/controller/black.go
@@ -16,10 +16,10 @@ package controller
 
 import (
 	"context"
+	"github.com/openimsdk/tools/utils/datautil"
 
+	"github.com/openimsdk/tools/db/pagination"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/pagination"
-	"github.com/openimsdk/tools/utils"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
@@ -87,7 +87,7 @@ func (b *blackDatabase) CheckIn(ctx context.Context, userID1, userID2 string) (i
 		return
 	}
 	log.ZDebug(ctx, "blackIDs", "user1BlackIDs", userID1BlackIDs, "user2BlackIDs", userID2BlackIDs)
-	return utils.IsContain(userID2, userID1BlackIDs), utils.IsContain(userID1, userID2BlackIDs), nil
+	return datautil.Contain(userID2, userID1BlackIDs...), datautil.Contain(userID1, userID2BlackIDs...), nil
 }
 
 // FindBlackIDs Get Blacklist List.
diff --git a/pkg/common/db/controller/conversation.go b/pkg/common/db/controller/conversation.go
index ae06ddcb8..8c69b5ae6 100644
--- a/pkg/common/db/controller/conversation.go
+++ b/pkg/common/db/controller/conversation.go
@@ -16,17 +16,17 @@ package controller
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/utils/datautil"
+	"github.com/openimsdk/tools/utils/stringutil"
 	"time"
 
-	"github.com/openimsdk/protocol/constant"
-	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/pagination"
-	"github.com/openimsdk/tools/tx"
-	"github.com/openimsdk/tools/utils"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
 	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/openimsdk/open-im-server/v3/pkg/msgprocessor"
+	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/db"
+	"github.com/openimsdk/tools/log"
 )
 
 type ConversationDatabase interface {
@@ -67,7 +67,7 @@ type ConversationDatabase interface {
 	//FindRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) ([]string, error)
 }
 
-func NewConversationDatabase(conversation relationtb.ConversationModelInterface, cache cache.ConversationCache, tx tx.CtxTx) ConversationDatabase {
+func NewConversationDatabase(conversation relationtb.ConversationModelInterface, cache cache.ConversationCache, tx db.CtxTx) ConversationDatabase {
 	return &conversationDatabase{
 		conversationDB: conversation,
 		cache:          cache,
@@ -78,7 +78,7 @@ func NewConversationDatabase(conversation relationtb.ConversationModelInterface,
 type conversationDatabase struct {
 	conversationDB relationtb.ConversationModelInterface
 	cache          cache.ConversationCache
-	tx             tx.CtxTx
+	tx             db.CtxTx
 }
 
 func (c *conversationDatabase) SetUsersConversationFieldTx(ctx context.Context, userIDs []string, conversation *relationtb.ConversationModel, fieldMap map[string]any) (err error) {
@@ -106,13 +106,13 @@ func (c *conversationDatabase) SetUsersConversationFieldTx(ctx context.Context,
 				cache = cache.DelConversationNotReceiveMessageUserIDs(conversation.ConversationID)
 			}
 		}
-		NotUserIDs := utils.DifferenceString(haveUserIDs, userIDs)
+		NotUserIDs := stringutil.DifferenceString(haveUserIDs, userIDs)
 		log.ZDebug(ctx, "SetUsersConversationFieldTx", "NotUserIDs", NotUserIDs, "haveUserIDs", haveUserIDs, "userIDs", userIDs)
 		var conversations []*relationtb.ConversationModel
 		now := time.Now()
 		for _, v := range NotUserIDs {
 			temp := new(relationtb.ConversationModel)
-			if err = utils.CopyStructFields(temp, conversation); err != nil {
+			if err = datautil.CopyStructFields(temp, conversation); err != nil {
 				return err
 			}
 			temp.OwnerUserID = v
@@ -206,7 +206,7 @@ func (c *conversationDatabase) GetUserAllConversation(ctx context.Context, owner
 func (c *conversationDatabase) SetUserConversations(ctx context.Context, ownerUserID string, conversations []*relationtb.ConversationModel) error {
 	return c.tx.Transaction(ctx, func(ctx context.Context) error {
 		cache := c.cache.NewCache()
-		groupIDs := utils.Distinct(utils.Filter(conversations, func(e *relationtb.ConversationModel) (string, bool) {
+		groupIDs := datautil.Distinct(datautil.Filter(conversations, func(e *relationtb.ConversationModel) (string, bool) {
 			return e.GroupID, e.GroupID != ""
 		}))
 		for _, groupID := range groupIDs {
@@ -236,7 +236,7 @@ func (c *conversationDatabase) SetUserConversations(ctx context.Context, ownerUs
 
 		var notExistConversations []*relationtb.ConversationModel
 		for _, conversation := range conversations {
-			if !utils.IsContain(conversation.ConversationID, existConversationIDs) {
+			if !datautil.Contain(conversation.ConversationID, existConversationIDs...) {
 				notExistConversations = append(notExistConversations, conversation)
 			}
 		}
@@ -247,7 +247,7 @@ func (c *conversationDatabase) SetUserConversations(ctx context.Context, ownerUs
 			}
 			cache = cache.DelConversationIDs(ownerUserID).
 				DelUserConversationIDsHash(ownerUserID).
-				DelConversationNotReceiveMessageUserIDs(utils.Slice(notExistConversations, func(e *relationtb.ConversationModel) string { return e.ConversationID })...)
+				DelConversationNotReceiveMessageUserIDs(datautil.Slice(notExistConversations, func(e *relationtb.ConversationModel) string { return e.ConversationID })...)
 		}
 		return cache.ExecDel(ctx)
 	})
@@ -265,7 +265,7 @@ func (c *conversationDatabase) CreateGroupChatConversation(ctx context.Context,
 		if err != nil {
 			return err
 		}
-		notExistUserIDs := utils.DifferenceString(userIDs, existConversationUserIDs)
+		notExistUserIDs := stringutil.DifferenceString(userIDs, existConversationUserIDs)
 		var conversations []*relationtb.ConversationModel
 		for _, v := range notExistUserIDs {
 			conversation := relationtb.ConversationModel{ConversationType: constant.SuperGroupChatType, GroupID: groupID, OwnerUserID: v, ConversationID: conversationID}
diff --git a/pkg/common/db/controller/friend.go b/pkg/common/db/controller/friend.go
index ba0441b2a..6b365be25 100644
--- a/pkg/common/db/controller/friend.go
+++ b/pkg/common/db/controller/friend.go
@@ -17,15 +17,15 @@ package controller
 import (
 	"context"
 	"fmt"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/utils/datautil"
 	"time"
 
 	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/db"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
-	"github.com/openimsdk/tools/pagination"
-	"github.com/openimsdk/tools/tx"
-	"github.com/openimsdk/tools/utils"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
@@ -81,11 +81,11 @@ type FriendDatabase interface {
 type friendDatabase struct {
 	friend        relation.FriendModelInterface
 	friendRequest relation.FriendRequestModelInterface
-	tx            tx.CtxTx
+	tx            db.CtxTx
 	cache         cache.FriendCache
 }
 
-func NewFriendDatabase(friend relation.FriendModelInterface, friendRequest relation.FriendRequestModelInterface, cache cache.FriendCache, tx tx.CtxTx) FriendDatabase {
+func NewFriendDatabase(friend relation.FriendModelInterface, friendRequest relation.FriendRequestModelInterface, cache cache.FriendCache, tx db.CtxTx) FriendDatabase {
 	return &friendDatabase{friend: friend, friendRequest: friendRequest, cache: cache, tx: tx}
 }
 
@@ -107,8 +107,8 @@ func (f *friendDatabase) CheckIn(ctx context.Context, userID1, userID2 string) (
 	}
 
 	// Check if userID2 is in userID1's friend list and vice versa
-	inUser1Friends = utils.IsContain(userID2, userID1FriendIDs)
-	inUser2Friends = utils.IsContain(userID1, userID2FriendIDs)
+	inUser1Friends = datautil.Contain(userID2, userID1FriendIDs...)
+	inUser2Friends = datautil.Contain(userID1, userID2FriendIDs...)
 	return inUser1Friends, inUser2Friends, nil
 }
 
@@ -149,7 +149,7 @@ func (f *friendDatabase) BecomeFriends(ctx context.Context, ownerUserID string,
 		for _, v := range friendUserIDs {
 			fs1 = append(fs1, &relation.FriendModel{OwnerUserID: ownerUserID, FriendUserID: v, AddSource: addSource, OperatorUserID: opUserID})
 		}
-		fs11 := utils.DistinctAny(fs1, func(e *relation.FriendModel) string {
+		fs11 := datautil.DistinctAny(fs1, func(e *relation.FriendModel) string {
 			return e.FriendUserID
 		})
 
@@ -166,7 +166,7 @@ func (f *friendDatabase) BecomeFriends(ctx context.Context, ownerUserID string,
 			fs2 = append(fs2, &relation.FriendModel{OwnerUserID: v, FriendUserID: ownerUserID, AddSource: addSource, OperatorUserID: opUserID})
 			newFriendIDs = append(newFriendIDs, v)
 		}
-		fs22 := utils.DistinctAny(fs2, func(e *relation.FriendModel) string {
+		fs22 := datautil.DistinctAny(fs2, func(e *relation.FriendModel) string {
 			return e.OwnerUserID
 		})
 		err = f.friend.Create(ctx, fs22)
@@ -247,7 +247,7 @@ func (f *friendDatabase) AgreeFriendRequest(ctx context.Context, friendRequest *
 		if err != nil {
 			return err
 		}
-		existsMap := utils.SliceSet(utils.Slice(exists, func(friend *relation.FriendModel) [2]string {
+		existsMap := datautil.SliceSet(datautil.Slice(exists, func(friend *relation.FriendModel) [2]string {
 			return [...]string{friend.OwnerUserID, friend.FriendUserID} // My - Friend
 		}))
 		var adds []*relation.FriendModel
diff --git a/pkg/common/db/controller/group.go b/pkg/common/db/controller/group.go
index 18b98f17b..1a11426ad 100644
--- a/pkg/common/db/controller/group.go
+++ b/pkg/common/db/controller/group.go
@@ -16,15 +16,15 @@ package controller
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/utils/datautil"
 	"time"
 
 	"github.com/dtm-labs/rockscache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
 	relationtb "github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/openimsdk/protocol/constant"
-	"github.com/openimsdk/tools/pagination"
-	"github.com/openimsdk/tools/tx"
-	"github.com/openimsdk/tools/utils"
+	"github.com/openimsdk/tools/db"
 	"github.com/redis/go-redis/v9"
 )
 
@@ -110,7 +110,7 @@ func NewGroupDatabase(
 	groupDB relationtb.GroupModelInterface,
 	groupMemberDB relationtb.GroupMemberModelInterface,
 	groupRequestDB relationtb.GroupRequestModelInterface,
-	ctxTx tx.CtxTx,
+	ctxTx db.CtxTx,
 	groupHash cache.GroupHash,
 ) GroupDatabase {
 	rcOptions := rockscache.NewDefaultOptions()
@@ -129,7 +129,7 @@ type groupDatabase struct {
 	groupDB        relationtb.GroupModelInterface
 	groupMemberDB  relationtb.GroupMemberModelInterface
 	groupRequestDB relationtb.GroupRequestModelInterface
-	ctxTx          tx.CtxTx
+	ctxTx          db.CtxTx
 	cache          cache.GroupCache
 }
 
@@ -270,7 +270,7 @@ func (g *groupDatabase) PageGetJoinGroup(ctx context.Context, userID string, pag
 	if err != nil {
 		return 0, nil, err
 	}
-	for _, groupID := range utils.Paginate(groupIDs, int(pagination.GetPageNumber()), int(pagination.GetShowNumber())) {
+	for _, groupID := range datautil.Paginate(groupIDs, int(pagination.GetPageNumber()), int(pagination.GetShowNumber())) {
 		groupMembers, err := g.cache.GetGroupMembersInfo(ctx, groupID, []string{userID})
 		if err != nil {
 			return 0, nil, err
@@ -285,7 +285,7 @@ func (g *groupDatabase) PageGetGroupMember(ctx context.Context, groupID string,
 	if err != nil {
 		return 0, nil, err
 	}
-	pageIDs := utils.Paginate(groupMemberIDs, int(pagination.GetPageNumber()), int(pagination.GetShowNumber()))
+	pageIDs := datautil.Paginate(groupMemberIDs, int(pagination.GetPageNumber()), int(pagination.GetShowNumber()))
 	if len(pageIDs) == 0 {
 		return int64(len(groupMemberIDs)), nil, nil
 	}
diff --git a/pkg/common/db/controller/msg.go b/pkg/common/db/controller/msg.go
index 485663c64..5702daeca 100644
--- a/pkg/common/db/controller/msg.go
+++ b/pkg/common/db/controller/msg.go
@@ -20,6 +20,8 @@ import (
 	"errors"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/mgo"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/utils/datautil"
+	"github.com/openimsdk/tools/utils/timeutil"
 	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -32,7 +34,6 @@ import (
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/utils"
 	"github.com/redis/go-redis/v9"
 	"go.mongodb.org/mongo-driver/mongo"
 )
@@ -602,7 +603,7 @@ func (db *commonMsgDatabase) GetMsgBySeqsRange(ctx context.Context, userID strin
 		}
 		var cacheDelNum int
 		for _, msg := range cachedMsgs {
-			if !utils.Contain(msg.Seq, delSeqs...) {
+			if !datautil.Contain(msg.Seq, delSeqs...) {
 				successMsgs = append(successMsgs, msg)
 			} else {
 				cacheDelNum += 1
@@ -613,7 +614,7 @@ func (db *commonMsgDatabase) GetMsgBySeqsRange(ctx context.Context, userID strin
 		for i := 1; i <= cacheDelNum; {
 			newSeq := newBegin - int64(i)
 			if newSeq >= begin {
-				if !utils.Contain(newSeq, delSeqs...) {
+				if !datautil.Contain(newSeq, delSeqs...) {
 					log.ZDebug(ctx, "seq del in cache, a new seq in range append", "new seq", newSeq)
 					reGetSeqsCache = append(reGetSeqsCache, newSeq)
 					i++
@@ -754,7 +755,7 @@ func (db *commonMsgDatabase) UserMsgsDestruct(ctx context.Context, userID string
 			for _, msg := range msgDocModel.Msg {
 				i++
 				if msg != nil && msg.Msg != nil && msg.Msg.SendTime+destructTime*1000 <= time.Now().UnixMilli() {
-					if msg.Msg.SendTime+destructTime*1000 > lastMsgDestructTime.UnixMilli() && !utils.Contain(userID, msg.DelList...) {
+					if msg.Msg.SendTime+destructTime*1000 > lastMsgDestructTime.UnixMilli() && !datautil.Contain(userID, msg.DelList...) {
 						seqs = append(seqs, msg.Msg.Seq)
 					}
 				} else {
@@ -821,7 +822,7 @@ func (db *commonMsgDatabase) deleteMsgRecursion(ctx context.Context, conversatio
 	if int64(len(msgDocModel.Msg)) > db.msg.GetSingleGocMsgNum() {
 		log.ZWarn(ctx, "msgs too large", nil, "lenth", len(msgDocModel.Msg), "docID:", msgDocModel.DocID)
 	}
-	if msgDocModel.IsFull() && msgDocModel.Msg[len(msgDocModel.Msg)-1].Msg.SendTime+(remainTime*1000) < utils.GetCurrentTimestampByMill() {
+	if msgDocModel.IsFull() && msgDocModel.Msg[len(msgDocModel.Msg)-1].Msg.SendTime+(remainTime*1000) < timeutil.GetCurrentTimestampByMill() {
 		log.ZDebug(ctx, "doc is full and all msg is expired", "docID", msgDocModel.DocID)
 		delStruct.delDocIDs = append(delStruct.delDocIDs, msgDocModel.DocID)
 		delStruct.minSeq = msgDocModel.Msg[len(msgDocModel.Msg)-1].Msg.Seq
@@ -829,7 +830,7 @@ func (db *commonMsgDatabase) deleteMsgRecursion(ctx context.Context, conversatio
 		var delMsgIndexs []int
 		for i, MsgInfoModel := range msgDocModel.Msg {
 			if MsgInfoModel != nil && MsgInfoModel.Msg != nil {
-				if utils.GetCurrentTimestampByMill() > MsgInfoModel.Msg.SendTime+(remainTime*1000) {
+				if timeutil.GetCurrentTimestampByMill() > MsgInfoModel.Msg.SendTime+(remainTime*1000) {
 					delMsgIndexs = append(delMsgIndexs, i)
 				}
 			}
diff --git a/pkg/common/db/controller/third.go b/pkg/common/db/controller/third.go
index a031244c6..40385f623 100644
--- a/pkg/common/db/controller/third.go
+++ b/pkg/common/db/controller/third.go
@@ -16,10 +16,9 @@ package controller
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 	"time"
 
-	"github.com/openimsdk/tools/pagination"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 )
diff --git a/pkg/common/db/controller/user.go b/pkg/common/db/controller/user.go
index 37619ace1..1c9cacfe6 100644
--- a/pkg/common/db/controller/user.go
+++ b/pkg/common/db/controller/user.go
@@ -16,13 +16,13 @@ package controller
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
+	"github.com/openimsdk/tools/utils/datautil"
 	"time"
 
 	"github.com/openimsdk/protocol/user"
+	"github.com/openimsdk/tools/db"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/pagination"
-	"github.com/openimsdk/tools/tx"
-	"github.com/openimsdk/tools/utils"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/cache"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
@@ -83,19 +83,19 @@ type UserDatabase interface {
 }
 
 type userDatabase struct {
-	tx      tx.CtxTx
+	tx      db.CtxTx
 	userDB  relation.UserModelInterface
 	cache   cache.UserCache
 	mongoDB relation.SubscribeUserModelInterface
 }
 
-func NewUserDatabase(userDB relation.UserModelInterface, cache cache.UserCache, tx tx.CtxTx, mongoDB relation.SubscribeUserModelInterface) UserDatabase {
+func NewUserDatabase(userDB relation.UserModelInterface, cache cache.UserCache, tx db.CtxTx, mongoDB relation.SubscribeUserModelInterface) UserDatabase {
 	return &userDatabase{userDB: userDB, cache: cache, tx: tx, mongoDB: mongoDB}
 }
 
 func (u *userDatabase) InitOnce(ctx context.Context, users []*relation.UserModel) error {
 	// Extract user IDs from the given user models.
-	userIDs := utils.Slice(users, func(e *relation.UserModel) string {
+	userIDs := datautil.Slice(users, func(e *relation.UserModel) string {
 		return e.UserID
 	})
 
@@ -106,7 +106,7 @@ func (u *userDatabase) InitOnce(ctx context.Context, users []*relation.UserModel
 	}
 
 	// Determine which users are missing from the database.
-	missingUsers := utils.SliceAnySub(users, existingUsers, func(e *relation.UserModel) string {
+	missingUsers := datautil.SliceAnySub(users, existingUsers, func(e *relation.UserModel) string {
 		return e.UserID
 	})
 
@@ -153,7 +153,7 @@ func (u *userDatabase) Create(ctx context.Context, users []*relation.UserModel)
 		if err = u.userDB.Create(ctx, users); err != nil {
 			return err
 		}
-		return u.cache.DelUsersInfo(utils.Slice(users, func(e *relation.UserModel) string {
+		return u.cache.DelUsersInfo(datautil.Slice(users, func(e *relation.UserModel) string {
 			return e.UserID
 		})...).ExecDel(ctx)
 	})
diff --git a/pkg/common/db/mgo/black.go b/pkg/common/db/mgo/black.go
index d115cfb6e..d588aece6 100644
--- a/pkg/common/db/mgo/black.go
+++ b/pkg/common/db/mgo/black.go
@@ -18,8 +18,8 @@ import (
 	"context"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
+	"github.com/openimsdk/tools/db/mongoutil"
+	"github.com/openimsdk/tools/db/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -63,42 +63,42 @@ func (b *BlackMgo) blacksFilter(blacks []*relation.BlackModel) bson.M {
 }
 
 func (b *BlackMgo) Create(ctx context.Context, blacks []*relation.BlackModel) (err error) {
-	return mgoutil.InsertMany(ctx, b.coll, blacks)
+	return mongoutil.InsertMany(ctx, b.coll, blacks)
 }
 
 func (b *BlackMgo) Delete(ctx context.Context, blacks []*relation.BlackModel) (err error) {
 	if len(blacks) == 0 {
 		return nil
 	}
-	return mgoutil.DeleteMany(ctx, b.coll, b.blacksFilter(blacks))
+	return mongoutil.DeleteMany(ctx, b.coll, b.blacksFilter(blacks))
 }
 
 func (b *BlackMgo) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]any) (err error) {
 	if len(args) == 0 {
 		return nil
 	}
-	return mgoutil.UpdateOne(ctx, b.coll, b.blackFilter(ownerUserID, blockUserID), bson.M{"$set": args}, false)
+	return mongoutil.UpdateOne(ctx, b.coll, b.blackFilter(ownerUserID, blockUserID), bson.M{"$set": args}, false)
 }
 
 func (b *BlackMgo) Find(ctx context.Context, blacks []*relation.BlackModel) (blackList []*relation.BlackModel, err error) {
-	return mgoutil.Find[*relation.BlackModel](ctx, b.coll, b.blacksFilter(blacks))
+	return mongoutil.Find[*relation.BlackModel](ctx, b.coll, b.blacksFilter(blacks))
 }
 
 func (b *BlackMgo) Take(ctx context.Context, ownerUserID, blockUserID string) (black *relation.BlackModel, err error) {
-	return mgoutil.FindOne[*relation.BlackModel](ctx, b.coll, b.blackFilter(ownerUserID, blockUserID))
+	return mongoutil.FindOne[*relation.BlackModel](ctx, b.coll, b.blackFilter(ownerUserID, blockUserID))
 }
 
 func (b *BlackMgo) FindOwnerBlacks(ctx context.Context, ownerUserID string, pagination pagination.Pagination) (total int64, blacks []*relation.BlackModel, err error) {
-	return mgoutil.FindPage[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID}, pagination)
+	return mongoutil.FindPage[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID}, pagination)
 }
 
 func (b *BlackMgo) FindOwnerBlackInfos(ctx context.Context, ownerUserID string, userIDs []string) (blacks []*relation.BlackModel, err error) {
 	if len(userIDs) == 0 {
-		return mgoutil.Find[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID})
+		return mongoutil.Find[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID})
 	}
-	return mgoutil.Find[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID, "block_user_id": bson.M{"$in": userIDs}})
+	return mongoutil.Find[*relation.BlackModel](ctx, b.coll, bson.M{"owner_user_id": ownerUserID, "block_user_id": bson.M{"$in": userIDs}})
 }
 
 func (b *BlackMgo) FindBlackUserIDs(ctx context.Context, ownerUserID string) (blackUserIDs []string, err error) {
-	return mgoutil.Find[string](ctx, b.coll, bson.M{"owner_user_id": ownerUserID}, options.Find().SetProjection(bson.M{"_id": 0, "block_user_id": 1}))
+	return mongoutil.Find[string](ctx, b.coll, bson.M{"owner_user_id": ownerUserID}, options.Find().SetProjection(bson.M{"_id": 0, "block_user_id": 1}))
 }
diff --git a/pkg/common/db/mgo/conversation.go b/pkg/common/db/mgo/conversation.go
index 981a0f2f0..fd70a715d 100644
--- a/pkg/common/db/mgo/conversation.go
+++ b/pkg/common/db/mgo/conversation.go
@@ -16,13 +16,14 @@ package mgo
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
+
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -48,15 +49,15 @@ type ConversationMgo struct {
 }
 
 func (c *ConversationMgo) Create(ctx context.Context, conversations []*relation.ConversationModel) (err error) {
-	return mgoutil.InsertMany(ctx, c.coll, conversations)
+	return mongoutil.InsertMany(ctx, c.coll, conversations)
 }
 
 func (c *ConversationMgo) Delete(ctx context.Context, groupIDs []string) (err error) {
-	return mgoutil.DeleteMany(ctx, c.coll, bson.M{"group_id": bson.M{"$in": groupIDs}})
+	return mongoutil.DeleteMany(ctx, c.coll, bson.M{"group_id": bson.M{"$in": groupIDs}})
 }
 
 func (c *ConversationMgo) UpdateByMap(ctx context.Context, userIDs []string, conversationID string, args map[string]any) (rows int64, err error) {
-	res, err := mgoutil.UpdateMany(ctx, c.coll, bson.M{"owner_user_id": bson.M{"$in": userIDs}, "conversation_id": conversationID}, bson.M{"$set": args})
+	res, err := mongoutil.UpdateMany(ctx, c.coll, bson.M{"owner_user_id": bson.M{"$in": userIDs}, "conversation_id": conversationID}, bson.M{"$set": args})
 	if err != nil {
 		return 0, err
 	}
@@ -64,15 +65,15 @@ func (c *ConversationMgo) UpdateByMap(ctx context.Context, userIDs []string, con
 }
 
 func (c *ConversationMgo) Update(ctx context.Context, conversation *relation.ConversationModel) (err error) {
-	return mgoutil.UpdateOne(ctx, c.coll, bson.M{"owner_user_id": conversation.OwnerUserID, "conversation_id": conversation.ConversationID}, bson.M{"$set": conversation}, true)
+	return mongoutil.UpdateOne(ctx, c.coll, bson.M{"owner_user_id": conversation.OwnerUserID, "conversation_id": conversation.ConversationID}, bson.M{"$set": conversation}, true)
 }
 
 func (c *ConversationMgo) Find(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []*relation.ConversationModel, err error) {
-	return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": ownerUserID, "conversation_id": bson.M{"$in": conversationIDs}})
+	return mongoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": ownerUserID, "conversation_id": bson.M{"$in": conversationIDs}})
 }
 
 func (c *ConversationMgo) FindUserID(ctx context.Context, userIDs []string, conversationIDs []string) ([]string, error) {
-	return mgoutil.Find[string](
+	return mongoutil.Find[string](
 		ctx,
 		c.coll,
 		bson.M{"owner_user_id": bson.M{"$in": userIDs}, "conversation_id": bson.M{"$in": conversationIDs}},
@@ -80,19 +81,19 @@ func (c *ConversationMgo) FindUserID(ctx context.Context, userIDs []string, conv
 	)
 }
 func (c *ConversationMgo) FindUserIDAllConversationID(ctx context.Context, userID string) ([]string, error) {
-	return mgoutil.Find[string](ctx, c.coll, bson.M{"owner_user_id": userID}, options.Find().SetProjection(bson.M{"_id": 0, "conversation_id": 1}))
+	return mongoutil.Find[string](ctx, c.coll, bson.M{"owner_user_id": userID}, options.Find().SetProjection(bson.M{"_id": 0, "conversation_id": 1}))
 }
 
 func (c *ConversationMgo) Take(ctx context.Context, userID, conversationID string) (conversation *relation.ConversationModel, err error) {
-	return mgoutil.FindOne[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID, "conversation_id": conversationID})
+	return mongoutil.FindOne[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID, "conversation_id": conversationID})
 }
 
 func (c *ConversationMgo) FindConversationID(ctx context.Context, userID string, conversationIDs []string) (existConversationID []string, err error) {
-	return mgoutil.Find[string](ctx, c.coll, bson.M{"owner_user_id": userID, "conversation_id": bson.M{"$in": conversationIDs}}, options.Find().SetProjection(bson.M{"_id": 0, "conversation_id": 1}))
+	return mongoutil.Find[string](ctx, c.coll, bson.M{"owner_user_id": userID, "conversation_id": bson.M{"$in": conversationIDs}}, options.Find().SetProjection(bson.M{"_id": 0, "conversation_id": 1}))
 }
 
 func (c *ConversationMgo) FindUserIDAllConversations(ctx context.Context, userID string) (conversations []*relation.ConversationModel, err error) {
-	return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID})
+	return mongoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"owner_user_id": userID})
 }
 
 func (c *ConversationMgo) FindRecvMsgUserIDs(ctx context.Context, conversationID string, recvOpts []int) ([]string, error) {
@@ -102,22 +103,22 @@ func (c *ConversationMgo) FindRecvMsgUserIDs(ctx context.Context, conversationID
 	} else {
 		filter = bson.M{"conversation_id": conversationID, "recv_msg_opt": bson.M{"$in": recvOpts}}
 	}
-	return mgoutil.Find[string](ctx, c.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "owner_user_id": 1}))
+	return mongoutil.Find[string](ctx, c.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "owner_user_id": 1}))
 }
 
 func (c *ConversationMgo) GetUserRecvMsgOpt(ctx context.Context, ownerUserID, conversationID string) (opt int, err error) {
-	return mgoutil.FindOne[int](ctx, c.coll, bson.M{"owner_user_id": ownerUserID, "conversation_id": conversationID}, options.FindOne().SetProjection(bson.M{"recv_msg_opt": 1}))
+	return mongoutil.FindOne[int](ctx, c.coll, bson.M{"owner_user_id": ownerUserID, "conversation_id": conversationID}, options.FindOne().SetProjection(bson.M{"recv_msg_opt": 1}))
 }
 
 func (c *ConversationMgo) GetAllConversationIDs(ctx context.Context) ([]string, error) {
-	return mgoutil.Aggregate[string](ctx, c.coll, []bson.M{
+	return mongoutil.Aggregate[string](ctx, c.coll, []bson.M{
 		{"$group": bson.M{"_id": "$conversation_id"}},
 		{"$project": bson.M{"_id": 0, "conversation_id": "$_id"}},
 	})
 }
 
 func (c *ConversationMgo) GetAllConversationIDsNumber(ctx context.Context) (int64, error) {
-	counts, err := mgoutil.Aggregate[int64](ctx, c.coll, []bson.M{
+	counts, err := mongoutil.Aggregate[int64](ctx, c.coll, []bson.M{
 		{"$group": bson.M{"_id": "$conversation_id"}},
 		{"$group": bson.M{"_id": nil, "count": bson.M{"$sum": 1}}},
 		{"$project": bson.M{"_id": 0}},
@@ -132,16 +133,16 @@ func (c *ConversationMgo) GetAllConversationIDsNumber(ctx context.Context) (int6
 }
 
 func (c *ConversationMgo) PageConversationIDs(ctx context.Context, pagination pagination.Pagination) (conversationIDs []string, err error) {
-	return mgoutil.FindPageOnly[string](ctx, c.coll, bson.M{}, pagination, options.Find().SetProjection(bson.M{"conversation_id": 1}))
+	return mongoutil.FindPageOnly[string](ctx, c.coll, bson.M{}, pagination, options.Find().SetProjection(bson.M{"conversation_id": 1}))
 }
 
 func (c *ConversationMgo) GetConversationsByConversationID(ctx context.Context, conversationIDs []string) ([]*relation.ConversationModel, error) {
-	return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"conversation_id": bson.M{"$in": conversationIDs}})
+	return mongoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{"conversation_id": bson.M{"$in": conversationIDs}})
 }
 
 func (c *ConversationMgo) GetConversationIDsNeedDestruct(ctx context.Context) ([]*relation.ConversationModel, error) {
 	// "is_msg_destruct = 1 && msg_destruct_time != 0 && (UNIX_TIMESTAMP(NOW()) > (msg_destruct_time + UNIX_TIMESTAMP(latest_msg_destruct_time)) || latest_msg_destruct_time is NULL)"
-	return mgoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{
+	return mongoutil.Find[*relation.ConversationModel](ctx, c.coll, bson.M{
 		"is_msg_destruct":   1,
 		"msg_destruct_time": bson.M{"$ne": 0},
 		"$or": []bson.M{
@@ -161,7 +162,7 @@ func (c *ConversationMgo) GetConversationIDsNeedDestruct(ctx context.Context) ([
 }
 
 func (c *ConversationMgo) GetConversationNotReceiveMessageUserIDs(ctx context.Context, conversationID string) ([]string, error) {
-	return mgoutil.Find[string](
+	return mongoutil.Find[string](
 		ctx,
 		c.coll,
 		bson.M{"conversation_id": conversationID, "recv_msg_opt": bson.M{"$ne": constant.ReceiveMessage}},
diff --git a/pkg/common/db/mgo/friend.go b/pkg/common/db/mgo/friend.go
index 3238909df..14bc288e9 100644
--- a/pkg/common/db/mgo/friend.go
+++ b/pkg/common/db/mgo/friend.go
@@ -16,10 +16,10 @@ package mgo
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -48,7 +48,7 @@ func NewFriendMongo(db *mongo.Database) (relation.FriendModelInterface, error) {
 
 // Create inserts multiple friend records.
 func (f *FriendMgo) Create(ctx context.Context, friends []*relation.FriendModel) error {
-	return mgoutil.InsertMany(ctx, f.coll, friends)
+	return mongoutil.InsertMany(ctx, f.coll, friends)
 }
 
 // Delete removes specified friends of the owner user.
@@ -57,7 +57,7 @@ func (f *FriendMgo) Delete(ctx context.Context, ownerUserID string, friendUserID
 		"owner_user_id":  ownerUserID,
 		"friend_user_id": bson.M{"$in": friendUserIDs},
 	}
-	return mgoutil.DeleteOne(ctx, f.coll, filter)
+	return mongoutil.DeleteOne(ctx, f.coll, filter)
 }
 
 // UpdateByMap updates specific fields of a friend document using a map.
@@ -69,7 +69,7 @@ func (f *FriendMgo) UpdateByMap(ctx context.Context, ownerUserID string, friendU
 		"owner_user_id":  ownerUserID,
 		"friend_user_id": friendUserID,
 	}
-	return mgoutil.UpdateOne(ctx, f.coll, filter, bson.M{"$set": args}, true)
+	return mongoutil.UpdateOne(ctx, f.coll, filter, bson.M{"$set": args}, true)
 }
 
 // Update modifies multiple friend documents.
@@ -92,7 +92,7 @@ func (f *FriendMgo) Take(ctx context.Context, ownerUserID, friendUserID string)
 		"owner_user_id":  ownerUserID,
 		"friend_user_id": friendUserID,
 	}
-	return mgoutil.FindOne[*relation.FriendModel](ctx, f.coll, filter)
+	return mongoutil.FindOne[*relation.FriendModel](ctx, f.coll, filter)
 }
 
 // FindUserState finds the friendship status between two users.
@@ -103,7 +103,7 @@ func (f *FriendMgo) FindUserState(ctx context.Context, userID1, userID2 string)
 			{"owner_user_id": userID2, "friend_user_id": userID1},
 		},
 	}
-	return mgoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
+	return mongoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
 }
 
 // FindFriends retrieves a list of friends for a given owner. Missing friends do not cause an error.
@@ -112,7 +112,7 @@ func (f *FriendMgo) FindFriends(ctx context.Context, ownerUserID string, friendU
 		"owner_user_id":  ownerUserID,
 		"friend_user_id": bson.M{"$in": friendUserIDs},
 	}
-	return mgoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
+	return mongoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
 }
 
 // FindReversalFriends finds users who have added the specified user as a friend.
@@ -121,25 +121,25 @@ func (f *FriendMgo) FindReversalFriends(ctx context.Context, friendUserID string
 		"owner_user_id":  bson.M{"$in": ownerUserIDs},
 		"friend_user_id": friendUserID,
 	}
-	return mgoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
+	return mongoutil.Find[*relation.FriendModel](ctx, f.coll, filter)
 }
 
 // FindOwnerFriends retrieves a paginated list of friends for a given owner.
 func (f *FriendMgo) FindOwnerFriends(ctx context.Context, ownerUserID string, pagination pagination.Pagination) (int64, []*relation.FriendModel, error) {
 	filter := bson.M{"owner_user_id": ownerUserID}
-	return mgoutil.FindPage[*relation.FriendModel](ctx, f.coll, filter, pagination)
+	return mongoutil.FindPage[*relation.FriendModel](ctx, f.coll, filter, pagination)
 }
 
 // FindInWhoseFriends finds users who have added the specified user as a friend, with pagination.
 func (f *FriendMgo) FindInWhoseFriends(ctx context.Context, friendUserID string, pagination pagination.Pagination) (int64, []*relation.FriendModel, error) {
 	filter := bson.M{"friend_user_id": friendUserID}
-	return mgoutil.FindPage[*relation.FriendModel](ctx, f.coll, filter, pagination)
+	return mongoutil.FindPage[*relation.FriendModel](ctx, f.coll, filter, pagination)
 }
 
 // FindFriendUserIDs retrieves a list of friend user IDs for a given owner.
 func (f *FriendMgo) FindFriendUserIDs(ctx context.Context, ownerUserID string) ([]string, error) {
 	filter := bson.M{"owner_user_id": ownerUserID}
-	return mgoutil.Find[string](ctx, f.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "friend_user_id": 1}))
+	return mongoutil.Find[string](ctx, f.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "friend_user_id": 1}))
 }
 
 func (f *FriendMgo) UpdateFriends(ctx context.Context, ownerUserID string, friendUserIDs []string, val map[string]any) error {
@@ -158,6 +158,6 @@ func (f *FriendMgo) UpdateFriends(ctx context.Context, ownerUserID string, frien
 	update := bson.M{"$set": val}
 
 	// Perform the update operation for all matching documents
-	_, err := mgoutil.UpdateMany(ctx, f.coll, filter, update)
+	_, err := mongoutil.UpdateMany(ctx, f.coll, filter, update)
 	return err
 }
diff --git a/pkg/common/db/mgo/friend_request.go b/pkg/common/db/mgo/friend_request.go
index 19f0feb3e..8026cd4ab 100644
--- a/pkg/common/db/mgo/friend_request.go
+++ b/pkg/common/db/mgo/friend_request.go
@@ -16,10 +16,10 @@ package mgo
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -45,11 +45,11 @@ type FriendRequestMgo struct {
 }
 
 func (f *FriendRequestMgo) FindToUserID(ctx context.Context, toUserID string, pagination pagination.Pagination) (total int64, friendRequests []*relation.FriendRequestModel, err error) {
-	return mgoutil.FindPage[*relation.FriendRequestModel](ctx, f.coll, bson.M{"to_user_id": toUserID}, pagination)
+	return mongoutil.FindPage[*relation.FriendRequestModel](ctx, f.coll, bson.M{"to_user_id": toUserID}, pagination)
 }
 
 func (f *FriendRequestMgo) FindFromUserID(ctx context.Context, fromUserID string, pagination pagination.Pagination) (total int64, friendRequests []*relation.FriendRequestModel, err error) {
-	return mgoutil.FindPage[*relation.FriendRequestModel](ctx, f.coll, bson.M{"from_user_id": fromUserID}, pagination)
+	return mongoutil.FindPage[*relation.FriendRequestModel](ctx, f.coll, bson.M{"from_user_id": fromUserID}, pagination)
 }
 
 func (f *FriendRequestMgo) FindBothFriendRequests(ctx context.Context, fromUserID, toUserID string) (friends []*relation.FriendRequestModel, err error) {
@@ -57,22 +57,22 @@ func (f *FriendRequestMgo) FindBothFriendRequests(ctx context.Context, fromUserI
 		{"from_user_id": fromUserID, "to_user_id": toUserID},
 		{"from_user_id": toUserID, "to_user_id": fromUserID},
 	}}
-	return mgoutil.Find[*relation.FriendRequestModel](ctx, f.coll, filter)
+	return mongoutil.Find[*relation.FriendRequestModel](ctx, f.coll, filter)
 }
 
 func (f *FriendRequestMgo) Create(ctx context.Context, friendRequests []*relation.FriendRequestModel) error {
-	return mgoutil.InsertMany(ctx, f.coll, friendRequests)
+	return mongoutil.InsertMany(ctx, f.coll, friendRequests)
 }
 
 func (f *FriendRequestMgo) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
-	return mgoutil.DeleteOne(ctx, f.coll, bson.M{"from_user_id": fromUserID, "to_user_id": toUserID})
+	return mongoutil.DeleteOne(ctx, f.coll, bson.M{"from_user_id": fromUserID, "to_user_id": toUserID})
 }
 
 func (f *FriendRequestMgo) UpdateByMap(ctx context.Context, formUserID, toUserID string, args map[string]any) (err error) {
 	if len(args) == 0 {
 		return nil
 	}
-	return mgoutil.UpdateOne(ctx, f.coll, bson.M{"from_user_id": formUserID, "to_user_id": toUserID}, bson.M{"$set": args}, true)
+	return mongoutil.UpdateOne(ctx, f.coll, bson.M{"from_user_id": formUserID, "to_user_id": toUserID}, bson.M{"$set": args}, true)
 }
 
 func (f *FriendRequestMgo) Update(ctx context.Context, friendRequest *relation.FriendRequestModel) (err error) {
@@ -99,11 +99,11 @@ func (f *FriendRequestMgo) Update(ctx context.Context, friendRequest *relation.F
 		return nil
 	}
 	filter := bson.M{"from_user_id": friendRequest.FromUserID, "to_user_id": friendRequest.ToUserID}
-	return mgoutil.UpdateOne(ctx, f.coll, filter, bson.M{"$set": updater}, true)
+	return mongoutil.UpdateOne(ctx, f.coll, filter, bson.M{"$set": updater}, true)
 }
 
 func (f *FriendRequestMgo) Find(ctx context.Context, fromUserID, toUserID string) (friendRequest *relation.FriendRequestModel, err error) {
-	return mgoutil.FindOne[*relation.FriendRequestModel](ctx, f.coll, bson.M{"from_user_id": fromUserID, "to_user_id": toUserID})
+	return mongoutil.FindOne[*relation.FriendRequestModel](ctx, f.coll, bson.M{"from_user_id": fromUserID, "to_user_id": toUserID})
 }
 
 func (f *FriendRequestMgo) Take(ctx context.Context, fromUserID, toUserID string) (friendRequest *relation.FriendRequestModel, err error) {
diff --git a/pkg/common/db/mgo/group.go b/pkg/common/db/mgo/group.go
index 7499cb368..0b8505a2f 100644
--- a/pkg/common/db/mgo/group.go
+++ b/pkg/common/db/mgo/group.go
@@ -16,13 +16,13 @@ package mgo
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -47,7 +47,7 @@ type GroupMgo struct {
 }
 
 func (g *GroupMgo) Create(ctx context.Context, groups []*relation.GroupModel) (err error) {
-	return mgoutil.InsertMany(ctx, g.coll, groups)
+	return mongoutil.InsertMany(ctx, g.coll, groups)
 }
 
 func (g *GroupMgo) UpdateStatus(ctx context.Context, groupID string, status int32) (err error) {
@@ -58,27 +58,27 @@ func (g *GroupMgo) UpdateMap(ctx context.Context, groupID string, args map[strin
 	if len(args) == 0 {
 		return nil
 	}
-	return mgoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID}, bson.M{"$set": args}, true)
+	return mongoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID}, bson.M{"$set": args}, true)
 }
 
 func (g *GroupMgo) Find(ctx context.Context, groupIDs []string) (groups []*relation.GroupModel, err error) {
-	return mgoutil.Find[*relation.GroupModel](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}})
+	return mongoutil.Find[*relation.GroupModel](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}})
 }
 
 func (g *GroupMgo) Take(ctx context.Context, groupID string) (group *relation.GroupModel, err error) {
-	return mgoutil.FindOne[*relation.GroupModel](ctx, g.coll, bson.M{"group_id": groupID})
+	return mongoutil.FindOne[*relation.GroupModel](ctx, g.coll, bson.M{"group_id": groupID})
 }
 
 func (g *GroupMgo) Search(ctx context.Context, keyword string, pagination pagination.Pagination) (total int64, groups []*relation.GroupModel, err error) {
-	return mgoutil.FindPage[*relation.GroupModel](ctx, g.coll, bson.M{"group_name": bson.M{"$regex": keyword},
+	return mongoutil.FindPage[*relation.GroupModel](ctx, g.coll, bson.M{"group_name": bson.M{"$regex": keyword},
 		"status": bson.M{"$ne": constant.GroupStatusDismissed}}, pagination)
 }
 
 func (g *GroupMgo) CountTotal(ctx context.Context, before *time.Time) (count int64, err error) {
 	if before == nil {
-		return mgoutil.Count(ctx, g.coll, bson.M{})
+		return mongoutil.Count(ctx, g.coll, bson.M{})
 	}
-	return mgoutil.Count(ctx, g.coll, bson.M{"create_time": bson.M{"$lt": before}})
+	return mongoutil.Count(ctx, g.coll, bson.M{"create_time": bson.M{"$lt": before}})
 }
 
 func (g *GroupMgo) CountRangeEverydayTotal(ctx context.Context, start time.Time, end time.Time) (map[string]int64, error) {
@@ -109,7 +109,7 @@ func (g *GroupMgo) CountRangeEverydayTotal(ctx context.Context, start time.Time,
 		Date  string `bson:"_id"`
 		Count int64  `bson:"count"`
 	}
-	items, err := mgoutil.Aggregate[Item](ctx, g.coll, pipeline)
+	items, err := mongoutil.Aggregate[Item](ctx, g.coll, pipeline)
 	if err != nil {
 		return nil, err
 	}
diff --git a/pkg/common/db/mgo/group_member.go b/pkg/common/db/mgo/group_member.go
index f018478ff..589b5c8eb 100644
--- a/pkg/common/db/mgo/group_member.go
+++ b/pkg/common/db/mgo/group_member.go
@@ -16,12 +16,12 @@ package mgo
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/openimsdk/protocol/constant"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -47,7 +47,7 @@ type GroupMemberMgo struct {
 }
 
 func (g *GroupMemberMgo) Create(ctx context.Context, groupMembers []*relation.GroupMemberModel) (err error) {
-	return mgoutil.InsertMany(ctx, g.coll, groupMembers)
+	return mongoutil.InsertMany(ctx, g.coll, groupMembers)
 }
 
 func (g *GroupMemberMgo) Delete(ctx context.Context, groupID string, userIDs []string) (err error) {
@@ -55,7 +55,7 @@ func (g *GroupMemberMgo) Delete(ctx context.Context, groupID string, userIDs []s
 	if len(userIDs) > 0 {
 		filter["user_id"] = bson.M{"$in": userIDs}
 	}
-	return mgoutil.DeleteMany(ctx, g.coll, filter)
+	return mongoutil.DeleteMany(ctx, g.coll, filter)
 }
 
 func (g *GroupMemberMgo) UpdateRoleLevel(ctx context.Context, groupID string, userID string, roleLevel int32) error {
@@ -63,7 +63,7 @@ func (g *GroupMemberMgo) UpdateRoleLevel(ctx context.Context, groupID string, us
 }
 
 func (g *GroupMemberMgo) Update(ctx context.Context, groupID string, userID string, data map[string]any) (err error) {
-	return mgoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID}, bson.M{"$set": data}, true)
+	return mongoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID}, bson.M{"$set": data}, true)
 }
 
 func (g *GroupMemberMgo) Find(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) (groupMembers []*relation.GroupMemberModel, err error) {
@@ -72,32 +72,32 @@ func (g *GroupMemberMgo) Find(ctx context.Context, groupIDs []string, userIDs []
 }
 
 func (g *GroupMemberMgo) FindMemberUserID(ctx context.Context, groupID string) (userIDs []string, err error) {
-	return mgoutil.Find[string](ctx, g.coll, bson.M{"group_id": groupID}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
+	return mongoutil.Find[string](ctx, g.coll, bson.M{"group_id": groupID}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
 }
 
 func (g *GroupMemberMgo) Take(ctx context.Context, groupID string, userID string) (groupMember *relation.GroupMemberModel, err error) {
-	return mgoutil.FindOne[*relation.GroupMemberModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
+	return mongoutil.FindOne[*relation.GroupMemberModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
 }
 
 func (g *GroupMemberMgo) TakeOwner(ctx context.Context, groupID string) (groupMember *relation.GroupMemberModel, err error) {
-	return mgoutil.FindOne[*relation.GroupMemberModel](ctx, g.coll, bson.M{"group_id": groupID, "role_level": constant.GroupOwner})
+	return mongoutil.FindOne[*relation.GroupMemberModel](ctx, g.coll, bson.M{"group_id": groupID, "role_level": constant.GroupOwner})
 }
 
 func (g *GroupMemberMgo) FindRoleLevelUserIDs(ctx context.Context, groupID string, roleLevel int32) ([]string, error) {
-	return mgoutil.Find[string](ctx, g.coll, bson.M{"group_id": groupID, "role_level": roleLevel}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
+	return mongoutil.Find[string](ctx, g.coll, bson.M{"group_id": groupID, "role_level": roleLevel}, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
 }
 
 func (g *GroupMemberMgo) SearchMember(ctx context.Context, keyword string, groupID string, pagination pagination.Pagination) (total int64, groupList []*relation.GroupMemberModel, err error) {
 	filter := bson.M{"group_id": groupID, "nickname": bson.M{"$regex": keyword}}
-	return mgoutil.FindPage[*relation.GroupMemberModel](ctx, g.coll, filter, pagination)
+	return mongoutil.FindPage[*relation.GroupMemberModel](ctx, g.coll, filter, pagination)
 }
 
 func (g *GroupMemberMgo) FindUserJoinedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) {
-	return mgoutil.Find[string](ctx, g.coll, bson.M{"user_id": userID}, options.Find().SetProjection(bson.M{"_id": 0, "group_id": 1}))
+	return mongoutil.Find[string](ctx, g.coll, bson.M{"user_id": userID}, options.Find().SetProjection(bson.M{"_id": 0, "group_id": 1}))
 }
 
 func (g *GroupMemberMgo) TakeGroupMemberNum(ctx context.Context, groupID string) (count int64, err error) {
-	return mgoutil.Count(ctx, g.coll, bson.M{"group_id": groupID})
+	return mongoutil.Count(ctx, g.coll, bson.M{"group_id": groupID})
 }
 
 func (g *GroupMemberMgo) FindUserManagedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) {
@@ -107,7 +107,7 @@ func (g *GroupMemberMgo) FindUserManagedGroupID(ctx context.Context, userID stri
 			"$in": []int{constant.GroupOwner, constant.GroupAdmin},
 		},
 	}
-	return mgoutil.Find[string](ctx, g.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "group_id": 1}))
+	return mongoutil.Find[string](ctx, g.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "group_id": 1}))
 }
 
 func (g *GroupMemberMgo) IsUpdateRoleLevel(data map[string]any) bool {
diff --git a/pkg/common/db/mgo/group_request.go b/pkg/common/db/mgo/group_request.go
index 94e4b7862..67fd4e1ba 100644
--- a/pkg/common/db/mgo/group_request.go
+++ b/pkg/common/db/mgo/group_request.go
@@ -16,11 +16,11 @@ package mgo
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -46,29 +46,29 @@ type GroupRequestMgo struct {
 }
 
 func (g *GroupRequestMgo) Create(ctx context.Context, groupRequests []*relation.GroupRequestModel) (err error) {
-	return mgoutil.InsertMany(ctx, g.coll, groupRequests)
+	return mongoutil.InsertMany(ctx, g.coll, groupRequests)
 }
 
 func (g *GroupRequestMgo) Delete(ctx context.Context, groupID string, userID string) (err error) {
-	return mgoutil.DeleteOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
+	return mongoutil.DeleteOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
 }
 
 func (g *GroupRequestMgo) UpdateHandler(ctx context.Context, groupID string, userID string, handledMsg string, handleResult int32) (err error) {
-	return mgoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID}, bson.M{"$set": bson.M{"handle_msg": handledMsg, "handle_result": handleResult}}, true)
+	return mongoutil.UpdateOne(ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID}, bson.M{"$set": bson.M{"handle_msg": handledMsg, "handle_result": handleResult}}, true)
 }
 
 func (g *GroupRequestMgo) Take(ctx context.Context, groupID string, userID string) (groupRequest *relation.GroupRequestModel, err error) {
-	return mgoutil.FindOne[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
+	return mongoutil.FindOne[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": userID})
 }
 
 func (g *GroupRequestMgo) FindGroupRequests(ctx context.Context, groupID string, userIDs []string) ([]*relation.GroupRequestModel, error) {
-	return mgoutil.Find[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": bson.M{"$in": userIDs}})
+	return mongoutil.Find[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": groupID, "user_id": bson.M{"$in": userIDs}})
 }
 
 func (g *GroupRequestMgo) Page(ctx context.Context, userID string, pagination pagination.Pagination) (total int64, groups []*relation.GroupRequestModel, err error) {
-	return mgoutil.FindPage[*relation.GroupRequestModel](ctx, g.coll, bson.M{"user_id": userID}, pagination)
+	return mongoutil.FindPage[*relation.GroupRequestModel](ctx, g.coll, bson.M{"user_id": userID}, pagination)
 }
 
 func (g *GroupRequestMgo) PageGroup(ctx context.Context, groupIDs []string, pagination pagination.Pagination) (total int64, groups []*relation.GroupRequestModel, err error) {
-	return mgoutil.FindPage[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}}, pagination)
+	return mongoutil.FindPage[*relation.GroupRequestModel](ctx, g.coll, bson.M{"group_id": bson.M{"$in": groupIDs}}, pagination)
 }
diff --git a/pkg/common/db/mgo/log.go b/pkg/common/db/mgo/log.go
index 8b760d749..b837e9783 100644
--- a/pkg/common/db/mgo/log.go
+++ b/pkg/common/db/mgo/log.go
@@ -16,11 +16,11 @@ package mgo
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -57,7 +57,7 @@ type LogMgo struct {
 }
 
 func (l *LogMgo) Create(ctx context.Context, log []*relation.LogModel) error {
-	return mgoutil.InsertMany(ctx, l.coll, log)
+	return mongoutil.InsertMany(ctx, l.coll, log)
 }
 
 func (l *LogMgo) Search(ctx context.Context, keyword string, start time.Time, end time.Time, pagination pagination.Pagination) (int64, []*relation.LogModel, error) {
@@ -65,19 +65,19 @@ func (l *LogMgo) Search(ctx context.Context, keyword string, start time.Time, en
 	if keyword != "" {
 		filter["user_id"] = bson.M{"$regex": keyword}
 	}
-	return mgoutil.FindPage[*relation.LogModel](ctx, l.coll, filter, pagination, options.Find().SetSort(bson.M{"create_time": -1}))
+	return mongoutil.FindPage[*relation.LogModel](ctx, l.coll, filter, pagination, options.Find().SetSort(bson.M{"create_time": -1}))
 }
 
 func (l *LogMgo) Delete(ctx context.Context, logID []string, userID string) error {
 	if userID == "" {
-		return mgoutil.DeleteMany(ctx, l.coll, bson.M{"log_id": bson.M{"$in": logID}})
+		return mongoutil.DeleteMany(ctx, l.coll, bson.M{"log_id": bson.M{"$in": logID}})
 	}
-	return mgoutil.DeleteMany(ctx, l.coll, bson.M{"log_id": bson.M{"$in": logID}, "user_id": userID})
+	return mongoutil.DeleteMany(ctx, l.coll, bson.M{"log_id": bson.M{"$in": logID}, "user_id": userID})
 }
 
 func (l *LogMgo) Get(ctx context.Context, logIDs []string, userID string) ([]*relation.LogModel, error) {
 	if userID == "" {
-		return mgoutil.Find[*relation.LogModel](ctx, l.coll, bson.M{"log_id": bson.M{"$in": logIDs}})
+		return mongoutil.Find[*relation.LogModel](ctx, l.coll, bson.M{"log_id": bson.M{"$in": logIDs}})
 	}
-	return mgoutil.Find[*relation.LogModel](ctx, l.coll, bson.M{"log_id": bson.M{"$in": logIDs}, "user_id": userID})
+	return mongoutil.Find[*relation.LogModel](ctx, l.coll, bson.M{"log_id": bson.M{"$in": logIDs}, "user_id": userID})
 }
diff --git a/pkg/common/db/mgo/msg.go b/pkg/common/db/mgo/msg.go
index 97aa56531..0b4598bb4 100644
--- a/pkg/common/db/mgo/msg.go
+++ b/pkg/common/db/mgo/msg.go
@@ -7,10 +7,10 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/sdkws"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/utils"
+	"github.com/openimsdk/tools/utils/jsonutil"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -40,11 +40,11 @@ type MsgMgo struct {
 func (m *MsgMgo) PushMsgsToDoc(ctx context.Context, docID string, msgsToMongo []relation.MsgInfoModel) error {
 	filter := bson.M{"doc_id": docID}
 	update := bson.M{"$push": bson.M{"msgs": bson.M{"$each": msgsToMongo}}}
-	return mgoutil.UpdateOne(ctx, m.coll, filter, update, false)
+	return mongoutil.UpdateOne(ctx, m.coll, filter, update, false)
 }
 
 func (m *MsgMgo) Create(ctx context.Context, model *relation.MsgDocModel) error {
-	return mgoutil.InsertMany(ctx, m.coll, []*relation.MsgDocModel{model})
+	return mongoutil.InsertMany(ctx, m.coll, []*relation.MsgDocModel{model})
 }
 
 func (m *MsgMgo) UpdateMsg(ctx context.Context, docID string, index int64, key string, value any) (*mongo.UpdateResult, error) {
@@ -56,7 +56,7 @@ func (m *MsgMgo) UpdateMsg(ctx context.Context, docID string, index int64, key s
 	}
 	filter := bson.M{"doc_id": docID}
 	update := bson.M{"$set": bson.M{field: value}}
-	return mgoutil.UpdateOneResult(ctx, m.coll, filter, update)
+	return mongoutil.UpdateOneResult(ctx, m.coll, filter, update)
 }
 
 func (m *MsgMgo) PushUnique(ctx context.Context, docID string, index int64, key string, value any) (*mongo.UpdateResult, error) {
@@ -72,21 +72,21 @@ func (m *MsgMgo) PushUnique(ctx context.Context, docID string, index int64, key
 			field: bson.M{"$each": value},
 		},
 	}
-	return mgoutil.UpdateOneResult(ctx, m.coll, filter, update)
+	return mongoutil.UpdateOneResult(ctx, m.coll, filter, update)
 }
 
 func (m *MsgMgo) UpdateMsgContent(ctx context.Context, docID string, index int64, msg []byte) error {
 	filter := bson.M{"doc_id": docID}
 	update := bson.M{"$set": bson.M{fmt.Sprintf("msgs.%d.msg", index): msg}}
-	return mgoutil.UpdateOne(ctx, m.coll, filter, update, false)
+	return mongoutil.UpdateOne(ctx, m.coll, filter, update, false)
 }
 
 func (m *MsgMgo) IsExistDocID(ctx context.Context, docID string) (bool, error) {
-	return mgoutil.Exist(ctx, m.coll, bson.M{"doc_id": docID})
+	return mongoutil.Exist(ctx, m.coll, bson.M{"doc_id": docID})
 }
 
 func (m *MsgMgo) FindOneByDocID(ctx context.Context, docID string) (*relation.MsgDocModel, error) {
-	return mgoutil.FindOne[*relation.MsgDocModel](ctx, m.coll, bson.M{"doc_id": docID})
+	return mongoutil.FindOne[*relation.MsgDocModel](ctx, m.coll, bson.M{"doc_id": docID})
 }
 
 func (m *MsgMgo) GetMsgBySeqIndexIn1Doc(ctx context.Context, userID, docID string, seqs []int64) ([]*relation.MsgInfoModel, error) {
@@ -130,7 +130,7 @@ func (m *MsgMgo) GetMsgBySeqIndexIn1Doc(ctx context.Context, userID, docID strin
 			{Key: "msgs.del_list", Value: 0},
 		}}},
 	}
-	msgDocModel, err := mgoutil.Aggregate[*relation.MsgDocModel](ctx, m.coll, pipeline)
+	msgDocModel, err := mongoutil.Aggregate[*relation.MsgDocModel](ctx, m.coll, pipeline)
 	if err != nil {
 		return nil, err
 	}
@@ -157,14 +157,14 @@ func (m *MsgMgo) GetMsgBySeqIndexIn1Doc(ctx context.Context, userID, docID strin
 				Seq:                         msg.Msg.Seq,
 				Ex:                          msg.Msg.Ex,
 			}
-			data, err := utils.JsonMarshal(&revokeContent)
+			data, err := jsonutil.JsonMarshal(&revokeContent)
 			if err != nil {
 				return nil, errs.WrapMsg(err, fmt.Sprintf("docID is %s, seqs is %v", docID, seqs))
 			}
 			elem := sdkws.NotificationElem{
 				Detail: string(data),
 			}
-			content, err := utils.JsonMarshal(&elem)
+			content, err := jsonutil.JsonMarshal(&elem)
 			if err != nil {
 				return nil, errs.WrapMsg(err, fmt.Sprintf("docID is %s, seqs is %v", docID, seqs))
 			}
@@ -208,7 +208,7 @@ func (m *MsgMgo) DeleteDocs(ctx context.Context, docIDs []string) error {
 	if len(docIDs) == 0 {
 		return nil
 	}
-	return mgoutil.DeleteMany(ctx, m.coll, bson.M{"doc_id": bson.M{"$in": docIDs}})
+	return mongoutil.DeleteMany(ctx, m.coll, bson.M{"doc_id": bson.M{"$in": docIDs}})
 }
 
 func (m *MsgMgo) GetMsgDocModelByIndex(ctx context.Context, conversationID string, index, sort int64) (*relation.MsgDocModel, error) {
@@ -217,7 +217,7 @@ func (m *MsgMgo) GetMsgDocModelByIndex(ctx context.Context, conversationID strin
 	}
 	opt := options.Find().SetLimit(1).SetSkip(index).SetSort(bson.M{"doc_id": sort}).SetLimit(1)
 	filter := bson.M{"doc_id": primitive.Regex{Pattern: fmt.Sprintf("^%s:", conversationID)}}
-	msgs, err := mgoutil.Find[*relation.MsgDocModel](ctx, m.coll, filter, opt)
+	msgs, err := mongoutil.Find[*relation.MsgDocModel](ctx, m.coll, filter, opt)
 	if err != nil {
 		return nil, err
 	}
@@ -236,7 +236,7 @@ func (m *MsgMgo) DeleteMsgsInOneDocByIndex(ctx context.Context, docID string, in
 			"msg": nil,
 		}
 	}
-	_, err := mgoutil.UpdateMany(ctx, m.coll, bson.M{"doc_id": docID}, update)
+	_, err := mongoutil.UpdateMany(ctx, m.coll, bson.M{"doc_id": docID}, update)
 	return err
 }
 
@@ -311,7 +311,7 @@ func (m *MsgMgo) SearchMessage(ctx context.Context, req *msg.SearchMessageReq) (
 		DocID string                 `bson:"doc_id"`
 		Msg   *relation.MsgInfoModel `bson:"msgs"`
 	}
-	msgsDocs, err := mgoutil.Aggregate[*docModel](ctx, m.coll, pipe)
+	msgsDocs, err := mongoutil.Aggregate[*docModel](ctx, m.coll, pipe)
 	if err != nil {
 		return 0, nil, err
 	}
@@ -335,12 +335,12 @@ func (m *MsgMgo) SearchMessage(ctx context.Context, req *msg.SearchMessageReq) (
 				Seq:                         msgInfo.Msg.Seq,
 				Ex:                          msgInfo.Msg.Ex,
 			}
-			data, err := utils.JsonMarshal(&revokeContent)
+			data, err := jsonutil.JsonMarshal(&revokeContent)
 			if err != nil {
 				return 0, nil, errs.WrapMsg(err, "json.Marshal revokeContent")
 			}
 			elem := sdkws.NotificationElem{Detail: string(data)}
-			content, err := utils.JsonMarshal(&elem)
+			content, err := jsonutil.JsonMarshal(&elem)
 			if err != nil {
 				return 0, nil, errs.WrapMsg(err, "json.Marshal elem")
 			}
@@ -589,7 +589,7 @@ func (m *MsgMgo) RangeUserSendCount(ctx context.Context, start time.Time, end ti
 			},
 		},
 	}
-	result, err := mgoutil.Aggregate[*Result](ctx, m.coll, pipeline, options.Aggregate().SetAllowDiskUse(true))
+	result, err := mongoutil.Aggregate[*Result](ctx, m.coll, pipeline, options.Aggregate().SetAllowDiskUse(true))
 	if err != nil {
 		return 0, 0, nil, nil, err
 	}
@@ -826,7 +826,7 @@ func (m *MsgMgo) RangeGroupSendCount(ctx context.Context, start time.Time, end t
 			},
 		},
 	}
-	result, err := mgoutil.Aggregate[*Result](ctx, m.coll, pipeline, options.Aggregate().SetAllowDiskUse(true))
+	result, err := mongoutil.Aggregate[*Result](ctx, m.coll, pipeline, options.Aggregate().SetAllowDiskUse(true))
 	if err != nil {
 		return 0, 0, nil, nil, err
 	}
@@ -850,7 +850,7 @@ func (m *MsgMgo) RangeGroupSendCount(ctx context.Context, start time.Time, end t
 func (m *MsgMgo) ConvertMsgsDocLen(ctx context.Context, conversationIDs []string) {
 	for _, conversationID := range conversationIDs {
 		regex := primitive.Regex{Pattern: fmt.Sprintf("^%s:", conversationID)}
-		msgDocs, err := mgoutil.Find[*relation.MsgDocModel](ctx, m.coll, bson.M{"doc_id": regex})
+		msgDocs, err := mongoutil.Find[*relation.MsgDocModel](ctx, m.coll, bson.M{"doc_id": regex})
 		if err != nil {
 			log.ZError(ctx, "convertAll find msg doc failed", err, "conversationID", conversationID)
 			continue
@@ -860,7 +860,7 @@ func (m *MsgMgo) ConvertMsgsDocLen(ctx context.Context, conversationIDs []string
 		}
 		log.ZInfo(ctx, "msg doc convert", "conversationID", conversationID, "len(msgDocs)", len(msgDocs))
 		if len(msgDocs[0].Msg) == int(m.model.GetSingleGocMsgNum5000()) {
-			if err := mgoutil.DeleteMany(ctx, m.coll, bson.M{"doc_id": regex}); err != nil {
+			if err := mongoutil.DeleteMany(ctx, m.coll, bson.M{"doc_id": regex}); err != nil {
 				log.ZError(ctx, "convertAll delete many failed", err, "conversationID", conversationID)
 				continue
 			}
@@ -887,7 +887,7 @@ func (m *MsgMgo) ConvertMsgsDocLen(ctx context.Context, conversationIDs []string
 					}
 				}
 			}
-			if err = mgoutil.InsertMany(ctx, m.coll, newMsgDocs); err != nil {
+			if err = mongoutil.InsertMany(ctx, m.coll, newMsgDocs); err != nil {
 				log.ZError(ctx, "convertAll insert many failed", err, "conversationID", conversationID, "len(newMsgDocs)", len(newMsgDocs))
 			} else {
 				log.ZInfo(ctx, "msg doc convert", "conversationID", conversationID, "len(newMsgDocs)", len(newMsgDocs))
diff --git a/pkg/common/db/mgo/object.go b/pkg/common/db/mgo/object.go
index f97d287ad..1c628bb51 100644
--- a/pkg/common/db/mgo/object.go
+++ b/pkg/common/db/mgo/object.go
@@ -18,8 +18,8 @@ import (
 	"context"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/mgoutil"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
@@ -54,16 +54,16 @@ func (o *S3Mongo) SetObject(ctx context.Context, obj *relation.ObjectModel) erro
 		"group":        obj.Group,
 		"create_time":  obj.CreateTime,
 	}
-	return mgoutil.UpdateOne(ctx, o.coll, filter, bson.M{"$set": update}, false, options.Update().SetUpsert(true))
+	return mongoutil.UpdateOne(ctx, o.coll, filter, bson.M{"$set": update}, false, options.Update().SetUpsert(true))
 }
 
 func (o *S3Mongo) Take(ctx context.Context, engine string, name string) (*relation.ObjectModel, error) {
 	if engine == "" {
-		return mgoutil.FindOne[*relation.ObjectModel](ctx, o.coll, bson.M{"name": name})
+		return mongoutil.FindOne[*relation.ObjectModel](ctx, o.coll, bson.M{"name": name})
 	}
-	return mgoutil.FindOne[*relation.ObjectModel](ctx, o.coll, bson.M{"name": name, "engine": engine})
+	return mongoutil.FindOne[*relation.ObjectModel](ctx, o.coll, bson.M{"name": name, "engine": engine})
 }
 
 func (o *S3Mongo) Delete(ctx context.Context, engine string, name string) error {
-	return mgoutil.DeleteOne(ctx, o.coll, bson.M{"name": name, "engine": engine})
+	return mongoutil.DeleteOne(ctx, o.coll, bson.M{"name": name, "engine": engine})
 }
diff --git a/pkg/common/db/mgo/user.go b/pkg/common/db/mgo/user.go
index 230f6c83f..9be3f808e 100644
--- a/pkg/common/db/mgo/user.go
+++ b/pkg/common/db/mgo/user.go
@@ -16,13 +16,13 @@ package mgo
 
 import (
 	"context"
+	"github.com/openimsdk/tools/db/pagination"
 	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/table/relation"
 	"github.com/openimsdk/protocol/user"
+	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/errs"
-	"github.com/openimsdk/tools/mgoutil"
-	"github.com/openimsdk/tools/pagination"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -48,34 +48,34 @@ type UserMgo struct {
 }
 
 func (u *UserMgo) Create(ctx context.Context, users []*relation.UserModel) error {
-	return mgoutil.InsertMany(ctx, u.coll, users)
+	return mongoutil.InsertMany(ctx, u.coll, users)
 }
 
 func (u *UserMgo) UpdateByMap(ctx context.Context, userID string, args map[string]any) (err error) {
 	if len(args) == 0 {
 		return nil
 	}
-	return mgoutil.UpdateOne(ctx, u.coll, bson.M{"user_id": userID}, bson.M{"$set": args}, true)
+	return mongoutil.UpdateOne(ctx, u.coll, bson.M{"user_id": userID}, bson.M{"$set": args}, true)
 }
 
 func (u *UserMgo) Find(ctx context.Context, userIDs []string) (users []*relation.UserModel, err error) {
-	return mgoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"user_id": bson.M{"$in": userIDs}})
+	return mongoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"user_id": bson.M{"$in": userIDs}})
 }
 
 func (u *UserMgo) Take(ctx context.Context, userID string) (user *relation.UserModel, err error) {
-	return mgoutil.FindOne[*relation.UserModel](ctx, u.coll, bson.M{"user_id": userID})
+	return mongoutil.FindOne[*relation.UserModel](ctx, u.coll, bson.M{"user_id": userID})
 }
 
 func (u *UserMgo) TakeNotification(ctx context.Context, level int64) (user []*relation.UserModel, err error) {
-	return mgoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"app_manger_level": level})
+	return mongoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"app_manger_level": level})
 }
 
 func (u *UserMgo) TakeByNickname(ctx context.Context, nickname string) (user []*relation.UserModel, err error) {
-	return mgoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"nickname": nickname})
+	return mongoutil.Find[*relation.UserModel](ctx, u.coll, bson.M{"nickname": nickname})
 }
 
 func (u *UserMgo) Page(ctx context.Context, pagination pagination.Pagination) (count int64, users []*relation.UserModel, err error) {
-	return mgoutil.FindPage[*relation.UserModel](ctx, u.coll, bson.M{}, pagination)
+	return mongoutil.FindPage[*relation.UserModel](ctx, u.coll, bson.M{}, pagination)
 }
 
 func (u *UserMgo) PageFindUser(ctx context.Context, level1 int64, level2 int64, pagination pagination.Pagination) (count int64, users []*relation.UserModel, err error) {
@@ -86,7 +86,7 @@ func (u *UserMgo) PageFindUser(ctx context.Context, level1 int64, level2 int64,
 		},
 	}
 
-	return mgoutil.FindPage[*relation.UserModel](ctx, u.coll, query, pagination)
+	return mongoutil.FindPage[*relation.UserModel](ctx, u.coll, query, pagination)
 }
 
 func (u *UserMgo) PageFindUserWithKeyword(
@@ -121,26 +121,26 @@ func (u *UserMgo) PageFindUserWithKeyword(
 	}
 
 	// Perform the paginated search
-	return mgoutil.FindPage[*relation.UserModel](ctx, u.coll, query, pagination)
+	return mongoutil.FindPage[*relation.UserModel](ctx, u.coll, query, pagination)
 }
 
 func (u *UserMgo) GetAllUserID(ctx context.Context, pagination pagination.Pagination) (int64, []string, error) {
-	return mgoutil.FindPage[string](ctx, u.coll, bson.M{}, pagination, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
+	return mongoutil.FindPage[string](ctx, u.coll, bson.M{}, pagination, options.Find().SetProjection(bson.M{"_id": 0, "user_id": 1}))
 }
 
 func (u *UserMgo) Exist(ctx context.Context, userID string) (exist bool, err error) {
-	return mgoutil.Exist(ctx, u.coll, bson.M{"user_id": userID})
+	return mongoutil.Exist(ctx, u.coll, bson.M{"user_id": userID})
 }
 
 func (u *UserMgo) GetUserGlobalRecvMsgOpt(ctx context.Context, userID string) (opt int, err error) {
-	return mgoutil.FindOne[int](ctx, u.coll, bson.M{"user_id": userID}, options.FindOne().SetProjection(bson.M{"_id": 0, "global_recv_msg_opt": 1}))
+	return mongoutil.FindOne[int](ctx, u.coll, bson.M{"user_id": userID}, options.FindOne().SetProjection(bson.M{"_id": 0, "global_recv_msg_opt": 1}))
 }
 
 func (u *UserMgo) CountTotal(ctx context.Context, before *time.Time) (count int64, err error) {
 	if before == nil {
-		return mgoutil.Count(ctx, u.coll, bson.M{})
+		return mongoutil.Count(ctx, u.coll, bson.M{})
 	}
-	return mgoutil.Count(ctx, u.coll, bson.M{"create_time": bson.M{"$lt": before}})
+	return mongoutil.Count(ctx, u.coll, bson.M{"create_time": bson.M{"$lt": before}})
 }
 
 func (u *UserMgo) AddUserCommand(ctx context.Context, userID string, Type int32, UUID string, value string, ex string) error {
@@ -308,7 +308,7 @@ func (u *UserMgo) CountRangeEverydayTotal(ctx context.Context, start time.Time,
 		Date  string `bson:"_id"`
 		Count int64  `bson:"count"`
 	}
-	items, err := mgoutil.Aggregate[Item](ctx, u.coll, pipeline)
+	items, err := mongoutil.Aggregate[Item](ctx, u.coll, pipeline)
 	if err != nil {
 		return nil, err
 	}