service 修改 Redis 存储 KV

2026-04-10 11:12:10 +00:00
parent c888ca8844
commit bc82e3e708
25 changed files with 322 additions and 3666 deletions
--- a/ai-chat-service/chat-server/chat-context/chat_context.go
+++ b/ai-chat-service/chat-server/chat-context/chat_context.go
@@ -1,20 +0,0 @@
-package chat_context
-
-import "github.com/sashabaranov/go-openai"
-
-type ChatMessage struct {
-	//当前记录ID
-	ID string `json:"id,omitempty"`
-	//上一条记录ID
-	PID string `json:"pid,omitempty"`
-	//消息内容
-	Message openai.ChatCompletionMessage `json:"message"`
-	//该消息tokens数
-	Tokens int `json:"tokens,omitempty"`
-}
-
-type ContextCache interface {
-	Get(key string) (*ChatMessage, error)
-	Set(key string, value *ChatMessage, ttl int) error
-	Close()
-}
--- a/ai-chat-service/chat-server/chat-context/redis.go
+++ b/ai-chat-service/chat-server/chat-context/redis.go
@@ -1,51 +0,0 @@
-package chat_context
-
-import (
-	predis "ai-chat-service/pkg/db/redis"
-	"context"
-	"encoding/json"
-	"time"
-
-	"github.com/redis/go-redis/v9"
-)
-
-type redisCache struct {
-	redisClient *redis.Client
-}
-
-func NewRedisCache() ContextCache {
-	pool := predis.GetPool()
-	return &redisCache{
-		redisClient: pool.Get(),
-	}
-}
-func getRedisKey(key string) string {
-	return predis.GetKey(key)
-}
-
-func (c *redisCache) Get(key string) (*ChatMessage, error) {
-	key = getRedisKey(key)
-	str, err := c.redisClient.Get(context.Background(), key).Result()
-	if err == redis.Nil {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	value := &ChatMessage{}
-	err = json.Unmarshal([]byte(str), value)
-	return value, err
-}
-func (c *redisCache) Set(key string, value *ChatMessage, ttl int) error {
-	key = getRedisKey(key)
-	bytes, err := json.Marshal(value)
-	if err != nil {
-		return err
-	}
-	str := string(bytes)
-	return c.redisClient.SetEx(context.Background(), key, str, time.Duration(ttl)*time.Second).Err()
-}
-func (c *redisCache) Close() {
-	pool := predis.GetPool()
-	pool.Put(c.redisClient)
-}
--- a/ai-chat-service/chat-server/data/chat_records.go
+++ b/ai-chat-service/chat-server/data/chat_records.go
@@ -1,54 +1,59 @@
 package data

 import (
-	"database/sql"
-	"strings"
+	predis "ai-chat-service/pkg/db/redis"
+	"context"
+	"encoding/json"
+
+	redis "github.com/redis/go-redis/v9"
 )

 type IChatRecordsData interface {
 	Add(record *ChatRecord) error
-	GetById(id int64) (record *ChatRecord, err error)
+	GetById(id string) (record *ChatRecord, err error)
 }

 type ChatRecord struct {
-	ID              int64    `json:"id"`
-	UserMsg         string   `json:"user_msg"`
-	UserMsgTokens   int      `json:"user_msg_tokens"`
-	UserMsgKeywords []string `json:"user_msg_keywords"`
-	AIMsg           string   `json:"ai_msg"`
-	AIMsgTokens     int      `json:"ai_msg_tokens"`
-	ReqTokens       int      `json:"req_tokens"`
-	CreateAt        int64    `json:"create_at"`
+	ID       string `json:"-"`
+	Question string `json:"q"`
+	Answer   string `json:"a"`
 }

-type chatRecordsData struct {
-	db *sql.DB
+type chatRecordsData struct{}
+
+func NewChatRecordsData() IChatRecordsData {
+	return &chatRecordsData{}
 }

-func NewChatRecordsData(db *sql.DB) IChatRecordsData {
-	return &chatRecordsData{
-		db: db,
-	}
-}
+func (data *chatRecordsData) Add(record *ChatRecord) error {
+	client := predis.GetPool().Get()
+	defer predis.GetPool().Put(client)

-func (data *chatRecordsData) Add(cr *ChatRecord) (err error) {
-	sqlStr := "insert into chat_records(user_msg,user_msg_tokens,user_msg_keywords,ai_msg,ai_msg_tokens,req_tokens,create_at)values(?,?,?,?,?,?,?)"
-	res, err := data.db.Exec(sqlStr, cr.UserMsg, cr.UserMsgTokens, strings.Join(cr.UserMsgKeywords, ","), cr.AIMsg, cr.AIMsgTokens, cr.ReqTokens, cr.CreateAt)
+	payload, err := json.Marshal(&ChatRecord{
+		Question: record.Question,
+		Answer:   record.Answer,
+	})
 	if err != nil {
-		return
+		return err
 	}
-	cr.ID, _ = res.LastInsertId()
-	return
+	return client.Set(context.Background(), predis.GetKey("qa", record.ID), string(payload), 0).Err()
 }
-func (data *chatRecordsData) GetById(id int64) (cr *ChatRecord, err error) {
-	sqlStr := "select id,user_msg,user_msg_tokens,user_msg_keywords,ai_msg,ai_msg_tokens,req_tokens,create_at from chat_records where id = ?"
-	row := data.db.QueryRow(sqlStr, id)
-	cr = &ChatRecord{}
-	var keywords string
-	err = row.Scan(&cr.ID, &cr.UserMsg, &cr.UserMsgTokens, &keywords, &cr.AIMsg, &cr.AIMsgTokens, &cr.ReqTokens, &cr.CreateAt)
+
+func (data *chatRecordsData) GetById(id string) (*ChatRecord, error) {
+	client := predis.GetPool().Get()
+	defer predis.GetPool().Put(client)
+
+	value, err := client.Get(context.Background(), predis.GetKey("qa", id)).Result()
+	if err == redis.Nil {
+		return nil, nil
+	}
 	if err != nil {
 		return nil, err
 	}
-	cr.UserMsgKeywords = strings.Split(keywords, ",")
-	return cr, err
+
+	record := &ChatRecord{ID: id}
+	if err = json.Unmarshal([]byte(value), record); err != nil {
+		return nil, err
+	}
+	return record, nil
 }
--- a/ai-chat-service/chat-server/main.go
+++ b/ai-chat-service/chat-server/main.go
@@ -5,13 +5,13 @@ import (
 	metrics_app "ai-chat-service/chat-server/metrics-app"
 	metrics_bus "ai-chat-service/chat-server/metrics-bus"
 	"ai-chat-service/chat-server/server"
-	vector_data "ai-chat-service/chat-server/vector-data"
 	"ai-chat-service/interceptor"
 	"ai-chat-service/pkg/config"
-	"ai-chat-service/pkg/db/mysql"
 	"ai-chat-service/pkg/db/redis"
 	"ai-chat-service/pkg/log"
 	"ai-chat-service/proto"
+	"ai-chat-service/services/embedding"
+	"ai-chat-service/services/faiss"
 	"flag"
 	"fmt"
 	"net/http"
@@ -52,23 +52,22 @@ func main() {
 	logger.SetOutput(log.GetRotateWriter(cnf.Log.LogPath))
 	logger.SetPrintCaller(true)

-	// 初始化Mysql
-	mysql.InitMysql(cnf)
 	// 初始化redis
 	redis.InitRedisPool(cnf)

-	recordsData := data.NewChatRecordsData(mysql.GetDB())
-	vectorRecordsData, err := vector_data.NewChatRecordsData(cnf)
+	recordsData := data.NewChatRecordsData()
+	embedder, err := embedding.NewEmbedder(cnf)
 	if err != nil {
 		log.Fatal(err)
 	}
+	faissClient := faiss.NewClient(cnf)

 	lis, err := net.Listen("tcp", fmt.Sprintf("%s:%d", cnf.Server.IP, cnf.Server.Port))
 	if err != nil {
 		log.Fatal(err)
 	}
 	s := grpc.NewServer(grpc.UnaryInterceptor(interceptor.UnaryAuthInterceptor), grpc.StreamInterceptor(metrics_app.NewStreamMiddleware(registry).WrapHandler()))
-	service := server.NewChatService(recordsData, vectorRecordsData, cnf, logger, busMetrics)
+	service := server.NewChatService(recordsData, embedder, faissClient, cnf, logger, busMetrics)
 	proto.RegisterChatServer(s, service)

 	healthCheckSrv := health.NewServer()
--- a/ai-chat-service/chat-server/server/app.go
+++ b/ai-chat-service/chat-server/server/app.go
@@ -1,7 +1,6 @@
 package server

 import (
-	chat_context "ai-chat-service/chat-server/chat-context"
 	"ai-chat-service/pkg/config"
 	"ai-chat-service/pkg/log"
 	"ai-chat-service/pkg/zerror"
@@ -29,18 +28,15 @@ type openaiConf struct {
 	PresencePenalty   float32
 	FrequencyPenalty  float32
 	BotDesc           string
-	ContextTTL        int
-	ContextLen        int
 	MinResponseTokens int
 }
+
 type app struct {
 	openaiConf *openaiConf
 	log        log.ILogger
-	// TODO 内容上下文对象
-	contextCache chat_context.ContextCache
 }

-func (s *chatService) newApp(in *proto.ChatCompletionRequest, contextCache chat_context.ContextCache) *app {
+func (s *chatService) newApp(in *proto.ChatCompletionRequest) *app {
 	conf := &openaiConf{
 		ApiKey:            s.config.Chat.ApiKey,
 		BaseUrl:           s.config.Chat.BaseUrl,
@@ -51,8 +47,6 @@ func (s *chatService) newApp(in *proto.ChatCompletionRequest, contextCache chat_
 		PresencePenalty:   s.config.Chat.PresencePenalty,
 		FrequencyPenalty:  s.config.Chat.FrequencyPenalty,
 		BotDesc:           s.config.Chat.BotDesc,
-		ContextTTL:        s.config.Chat.ContextTTL,
-		ContextLen:        s.config.Chat.ContextLen,
 		MinResponseTokens: s.config.Chat.MinResponseTokens,
 	}
 	if in.ChatParam != nil {
@@ -69,40 +63,29 @@ func (s *chatService) newApp(in *proto.ChatCompletionRequest, contextCache chat_
 		if in.ChatParam.MaxTokens != 0 {
 			conf.MaxTokens = int(in.ChatParam.MaxTokens)
 		}
-		if in.ChatParam.ContextTTL != 0 {
-			conf.ContextTTL = int(in.ChatParam.ContextTTL)
-		}
-		if in.ChatParam.ContextLen != 0 {
-			conf.ContextLen = int(in.ChatParam.ContextLen)
-		}
 		if in.ChatParam.MinResponseTokens != 0 {
 			conf.MinResponseTokens = int(in.ChatParam.MinResponseTokens)
 		}
 	}
 	return &app{
-		openaiConf:   conf,
-		log:          s.log,
-		contextCache: contextCache,
+		openaiConf: conf,
+		log:        s.log,
 	}
 }
+
 func (a *app) getOpenaiClient() *openai.Client {
-	accessToken := a.openaiConf.ApiKey
-	config := openai.DefaultConfig(accessToken)
-	config.BaseURL = a.openaiConf.BaseUrl
-	client := openai.NewClientWithConfig(config)
-	return client
+	conf := openai.DefaultConfig(a.openaiConf.ApiKey)
+	conf.BaseURL = a.openaiConf.BaseUrl
+	return openai.NewClientWithConfig(conf)
 }
+
 func (a *app) buildChatCompletionRequest(in *proto.ChatCompletionRequest, stream bool) (req openai.ChatCompletionRequest, tokens, currTokens int, currMessage openai.ChatCompletionMessage, err error) {
-	//当前消息
 	currMessage = openai.ChatCompletionMessage{
 		Role:    openai.ChatMessageRoleUser,
 		Content: in.Message,
 	}
 	req = openai.ChatCompletionRequest{
-		Model: a.openaiConf.Model,
-		Messages: []openai.ChatCompletionMessage{
-			currMessage,
-		},
+		Model:            a.openaiConf.Model,
 		MaxTokens:        a.openaiConf.MinResponseTokens,
 		Temperature:      a.openaiConf.Temperature,
 		TopP:             a.openaiConf.TopP,
@@ -110,13 +93,7 @@ func (a *app) buildChatCompletionRequest(in *proto.ChatCompletionRequest, stream
 		FrequencyPenalty: a.openaiConf.FrequencyPenalty,
 		Stream:           stream,
 	}
-	contextList := make([]*chat_context.ChatMessage, 0)
-	if in.EnableContext {
-		//从缓存中获取上下文信息
-		contextList = a.getContext(in.Pid)
-	}
-	//重构req.Messages
-	tokens, currTokens, req.Messages, err = a.rebuildMessages(contextList, currMessage)
+	tokens, currTokens, req.Messages, err = a.rebuildMessages(currMessage)
 	if err != nil {
 		a.log.Error(err)
 		return
@@ -124,51 +101,37 @@ func (a *app) buildChatCompletionRequest(in *proto.ChatCompletionRequest, stream
 	req.MaxTokens = a.openaiConf.MaxTokens - tokens
 	return
 }
-func (a *app) rebuildMessages(contextList []*chat_context.ChatMessage, currMessage openai.ChatCompletionMessage) (tokens, currTokens int, messages []openai.ChatCompletionMessage, err error) {
-	var sysMessage openai.ChatCompletionMessage
+
+func (a *app) rebuildMessages(currMessage openai.ChatCompletionMessage) (tokens, currTokens int, messages []openai.ChatCompletionMessage, err error) {
+	messages = make([]openai.ChatCompletionMessage, 0, 2)
 	botTokens := 0
 	if a.openaiConf.BotDesc != "" {
-		sysMessage = openai.ChatCompletionMessage{
+		sysMessage := openai.ChatCompletionMessage{
 			Role:    openai.ChatMessageRoleSystem,
 			Content: a.openaiConf.BotDesc,
 		}
 		botTokens, err = tokenizer.GetTokens(&sysMessage, a.openaiConf.Model)
 		if err != nil {
-			a.log.Error(err)
 			return
 		}
+		messages = append(messages, sysMessage)
 	}
-	messages = []openai.ChatCompletionMessage{currMessage}
+
 	currTokens, err = tokenizer.GetTokens(&currMessage, a.openaiConf.Model)
 	if err != nil {
-		a.log.Error(err)
 		return
 	}
 	if currTokens > a.openaiConf.MaxTokens-a.openaiConf.MinResponseTokens-botTokens-ChatPrimedTokens {
-		err = zerror.NewByMsg("请求消息超限")
-		a.log.Error(err)
-		return
+		return 0, 0, nil, zerror.NewByMsg("请求消息超限")
 	}
+
 	tokens = currTokens + botTokens + ChatPrimedTokens
-	if contextList != nil {
-		for _, item := range contextList {
-			if tokens+item.Tokens+ChatPrimedTokens > a.openaiConf.MaxTokens-a.openaiConf.MinResponseTokens {
-				break
-			}
-			messages = append(messages, item.Message)
-			tokens += item.Tokens + ChatPrimedTokens
-		}
-	}
-	for i, j := 0, len(messages)-1; i < j; i, j = i+1, j-1 {
-		messages[i], messages[j] = messages[j], messages[i]
-	}
-	if botTokens > 0 {
-		messages = append([]openai.ChatCompletionMessage{sysMessage}, messages...)
-	}
+	messages = append(messages, currMessage)
 	return
 }
+
 func (a *app) buildChatCompletionResponse(msg string) *proto.ChatCompletionResponse {
-	res := &proto.ChatCompletionResponse{
+	return &proto.ChatCompletionResponse{
 		Id:      uuid.New().String(),
 		Object:  "chat.completion",
 		Created: time.Now().Unix(),
@@ -182,17 +145,12 @@ func (a *app) buildChatCompletionResponse(msg string) *proto.ChatCompletionRespo
 				FinishReason: "stop",
 			},
 		},
-		Usage: &proto.Usage{
-			PromptTokens:     0,
-			CompletionTokens: 0,
-			TotalTokens:      0,
-		},
+		Usage: &proto.Usage{},
 	}
-	return res
 }

 func (a *app) buildChatCompletionStreamResponse(id, delta, finishReason string) *proto.ChatCompletionStreamResponse {
-	res := &proto.ChatCompletionStreamResponse{
+	return &proto.ChatCompletionStreamResponse{
 		Id:      id,
 		Object:  "chat.completion.chunk",
 		Created: time.Now().Unix(),
@@ -208,79 +166,49 @@ func (a *app) buildChatCompletionStreamResponse(id, delta, finishReason string)
 			},
 		},
 	}
-	return res
 }

 func (a *app) buildChatCompletionStreamResponseList(id, msg string) []*proto.ChatCompletionStreamResponse {
-	list := make([]*proto.ChatCompletionStreamResponse, 0)
+	list := make([]*proto.ChatCompletionStreamResponse, 0, len(msg))
 	for _, delta := range msg {
 		list = append(list, a.buildChatCompletionStreamResponse(id, string(delta), ""))
 	}
 	return list
 }

-func (a *app) getContext(id string) []*chat_context.ChatMessage {
-	maxLen := a.openaiConf.ContextLen
-	list := make([]*chat_context.ChatMessage, 0, maxLen)
-	key := id
-	for i := 0; i < maxLen; i++ {
-		value, err := a.contextCache.Get(key)
-		if err != nil {
-			a.log.Error(err)
-			return nil
-		}
-		if value == nil {
-			break
-		}
-		list = append(list, value)
-		key = value.PID
-	}
-	return list
-}
-func (a *app) saveContext(value *chat_context.ChatMessage) error {
-	err := a.contextCache.Set(value.ID, value, a.openaiConf.ContextTTL)
-	if err != nil {
-		a.log.Error(err)
-		return err
-	}
-	return nil
-}
 func (a *app) keywords(in *proto.ChatCompletionRequest) []string {
 	pool := keywords_filter.GetKeywordsClientPool()
 	conn := pool.Get()
 	defer pool.Put(conn)
+
 	accessToken := config.GetConfig().DependOn.Keywords.AccessToken
 	client := keywords_proto.NewFilterClient(conn)
 	ctx := services.AppendBearerTokenToContext(context.Background(), accessToken)
-	req := &keywords_proto.FilterReq{
-		Text: in.Message,
-	}
+	req := &keywords_proto.FilterReq{Text: in.Message}
 	res, err := client.FindAll(ctx, req)
 	if err != nil {
 		a.log.Error(err)
 		return []string{}
 	}
 	return res.Keywords
-
 }
+
 func (a *app) sensitive(in *proto.ChatCompletionRequest) (ok bool, msg string, err error) {
 	pool := keywords_filter.GetSensitiveClientPool()
 	conn := pool.Get()
 	defer pool.Put(conn)
+
 	accessToken := config.GetConfig().DependOn.Sensitive.AccessToken
 	client := keywords_proto.NewFilterClient(conn)
 	ctx := services.AppendBearerTokenToContext(context.Background(), accessToken)
-	req := &keywords_proto.FilterReq{
-		Text: in.Message,
-	}
+	req := &keywords_proto.FilterReq{Text: in.Message}
 	res, err := client.Validate(ctx, req)
 	if err != nil {
 		a.log.Error(err)
 		return false, "", err
 	}
-	ok = res.Ok
-	if !ok {
-		msg = "触发到了知识盲区，请换个问题再问"
+	if !res.Ok {
+		return false, "触发到了知识盲区，请换个问题再问", nil
 	}
-	return
+	return true, "", nil
 }
--- a/ai-chat-service/chat-server/server/server.go
+++ b/ai-chat-service/chat-server/server/server.go
@@ -1,20 +1,18 @@
 package server

 import (
-	chat_context "ai-chat-service/chat-server/chat-context"
 	"ai-chat-service/chat-server/data"
 	metrics_bus "ai-chat-service/chat-server/metrics-bus"
-	vector_data "ai-chat-service/chat-server/vector-data"
 	"ai-chat-service/pkg/config"
 	"ai-chat-service/pkg/log"
 	"ai-chat-service/proto"
+	"ai-chat-service/services/embedding"
+	"ai-chat-service/services/faiss"
 	"ai-chat-service/services/tokenizer"
 	"context"
 	"encoding/json"
 	"io"
 	"strconv"
-	"strings"
-	"time"

 	"github.com/golang/protobuf/jsonpb"
 	"github.com/google/uuid"
@@ -26,218 +24,127 @@ type chatService struct {
 	config     *config.Config
 	log        log.ILogger
 	data       data.IChatRecordsData
-	vectorData vector_data.IChatRecordsData
+	embedder   embedding.Embedder
+	faiss      faiss.Client
 	busMetrics *metrics_bus.BusMetrics
 }

-func NewChatService(data data.IChatRecordsData, vectorData vector_data.IChatRecordsData, config *config.Config, log log.ILogger, busMetrics *metrics_bus.BusMetrics) proto.ChatServer {
+func NewChatService(data data.IChatRecordsData, embedder embedding.Embedder, faissClient faiss.Client, config *config.Config, log log.ILogger, busMetrics *metrics_bus.BusMetrics) proto.ChatServer {
 	return &chatService{
 		config:     config,
 		log:        log,
 		data:       data,
-		vectorData: vectorData,
+		embedder:   embedder,
+		faiss:      faissClient,
 		busMetrics: busMetrics,
 	}
 }

 func (s *chatService) ChatCompletion(ctx context.Context, in *proto.ChatCompletionRequest) (*proto.ChatCompletionResponse, error) {
-	redisContextCache := chat_context.NewRedisCache()
-	defer redisContextCache.Close()
+	app := s.newApp(in)

-	app := s.newApp(in, redisContextCache)
-	//敏感词过滤
-	ok, msg, err := app.sensitive(in)
-	if err != nil {
-		s.log.Error(err)
-		return nil, err
-	}
-	if !ok {
-		res := app.buildChatCompletionResponse(msg)
-		return res, nil
-	}
-
-	//关键词提取
-	keywords := app.keywords(in)
-	if len(keywords) > 0 {
-		idStr, score, err := s.vectorData.QueryData(context.Background(), map[string][]string{"keywords": {strings.Join(keywords, ",")}})
-		if err != nil {
-			s.log.Error(err)
-		} else if score > s.config.Vector.Threshold {
-			id, err := strconv.ParseInt(idStr, 10, 64)
-			if err != nil {
-				s.log.Error(err)
-			} else {
-				record, err := s.data.GetById(id)
-				if err != nil {
-					s.log.Error(err)
-				} else {
-					res := app.buildChatCompletionResponse(record.AIMsg)
-					return res, nil
-				}
-			}
-		}
-	}
-
-	client := app.getOpenaiClient()
-	req, tokens, currTokens, currMessage, err := app.buildChatCompletionRequest(in, false)
-	resp, err := client.CreateChatCompletion(ctx, req)
-	if err != nil {
-		s.log.Error(err)
-		return nil, err
-	}
-	res := &proto.ChatCompletionResponse{}
-	bytes, err := json.Marshal(resp)
-	if err != nil {
-		s.log.Error(err)
-		return nil, err
-	}
-	err = jsonpb.UnmarshalString(string(bytes), res)
-	if err != nil {
-		s.log.Error(err)
-		return nil, err
-	}
-	go func() {
-		reqContext := &chat_context.ChatMessage{
-			ID:      in.Id,
-			PID:     in.Pid,
-			Message: currMessage,
-			Tokens:  currTokens,
-		}
-		err := app.saveContext(reqContext)
-		if err != nil {
-			s.log.Error(err)
-			return
-		}
-		resContext := &chat_context.ChatMessage{
-			ID:      resp.ID,
-			PID:     reqContext.ID,
-			Message: resp.Choices[0].Message,
-			Tokens:  resp.Usage.CompletionTokens,
-		}
-		err = app.saveContext(resContext)
-		if err != nil {
-			s.log.Error(err)
-			return
-		}
-	}()
-	go func() {
-		records := &data.ChatRecord{
-			UserMsg:         in.Message,
-			UserMsgTokens:   currTokens,
-			UserMsgKeywords: keywords,
-			AIMsg:           resp.Choices[0].Message.Content,
-			AIMsgTokens:     resp.Usage.CompletionTokens,
-			ReqTokens:       tokens,
-			CreateAt:        time.Now().Unix(),
-		}
-		err := s.data.Add(records)
-		if err != nil {
-			s.log.Error(err)
-			return
-		}
-		//保存到向量数据库
-		if len(keywords) > 0 {
-			list := []*vector_data.ChatRecord{
-				{
-					ID: strconv.FormatInt(records.ID, 10),
-					KVs: map[string]string{
-						"keywords": strings.Join(keywords, ","),
-					},
-				},
-			}
-			err = s.vectorData.UpsertData(context.Background(), list)
-			if err != nil {
-				s.log.Error(err)
-				return
-			}
-		}
-	}()
-	return res, err
-}
-func (s *chatService) ChatCompletionStream(in *proto.ChatCompletionRequest, stream proto.Chat_ChatCompletionStreamServer) error {
-	redisContextCache := chat_context.NewRedisCache()
-	defer redisContextCache.Close()
-
-	app := s.newApp(in, redisContextCache)
-	//敏感词过滤
 	ok, msg, err := app.sensitive(in)
+	if err != nil {
+		s.busMetrics.ErrQuestionsTotalCounter.Inc()
+		return nil, err
+	}
+	if !ok {
+		s.busMetrics.SensitiveQuestionsTotalCounter.Inc()
+		return app.buildChatCompletionResponse(msg), nil
+	}
+
+	keywords := app.keywords(in)
+	if len(keywords) > 0 {
+		s.busMetrics.KeywordsQuestionsTotalCounter.Inc()
+	}
+
+	req, _, _, _, err := app.buildChatCompletionRequest(in, false)
+	if err != nil {
+		s.busMetrics.ErrQuestionsTotalCounter.Inc()
+		return nil, err
+	}
+
+	questionEmbedding, cachedRecord := s.searchCachedAnswer(ctx, in.Message)
+	if cachedRecord != nil {
+		return app.buildChatCompletionResponse(cachedRecord.Answer), nil
+	}
+
+	client := app.getOpenaiClient()
+	resp, err := client.CreateChatCompletion(ctx, req)
 	if err != nil {
 		s.busMetrics.ErrQuestionsTotalCounter.Inc()
 		s.log.Error(err)
+		return nil, err
+	}
+
+	res := &proto.ChatCompletionResponse{}
+	bytes, err := json.Marshal(resp)
+	if err != nil {
+		s.busMetrics.ErrQuestionsTotalCounter.Inc()
+		return nil, err
+	}
+	if err = jsonpb.UnmarshalString(string(bytes), res); err != nil {
+		s.busMetrics.ErrQuestionsTotalCounter.Inc()
+		return nil, err
+	}
+
+	if len(resp.Choices) > 0 {
+		if err = s.persistQA(ctx, questionEmbedding, in.Message, resp.Choices[0].Message.Content); err != nil {
+			s.log.Error(err)
+		} else {
+			s.busMetrics.QuestionsTotalCounter.Inc()
+		}
+	}
+	return res, nil
+}
+
+func (s *chatService) ChatCompletionStream(in *proto.ChatCompletionRequest, stream proto.Chat_ChatCompletionStreamServer) error {
+	app := s.newApp(in)
+
+	ok, msg, err := app.sensitive(in)
+	if err != nil {
+		s.busMetrics.ErrQuestionsTotalCounter.Inc()
 		return err
 	}
 	if !ok {
 		s.busMetrics.SensitiveQuestionsTotalCounter.Inc()
-		resId := uuid.New().String()
-		startRes := app.buildChatCompletionStreamResponse(resId, "", "")
-		endRes := app.buildChatCompletionStreamResponse(resId, "", "stop")
-		err = stream.Send(startRes)
-		if err != nil {
-			s.log.Error(err)
+		resID := uuid.New().String()
+		if err = stream.Send(app.buildChatCompletionStreamResponse(resID, "", "")); err != nil {
 			return err
 		}
-		resList := app.buildChatCompletionStreamResponseList(resId, msg)
-		for _, res := range resList {
-			err = stream.Send(res)
-			if err != nil {
-				s.log.Error(err)
+		for _, res := range app.buildChatCompletionStreamResponseList(resID, msg) {
+			if err = stream.Send(res); err != nil {
 				return err
 			}
 		}
-		err = stream.Send(endRes)
-		if err != nil {
-			s.log.Error(err)
-			return err
-		}
-		return nil
+		return stream.Send(app.buildChatCompletionStreamResponse(resID, "", "stop"))
 	}

-	//关键词提取
 	keywords := app.keywords(in)
-
 	if len(keywords) > 0 {
 		s.busMetrics.KeywordsQuestionsTotalCounter.Inc()
-		idStr, score, err := s.vectorData.QueryData(context.Background(), map[string][]string{"keywords": {strings.Join(keywords, ",")}})
-		if err != nil {
-			s.log.Error(err)
-		} else if score > s.config.Vector.Threshold {
-			id, err := strconv.ParseInt(idStr, 10, 64)
-			if err != nil {
-				s.log.Error(err)
-			} else {
-				record, err := s.data.GetById(id)
-				if err != nil {
-					s.log.Error(err)
-				} else {
-					resId := uuid.New().String()
-					startRes := app.buildChatCompletionStreamResponse(resId, "", "")
-					endRes := app.buildChatCompletionStreamResponse(resId, "", "stop")
-					err = stream.Send(startRes)
-					if err != nil {
-						s.log.Error(err)
-						return err
-					}
-					resList := app.buildChatCompletionStreamResponseList(resId, record.AIMsg)
-					for _, res := range resList {
-						err = stream.Send(res)
-						if err != nil {
-							s.log.Error(err)
-							return err
-						}
-					}
-					err = stream.Send(endRes)
-					if err != nil {
-						s.log.Error(err)
-						return err
-					}
-					return nil
-				}
+	}
+
+	req, _, _, _, err := app.buildChatCompletionRequest(in, true)
+	if err != nil {
+		s.busMetrics.ErrQuestionsTotalCounter.Inc()
+		return err
+	}
+
+	questionEmbedding, cachedRecord := s.searchCachedAnswer(stream.Context(), in.Message)
+	if cachedRecord != nil {
+		if err = stream.Send(app.buildChatCompletionStreamResponse(cachedRecord.ID, "", "")); err != nil {
+			return err
+		}
+		for _, res := range app.buildChatCompletionStreamResponseList(cachedRecord.ID, cachedRecord.Answer) {
+			if err = stream.Send(res); err != nil {
+				return err
 			}
 		}
+		return stream.Send(app.buildChatCompletionStreamResponse(cachedRecord.ID, "", "stop"))
 	}

 	client := app.getOpenaiClient()
-	req, tokens, currTokens, currMessage, err := app.buildChatCompletionRequest(in, false)
 	chatStream, err := client.CreateChatCompletionStream(stream.Context(), req)
 	if err != nil {
 		s.busMetrics.ErrQuestionsTotalCounter.Inc()
@@ -245,109 +152,106 @@ func (s *chatService) ChatCompletionStream(in *proto.ChatCompletionRequest, stre
 		return err
 	}
 	defer chatStream.Close()
+
 	completionContent := ""
-	resultID := ""
 	for {
 		resp, err := chatStream.Recv()
 		if err != nil && err != io.EOF {
+			s.busMetrics.ErrQuestionsTotalCounter.Inc()
 			s.log.Error(err)
 			return err
 		}
 		if err == io.EOF {
 			break
 		}
-		if resultID == "" {
-			resultID = resp.ID
-		}
 		completionContent += resp.Choices[0].Delta.Content
+
 		res := &proto.ChatCompletionStreamResponse{}
 		bytes, err := json.Marshal(resp)
 		if err != nil {
-			s.log.Error(err)
+			s.busMetrics.ErrQuestionsTotalCounter.Inc()
 			return err
 		}
-		err = jsonpb.UnmarshalString(string(bytes), res)
-		if err != nil {
-			s.log.Error(err)
+		if err = jsonpb.UnmarshalString(string(bytes), res); err != nil {
+			s.busMetrics.ErrQuestionsTotalCounter.Inc()
 			return err
 		}
-		err = stream.Send(res)
-		if err != nil {
-			s.log.Error(err)
+		if err = stream.Send(res); err != nil {
 			return err
 		}
 	}
+
+	model := s.config.Chat.Model
+	if in.ChatParam != nil && in.ChatParam.Model != "" {
+		model = in.ChatParam.Model
+	}
 	resultMessage := openai.ChatCompletionMessage{
 		Role:    openai.ChatMessageRoleAssistant,
 		Content: completionContent,
 	}
-	model := s.config.Chat.Model
-	if in.ChatParam != nil && in.ChatParam.Model != "" {
-		model = in.ChatParam.Model
-	}
-	resultTokens, err := tokenizer.GetTokens(&resultMessage, model)
-	if err != nil {
+	if _, err = tokenizer.GetTokens(&resultMessage, model); err != nil {
 		s.busMetrics.ErrQuestionsTotalCounter.Inc()
-		s.log.Error(err)
 		return err
 	}

-	go func() {
-		reqContext := &chat_context.ChatMessage{
-			ID:      in.Id,
-			PID:     in.Pid,
-			Message: currMessage,
-			Tokens:  currTokens,
-		}
-		err := app.saveContext(reqContext)
-		if err != nil {
-			s.log.Error(err)
-			return
-		}
-		resContext := &chat_context.ChatMessage{
-			ID:      resultID,
-			PID:     reqContext.ID,
-			Message: resultMessage,
-			Tokens:  resultTokens,
-		}
-		err = app.saveContext(resContext)
-		if err != nil {
-			s.log.Error(err)
-			return
-		}
-	}()
-	go func() {
+	if err = s.persistQA(stream.Context(), questionEmbedding, in.Message, completionContent); err != nil {
+		s.log.Error(err)
+	} else {
 		s.busMetrics.QuestionsTotalCounter.Inc()
-		records := &data.ChatRecord{
-			UserMsg:         in.Message,
-			UserMsgTokens:   currTokens,
-			UserMsgKeywords: keywords,
-			AIMsg:           completionContent,
-			AIMsgTokens:     resultTokens,
-			ReqTokens:       tokens,
-			CreateAt:        time.Now().Unix(),
-		}
-		err := s.data.Add(records)
-		if err != nil {
-			s.log.Error(err)
-			return
-		}
-		//保存到向量数据库
-		if len(keywords) > 0 {
-			list := []*vector_data.ChatRecord{
-				{
-					ID: strconv.FormatInt(records.ID, 10),
-					KVs: map[string]string{
-						"keywords": strings.Join(keywords, ","),
-					},
-				},
-			}
-			err = s.vectorData.UpsertData(context.Background(), list)
-			if err != nil {
-				s.log.Error(err)
-				return
-			}
-		}
-	}()
+	}
 	return nil
 }
+
+func (s *chatService) searchCachedAnswer(ctx context.Context, question string) ([]float32, *data.ChatRecord) {
+	embeddingVector, err := s.embedder.Embed(ctx, question)
+	if err != nil {
+		s.log.Error(err)
+		return nil, nil
+	}
+
+	searchRes, err := s.faiss.Search(ctx, embeddingVector, s.config.Faiss.SearchK)
+	if err != nil {
+		s.log.Error(err)
+		return embeddingVector, nil
+	}
+	if searchRes == nil || len(searchRes.IDs) == 0 || len(searchRes.SimilarityScores) == 0 {
+		return embeddingVector, nil
+	}
+	limit := len(searchRes.IDs)
+	if len(searchRes.SimilarityScores) < limit {
+		limit = len(searchRes.SimilarityScores)
+	}
+	for i := 0; i < limit; i++ {
+		if searchRes.IDs[i] < 0 || searchRes.SimilarityScores[i] < s.config.Faiss.SimilarityThreshold {
+			continue
+		}
+		record, err := s.data.GetById(strconv.FormatInt(searchRes.IDs[i], 10))
+		if err != nil {
+			s.log.Error(err)
+			return embeddingVector, nil
+		}
+		if record != nil {
+			return embeddingVector, record
+		}
+	}
+	return embeddingVector, nil
+}
+
+func (s *chatService) persistQA(ctx context.Context, questionEmbedding []float32, question, answer string) error {
+	if len(questionEmbedding) == 0 {
+		vector, err := s.embedder.Embed(ctx, question)
+		if err != nil {
+			return err
+		}
+		questionEmbedding = vector
+	}
+	id, err := s.faiss.Insert(ctx, questionEmbedding)
+	if err != nil {
+		return err
+	}
+	return s.data.Add(&data.ChatRecord{
+		ID:       id,
+		Question: question,
+		Answer:   answer,
+	})
+}
--- a/ai-chat-service/chat-server/vector-data/chat_records.go
+++ b/ai-chat-service/chat-server/vector-data/chat_records.go
@@ -1,29 +0,0 @@
-package vector_data
-
-import (
-	"ai-chat-service/pkg/config"
-	"context"
-	"fmt"
-)
-
-const CHAT_RECORDS = "chat_records"
-
-type ChatRecord struct {
-	ID  string
-	KVs map[string]string
-}
-type IChatRecordsData interface {
-	UpsertData(ctx context.Context, list []*ChatRecord) error
-	QueryData(ctx context.Context, text map[string][]string) (id string, score float32, err error)
-}
-
-func NewChatRecordsData(config *config.Config) (IChatRecordsData, error) {
-	switch config.Vector.Provider {
-	case "tencent", "":
-		return newTencentChatRecordsData(config)
-	case "pgvector":
-		return newPgvectorChatRecordsData(config)
-	default:
-		return nil, fmt.Errorf("unsupported vector provider: %s", config.Vector.Provider)
-	}
-}
--- a/ai-chat-service/chat-server/vector-data/pgvector.go
+++ b/ai-chat-service/chat-server/vector-data/pgvector.go
@@ -1,121 +0,0 @@
-package vector_data
-
-import (
-	"ai-chat-service/pkg/config"
-	"ai-chat-service/services/embedding"
-	"context"
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/jackc/pgx"
-)
-
-type pgvectorChatRecordsData struct {
-	config   *config.Config
-	pool     *pgx.ConnPool
-	embedder embedding.Embedder
-}
-
-func newPgvectorChatRecordsData(config *config.Config) (IChatRecordsData, error) {
-	connConfig, err := pgx.ParseConnectionString(config.Vector.Pgvector.DSN)
-	if err != nil {
-		return nil, err
-	}
-	pool, err := pgx.NewConnPool(pgx.ConnPoolConfig{
-		ConnConfig:     connConfig,
-		MaxConnections: config.Vector.Pgvector.MaxOpenConn,
-	})
-	if err != nil {
-		return nil, err
-	}
-	embedder, err := embedding.NewEmbedder(config)
-	if err != nil {
-		pool.Close()
-		return nil, err
-	}
-	return &pgvectorChatRecordsData{
-		config:   config,
-		pool:     pool,
-		embedder: embedder,
-	}, nil
-}
-
-func (data *pgvectorChatRecordsData) UpsertData(ctx context.Context, list []*ChatRecord) error {
-	table := data.config.Vector.Pgvector.Table
-	if table == "" {
-		table = "chat_record_vectors"
-	}
-	for _, item := range list {
-		recordID, err := strconv.ParseInt(item.ID, 10, 64)
-		if err != nil {
-			return err
-		}
-		keywordsText := embedding.BuildText(item.KVs["keywords"])
-		if keywordsText == "" {
-			continue
-		}
-		vector, err := data.embedder.Embed(ctx, keywordsText)
-		if err != nil {
-			return err
-		}
-		commandTag, err := data.pool.Exec(
-			fmt.Sprintf(
-				"INSERT INTO %s (record_id, keywords_text, embedding, created_at) VALUES ($1, $2, $3::vector, $4) ON CONFLICT (record_id) DO UPDATE SET keywords_text = EXCLUDED.keywords_text, embedding = EXCLUDED.embedding, created_at = EXCLUDED.created_at",
-				table,
-			),
-			recordID,
-			keywordsText,
-			vectorLiteral(vector),
-			time.Now().Unix(),
-		)
-		if err != nil {
-			return err
-		}
-		if commandTag.RowsAffected() == 0 {
-			return fmt.Errorf("pgvector upsert affected 0 rows for record_id=%d", recordID)
-		}
-	}
-	return nil
-}
-
-func (data *pgvectorChatRecordsData) QueryData(ctx context.Context, text map[string][]string) (id string, score float32, err error) {
-	keywordsText := embedding.BuildText(text["keywords"]...)
-	if keywordsText == "" {
-		return "", 0, nil
-	}
-	vector, err := data.embedder.Embed(ctx, keywordsText)
-	if err != nil {
-		return "", 0, err
-	}
-	table := data.config.Vector.Pgvector.Table
-	if table == "" {
-		table = "chat_record_vectors"
-	}
-	var recordID int64
-	err = data.pool.QueryRowEx(
-		ctx,
-		fmt.Sprintf(
-			"SELECT record_id, CAST(1 - (embedding <=> $1::vector) AS real) AS score FROM %s ORDER BY embedding <=> $1::vector LIMIT 1",
-			table,
-		),
-		nil,
-		vectorLiteral(vector),
-	).Scan(&recordID, &score)
-	if err != nil {
-		if err == pgx.ErrNoRows {
-			return "", 0, nil
-		}
-		return "", 0, err
-	}
-	return strconv.FormatInt(recordID, 10), score, nil
-}
-
-func vectorLiteral(values []float32) string {
-	parts := make([]string, 0, len(values))
-	for _, value := range values {
-		parts = append(parts, strconv.FormatFloat(float64(value), 'f', -1, 32))
-	}
-	return "[" + strings.Join(parts, ",") + "]"
-}
--- a/ai-chat-service/chat-server/vector-data/tencent.go
+++ b/ai-chat-service/chat-server/vector-data/tencent.go
@@ -1,66 +0,0 @@
-package vector_data
-
-import (
-	"ai-chat-service/pkg/config"
-	"context"
-	"time"
-
-	"github.com/tencent/vectordatabase-sdk-go/tcvectordb"
-)
-
-type tencentChatRecordsData struct {
-	config   *config.Config
-	vectorDB *tcvectordb.Client
-}
-
-func newTencentChatRecordsData(config *config.Config) (IChatRecordsData, error) {
-	option := &tcvectordb.ClientOption{
-		Timeout:            time.Second * time.Duration(config.Vector.Tencent.Timeout),
-		MaxIdldConnPerHost: config.Vector.Tencent.MaxIdleConnPerHost,
-		IdleConnTimeout:    time.Second * time.Duration(config.Vector.Tencent.IdleConnTimeout),
-		ReadConsistency:    tcvectordb.ReadConsistency(config.Vector.Tencent.ReadConsistency),
-	}
-	client, err := tcvectordb.NewClient(config.Vector.Tencent.Url, config.Vector.Tencent.Username, config.Vector.Tencent.Pwd, option)
-	if err != nil {
-		return nil, err
-	}
-	return &tencentChatRecordsData{
-		config:   config,
-		vectorDB: client,
-	}, nil
-}
-
-func (data *tencentChatRecordsData) UpsertData(ctx context.Context, list []*ChatRecord) error {
-	database := data.config.Vector.Tencent.Database
-	collection := CHAT_RECORDS
-	coll := data.vectorDB.Database(database).Collection(collection)
-	documentList := make([]tcvectordb.Document, 0, len(list))
-	for _, l := range list {
-		doc := tcvectordb.Document{Id: l.ID}
-		doc.Fields = make(map[string]tcvectordb.Field, len(l.KVs))
-		for k, v := range l.KVs {
-			doc.Fields[k] = tcvectordb.Field{Val: v}
-		}
-		documentList = append(documentList, doc)
-	}
-	_, err := coll.Upsert(ctx, documentList)
-	return err
-}
-
-func (data *tencentChatRecordsData) QueryData(ctx context.Context, text map[string][]string) (id string, score float32, err error) {
-	database := data.config.Vector.Tencent.Database
-	collection := CHAT_RECORDS
-	coll := data.vectorDB.Database(database).Collection(collection)
-	result, err := coll.SearchByText(ctx, text, &tcvectordb.SearchDocumentParams{
-		Params: &tcvectordb.SearchDocParams{Ef: 100},
-		Limit:  1,
-	})
-	if err != nil {
-		return "", 0, err
-	}
-	if len(result.Documents) > 0 && len(result.Documents[0]) > 0 {
-		doc := result.Documents[0][0]
-		return doc.Id, doc.Score, nil
-	}
-	return "", 0, nil
-}