diff --git a/go.mod b/go.mod
index 8906321b6..d06edc1d9 100644
--- a/go.mod
+++ b/go.mod
@@ -14,7 +14,7 @@ require (
 	github.com/lestrrat-go/file-rotatelogs v2.4.0+incompatible // indirect
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/openimsdk/localcache v0.0.1
-	github.com/openimsdk/protocol v0.0.58
+	github.com/openimsdk/protocol v0.0.59
 	github.com/openimsdk/tools v0.0.47-alpha.10
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_golang v1.18.0
diff --git a/go.sum b/go.sum
index 53271fc0c..29230581e 100644
--- a/go.sum
+++ b/go.sum
@@ -257,8 +257,8 @@ github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1y
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
 github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE=
 github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs=
-github.com/openimsdk/protocol v0.0.58 h1:wxCZBty7zNOcBsiZmrZRQLtaLPv4UpGyxLZp1GGrwic=
-github.com/openimsdk/protocol v0.0.58/go.mod h1:OZQA9FR55lseYoN2Ql1XAHYKHJGu7OMNkUbuekrKCM8=
+github.com/openimsdk/protocol v0.0.59 h1:eINLjWs4pnBl33JccwHV5qUYCRm3UWk+1ED4HbDENC8=
+github.com/openimsdk/protocol v0.0.59/go.mod h1:OZQA9FR55lseYoN2Ql1XAHYKHJGu7OMNkUbuekrKCM8=
 github.com/openimsdk/tools v0.0.47-alpha.10 h1:bel44PB4xcC1uO+1y/LYhgsPmAGpxrlNd8JaFL4yc50=
 github.com/openimsdk/tools v0.0.47-alpha.10/go.mod h1:mUsH+ANKbdmhUih43ijJHvuYcU8owm7X3kdFH7FsIec=
 github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
diff --git a/internal/push/push_to_client.go b/internal/push/push_to_client.go
index cf69fb13d..9390eb17f 100644
--- a/internal/push/push_to_client.go
+++ b/internal/push/push_to_client.go
@@ -246,7 +246,7 @@ func (p *Pusher) Push2SuperGroup(ctx context.Context, groupID string, msg *sdkws
 				}
 				defer func(groupID string) {
 					if err = p.groupRpcClient.DismissGroup(ctx, groupID); err != nil {
-						log.ZError(ctx, "DismissGroup Notification clear members", err, "groupID", groupID)
+						log.ZError(ctx, "DismissGroup notification clear members", err, "groupID", groupID)
 					}
 				}(groupID)
 			}
diff --git a/internal/rpc/group/cache.go b/internal/rpc/group/cache.go
index 435f6bb68..022a0f4ef 100644
--- a/internal/rpc/group/cache.go
+++ b/internal/rpc/group/cache.go
@@ -22,20 +22,22 @@ import (
 )
 
 // GetGroupInfoCache get group info from cache.
-func (s *groupServer) GetGroupInfoCache(ctx context.Context, req *pbgroup.GetGroupInfoCacheReq) (resp *pbgroup.GetGroupInfoCacheResp, err error) {
+func (s *groupServer) GetGroupInfoCache(ctx context.Context, req *pbgroup.GetGroupInfoCacheReq) (*pbgroup.GetGroupInfoCacheResp, error) {
 	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	resp = &pbgroup.GetGroupInfoCacheResp{GroupInfo: convert.Db2PbGroupInfo(group, "", 0)}
-	return resp, nil
+	return &pbgroup.GetGroupInfoCacheResp{
+		GroupInfo: convert.Db2PbGroupInfo(group, "", 0),
+	}, nil
 }
 
-func (s *groupServer) GetGroupMemberCache(ctx context.Context, req *pbgroup.GetGroupMemberCacheReq) (resp *pbgroup.GetGroupMemberCacheResp, err error) {
+func (s *groupServer) GetGroupMemberCache(ctx context.Context, req *pbgroup.GetGroupMemberCacheReq) (*pbgroup.GetGroupMemberCacheResp, error) {
 	members, err := s.db.TakeGroupMember(ctx, req.GroupID, req.GroupMemberID)
 	if err != nil {
 		return nil, err
 	}
-	resp = &pbgroup.GetGroupMemberCacheResp{Member: convert.Db2PbGroupMember(members)}
-	return resp, nil
+	return &pbgroup.GetGroupMemberCacheResp{
+		Member: convert.Db2PbGroupMember(members),
+	}, nil
 }
diff --git a/internal/rpc/group/callback.go b/internal/rpc/group/callback.go
index cbe5514b5..eea69fe43 100644
--- a/internal/rpc/group/callback.go
+++ b/internal/rpc/group/callback.go
@@ -38,7 +38,7 @@ type GroupEventCallbackConfig struct {
 }
 
 // CallbackBeforeCreateGroup callback before create group.
-func CallbackBeforeCreateGroup(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.CreateGroupReq) (err error) {
+func CallbackBeforeCreateGroup(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.CreateGroupReq) error {
 	if !cfg.BeforeCreateGroup.Enable {
 		return nil
 	}
@@ -65,7 +65,7 @@ func CallbackBeforeCreateGroup(ctx context.Context, cfg *GroupEventCallbackConfi
 	}
 	resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
 
-	if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
+	if err := http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
 		return err
 	}
 	datautil.NotNilReplace(&req.GroupInfo.GroupID, resp.GroupID)
@@ -83,7 +83,7 @@ func CallbackBeforeCreateGroup(ctx context.Context, cfg *GroupEventCallbackConfi
 	return nil
 }
 
-func CallbackAfterCreateGroup(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.CreateGroupReq) (err error) {
+func CallbackAfterCreateGroup(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.CreateGroupReq) error {
 	if !cfg.BeforeCreateGroup.Enable {
 		return nil
 	}
@@ -109,13 +109,10 @@ func CallbackAfterCreateGroup(ctx context.Context, cfg *GroupEventCallbackConfig
 		})
 	}
 	resp := &callbackstruct.CallbackAfterCreateGroupResp{}
-	if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
-		return err
-	}
-	return nil
+	return http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup)
 }
 
-func CallbackBeforeMemberJoinGroup(ctx context.Context, cfg *GroupEventCallbackConfig, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
+func CallbackBeforeMemberJoinGroup(ctx context.Context, cfg *GroupEventCallbackConfig, groupMember *relation.GroupMemberModel, groupEx string) error {
 	if !cfg.BeforeCreateGroup.Enable {
 		return nil
 	}
@@ -128,7 +125,7 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, cfg *GroupEventCallbackC
 	}
 	resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
 
-	if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup); err != nil {
+	if err := http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup); err != nil {
 		return err
 	}
 
@@ -143,7 +140,7 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, cfg *GroupEventCallbackC
 	return nil
 }
 
-func CallbackBeforeSetGroupMemberInfo(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.SetGroupMemberInfo) (err error) {
+func CallbackBeforeSetGroupMemberInfo(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.SetGroupMemberInfo) error {
 	if !cfg.BeforeCreateGroup.Enable {
 		return nil
 	}
@@ -166,13 +163,7 @@ func CallbackBeforeSetGroupMemberInfo(ctx context.Context, cfg *GroupEventCallba
 		callbackReq.Ex = &req.Ex.Value
 	}
 	resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
-	err = http.CallBackPostReturn(
-		ctx,
-		cfg.CallbackUrl,
-		callbackReq,
-		resp,
-		cfg.BeforeCreateGroup,
-	)
+	err := http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup)
 	if err != nil {
 		return err
 	}
@@ -191,7 +182,7 @@ func CallbackBeforeSetGroupMemberInfo(ctx context.Context, cfg *GroupEventCallba
 	return nil
 }
 
-func CallbackAfterSetGroupMemberInfo(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.SetGroupMemberInfo) (err error) {
+func CallbackAfterSetGroupMemberInfo(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.SetGroupMemberInfo) error {
 	if !cfg.BeforeCreateGroup.Enable {
 		return nil
 	}
@@ -213,13 +204,10 @@ func CallbackAfterSetGroupMemberInfo(ctx context.Context, cfg *GroupEventCallbac
 		callbackReq.Ex = &req.Ex.Value
 	}
 	resp := &callbackstruct.CallbackAfterSetGroupMemberInfoResp{}
-	if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup); err != nil {
-		return err
-	}
-	return nil
+	return http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup)
 }
 
-func CallbackQuitGroup(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.QuitGroupReq) (err error) {
+func CallbackQuitGroup(ctx context.Context, cfg *GroupEventCallbackConfig, req *group.QuitGroupReq) error {
 	if !cfg.BeforeCreateGroup.Enable {
 		return nil
 	}
@@ -229,10 +217,7 @@ func CallbackQuitGroup(ctx context.Context, cfg *GroupEventCallbackConfig, req *
 		UserID:          req.UserID,
 	}
 	resp := &callbackstruct.CallbackQuitGroupResp{}
-	if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
-		return err
-	}
-	return nil
+	return http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup)
 }
 
 func CallbackKillGroupMember(ctx context.Context, cfg *GroupEventCallbackConfig, req *pbgroup.KickGroupMemberReq) (err error) {
@@ -425,8 +410,5 @@ func CallbackAfterSetGroupInfo(ctx context.Context, cfg *GroupEventCallbackConfi
 		callbackReq.ApplyMemberFriend = &req.GroupInfoForSet.ApplyMemberFriend.Value
 	}
 	resp := &callbackstruct.CallbackAfterSetGroupInfoResp{}
-	if err := http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup); err != nil {
-		return err
-	}
-	return nil
+	return http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup)
 }
diff --git a/internal/rpc/group/fill.go b/internal/rpc/group/fill.go
index ac539de19..c504db8d6 100644
--- a/internal/rpc/group/fill.go
+++ b/internal/rpc/group/fill.go
@@ -21,5 +21,5 @@ import (
 )
 
 func (s *groupServer) PopulateGroupMember(ctx context.Context, members ...*relationtb.GroupMemberModel) error {
-	return s.Notification.PopulateGroupMember(ctx, members...)
+	return s.notification.PopulateGroupMember(ctx, members...)
 }
diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go
index 143526ffa..bbb9a1ce8 100644
--- a/internal/rpc/group/group.go
+++ b/internal/rpc/group/group.go
@@ -54,8 +54,8 @@ import (
 
 type groupServer struct {
 	db                    controller.GroupDatabase
-	User                  rpcclient.UserRpcClient
-	Notification          *notification.GroupNotificationSender
+	user                  rpcclient.UserRpcClient
+	notification          *notification.GroupNotificationSender
 	conversationRpcClient rpcclient.ConversationRpcClient
 	msgRpcClient          rpcclient.MessageRpcClient
 	config                *config.GlobalConfig
@@ -88,8 +88,8 @@ func Start(ctx context.Context, config *config.GlobalConfig, client discovery.Sv
 	var gs groupServer
 	database := controller.NewGroupDatabase(rdb, groupDB, groupMemberDB, groupRequestDB, mgocli.GetTx(), grouphash.NewGroupHashFromGroupServer(&gs))
 	gs.db = database
-	gs.User = userRpcClient
-	gs.Notification = notification.NewGroupNotificationSender(database, &msgRpcClient, &userRpcClient, config, func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error) {
+	gs.user = userRpcClient
+	gs.notification = notification.NewGroupNotificationSender(database, &msgRpcClient, &userRpcClient, config, func(ctx context.Context, userIDs []string) ([]notification.CommonUser, error) {
 		users, err := userRpcClient.GetUsersInfo(ctx, userIDs)
 		if err != nil {
 			return nil, err
@@ -103,11 +103,6 @@ func Start(ctx context.Context, config *config.GlobalConfig, client discovery.Sv
 	return nil
 }
 
-func (s *groupServer) GetJoinedGroupIDs(ctx context.Context, req *pbgroup.GetJoinedGroupIDsReq) (*pbgroup.GetJoinedGroupIDsResp, error) {
-	// TODO implement me
-	panic("implement me")
-}
-
 func (s *groupServer) NotificationUserInfoUpdate(ctx context.Context, req *pbgroup.NotificationUserInfoUpdateReq) (*pbgroup.NotificationUserInfoUpdateResp, error) {
 	members, err := s.db.FindGroupMemberUser(ctx, nil, req.UserID)
 	if err != nil {
@@ -121,7 +116,7 @@ func (s *groupServer) NotificationUserInfoUpdate(ctx context.Context, req *pbgro
 		groupIDs = append(groupIDs, member.GroupID)
 	}
 	for _, groupID := range groupIDs {
-		if err = s.Notification.GroupMemberInfoSetNotification(ctx, groupID, req.UserID); err != nil {
+		if err = s.notification.GroupMemberInfoSetNotification(ctx, groupID, req.UserID); err != nil {
 			return nil, err
 		}
 	}
@@ -149,7 +144,7 @@ func (s *groupServer) GetPublicUserInfoMap(ctx context.Context, userIDs []string
 	if len(userIDs) == 0 {
 		return map[string]*sdkws.PublicUserInfo{}, nil
 	}
-	users, err := s.User.GetPublicUserInfos(ctx, userIDs, complete)
+	users, err := s.user.GetPublicUserInfos(ctx, userIDs, complete)
 	if err != nil {
 		return nil, err
 	}
@@ -211,7 +206,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		return nil, errs.ErrArgs.WrapMsg("group member repeated")
 	}
 
-	userMap, err := s.User.GetUsersInfoMap(ctx, userIDs)
+	userMap, err := s.user.GetUsersInfoMap(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -295,7 +290,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 	if req.GroupInfo.GroupType == constant.SuperGroup {
 		go func() {
 			for _, userID := range userIDs {
-				s.Notification.SuperGroupNotification(ctx, userID, userID)
+				s.notification.SuperGroupNotification(ctx, userID, userID)
 			}
 		}()
 	} else {
@@ -312,11 +307,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 				break
 			}
 		}
-		s.Notification.GroupCreatedNotification(ctx, tips)
+		s.notification.GroupCreatedNotification(ctx, tips)
 	}
 
-	afterCreateGroupConfig := beforeCreateGroupConfig
-
 	reqCallBackAfter := &pbgroup.CreateGroupReq{
 		MemberUserIDs: userIDs,
 		GroupInfo:     resp.GroupInfo,
@@ -324,7 +317,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		AdminUserIDs:  req.AdminUserIDs,
 	}
 
-	if err := CallbackAfterCreateGroup(ctx, afterCreateGroupConfig, reqCallBackAfter); err != nil {
+	if err := CallbackAfterCreateGroup(ctx, beforeCreateGroupConfig, reqCallBackAfter); err != nil {
 		return nil, err
 	}
 
@@ -393,7 +386,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 		return nil, servererrs.ErrDismissedAlready.WrapMsg("group dismissed checking group status found it dismissed")
 	}
 
-	userMap, err := s.User.GetUsersInfoMap(ctx, req.InvitedUserIDs)
+	userMap, err := s.user.GetUsersInfoMap(ctx, req.InvitedUserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -443,7 +436,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 					return nil, err
 				}
 				for _, request := range requests {
-					s.Notification.JoinGroupApplicationNotification(ctx, &pbgroup.JoinGroupReq{
+					s.notification.JoinGroupApplicationNotification(ctx, &pbgroup.JoinGroupReq{
 						GroupID:       request.GroupID,
 						ReqMessage:    request.ReqMsg,
 						JoinSource:    request.JoinSource,
@@ -480,7 +473,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 	if err := s.conversationRpcClient.GroupChatFirstCreateConversation(ctx, req.GroupID, req.InvitedUserIDs); err != nil {
 		return nil, err
 	}
-	s.Notification.MemberInvitedNotification(ctx, req.GroupID, req.Reason, req.InvitedUserIDs)
+	s.notification.MemberInvitedNotification(ctx, req.GroupID, req.Reason, req.InvitedUserIDs)
 	return &pbgroup.InviteUserToGroupResp{}, nil
 }
 
@@ -636,7 +629,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 	for _, userID := range req.KickedUserIDs {
 		tips.KickedUserList = append(tips.KickedUserList, convert.Db2PbGroupMember(memberMap[userID]))
 	}
-	s.Notification.MemberKickedNotification(ctx, tips)
+	s.notification.MemberKickedNotification(ctx, tips)
 	if err := s.deleteMemberAndSetConversationSeq(ctx, req.GroupID, req.KickedUserIDs); err != nil {
 		return nil, err
 	}
@@ -697,7 +690,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.
 		userIDs = append(userIDs, gr.UserID)
 	}
 	userIDs = datautil.Distinct(userIDs)
-	userMap, err := s.User.GetPublicUserInfoMap(ctx, userIDs, true)
+	userMap, err := s.user.GetPublicUserInfoMap(ctx, userIDs, true)
 	if err != nil {
 		return nil, err
 	}
@@ -798,7 +791,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 	} else if !s.IsNotFound(err) {
 		return nil, err
 	}
-	if _, err := s.User.GetPublicUserInfo(ctx, req.FromUserID); err != nil {
+	if _, err := s.user.GetPublicUserInfo(ctx, req.FromUserID); err != nil {
 		return nil, err
 	}
 	var member *relationtb.GroupMemberModel
@@ -835,21 +828,21 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 		if err := s.conversationRpcClient.GroupChatFirstCreateConversation(ctx, req.GroupID, []string{req.FromUserID}); err != nil {
 			return nil, err
 		}
-		s.Notification.GroupApplicationAcceptedNotification(ctx, req)
+		s.notification.GroupApplicationAcceptedNotification(ctx, req)
 		if member == nil {
 			log.ZDebug(ctx, "GroupApplicationResponse", "member is nil")
 		} else {
-			s.Notification.MemberEnterNotification(ctx, req.GroupID, req.FromUserID)
+			s.notification.MemberEnterNotification(ctx, req.GroupID, req.FromUserID)
 		}
 	case constant.GroupResponseRefuse:
-		s.Notification.GroupApplicationRejectedNotification(ctx, req)
+		s.notification.GroupApplicationRejectedNotification(ctx, req)
 	}
 
 	return &pbgroup.GroupApplicationResponseResp{}, nil
 }
 
-func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq) (resp *pbgroup.JoinGroupResp, err error) {
-	user, err := s.User.GetUserInfo(ctx, req.InviterUserID)
+func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq) (*pbgroup.JoinGroupResp, error) {
+	user, err := s.user.GetUserInfo(ctx, req.InviterUserID)
 	if err != nil {
 		return nil, err
 	}
@@ -905,7 +898,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
 		if err := s.conversationRpcClient.GroupChatFirstCreateConversation(ctx, req.GroupID, []string{req.InviterUserID}); err != nil {
 			return nil, err
 		}
-		s.Notification.MemberEnterNotification(ctx, req.GroupID, req.InviterUserID)
+		s.notification.MemberEnterNotification(ctx, req.GroupID, req.InviterUserID)
 		afterJoinGroupConfig := applyJoinGroupBeforeConfig
 		if err = CallbackAfterJoinGroup(ctx, afterJoinGroupConfig, req); err != nil {
 			return nil, err
@@ -924,7 +917,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
 	if err = s.db.CreateGroupRequest(ctx, []*relationtb.GroupRequestModel{&groupRequest}); err != nil {
 		return nil, err
 	}
-	s.Notification.JoinGroupApplicationNotification(ctx, req)
+	s.notification.JoinGroupApplicationNotification(ctx, req)
 	return &pbgroup.JoinGroupResp{}, nil
 }
 
@@ -950,7 +943,7 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbgroup.QuitGroupReq)
 	if err != nil {
 		return nil, err
 	}
-	_ = s.Notification.MemberQuitNotification(ctx, s.groupMemberDB2PB(member, 0))
+	_ = s.notification.MemberQuitNotification(ctx, s.groupMemberDB2PB(member, 0))
 	if err := s.deleteMemberAndSetConversationSeq(ctx, req.GroupID, []string{req.UserID}); err != nil {
 		return nil, err
 	}
@@ -1056,14 +1049,14 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
 				log.ZWarn(ctx, "SetConversations", err, resp.UserIDs, conversation)
 			}
 		}()
-		_ = s.Notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser})
+		_ = s.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser})
 	}
 	if req.GroupInfoForSet.GroupName != "" {
 		num--
-		_ = s.Notification.GroupInfoSetNameNotification(ctx, &sdkws.GroupInfoSetNameTips{Group: tips.Group, OpUser: tips.OpUser})
+		_ = s.notification.GroupInfoSetNameNotification(ctx, &sdkws.GroupInfoSetNameTips{Group: tips.Group, OpUser: tips.OpUser})
 	}
 	if num > 0 {
-		_ = s.Notification.GroupInfoSetNotification(ctx, tips)
+		_ = s.notification.GroupInfoSetNotification(ctx, tips)
 	}
 
 	afterSetGroupInfoConfig := beforeSetGroupInfoConfig
@@ -1120,7 +1113,7 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.Trans
 	if err := CallbackAfterTransferGroupOwner(ctx, afterTransferGroupOwnerConfig, req); err != nil {
 		return nil, err
 	}
-	s.Notification.GroupOwnerTransferredNotification(ctx, req)
+	s.notification.GroupOwnerTransferredNotification(ctx, req)
 	return &pbgroup.TransferGroupOwnerResp{}, nil
 }
 
@@ -1190,7 +1183,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbgroup.GetGr
 }
 
 func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbgroup.GetUserReqApplicationListReq) (*pbgroup.GetUserReqApplicationListResp, error) {
-	user, err := s.User.GetPublicUserInfo(ctx, req.UserID)
+	user, err := s.user.GetPublicUserInfo(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -1272,7 +1265,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGrou
 		if mcontext.GetOpUserID(ctx) == owner.UserID {
 			tips.OpUser = s.groupMemberDB2PB(owner, 0)
 		}
-		s.Notification.GroupDismissedNotification(ctx, tips)
+		s.notification.GroupDismissedNotification(ctx, tips)
 	}
 	membersID, err := s.db.FindGroupMemberUserID(ctx, group.GroupID)
 	if err != nil {
@@ -1327,7 +1320,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbgroup.MuteGrou
 	if err := s.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
-	s.Notification.GroupMemberMutedNotification(ctx, req.GroupID, req.UserID, req.MutedSeconds)
+	s.notification.GroupMemberMutedNotification(ctx, req.GroupID, req.UserID, req.MutedSeconds)
 	return &pbgroup.MuteGroupMemberResp{}, nil
 }
 
@@ -1361,7 +1354,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbgroup.Ca
 	if err := s.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
-	s.Notification.GroupMemberCancelMutedNotification(ctx, req.GroupID, req.UserID)
+	s.notification.GroupMemberCancelMutedNotification(ctx, req.GroupID, req.UserID)
 	return &pbgroup.CancelMuteGroupMemberResp{}, nil
 }
 
@@ -1372,7 +1365,7 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbgroup.MuteGroupReq)
 	if err := s.db.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupStatusMuted)); err != nil {
 		return nil, err
 	}
-	s.Notification.GroupMutedNotification(ctx, req.GroupID)
+	s.notification.GroupMutedNotification(ctx, req.GroupID)
 	return &pbgroup.MuteGroupResp{}, nil
 }
 
@@ -1383,7 +1376,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbgroup.CancelMu
 	if err := s.db.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupOk)); err != nil {
 		return nil, err
 	}
-	s.Notification.GroupCancelMutedNotification(ctx, req.GroupID)
+	s.notification.GroupCancelMutedNotification(ctx, req.GroupID)
 	return &pbgroup.CancelMuteGroupResp{}, nil
 }
 
@@ -1501,13 +1494,13 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
 		if member.RoleLevel != nil {
 			switch member.RoleLevel.Value {
 			case constant.GroupAdmin:
-				s.Notification.GroupMemberSetToAdminNotification(ctx, member.GroupID, member.UserID)
+				s.notification.GroupMemberSetToAdminNotification(ctx, member.GroupID, member.UserID)
 			case constant.GroupOrdinaryUsers:
-				s.Notification.GroupMemberSetToOrdinaryUserNotification(ctx, member.GroupID, member.UserID)
+				s.notification.GroupMemberSetToOrdinaryUserNotification(ctx, member.GroupID, member.UserID)
 			}
 		}
 		if member.Nickname != nil || member.FaceURL != nil || member.Ex != nil {
-			s.Notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
+			s.notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
 		}
 	}
 	afterSetGroupMemberInfoConfig := beforeSetGroupMemberInfoConfig
@@ -1569,7 +1562,7 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbgroup.Ge
 	}, nil
 }
 
