知识库分享，历史记录文件

zhaoqingang

2025-03-28 226202d6eee6480f3386c6295be26fad42940cc8

知识库分享，历史记录文件

 app/api/knowledge.py

@@ -2,41 +2,48 @@

from fastapi import APIRouter, Depends, Query, HTTPException
from app.api import Response, get_current_user, ResponseList
from app.models import klgParameter, klgIcon
from app.models import klgParameter, klgIcon, KlgOwner
from app.models.base_model import get_db
from app.models.user_model import UserModel
from app.service.knowledge import get_knowledge_list, create_knowledge_service, sync_knowledge_service, \
    delete_knowledge_service, update_knowledge_icon_service
    delete_knowledge_service, update_knowledge_icon_service, get_knowledge_users_service, set_knowledge_owner_service, \
    add_knowledge_user_service
from typing import Optional

knowledge_router = APIRouter()


@knowledge_router.get("/list", response_model=Response)
async def knowledge_list(
        current: int,
        pageSize: int,
        keyword: str="",
        status: str="",
        knowledge: str="1",
        location: str="",
        keyword: str = "",
        status: str = "",
        knowledge: str = "1",
        location: str = "",
        current_user: UserModel = Depends(get_current_user),
        db=Depends(get_db)):
    if current and not pageSize:
        return ResponseList(code=400, msg="缺少参数")
    getknowledgelist = await get_knowledge_list(db, current_user.id, keyword, pageSize, current, status, knowledge, location)
    getknowledgelist = await get_knowledge_list(db, current_user.id, keyword, pageSize, current, status, knowledge,
                                                location)

    return Response(code=200, msg="", data=getknowledgelist)