-func (s *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetGroupMemberUserIDsReq) (resp *pbgroup.GetGroupMemberUserIDsResp, err error) {
+func (s *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetGroupMemberUserIDsReq) (*pbgroup.GetGroupMemberUserIDsResp, error) {
 	userIDs, err := s.db.FindGroupMemberUserID(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
diff --git a/internal/rpc/msg/as_read.go b/internal/rpc/msg/as_read.go
index 42d60b242..e8a0bed39 100644
--- a/internal/rpc/msg/as_read.go
+++ b/internal/rpc/msg/as_read.go
@@ -27,9 +27,10 @@ import (
 	"github.com/redis/go-redis/v9"
 )
 
-func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *msg.GetConversationsHasReadAndMaxSeqReq) (resp *msg.GetConversationsHasReadAndMaxSeqResp, err error) {
+func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *msg.GetConversationsHasReadAndMaxSeqReq) (*msg.GetConversationsHasReadAndMaxSeqResp, error) {
 	var conversationIDs []string
 	if len(req.ConversationIDs) == 0 {
+		var err error
 		conversationIDs, err = m.ConversationLocalCache.GetConversationIDs(ctx, req.UserID)
 		if err != nil {
 			return nil, err
@@ -58,7 +59,7 @@ func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *m
 	if err != nil {
 		return nil, err
 	}
-	resp = &msg.GetConversationsHasReadAndMaxSeqResp{Seqs: make(map[string]*msg.Seqs)}
+	resp := &msg.GetConversationsHasReadAndMaxSeqResp{Seqs: make(map[string]*msg.Seqs)}
 	for conversationID, maxSeq := range maxSeqs {
 		resp.Seqs[conversationID] = &msg.Seqs{
 			HasReadSeq: hasReadSeqs[conversationID],
@@ -71,10 +72,10 @@ func (m *msgServer) GetConversationsHasReadAndMaxSeq(ctx context.Context, req *m
 	return resp, nil
 }
 
-func (m *msgServer) SetConversationHasReadSeq(ctx context.Context, req *msg.SetConversationHasReadSeqReq) (resp *msg.SetConversationHasReadSeqResp, err error) {
+func (m *msgServer) SetConversationHasReadSeq(ctx context.Context, req *msg.SetConversationHasReadSeqReq) (*msg.SetConversationHasReadSeqResp, error) {
 	maxSeq, err := m.MsgDatabase.GetMaxSeq(ctx, req.ConversationID)
 	if err != nil {
-		return
+		return nil, err
 	}
 	if req.HasReadSeq > maxSeq {
 		return nil, errs.ErrArgs.WrapMsg("hasReadSeq must not be bigger than maxSeq")
@@ -82,20 +83,19 @@ func (m *msgServer) SetConversationHasReadSeq(ctx context.Context, req *msg.SetC
 	if err := m.MsgDatabase.SetHasReadSeq(ctx, req.UserID, req.ConversationID, req.HasReadSeq); err != nil {
 		return nil, err
 	}
-	if err = m.sendMarkAsReadNotification(ctx, req.ConversationID, constant.SingleChatType, req.UserID,
-		req.UserID, nil, req.HasReadSeq); err != nil {
-		return
+	if err = m.sendMarkAsReadNotification(ctx, req.ConversationID, constant.SingleChatType, req.UserID, req.UserID, nil, req.HasReadSeq); err != nil {
+		return nil, err
 	}
 	return &msg.SetConversationHasReadSeqResp{}, nil
 }
 
-func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadReq) (resp *msg.MarkMsgsAsReadResp, err error) {
+func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadReq) (*msg.MarkMsgsAsReadResp, error) {
 	if len(req.Seqs) < 1 {
 		return nil, errs.ErrArgs.WrapMsg("seqs must not be empty")
 	}
 	maxSeq, err := m.MsgDatabase.GetMaxSeq(ctx, req.ConversationID)
 	if err != nil {
-		return
+		return nil, err
 	}
 	hasReadSeq := req.Seqs[len(req.Seqs)-1]
 	if hasReadSeq > maxSeq {
@@ -103,21 +103,19 @@ func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadR
 	}
 	conversation, err := m.ConversationLocalCache.GetConversation(ctx, req.UserID, req.ConversationID)
 	if err != nil {
-		return
+		return nil, err
 	}
-	if err = m.MsgDatabase.MarkSingleChatMsgsAsRead(ctx, req.UserID, req.ConversationID, req.Seqs); err != nil {
-		return
+	if err := m.MsgDatabase.MarkSingleChatMsgsAsRead(ctx, req.UserID, req.ConversationID, req.Seqs); err != nil {
+		return nil, err
 	}
-
 	currentHasReadSeq, err := m.MsgDatabase.GetHasReadSeq(ctx, req.UserID, req.ConversationID)
 	if err != nil && errs.Unwrap(err) != redis.Nil {
-		return
+		return nil, err
 	}
-
 	if hasReadSeq > currentHasReadSeq {
 		err = m.MsgDatabase.SetHasReadSeq(ctx, req.UserID, req.ConversationID, hasReadSeq)
 		if err != nil {
-			return
+			return nil, err
 		}
 	}
 
@@ -127,18 +125,18 @@ func (m *msgServer) MarkMsgsAsRead(ctx context.Context, req *msg.MarkMsgsAsReadR
 		Seqs:           req.Seqs,
 		ContentType:    conversation.ConversationType,
 	}
-	if err = CallbackSingleMsgRead(ctx, m.config, reqCallback); err != nil {
+	if err := CallbackSingleMsgRead(ctx, m.config, reqCallback); err != nil {
 		return nil, err
 	}
 
 	if err = m.sendMarkAsReadNotification(ctx, req.ConversationID, conversation.ConversationType, req.UserID,
 		m.conversationAndGetRecvID(conversation, req.UserID), req.Seqs, hasReadSeq); err != nil {
-		return
+		return nil, err
 	}
 	return &msg.MarkMsgsAsReadResp{}, nil
 }
 
-func (m *msgServer) MarkConversationAsRead(ctx context.Context, req *msg.MarkConversationAsReadReq) (resp *msg.MarkConversationAsReadResp, err error) {
+func (m *msgServer) MarkConversationAsRead(ctx context.Context, req *msg.MarkConversationAsReadReq) (*msg.MarkConversationAsReadResp, error) {
 	conversation, err := m.ConversationLocalCache.GetConversation(ctx, req.UserID, req.ConversationID)
 	if err != nil {
 		return nil, err
@@ -149,8 +147,7 @@ func (m *msgServer) MarkConversationAsRead(ctx context.Context, req *msg.MarkCon
 	}
 	var seqs []int64
 
-	log.ZDebug(ctx, "MarkConversationAsRead", "hasReadSeq", hasReadSeq,
-		"req.HasReadSeq", req.HasReadSeq)
+	log.ZDebug(ctx, "MarkConversationAsRead", "hasReadSeq", hasReadSeq, "req.HasReadSeq", req.HasReadSeq)
 	if conversation.ConversationType == constant.SingleChatType {
 		for i := hasReadSeq + 1; i <= req.HasReadSeq; i++ {
 			seqs = append(seqs, i)
diff --git a/internal/rpc/msg/callback.go b/internal/rpc/msg/callback.go
index 49f1003ad..7eb3ebc1c 100644
--- a/internal/rpc/msg/callback.go
+++ b/internal/rpc/msg/callback.go
@@ -23,7 +23,6 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	pbchat "github.com/openimsdk/protocol/msg"
 	"github.com/openimsdk/protocol/sdkws"
-	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
 	"github.com/openimsdk/tools/utils/datautil"
 	"google.golang.org/protobuf/proto"
@@ -152,7 +151,6 @@ func callbackMsgModify(ctx context.Context, globalConfig *config.GlobalConfig, m
 	datautil.NotNilReplace(&msg.MsgData.AtUserIDList, resp.AtUserIDList)
 	datautil.NotNilReplace(&msg.MsgData.AttachedInfo, resp.AttachedInfo)
 	datautil.NotNilReplace(&msg.MsgData.Ex, resp.Ex)
-	log.ZDebug(ctx, "callbackMsgModify", "msg", msg.MsgData)
 	return nil
 }
 
diff --git a/internal/rpc/msg/delete.go b/internal/rpc/msg/delete.go
index a818df332..8f6773c8b 100644
--- a/internal/rpc/msg/delete.go
+++ b/internal/rpc/msg/delete.go
@@ -59,7 +59,6 @@ func (m *msgServer) UserClearAllMsg(ctx context.Context, req *msg.UserClearAllMs
 	if err != nil {
 		return nil, err
 	}
-	log.ZDebug(ctx, "GetMaxSeq", "conversationIDs", conversationIDs)
 	if err := m.clearConversation(ctx, conversationIDs, req.UserID, req.DeleteSyncOpt); err != nil {
 		return nil, err
 	}
@@ -115,27 +114,13 @@ func (m *msgServer) DeleteMsgPhysical(ctx context.Context, req *msg.DeleteMsgPhy
 	remainTime := timeutil.GetCurrentTimestampBySecond() - req.Timestamp
 	for _, conversationID := range req.ConversationIDs {
 		if err := m.MsgDatabase.DeleteConversationMsgsAndSetMinSeq(ctx, conversationID, remainTime); err != nil {
-			log.ZWarn(
-				ctx,
-				"DeleteConversationMsgsAndSetMinSeq error",
-				err,
-				"conversationID",
-				conversationID,
-				"err",
-				err,
-			)
+			log.ZWarn(ctx, "DeleteConversationMsgsAndSetMinSeq error", err, "conversationID", conversationID, "err", err)
 		}
 	}
 	return &msg.DeleteMsgPhysicalResp{}, nil
 }
 
-func (m *msgServer) clearConversation(
-	ctx context.Context,
-	conversationIDs []string,
-	userID string,
-	deleteSyncOpt *msg.DeleteSyncOpt,
-) error {
-	defer log.ZDebug(ctx, "clearConversation return line")
+func (m *msgServer) clearConversation(ctx context.Context, conversationIDs []string, userID string, deleteSyncOpt *msg.DeleteSyncOpt) error {
 	conversations, err := m.Conversation.GetConversationsByConversationID(ctx, conversationIDs)
 	if err != nil {
 		return err
@@ -159,14 +144,7 @@ func (m *msgServer) clearConversation(
 		// notification 2 self
 		if isSyncSelf {
 			tips := &sdkws.ClearConversationTips{UserID: userID, ConversationIDs: existConversationIDs}
-			m.notificationSender.NotificationWithSesstionType(
-				ctx,
-				userID,
-				userID,
-				constant.ClearConversationNotification,
-				constant.SingleChatType,
-				tips,
-			)
+			m.notificationSender.NotificationWithSesstionType(ctx, userID, userID, constant.ClearConversationNotification, constant.SingleChatType, tips)
 		}
 	} else {
 		if err := m.MsgDatabase.SetMinSeqs(ctx, m.getMinSeqs(maxSeqs)); err != nil {
diff --git a/internal/rpc/msg/message_interceptor.go b/internal/rpc/msg/message_interceptor.go
index 7c13a3666..34d26cac2 100644
--- a/internal/rpc/msg/message_interceptor.go
+++ b/internal/rpc/msg/message_interceptor.go
@@ -26,7 +26,7 @@ import (
 
 type MessageInterceptorFunc func(ctx context.Context, globalConfig *config.GlobalConfig, req *msg.SendMsgReq) (*sdkws.MsgData, error)
 
-func MessageHasReadEnabled(_ context.Context, globalConfig *config.GlobalConfig, req *msg.SendMsgReq) (*sdkws.MsgData, error) {
+func MessageHasReadEnabled(ctx context.Context, globalConfig *config.GlobalConfig, req *msg.SendMsgReq) (*sdkws.MsgData, error) {
 	switch {
 	case req.MsgData.ContentType == constant.HasReadReceipt && req.MsgData.SessionType == constant.SingleChatType:
 		if !globalConfig.SingleMessageHasReadReceiptEnable {
diff --git a/internal/rpc/msg/revoke.go b/internal/rpc/msg/revoke.go
index d190ddcb3..0c0761e60 100644
--- a/internal/rpc/msg/revoke.go
+++ b/internal/rpc/msg/revoke.go
@@ -32,7 +32,6 @@ import (
 )
 
 func (m *msgServer) RevokeMsg(ctx context.Context, req *msg.RevokeMsgReq) (*msg.RevokeMsgResp, error) {
-	defer log.ZDebug(ctx, "RevokeMsg return line")
 	if req.UserID == "" {
 		return nil, errs.ErrArgs.WrapMsg("user_id is empty")
 	}
diff --git a/internal/rpc/msg/send.go b/internal/rpc/msg/send.go
index 255555242..1881913eb 100644
--- a/internal/rpc/msg/send.go
+++ b/internal/rpc/msg/send.go
@@ -33,8 +33,7 @@ import (
 	"google.golang.org/protobuf/types/known/wrapperspb"
 )
 
-func (m *msgServer) SendMsg(ctx context.Context, req *pbmsg.SendMsgReq) (resp *pbmsg.SendMsgResp, error error) {
-	resp = &pbmsg.SendMsgResp{}
+func (m *msgServer) SendMsg(ctx context.Context, req *pbmsg.SendMsgReq) (*pbmsg.SendMsgResp, error) {
 	if req.MsgData != nil {
 		flag := isMessageHasReadEnabled(req.MsgData, m.config)
 		if !flag {
@@ -63,7 +62,6 @@ func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *pbmsg.SendMs
 	if err = callbackBeforeSendGroupMsg(ctx, m.config, req); err != nil {
 		return nil, err
 	}
-
 	if err := callbackMsgModify(ctx, m.config, req); err != nil {
 		return nil, err
 	}
@@ -138,7 +136,6 @@ func (m *msgServer) sendMsgNotification(ctx context.Context, req *pbmsg.SendMsgR
 }
 
 func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *pbmsg.SendMsgReq) (resp *pbmsg.SendMsgResp, err error) {
-	log.ZDebug(ctx, "sendMsgSingleChat return")
 	if err := m.messageVerification(ctx, req); err != nil {
 		return nil, err
 	}
@@ -175,16 +172,11 @@ func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *pbmsg.SendMsgReq
 		if err != nil {
 			log.ZWarn(ctx, "CallbackAfterSendSingleMsg", err, "req", req)
 		}
-		resp = &pbmsg.SendMsgResp{
+		prommetrics.SingleChatMsgProcessSuccessCounter.Inc()
+		return &pbmsg.SendMsgResp{
 			ServerMsgID: req.MsgData.ServerMsgID,
 			ClientMsgID: req.MsgData.ClientMsgID,
 			SendTime:    req.MsgData.SendTime,
-		}
-		prommetrics.SingleChatMsgProcessSuccessCounter.Inc()
-		return resp, nil
+		}, nil
 	}
 }
-
-func (m *msgServer) BatchSendMsg(ctx context.Context, in *pbmsg.BatchSendMessageReq) (*pbmsg.BatchSendMessageResp, error) {
-	return nil, nil
-}
diff --git a/internal/rpc/msg/seq.go b/internal/rpc/msg/seq.go
index c9595699e..27465c210 100644
--- a/internal/rpc/msg/seq.go
+++ b/internal/rpc/msg/seq.go
@@ -20,7 +20,7 @@ import (
 	pbmsg "github.com/openimsdk/protocol/msg"
 )
 
-func (m *msgServer) GetConversationMaxSeq(ctx context.Context, req *pbmsg.GetConversationMaxSeqReq) (resp *pbmsg.GetConversationMaxSeqResp, err error) {
+func (m *msgServer) GetConversationMaxSeq(ctx context.Context, req *pbmsg.GetConversationMaxSeqReq) (*pbmsg.GetConversationMaxSeqResp, error) {
 	maxSeq, err := m.MsgDatabase.GetMaxSeq(ctx, req.ConversationID)
 	if err != nil {
 		return nil, err
diff --git a/internal/rpc/msg/server.go b/internal/rpc/msg/server.go
index 2b0bbe410..65032c11f 100644
--- a/internal/rpc/msg/server.go
+++ b/internal/rpc/msg/server.go
@@ -55,17 +55,6 @@ func (m *msgServer) addInterceptorHandler(interceptorFunc ...MessageInterceptorF
 	m.Handlers = append(m.Handlers, interceptorFunc...)
 }
 
-// func (m *msgServer) execInterceptorHandler(ctx context.Context, config *config.GlobalConfig, req *msg.SendMsgReq) error {
-//	for _, handler := range m.Handlers {
-//		msgData, err := handler(ctx, config, req)
-//		if err != nil {
-//			return err
-//		}
-//		req.MsgData = msgData
-//	}
-//	return nil
-//}
-
 func Start(ctx context.Context, config *config.GlobalConfig, client discovery.SvcDiscoveryRegistry, server *grpc.Server) error {
 	mgocli, err := mongoutil.NewMongoDB(ctx, config.Mongo.Build())
 	if err != nil {
@@ -105,16 +94,16 @@ func Start(ctx context.Context, config *config.GlobalConfig, client discovery.Sv
 	return nil
 }
 
-func (m *msgServer) conversationAndGetRecvID(conversation *conversation.Conversation, userID string) (recvID string) {
+func (m *msgServer) conversationAndGetRecvID(conversation *conversation.Conversation, userID string) string {
 	if conversation.ConversationType == constant.SingleChatType ||
 		conversation.ConversationType == constant.NotificationChatType {
 		if userID == conversation.OwnerUserID {
-			recvID = conversation.UserID
+			return conversation.UserID
 		} else {
-			recvID = conversation.OwnerUserID
+			return conversation.OwnerUserID
 		}
 	} else if conversation.ConversationType == constant.SuperGroupChatType {
-		recvID = conversation.GroupID
+		return conversation.GroupID
 	}
-	return
+	return ""
 }
diff --git a/internal/rpc/msg/statistics.go b/internal/rpc/msg/statistics.go
index fc97e72eb..15a0aaa57 100644
--- a/internal/rpc/msg/statistics.go
+++ b/internal/rpc/msg/statistics.go
@@ -25,15 +25,7 @@ import (
 )
 
 func (m *msgServer) GetActiveUser(ctx context.Context, req *msg.GetActiveUserReq) (*msg.GetActiveUserResp, error) {
-	msgCount, userCount, users, dateCount, err := m.MsgDatabase.RangeUserSendCount(
-		ctx,
-		time.UnixMilli(req.Start),
-		time.UnixMilli(req.End),
-		req.Group,
-		req.Ase,
-		req.Pagination.PageNumber,
-		req.Pagination.ShowNumber,
-	)
+	msgCount, userCount, users, dateCount, err := m.MsgDatabase.RangeUserSendCount(ctx, time.UnixMilli(req.Start), time.UnixMilli(req.End), req.Group, req.Ase, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -68,14 +60,7 @@ func (m *msgServer) GetActiveUser(ctx context.Context, req *msg.GetActiveUserReq
 }
 
 func (m *msgServer) GetActiveGroup(ctx context.Context, req *msg.GetActiveGroupReq) (*msg.GetActiveGroupResp, error) {
-	msgCount, groupCount, groups, dateCount, err := m.MsgDatabase.RangeGroupSendCount(
-		ctx,
-		time.UnixMilli(req.Start),
-		time.UnixMilli(req.End),
-		req.Ase,
-		req.Pagination.PageNumber,
-		req.Pagination.ShowNumber,
-	)
+	msgCount, groupCount, groups, dateCount, err := m.MsgDatabase.RangeGroupSendCount(ctx, time.UnixMilli(req.Start), time.UnixMilli(req.End), req.Ase, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/rpc/msg/verify.go b/internal/rpc/msg/verify.go
index 6680faaa6..6dbdb5b33 100644
--- a/internal/rpc/msg/verify.go
+++ b/internal/rpc/msg/verify.go
@@ -202,7 +202,6 @@ func (m *msgServer) modifyMessageByUserMessageReceiveOpt(ctx context.Context, us
 		datautil.SetSwitchFromOptions(pb.MsgData.Options, constant.IsOfflinePush, false)
 		return true, nil
 	}
-	// conversationID := utils.GetConversationIDBySessionType(conversationID, sessionType)
 	singleOpt, err := m.ConversationLocalCache.GetSingleConversationRecvMsgOpt(ctx, userID, conversationID)
 	if errs.ErrRecordNotFound.Is(err) {
 		return true, nil
diff --git a/internal/rpc/statistics/statistics.go b/internal/rpc/statistics/statistics.go
deleted file mode 100644
index 2f81301a1..000000000
--- a/internal/rpc/statistics/statistics.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright © 2023 OpenIM. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package statistics
diff --git a/internal/rpc/third/log.go b/internal/rpc/third/log.go
index 249031b7c..b1e10216c 100644
--- a/internal/rpc/third/log.go
+++ b/internal/rpc/third/log.go
@@ -17,7 +17,6 @@ package third
 import (
 	"context"
 	"crypto/rand"
-	"fmt"
 	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
@@ -46,7 +45,7 @@ func genLogID() string {
 }
 
 func (t *thirdServer) UploadLogs(ctx context.Context, req *third.UploadLogsReq) (*third.UploadLogsResp, error) {
-	var DBlogs []*relationtb.LogModel
+	var dbLogs []*relationtb.LogModel
 	userID := ctx.Value(constant.OpUserID).(string)
 	platform := constant.PlatformID2Name[int(req.Platform)]
 	for _, fileURL := range req.FileURLs {
@@ -73,9 +72,9 @@ func (t *thirdServer) UploadLogs(ctx context.Context, req *third.UploadLogsReq)
 		if log.LogID == "" {
 			return nil, servererrs.ErrData.WrapMsg("LogModel id gen error")
 		}
-		DBlogs = append(DBlogs, &log)
+		dbLogs = append(dbLogs, &log)
 	}
-	err := t.thirdDatabase.UploadLogs(ctx, DBlogs)
+	err := t.thirdDatabase.UploadLogs(ctx, dbLogs)
 	if err != nil {
 		return nil, err
 	}
@@ -96,7 +95,7 @@ func (t *thirdServer) DeleteLogs(ctx context.Context, req *third.DeleteLogsReq)
 		logIDs = append(logIDs, log.LogID)
 	}
 	if ids := datautil.Single(req.LogIDs, logIDs); len(ids) > 0 {
-		return nil, errs.ErrRecordNotFound.WrapMsg(fmt.Sprintf("logIDs not found%#v", ids))
+		return nil, errs.ErrRecordNotFound.WrapMsg("logIDs not found", "logIDs", ids)
 	}
 	err = t.thirdDatabase.DeleteLogs(ctx, req.LogIDs, userID)
 	if err != nil {
diff --git a/internal/rpc/user/statistics.go b/internal/rpc/user/statistics.go
index d63a7ce31..709c0146b 100644
--- a/internal/rpc/user/statistics.go
+++ b/internal/rpc/user/statistics.go
@@ -26,16 +26,16 @@ func (s *userServer) UserRegisterCount(ctx context.Context, req *pbuser.UserRegi
 	if req.Start > req.End {
 		return nil, errs.ErrArgs.WrapMsg("start > end")
 	}
-	total, err := s.CountTotal(ctx, nil)
+	total, err := s.db.CountTotal(ctx, nil)
 	if err != nil {
 		return nil, err
 	}
 	start := time.UnixMilli(req.Start)
-	before, err := s.CountTotal(ctx, &start)
+	before, err := s.db.CountTotal(ctx, &start)
 	if err != nil {
 		return nil, err
 	}
-	count, err := s.CountRangeEverydayTotal(ctx, start, time.UnixMilli(req.End))
+	count, err := s.db.CountRangeEverydayTotal(ctx, start, time.UnixMilli(req.End))
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/rpc/user/user.go b/internal/rpc/user/user.go
index 955d66ad5..32617b507 100644
--- a/internal/rpc/user/user.go
+++ b/internal/rpc/user/user.go
@@ -45,7 +45,7 @@ import (
 )
 
 type userServer struct {
-	controller.UserDatabase
+	db                       controller.UserDatabase
 	friendNotificationSender *notification.FriendNotificationSender
 	userNotificationSender   *notification.UserNotificationSender
 	friendRpcClient          *rpcclient.FriendRpcClient
@@ -54,11 +54,6 @@ type userServer struct {
 	config                   *config.GlobalConfig
 }
 
-func (s *userServer) GetGroupOnlineUser(ctx context.Context, req *pbuser.GetGroupOnlineUserReq) (*pbuser.GetGroupOnlineUserResp, error) {
-	// TODO implement me
-	panic("implement me")
-}
-
 func Start(ctx context.Context, config *config.GlobalConfig, client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	mgocli, err := mongoutil.NewMongoDB(ctx, config.Mongo.Build())
 	if err != nil {
@@ -86,7 +81,7 @@ func Start(ctx context.Context, config *config.GlobalConfig, client registry.Svc
 	groupRpcClient := rpcclient.NewGroupRpcClient(client, config.RpcRegisterName.OpenImGroupName)
 	msgRpcClient := rpcclient.NewMessageRpcClient(client, config.RpcRegisterName.OpenImMsgName)
 	u := &userServer{
-		UserDatabase:             database,
+		db:                       database,
 		RegisterCenter:           client,
 		friendRpcClient:          &friendRpcClient,
 		groupRpcClient:           &groupRpcClient,
@@ -95,12 +90,12 @@ func Start(ctx context.Context, config *config.GlobalConfig, client registry.Svc
 		config:                   config,
 	}
 	pbuser.RegisterUserServer(server, u)
-	return u.UserDatabase.InitOnce(context.Background(), users)
+	return u.db.InitOnce(context.Background(), users)
 }
 
 func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbuser.GetDesignateUsersReq) (resp *pbuser.GetDesignateUsersResp, err error) {
 	resp = &pbuser.GetDesignateUsersResp{}
-	users, err := s.FindWithError(ctx, req.UserIDs)
+	users, err := s.db.FindWithError(ctx, req.UserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -118,7 +113,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 		return nil, err
 	}
 	data := convert.UserPb2DBMap(req.UserInfo)
-	if err := s.UpdateByMap(ctx, req.UserInfo.UserID, data); err != nil {
+	if err := s.db.UpdateByMap(ctx, req.UserInfo.UserID, data); err != nil {
 		return nil, err
 	}
 	_ = s.friendNotificationSender.UserInfoUpdatedNotification(ctx, req.UserInfo.UserID)
@@ -153,7 +148,7 @@ func (s *userServer) UpdateUserInfoEx(ctx context.Context, req *pbuser.UpdateUse
 		return nil, err
 	}
 	data := convert.UserPb2DBMapEx(req.UserInfo)
-	if err = s.UpdateByMap(ctx, req.UserInfo.UserID, data); err != nil {
+	if err = s.db.UpdateByMap(ctx, req.UserInfo.UserID, data); err != nil {
 		return nil, err
 	}
 	_ = s.friendNotificationSender.UserInfoUpdatedNotification(ctx, req.UserInfo.UserID)
@@ -179,12 +174,12 @@ func (s *userServer) UpdateUserInfoEx(ctx context.Context, req *pbuser.UpdateUse
 }
 func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.SetGlobalRecvMessageOptReq) (resp *pbuser.SetGlobalRecvMessageOptResp, err error) {
 	resp = &pbuser.SetGlobalRecvMessageOptResp{}
-	if _, err := s.FindWithError(ctx, []string{req.UserID}); err != nil {
+	if _, err := s.db.FindWithError(ctx, []string{req.UserID}); err != nil {
 		return nil, err
 	}
 	m := make(map[string]any, 1)
 	m["global_recv_msg_opt"] = req.GlobalRecvMsgOpt
-	if err := s.UpdateByMap(ctx, req.UserID, m); err != nil {
+	if err := s.db.UpdateByMap(ctx, req.UserID, m); err != nil {
 		return nil, err
 	}
 	s.friendNotificationSender.UserInfoUpdatedNotification(ctx, req.UserID)
@@ -200,7 +195,7 @@ func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckR
 	if err != nil {
 		return nil, err
 	}
-	users, err := s.Find(ctx, req.CheckUserIDs)
+	users, err := s.db.Find(ctx, req.CheckUserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -222,13 +217,13 @@ func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckR
 
 func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbuser.GetPaginationUsersReq) (resp *pbuser.GetPaginationUsersResp, err error) {
 	if req.UserID == "" && req.NickName == "" {
-		total, users, err := s.PageFindUser(ctx, constant.IMOrdinaryUser, constant.AppOrdinaryUsers, req.Pagination)
+		total, users, err := s.db.PageFindUser(ctx, constant.IMOrdinaryUser, constant.AppOrdinaryUsers, req.Pagination)
 		if err != nil {
 			return nil, err
 		}
 		return &pbuser.GetPaginationUsersResp{Total: int32(total), Users: convert.UsersDB2Pb(users)}, err
 	} else {
-		total, users, err := s.PageFindUserWithKeyword(ctx, constant.IMOrdinaryUser, constant.AppOrdinaryUsers, req.UserID, req.NickName, req.Pagination)
+		total, users, err := s.db.PageFindUserWithKeyword(ctx, constant.IMOrdinaryUser, constant.AppOrdinaryUsers, req.UserID, req.NickName, req.Pagination)
 		if err != nil {
 			return nil, err
 		}
@@ -260,7 +255,7 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 		}
 		userIDs = append(userIDs, user.UserID)
 	}
-	exist, err := s.IsExist(ctx, userIDs)
+	exist, err := s.db.IsExist(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -283,7 +278,7 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 			GlobalRecvMsgOpt: user.GlobalRecvMsgOpt,
 		})
 	}
-	if err := s.Create(ctx, users); err != nil {
+	if err := s.db.Create(ctx, users); err != nil {
 		return nil, err
 	}
 
@@ -294,7 +289,7 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 }
 
 func (s *userServer) GetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.GetGlobalRecvMessageOptReq) (resp *pbuser.GetGlobalRecvMessageOptResp, err error) {
-	user, err := s.FindWithError(ctx, []string{req.UserID})
+	user, err := s.db.FindWithError(ctx, []string{req.UserID})
 	if err != nil {
 		return nil, err
 	}
@@ -303,7 +298,7 @@ func (s *userServer) GetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Ge
 
 // GetAllUserID Get user account by page.
 func (s *userServer) GetAllUserID(ctx context.Context, req *pbuser.GetAllUserIDReq) (resp *pbuser.GetAllUserIDResp, err error) {
-	total, userIDs, err := s.UserDatabase.GetAllUserID(ctx, req.Pagination)
+	total, userIDs, err := s.db.GetAllUserID(ctx, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
@@ -313,18 +308,18 @@ func (s *userServer) GetAllUserID(ctx context.Context, req *pbuser.GetAllUserIDR
 // SubscribeOrCancelUsersStatus Subscribe online or cancel online users.
 func (s *userServer) SubscribeOrCancelUsersStatus(ctx context.Context, req *pbuser.SubscribeOrCancelUsersStatusReq) (resp *pbuser.SubscribeOrCancelUsersStatusResp, err error) {
 	if req.Genre == constant.SubscriberUser {
-		err = s.UserDatabase.SubscribeUsersStatus(ctx, req.UserID, req.UserIDs)
+		err = s.db.SubscribeUsersStatus(ctx, req.UserID, req.UserIDs)
 		if err != nil {
 			return nil, err
 		}
 		var status []*pbuser.OnlineStatus
-		status, err = s.UserDatabase.GetUserStatus(ctx, req.UserIDs)
+		status, err = s.db.GetUserStatus(ctx, req.UserIDs)
 		if err != nil {
 			return nil, err
 		}
 		return &pbuser.SubscribeOrCancelUsersStatusResp{StatusList: status}, nil
 	} else if req.Genre == constant.Unsubscribe {
-		err = s.UserDatabase.UnsubscribeUsersStatus(ctx, req.UserID, req.UserIDs)
+		err = s.db.UnsubscribeUsersStatus(ctx, req.UserID, req.UserIDs)
 		if err != nil {
 			return nil, err
 		}
@@ -335,7 +330,7 @@ func (s *userServer) SubscribeOrCancelUsersStatus(ctx context.Context, req *pbus
 // GetUserStatus Get the online status of the user.
 func (s *userServer) GetUserStatus(ctx context.Context, req *pbuser.GetUserStatusReq) (resp *pbuser.GetUserStatusResp,
 	err error) {
-	onlineStatusList, err := s.UserDatabase.GetUserStatus(ctx, req.UserIDs)
+	onlineStatusList, err := s.db.GetUserStatus(ctx, req.UserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -345,11 +340,11 @@ func (s *userServer) GetUserStatus(ctx context.Context, req *pbuser.GetUserStatu
 // SetUserStatus Synchronize user's online status.
 func (s *userServer) SetUserStatus(ctx context.Context, req *pbuser.SetUserStatusReq) (resp *pbuser.SetUserStatusResp,
 	err error) {
-	err = s.UserDatabase.SetUserStatus(ctx, req.UserID, req.Status, req.PlatformID)
+	err = s.db.SetUserStatus(ctx, req.UserID, req.Status, req.PlatformID)
 	if err != nil {
 		return nil, err
 	}
-	list, err := s.UserDatabase.GetSubscribedList(ctx, req.UserID)
+	list, err := s.db.GetSubscribedList(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -369,11 +364,11 @@ func (s *userServer) SetUserStatus(ctx context.Context, req *pbuser.SetUserStatu
 // GetSubscribeUsersStatus Get the online status of subscribers.
 func (s *userServer) GetSubscribeUsersStatus(ctx context.Context,
 	req *pbuser.GetSubscribeUsersStatusReq) (*pbuser.GetSubscribeUsersStatusResp, error) {
-	userList, err := s.UserDatabase.GetAllSubscribeList(ctx, req.UserID)
+	userList, err := s.db.GetAllSubscribeList(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
-	onlineStatusList, err := s.UserDatabase.GetUserStatus(ctx, userList)
+	onlineStatusList, err := s.db.GetUserStatus(ctx, userList)
 	if err != nil {
 		return nil, err
 	}
@@ -395,8 +390,8 @@ func (s *userServer) ProcessUserCommandAdd(ctx context.Context, req *pbuser.Proc
 	if req.Ex != nil {
 		value = req.Ex.Value
 	}
-	// Assuming you have a method in s.UserDatabase to add a user command
-	err = s.UserDatabase.AddUserCommand(ctx, req.UserID, req.Type, req.Uuid, value, ex)
+	// Assuming you have a method in s.db to add a user command
+	err = s.db.AddUserCommand(ctx, req.UserID, req.Type, req.Uuid, value, ex)
 	if err != nil {
 		return nil, err
 	}
@@ -418,7 +413,7 @@ func (s *userServer) ProcessUserCommandDelete(ctx context.Context, req *pbuser.P
 		return nil, err
 	}
 
-	err = s.UserDatabase.DeleteUserCommand(ctx, req.UserID, req.Type, req.Uuid)
+	err = s.db.DeleteUserCommand(ctx, req.UserID, req.Type, req.Uuid)
 	if err != nil {
 		return nil, err
 	}
@@ -450,8 +445,8 @@ func (s *userServer) ProcessUserCommandUpdate(ctx context.Context, req *pbuser.P
 		val["ex"] = req.Ex.Value
 	}
 
-	// Assuming you have a method in s.UserDatabase to update a user command
-	err = s.UserDatabase.UpdateUserCommand(ctx, req.UserID, req.Type, req.Uuid, val)
+	// Assuming you have a method in s.db to update a user command
+	err = s.db.UpdateUserCommand(ctx, req.UserID, req.Type, req.Uuid, val)
 	if err != nil {
 		return nil, err
 	}
@@ -473,7 +468,7 @@ func (s *userServer) ProcessUserCommandGet(ctx context.Context, req *pbuser.Proc
 		return nil, err
 	}
 	// Fetch user commands from the database
-	commands, err := s.UserDatabase.GetUserCommands(ctx, req.UserID, req.Type)
+	commands, err := s.db.GetUserCommands(ctx, req.UserID, req.Type)
 	if err != nil {
 		return nil, err
 	}
@@ -502,7 +497,7 @@ func (s *userServer) ProcessUserCommandGetAll(ctx context.Context, req *pbuser.P
 		return nil, err
 	}
 	// Fetch user commands from the database
-	commands, err := s.UserDatabase.GetAllUserCommands(ctx, req.UserID)
+	commands, err := s.db.GetAllUserCommands(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -533,7 +528,7 @@ func (s *userServer) AddNotificationAccount(ctx context.Context, req *pbuser.Add
 	if req.UserID == "" {
 		for i := 0; i < 20; i++ {
 			userId := s.genUserID()
-			_, err := s.UserDatabase.FindWithError(ctx, []string{userId})
+			_, err := s.db.FindWithError(ctx, []string{userId})
 			if err == nil {
 				continue
 			}
@@ -544,7 +539,7 @@ func (s *userServer) AddNotificationAccount(ctx context.Context, req *pbuser.Add
 			return nil, errs.ErrInternalServer.WrapMsg("gen user id failed")
 		}
 	} else {
-		_, err := s.UserDatabase.FindWithError(ctx, []string{req.UserID})
+		_, err := s.db.FindWithError(ctx, []string{req.UserID})
 		if err == nil {
 			return nil, errs.ErrArgs.WrapMsg("userID is used")
 		}
@@ -557,7 +552,7 @@ func (s *userServer) AddNotificationAccount(ctx context.Context, req *pbuser.Add
 		CreateTime:     time.Now(),
 		AppMangerLevel: constant.AppNotificationAdmin,
 	}
-	if err := s.UserDatabase.Create(ctx, []*tablerelation.UserModel{user}); err != nil {
+	if err := s.db.Create(ctx, []*tablerelation.UserModel{user}); err != nil {
 		return nil, err
 	}
 
@@ -573,7 +568,7 @@ func (s *userServer) UpdateNotificationAccountInfo(ctx context.Context, req *pbu
 		return nil, err
 	}
 
-	if _, err := s.UserDatabase.FindWithError(ctx, []string{req.UserID}); err != nil {
+	if _, err := s.db.FindWithError(ctx, []string{req.UserID}); err != nil {
 		return nil, errs.ErrArgs.Wrap()
 	}
 
@@ -587,7 +582,7 @@ func (s *userServer) UpdateNotificationAccountInfo(ctx context.Context, req *pbu
 		user["face_url"] = req.FaceURL
 	}
 
-	if err := s.UserDatabase.UpdateByMap(ctx, req.UserID, user); err != nil {
+	if err := s.db.UpdateByMap(ctx, req.UserID, user); err != nil {
 		return nil, err
 	}
 
@@ -606,7 +601,7 @@ func (s *userServer) SearchNotificationAccount(ctx context.Context, req *pbuser.
 	// If a keyword is provided in the request
 	if req.Keyword != "" {
 		// Find users by keyword
-		users, err = s.UserDatabase.Find(ctx, []string{req.Keyword})
+		users, err = s.db.Find(ctx, []string{req.Keyword})
 		if err != nil {
 			return nil, err
 		}
@@ -618,7 +613,7 @@ func (s *userServer) SearchNotificationAccount(ctx context.Context, req *pbuser.
 		}
 
 		// Find users by nickname if no users found by keyword
-		users, err = s.UserDatabase.FindByNickname(ctx, req.Keyword)
+		users, err = s.db.FindByNickname(ctx, req.Keyword)
 		if err != nil {
 			return nil, err
 		}
@@ -627,7 +622,7 @@ func (s *userServer) SearchNotificationAccount(ctx context.Context, req *pbuser.
 	}
 
 	// If no keyword, find users with notification settings
-	users, err = s.UserDatabase.FindNotification(ctx, constant.AppNotificationAdmin)
+	users, err = s.db.FindNotification(ctx, constant.AppNotificationAdmin)
 	if err != nil {
 		return nil, err
 	}
@@ -640,7 +635,7 @@ func (s *userServer) GetNotificationAccount(ctx context.Context, req *pbuser.Get
 	if req.UserID == "" {
 		return nil, errs.ErrArgs.WrapMsg("userID is empty")
 	}
-	user, err := s.UserDatabase.GetUserByID(ctx, req.UserID)
+	user, err := s.db.GetUserByID(ctx, req.UserID)
 	if err != nil {
 		return nil, servererrs.ErrUserIDNotFound.Wrap()
 	}
diff --git a/pkg/common/db/cache/group.go b/pkg/common/db/cache/group.go
index ed303e135..b1204253a 100644
--- a/pkg/common/db/cache/group.go
+++ b/pkg/common/db/cache/group.go
@@ -32,13 +32,6 @@ import (
 
 const (
 	groupExpireTime = time.Second * 60 * 60 * 12
-	// GroupInfoKey        = "GROUP_INFO:"
-	// groupMemberIDsKey   = "GROUP_MEMBER_IDS:"
-	// groupMembersHashKey = "GROUP_MEMBERS_HASH2:"
-	// groupMemberInfoKey  = "GROUP_MEMBER_INFO:"
-	// joinedGroupsKey            = "JOIN_GROUPS_KEY:"
-	// groupMemberNumKey          = "GROUP_MEMBER_NUM_CACHE:"
-	// groupRoleLevelMemberIDsKey = "GROUP_ROLE_LEVEL_MEMBER_IDS:".
 )
 
 type GroupHash interface {
diff --git a/pkg/common/db/cache/msg.go b/pkg/common/db/cache/msg.go
index 5b258ea8a..8857a80a3 100644
--- a/pkg/common/db/cache/msg.go
+++ b/pkg/common/db/cache/msg.go
@@ -38,12 +38,9 @@ const (
 	conversationUserMinSeq = "CON_USER_MIN_SEQ:"
 	hasReadSeq             = "HAS_READ_SEQ:"
 
-	// AppleDeviceToken = "DEVICE_TOKEN".
 	getuiToken  = "GETUI_TOKEN"
 	getuiTaskID = "GETUI_TASK_ID"
-	// SignalCache      = "SIGNAL_CACHE:"
-	// signalListCache  = "SIGNAL_LIST_CACHE:".
-	FCM_TOKEN = "FCM_TOKEN:"
+	FCM_TOKEN   = "FCM_TOKEN:"
 
 	messageCache            = "MESSAGE_CACHE:"
 	messageDelUserList      = "MESSAGE_DEL_USER_LIST:"
diff --git a/pkg/common/db/cache/user.go b/pkg/common/db/cache/user.go
index 18b3c347d..45105bcdd 100644
--- a/pkg/common/db/cache/user.go
+++ b/pkg/common/db/cache/user.go
@@ -34,13 +34,10 @@ import (
 )
 
 const (
-	userExpireTime = time.Second * 60 * 60 * 12
-	// UserInfoKey               = "USER_INFO:".
-	userGlobalRecvMsgOptKey   = "USER_GLOBAL_RECV_MSG_OPT_KEY:"
+	userExpireTime            = time.Second * 60 * 60 * 12
 	olineStatusKey            = "ONLINE_STATUS:"
 	userOlineStatusExpireTime = time.Second * 60 * 60 * 24
 	statusMod                 = 501
-	platformID                = "_PlatformIDSuffix"
 )
 
 type UserCache interface {
@@ -64,11 +61,7 @@ type UserCacheRedis struct {
 	rcClient   *rockscache.Client
 }
 
-func NewUserCacheRedis(
-	rdb redis.UniversalClient,
-	userDB relationtb.UserModelInterface,
-	options rockscache.Options,
-) UserCache {
+func NewUserCacheRedis(rdb redis.UniversalClient, userDB relationtb.UserModelInterface, options rockscache.Options) UserCache {
 	rcClient := rockscache.NewClient(rdb, options)
 	mc := NewMetaCacheRedis(rcClient)
 	u := config.Config.LocalCache.User
diff --git a/pkg/common/db/controller/friend.go b/pkg/common/db/controller/friend.go
index 654cefe3d..0dcd59052 100644
--- a/pkg/common/db/controller/friend.go
+++ b/pkg/common/db/controller/friend.go
@@ -139,7 +139,7 @@ func (f *friendDatabase) AddFriendRequest(ctx context.Context, fromUserID, toUse
 func (f *friendDatabase) BecomeFriends(ctx context.Context, ownerUserID string, friendUserIDs []string, addSource int32) (err error) {
 	return f.tx.Transaction(ctx, func(ctx context.Context) error {
 		cache := f.cache.NewCache()
-		// User find friends
+		// user find friends
 		fs1, err := f.friend.FindFriends(ctx, ownerUserID, friendUserIDs)
 		if err != nil {
 			return err
diff --git a/pkg/common/db/controller/user.go b/pkg/common/db/controller/user.go
index 2da2b952f..b2aba41fa 100644
--- a/pkg/common/db/controller/user.go
+++ b/pkg/common/db/controller/user.go
@@ -39,8 +39,6 @@ type UserDatabase interface {
 	FindNotification(ctx context.Context, level int64) (users []*relation.UserModel, err error)
 	// Create Insert multiple external guarantees that the userID is not repeated and does not exist in the db
 	Create(ctx context.Context, users []*relation.UserModel) (err error)
-	// Update update (non-zero value) external guarantee userID exists
-	// Update(ctx context.Context, user *relation.UserModel) (err error)
 	// UpdateByMap update (zero value) external guarantee userID exists
 	UpdateByMap(ctx context.Context, userID string, args map[string]any) (err error)
 	// FindUser
@@ -137,12 +135,10 @@ func (u *userDatabase) Find(ctx context.Context, userIDs []string) (users []*rel
 	return u.cache.GetUsersInfo(ctx, userIDs)
 }
 
-// Find userInfo By Nickname.
 func (u *userDatabase) FindByNickname(ctx context.Context, nickname string) (users []*relation.UserModel, err error) {
 	return u.userDB.TakeByNickname(ctx, nickname)
 }
 
-// Find notificationAccouts.
 func (u *userDatabase) FindNotification(ctx context.Context, level int64) (users []*relation.UserModel, err error) {
 	return u.userDB.TakeNotification(ctx, level)
 }
@@ -159,14 +155,6 @@ func (u *userDatabase) Create(ctx context.Context, users []*relation.UserModel)
 	})
 }
 
-//// Update (non-zero value) externally guarantees that userID exists.
-// func (u *userDatabase) Update(ctx context.Context, user *relation.SubscribeUserModel) (err error) {
-//	if err := u.userDB.Update(ctx, user); err != nil {
-//		return err
-//	}
-//	return u.cache.DelUsersInfo(user.UserID).ExecDel(ctx)
-//}
-
 // UpdateByMap update (zero value) externally guarantees that userID exists.
 func (u *userDatabase) UpdateByMap(ctx context.Context, userID string, args map[string]any) (err error) {
 	return u.tx.Transaction(ctx, func(ctx context.Context) error {
@@ -186,13 +174,7 @@ func (u *userDatabase) PageFindUser(ctx context.Context, level1 int64, level2 in
 	return u.userDB.PageFindUser(ctx, level1, level2, pagination)
 }
 
-func (u *userDatabase) PageFindUserWithKeyword(
-	ctx context.Context,
-	level1 int64,
-	level2 int64,
-	userID, nickName string,
-	pagination pagination.Pagination,
-) (count int64, users []*relation.UserModel, err error) {
+func (u *userDatabase) PageFindUserWithKeyword(ctx context.Context, level1 int64, level2 int64, userID, nickName string, pagination pagination.Pagination) (count int64, users []*relation.UserModel, err error) {
 	return u.userDB.PageFindUserWithKeyword(ctx, level1, level2, userID, nickName, pagination)
 }
 
@@ -267,19 +249,24 @@ func (u *userDatabase) GetUserStatus(ctx context.Context, userIDs []string) ([]*
 func (u *userDatabase) SetUserStatus(ctx context.Context, userID string, status, platformID int32) error {
 	return u.cache.SetUserStatus(ctx, userID, status, platformID)
 }
+
 func (u *userDatabase) AddUserCommand(ctx context.Context, userID string, Type int32, UUID string, value string, ex string) error {
 	return u.userDB.AddUserCommand(ctx, userID, Type, UUID, value, ex)
 }
+
 func (u *userDatabase) DeleteUserCommand(ctx context.Context, userID string, Type int32, UUID string) error {
 	return u.userDB.DeleteUserCommand(ctx, userID, Type, UUID)
 }
+
 func (u *userDatabase) UpdateUserCommand(ctx context.Context, userID string, Type int32, UUID string, val map[string]any) error {
 	return u.userDB.UpdateUserCommand(ctx, userID, Type, UUID, val)
 }
+
 func (u *userDatabase) GetUserCommands(ctx context.Context, userID string, Type int32) ([]*user.CommandInfoResp, error) {
 	commands, err := u.userDB.GetUserCommand(ctx, userID, Type)
 	return commands, err
 }
+
 func (u *userDatabase) GetAllUserCommands(ctx context.Context, userID string) ([]*user.AllCommandInfoResp, error) {
 	commands, err := u.userDB.GetAllUserCommand(ctx, userID)
 	return commands, err
diff --git a/pkg/common/servererrs/code.go b/pkg/common/servererrs/code.go
index a3d21a09c..3d0aa4a71 100644
--- a/pkg/common/servererrs/code.go
+++ b/pkg/common/servererrs/code.go
@@ -20,8 +20,8 @@ const UnknownCode = 1000
 // Error codes for various error scenarios.
 const (
 	FormattingError      = 10001 // Error in formatting
-	HasRegistered        = 10002 // User has already registered
-	NotRegistered        = 10003 // User is not registered
+	HasRegistered        = 10002 // user has already registered
+	NotRegistered        = 10003 // user is not registered
 	PasswordErr          = 10004 // Password error
 	GetIMTokenErr        = 10005 // Error in getting IM token
 	RepeatSendCode       = 10006 // Repeat sending code
@@ -53,7 +53,7 @@ const (
 
 	// Account error codes.
 	UserIDNotFoundError    = 1101 // UserID does not exist or is not registered
-	RegisteredAlreadyError = 1102 // User is already registered
+	RegisteredAlreadyError = 1102 // user is already registered
 
 	// Group error codes.
 	GroupIDNotFoundError  = 1201 // GroupID does not exist