@knowledge_router.post("/create", response_model=Response)
async def create_knowledge_api(klg: klgParameter, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    is_create = await create_knowledge_service(db, klg.id, klg.name, klg.description, klg.icon, klg.klgType, current_user.id)
async def create_knowledge_api(klg: klgParameter, current_user: UserModel = Depends(get_current_user),
                               db=Depends(get_db)):
    is_create = await create_knowledge_service(db, klg.id, klg.name, klg.description, klg.icon, klg.klgType,
                                               current_user.id)
    if not is_create:
        return Response(code=500, msg="role knowledge failure", data={})
    return Response(code=200, msg="role knowledge success", data={})


@knowledge_router.get("/update", response_model=Response)
async def change_knowledge_api(knowledgeId: str, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
async def change_knowledge_api(knowledgeId: str, current_user: UserModel = Depends(get_current_user),
                               db=Depends(get_db)):
    # is_create = await update_dialog_status_service(db, dialog.id, dialog.status)
    # if not is_create:
    #     return Response(code=500, msg="dialog update failure", data={})
@@ -59,10 +66,38 @@
    return Response(code=200, msg="knowledge delete success", data={})



@knowledge_router.put("/update_icon", response_model=Response)
async def change_dialog_icon(klg: klgIcon, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    is_create = await update_knowledge_icon_service(db, klg.id, klg.icon)
    if not is_create:
        return Response(code=500, msg="knowledge update failure", data={})
    return Response(code=200, msg="knowledge update success", data={})
    return Response(code=200, msg="knowledge update success", data={})


@knowledge_router.get("/{knowledgeId}/users", response_model=Response)
async def get_kb_users(knowledgeId: str,
                       current: int,
                       pageSize: int,
                       member:int = 0,
                       current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    kb_user = await get_knowledge_users_service(db, knowledgeId, current_user.id, current, pageSize, member)

    return Response(code=200, msg="knowledge user success", data={"rows": kb_user})


@knowledge_router.post("/transfer/owner", response_model=Response)
async def transfer_kb_owner(klgOwner: KlgOwner,
                       current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    is_update = await set_knowledge_owner_service(db, klgOwner.knowledgeId, klgOwner.UserId, current_user.id)
    if not is_update:
        return Response(code=500, msg="knowledge update failure", data={})
    return Response(code=200, msg="knowledge update success", data={})


@knowledge_router.get("/{knowledgeId}/join", response_model=Response)
async def join_kb_user(knowledgeId: str,
                       current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    is_add = await add_knowledge_user_service(db, knowledgeId, current_user.id)
    if not is_add:
        return Response(code=500, msg="knowledge join failure", data={})
    return Response(code=200, msg="knowledge join success", data={})

 app/api/user.py

@@ -154,4 +154,9 @@
    is_edit = await edit_user_dept(db, user.userId, user.depts)
    if not is_edit:
        return Response(code=500, msg="user edit failure", data={})
    return Response(code=200, msg="user edit successfully", data={})
    return Response(code=200, msg="user edit successfully", data={})


@user_router.get("/ping", response_model=Response)
async def user_ping(current_user: UserModel = Depends(get_current_user)):
    return Response(code=200, msg="", data={})

 app/config/env_conf/admin.yaml

@@ -3,9 +3,9 @@
  password: gAAAAABnvAq8bErFiR9x_ZcODjUeOdrDo8Z5UVOzyqo6SxIhAvLpw81kciQN0frwIFVfY9wrxH1WqrpTICpEwfH7r2SkLjS7SQ==

chat_server:
  id: 2c039666c29d11efa4670242ac1b0006
  account: zhao1@example.com
  password: gAAAAABnpFLtotY2OIRH12BJh4MzMgn5Zil7-DVpIeuqlFwvr0g6g_n4ULogn-LNhCbtk6cCDkzZlqAHvBSX2e_zf7AsoyzbiQ==
  id: e7f1b3a6062911f0a9650242ac120004
  account: 1528276425@qq.com
  password: gAAAAABn4MzQzoGBSFI6Gx1Nz1RdEY31E0exNFwUtD7q0iWtaUeFCgA6ruDxjLxA7sNgP_lV_Un_SgN0xnaCdwd9a_XH3VAHMg==

workflow_server:
  account: admin@basic.com

 app/models/knowledge_model.py

@@ -30,7 +30,7 @@
    def get_id(self):
        return str(self.id)

    def to_json(self):
    def to_json(self, user_id=""):
        return {
            'id': self.id,
            'name': self.name,
@@ -42,7 +42,8 @@
            'status': self.status,
            'documents': self.documents if self.documents else 0,
            'icon': self.icon,
            'embd_id': self.embd_id
            'embd_id': self.embd_id,
            'link': True if (self.tenant_id == user_id or user_id == "admin" ) and self.permission == "team" else False,
        }
    def __repr__(self):
        return '<Knowledge name:%r url:%r>\n' % (self.name, self.id)
@@ -59,4 +60,40 @@

class klgIcon(BaseModel):
    id: str
    icon: str
    icon: str



class KnowledgeUserModel(Base):
    __tablename__ = 'knowledgebase_user'

    id = Column(Integer, primary_key=True)  # id
    kb_id = Column(String(36))
    user_id = Column(Integer)
    create_date = Column(DateTime, default=datetime.now())             # 创建时间
    update_date = Column(DateTime, default=datetime.now(), onupdate=datetime.now())             # 更新时间
    status = Column(Integer)  # 状态



    def get_id(self):
        return str(self.id)

    def to_json(self, user_id=""):
        return {
            'id': self.id,
            'kb_id': self.kb_id,
            'create_time': self.create_date.strftime('%Y-%m-%d %H:%M:%S'),
            'update_time': self.update_date.strftime('%Y-%m-%d %H:%M:%S'),
            'user_id': self.user_id,
            'status': self.status,
            'owner': True if str(self.user_id) == user_id else False,
        }
    def __repr__(self):
        return '<Knowledge name:%r url:%r>\n' % (self.name, self.id)



class KlgOwner(BaseModel):
    knowledgeId: str
    UserId: int

 app/models/v2/chat.py

@@ -177,16 +177,17 @@
        }

    def log_to_json(self):
        query = {}
        if self.query:
            query = json.loads(self.query)
        if self.message_type == 1:
            return {
                'id': self.id,
                'role': "user",
                'content': self.content,
                'files': query.get("files", []),
            }
        else:
            query = {}
            if self.query:
                query = json.loads(self.query)

            res = {
                'id': self.id,
@@ -195,6 +196,7 @@
                'chat_mode': self.chat_mode,
                "parentId": query.get("parentId"),
                "isDeep": query.get("isDeep", 1),
                "mindmap": True if self.mindmap else False,
            }
            if self.chat_mode == complex_knowledge_chat:
                res['reference'] = json.loads(self.node_data) if self.node_data else {}

 app/models/v2/session_model.py

@@ -82,6 +82,17 @@



    def to_dict(self):
        res = {"files": [], "inputs": {}}
        if hasattr(self, 'files'):
            res['files'] = self.files
        if hasattr(self, 'inputs'):
            res['inputs'] = self.inputs
        return res




class ChatSessionDao:
    def __init__(self, db: Session):
        self.db = db

 app/service/knowledge.py

@@ -2,7 +2,7 @@

from sqlalchemy import or_

from app.models import KnowledgeModel, group_knowledge_table
from app.models import KnowledgeModel, group_knowledge_table, KnowledgeUserModel
from app.models.user_model import UserModel
from Log import logger
from app.task.fetch_agent import get_one_from_ragflow_knowledge
@@ -15,6 +15,9 @@
    query = db.query(KnowledgeModel).filter(KnowledgeModel.knowledge_type==knowledge)
    if user.permission != "admin":
        klg_list = [j.id for i in user.groups for j in i.knowledges]
        for i in db.query(KnowledgeUserModel).filter(KnowledgeUserModel.user_id == user_id, KnowledgeUserModel.status == 1).all():
            if i.kb_id not in klg_list:
                klg_list.append(i.kb_id)
        query = query.filter(or_(KnowledgeModel.id.in_(klg_list), KnowledgeModel.tenant_id == str(user_id)))

        if location:
@@ -25,13 +28,16 @@
    total = query.count()
    if page_size:
        query = query.order_by(KnowledgeModel.update_date.desc()).limit(page_size).offset((page_index - 1) * page_size)
    return {"total":  total, "rows": [kld.to_json() for kld in query.all()]}
    return {"total":  total, "rows": [kld.to_json(str(user_id) if user.permission != "admin" else "admin") for kld in query.all()]}


async def create_knowledge_service(db, klg_id, name, description, icon, klg_type, user_id):
    try:
        dialog_model = KnowledgeModel(id=klg_id,name=name, description=description,icon=icon, knowledge_type=klg_type, tenant_id=user_id,update_date=datetime.now(),create_date=datetime.now())
        db.add(dialog_model)
        kb_user = KnowledgeUserModel(kb_id=klg_id, user_id=user_id, status=1, update_date=datetime.now(),
                                     create_date=datetime.now())
        db.add(kb_user)
        db.commit()
        db.refresh(dialog_model)
    except Exception as e:
@@ -87,3 +93,47 @@
        return False
    return True



async def get_knowledge_users_service(db, kb_id, user_id, page, page_size, member):
    kb_user_list = []
    user_ids = []
    kb_info = db.query(KnowledgeModel).filter(KnowledgeModel.id == kb_id).first()
    query = db.query(KnowledgeUserModel).filter(KnowledgeUserModel.kb_id == kb_id)
    if member:
        query = query.filter(KnowledgeUserModel.user_id != user_id)
    total = query.count()

    for kld in query.limit(page_size).offset((page - 1) * page_size).all():
        user_ids.append(kld.user_id)
        print(kb_info.tenant_id)
        kb_user_list.append(kld.to_json(kb_info.tenant_id))
    user = {i.id: i.username for i in db.query(UserModel).filter(UserModel.id.in_(user_ids)).all()}
    for kld in kb_user_list:
        kld["username"] = user.get(kld["user_id"], "")
    return {"total": total, "rows": kb_user_list}


async def set_knowledge_owner_service(db, kb_id, user_id, u_id):
    try:
        db.query(KnowledgeModel).filter_by(id=kb_id).update({"tenant_id": str(user_id), "update_date": datetime.now()})
        db.commit()
    except Exception as e:
        logger.error(e)
        db.rollback()
        return False
    return True


async def add_knowledge_user_service(db, kb_id, user_id):
    try:

        kb_user = KnowledgeUserModel(kb_id=kb_id, user_id=user_id, status=1, update_date=datetime.now(),
                                     create_date=datetime.now())
        db.add(kb_user)
        db.commit()
    except Exception as e:
        logger.error(e)
        db.rollback()
        return False
    return True

 app/service/v2/chat.py

@@ -14,7 +14,7 @@
from app.config.config import settings
from app.config.const import *
from app.models import DialogModel, ApiTokenModel, UserTokenModel, ComplexChatSessionDao, ChatDataRequest, \
    ComplexChatDao, KnowledgeModel, UserModel
    ComplexChatDao, KnowledgeModel, UserModel, KnowledgeUserModel
from app.models.v2.session_model import ChatSessionDao, ChatData
from app.service.v2.app_driver.chat_agent import ChatAgent
from app.service.v2.app_driver.chat_data import ChatBaseApply
@@ -34,7 +34,7 @@


async def add_session_log(db, session_id: str, question: str, chat_id: str, user_id, event_type: str,
                          conversation_id: str, agent_type):
                          conversation_id: str, agent_type, query: dict=None):
    try:
        session = await ChatSessionDao(db).update_or_insert_by_id(
            session_id=session_id,
@@ -42,7 +42,7 @@
            agent_id=chat_id,
            agent_type=agent_type,
            tenant_id=user_id,
            message={"role": "user", "content": question},
            message={"role": "user", "content": question, "query": query},
            conversation_id=conversation_id,
            event_type=event_type
        )
@@ -97,6 +97,9 @@
    query = db.query(KnowledgeModel)
    if user.permission != "admin":
        klg_list = [j.id for i in user.groups for j in i.knowledges]
        for i in db.query(KnowledgeUserModel).filter(KnowledgeUserModel.user_id == user_id, KnowledgeUserModel.status == 1).all():
            if i.kb_id not in klg_list:
                klg_list.append(i.kb_id)
        query = query.filter(or_(KnowledgeModel.id.in_(klg_list), KnowledgeModel.tenant_id == str(user_id)))
        kb_list= query.all()
        for kb in kb_list:
@@ -204,7 +207,7 @@
    else:
        query = "start new conversation"
    session = await add_session_log(db, session_id, query if query else "start new conversation", chat_id, user_id,
                                    mode, conversation_id, DF_TYPE)
                                    mode, conversation_id, DF_TYPE, chat_data.to_dict())
    if session:
        conversation_id = session.conversation_id
    try: