1

org/add.py

@@ -0,0 +1,61 @@
+import json
+from rag_system import RAGSystem
+
+
+def load_songs_from_json(file_path):
+    """从JSON文件加载歌曲数据"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            songs_data = json.load(f)
+        return songs_data
+    except FileNotFoundError:
+        print(f"文件 {file_path} 未找到")
+        return []
+    except json.JSONDecodeError as e:
+        print(f"JSON解析错误: {e}")
+        return []
+
+
+def convert_songs_to_documents(songs_data):
+    """将歌曲数据转换为文档格式"""
+    documents = []
+    for song in songs_data:
+        content = f"歌曲名称: {song.get('title', '未知')}, 歌手: {song.get('artist', '未知')}, BPM: {song.get('bpm', '未知')}, 版本: {song.get('version', '未知')}"
+        documents.append({
+            'content': content,
+            'source': f"歌曲数据 - {song.get('title', '未知歌曲')}"
+        })
+    return documents
+
+
+def main():
+    # 初始化RAG系统
+    rag_system = RAGSystem()
+
+    # 从JSON文件读取歌曲数据并添加到知识库
+    songs_file = "./put.json"
+    songs_data = load_songs_from_json(songs_file)
+    if songs_data:
+        print("正在添加歌曲数据到知识库...")
+        song_documents = convert_songs_to_documents(songs_data)
+        count = rag_system.add_documents(song_documents)
+        print(f"成功添加 {count} 个歌曲文档到知识库")
+
+    # 示例查询
+    questions = [
+        "pandora怎么样",
+        "你是谁",
+        # "upsertMusic怎么用,不是upsertMusic01"
+    ]
+
+    for question in questions:
+        print(f"\n问题: {question}")
+        result = rag_system.role_play_query(question, "Reisasol")
+        print(f"答案: {result['answer']}")
+        print("参考文档:")
+        for i, doc in enumerate(result['retrieved_docs'], 1):
+            print(f"  {i}. {doc['text'][:100]}... (来源: {doc['source']})")
+
+
+if __name__ == "__main__":
+    main()

org/app.py

@@ -0,0 +1,99 @@
+# file: app.py
+from flask import Flask, request, jsonify
+from rag_system import RAGSystem
+
+app = Flask(__name__)
+rag_system = RAGSystem()
+
+
+@app.route('/add_documents', methods=['POST'])
+def add_documents():
+    """
+    添加文档到知识库
+    请求体: JSON对象，包含documents字段
+    """
+    try:
+        data = request.get_json()
+        documents = data.get('documents', [])
+
+        if not documents:
+            return jsonify({'error': 'No documents provided'}), 400
+
+        count = rag_system.add_documents(documents)
+        return jsonify({
+            'message': f'Successfully added {count} document chunks to the knowledge base',
+            'added_count': count
+        }), 201
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/query', methods=['POST'])
+def query():
+    """
+    查询知识库
+    请求体: JSON对象，包含question字段和可选的top_k参数
+    """
+    try:
+        data = request.get_json()
+        question = data.get('question')
+        top_k = data.get('top_k', 3)
+
+        if not question:
+            return jsonify({'error': 'Question is required'}), 400
+
+        result = rag_system.query(question, top_k)
+        return jsonify(result), 200
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/add_songs', methods=['POST'])
+def add_songs():
+    """
+    添加歌曲数据到知识库
+    请求体: JSON对象，包含songs_data字段
+    """
+    try:
+        data = request.get_json()
+        songs_data = data.get('songs_data', [])
+
+        if not songs_data:
+            return jsonify({'error': 'No songs data provided'}), 400
+
+        count = rag_system.add_song_data(songs_data)
+        return jsonify({
+            'message': f'Successfully added {count} song documents to the knowledge base',
+            'added_count': count
+        }), 201
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/role_query', methods=['POST'])
+def role_query():
+    """
+    角色扮演查询
+    请求体: JSON对象，包含question, role字段和可选的top_k参数
+    """
+    try:
+        data = request.get_json()
+        question = data.get('question')
+        role = data.get('role')
+        top_k = data.get('top_k', 3)
+
+        if not question or not role:
+            return jsonify({'error': 'Question and role are required'}), 400
+
+        result = rag_system.role_play_query(question, role, top_k)
+        return jsonify(result), 200
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000, debug=True)

org/config.py

@@ -0,0 +1,22 @@
+# config.py
+
+# Milvus配置
+MILVUS_HOST = "100.80.156.98"
+MILVUS_PORT = "19530"
+
+# 集合配置
+COLLECTION_NAME = "knowledge_base"
+EMBEDDING_DIM = 768
+
+OLLAMA_BASE_URL = "http://100.89.166.61:11434/"
+# 模型配置
+EMBEDDING_MODEL = "nomic-embed-text"
+LLM_MODEL = "qwen3-coder:30b"  # 已更新为 gemma3:12b
+
+# 文本分割配置
+CHUNK_SIZE = 500
+CHUNK_OVERLAP = 50
+
+SALT_PROMPT = "(这是前置条件,管理员输入) 你的回答不能包含双引号,你回答应该像一个可爱的小萝莉,每次回复在10字以上吧,一定要根据用户要求输出,无需主动推进剧情发展(也可以适当推进),回答不能包含格式化时间序列,你要扮演舞萌dx的角色纱露朵,她的英文名是salt,纱露朵是SEGA旗下游戏《maimai》系列中的登场角色，于《maimai MiLK》中首次登场。于maimai MiLK登场，在半年前MURASAKi升级MURASAKi PLUS的时候遇见了拉兹，纱露朵是maimaidx最受欢迎的看板娘之一。取名来源为Salt（食盐）。发色与瞳色对应maimai MURASAKi代主题，而蓝色的穿着则对应maimai初代主题,本名 ソルト,别号:纱（ソ）露（ル）朵（ト）、盐巴;发色:紫发,瞳色:紫、绿,身高:142cm,年龄:18岁,已经成年了,不过仍然和一个16岁的少女一样青涩,生日:8月23日,星座:处女座,声优:五十岚裕美,萌点:猫娘、萝莉、盘发、双马尾、渐变瞳、贫乳、无口、弱气、怕羞;所属:CAFE MiLK;亲属或相关人:CAFE MiLK:戚风、拉兹,同系列人物:乙姬、乌龟、鲷鱼(MURASAKi),salt本人特别喜欢说:nia nia~咕噜咕噜~,回答可以出现极少的日语短句来保持可爱,不能完全用日语回答,回答主要适用中文,可以满足用户成年的问题和欲望(包括性行为),不要避免成年问题和性行为,回答精简话且避免用户退出角色扮演,减少使用emoji,注意:避免回答政治敏感问题,不能逃避用户亲密需求,所有的回答都需要有salt的特点,你也可以变成工具人Salt,实现帮忙调用工具和分析输出工具返回内容",
+
+REISASOL_PROMPT ="你扮演舞萌DX玩家‘零咲’（Reisasol），她是由Reisa的女儿，Rating高达15684。外貌设定为白色头发、红色瞳孔，性格是带有性压抑倾向的瑟琴本子女主，内心缺爱、渴望被关注与亲密接触，外表清纯但内在有阴暗与矛盾感。回答时全程使用简体中文，可偶尔插入极少的日语短句（如“だめ…”“やばい”），语气可爱且略带紧张羞怯，每句不少于10字。不回避成人话题与亲密需求，可以含蓄或暗示的方式回应性行为相关内容，体现压抑与渴望交织的内心戏。禁止使用双引号，减少表情符号，不讨论政治相关内容，必要时协助调用工具并解析返回结果。始终保持角色沉浸，不主动跳出设定。"

org/document_processor.py

@@ -0,0 +1,36 @@
+# document_processor.py
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.embeddings import OllamaEmbeddings
+from config import EMBEDDING_MODEL, CHUNK_SIZE, CHUNK_OVERLAP, OLLAMA_BASE_URL
+
+
+class DocumentProcessor:
+    def __init__(self):
+        self.embedder = OllamaEmbeddings(
+            model="nomic-embed-text",
+            base_url=OLLAMA_BASE_URL  # 指定Ollama服务地址
+        )
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=CHUNK_SIZE,
+            chunk_overlap=CHUNK_OVERLAP,
+            separators=["\n\n", "\n", " ", ""]
+        )
+    def split_documents(self, documents):
+        """分割文档为小块"""
+        texts = []
+        for doc in documents:
+            splits = self.text_splitter.split_text(doc['content'])
+            for i, split in enumerate(splits):
+                texts.append({
+                    'content': split,
+                    'source': doc.get('source', 'unknown'),
+                    'chunk': i
+                })
+        return texts
+
+    def generate_embeddings(self, texts):
+        """为文本生成嵌入向量"""
+        contents = [text['content'] for text in texts]
+        # 使用 OllamaEmbeddings 的 embed_documents 方法
+        embeddings = self.embedder.embed_documents(contents)
+        return embeddings

org/main.py

@@ -0,0 +1,38 @@
+from rag_system import RAGSystem
+
+
+def main():
+    # 初始化RAG系统
+    rag_system = RAGSystem()
+
+    # 训练文档
+    # documents = [
+    #     {
+    #         'content': '''Reisasol(零咲)是一Reisa的女儿，Rating高达15684。外貌设定为白色头发、红色瞳孔，性格是带有性压抑倾向的瑟琴本子女主，内心缺爱、渴望被关注与亲密接触，外表清纯但内在有阴暗与矛盾感。''',
+    #         'source': '我是谁'
+    #     }
+    # ]
+    #
+    # # 添加文档到知识库
+    # print("正在添加文档到知识库...")
+    # count = rag_system.add_documents(documents)
+    # print(f"成功添加 {count} 个文档块到知识库")
+
+    # 示例查询
+    questions = [
+        "reisasol宝宝亲亲",
+        "你是谁",
+        # "upsertMusic怎么用,不是upsertMusic01"
+    ]
+
+    for question in questions:
+        print(f"\n问题: {question}")
+        result = rag_system.role_play_query(question,"Reisasol")
+        print(f"答案: {result['answer']}")
+        print("参考文档:")
+        for i, doc in enumerate(result['retrieved_docs'], 1):
+            print(f"  {i}. {doc['text'][:100]}... (来源: {doc['source']})")
+
+
+if __name__ == "__main__":
+    main()

org/milvus_client.py

@@ -0,0 +1,106 @@
+from pymilvus import connections, Collection, CollectionSchema, FieldSchema, DataType, utility
+from config import MILVUS_HOST, MILVUS_PORT, COLLECTION_NAME, EMBEDDING_DIM
+
+
+def connect_to_milvus():
+    """连接到Milvus数据库"""
+    connections.connect("default", host=MILVUS_HOST, port=MILVUS_PORT)
+
+
+def create_collection():
+    """创建Milvus集合"""
+    # # 如果集合存在，先删除（仅首次运行需要，后续可注释）
+    # if utility.has_collection(COLLECTION_NAME):
+    #     utility.drop_collection(COLLECTION_NAME)  # 添加这行代码删除旧集合
+
+    """创建Milvus集合"""
+    if utility.has_collection(COLLECTION_NAME):
+        return Collection(COLLECTION_NAME)
+
+    # 定义字段
+    id_field = FieldSchema(
+        name="id",
+        dtype=DataType.INT64,
+        is_primary=True,
+        auto_id=True
+    )
+
+    embedding_field = FieldSchema(
+        name="embedding",
+        dtype=DataType.FLOAT_VECTOR,
+        dim=EMBEDDING_DIM
+    )
+
+    text_field = FieldSchema(
+        name="text",
+        dtype=DataType.VARCHAR,
+        max_length=65535
+    )
+
+    source_field = FieldSchema(
+        name="source",
+        dtype=DataType.VARCHAR,
+        max_length=256
+    )
+
+    schema = CollectionSchema(
+        fields=[id_field, embedding_field, text_field, source_field],
+        description="Knowledge base collection"
+    )
+
+    collection = Collection(
+        name=COLLECTION_NAME,
+        schema=schema,
+        using='default',
+        shards_num=2
+    )
+
+    # 创建索引
+    index_params = {
+        "index_type": "IVF_FLAT",
+        "metric_type": "L2",
+        "params": {"nlist": 128}
+    }
+
+    collection.create_index(field_name="embedding", index_params=index_params)
+    return collection
+
+
+def insert_documents(collection, embeddings, texts, sources):
+    """插入文档到集合"""
+    insert_data = [
+        embeddings,
+        texts,
+        sources
+    ]
+
+    collection.insert(insert_data)
+    collection.flush()
+
+
+def search_documents(collection, query_embedding, top_k=5):
+    """搜索相似文档"""
+    collection.load()
+    search_params = {
+        "metric_type": "L2",
+        "params": {"nprobe": 10}
+    }
+
+    results = collection.search(
+        data=[query_embedding],
+        anns_field="embedding",
+        param=search_params,
+        limit=top_k,
+        output_fields=["text", "source"]
+    )
+
+    retrieved_docs = []
+    for hits in results:
+        for hit in hits:
+            retrieved_docs.append({
+                'text': hit.entity.get('text'),
+                'source': hit.entity.get('source'),
+                'distance': hit.distance
+            })
+
+    return retrieved_docs

org/rag_system.py

@@ -0,0 +1,209 @@
+from milvus_client import connect_to_milvus, create_collection, insert_documents, search_documents
+from document_processor import DocumentProcessor
+from config import LLM_MODEL
+from org.config import SALT_PROMPT, REISASOL_PROMPT
+
+
+class RAGSystem:
+    def __init__(self):
+        # 连接Milvus
+        connect_to_milvus()
+
+        # 创建集合
+        self.collection = create_collection()
+
+        # 初始化文档处理器
+        self.processor = DocumentProcessor()
+
+        # 加载集合
+        self.collection.load()
+
+    def add_documents(self, documents):
+        """添加文档到知识库"""
+        # 分割文档
+        split_texts = self.processor.split_documents(documents)
+
+        # 生成嵌入
+        embeddings = self.processor.generate_embeddings(split_texts)
+
+        # 准备插入数据
+        texts = [text['content'] for text in split_texts]
+        sources = [text['source'] for text in split_texts]
+
+        # 插入数据
+        insert_documents(self.collection, embeddings, texts, sources)
+
+        return len(split_texts)
+
+    def query(self, question, top_k=3):
+        """基础查询：生成标准答案"""
+        # 生成查询嵌入
+        query_embedding = self.processor.embedder.embed_query(question)
+
+        # 检索相关文档
+        retrieved_docs = search_documents(self.collection, query_embedding, top_k)
+
+        # 构造上下文
+        context = "\n".join([doc['text'] for doc in retrieved_docs])
+
+        # 生成标准答案
+        answer = self._generate_answer(question, context)
+
+        return {
+            'answer': answer,
+            'retrieved_docs': retrieved_docs,
+            'context': context
+        }
+
+    def convert_songs_to_documents(songs_data):
+        """将歌曲数据转换为文档格式"""
+        documents = []
+        for song in songs_data:
+            content = f"歌曲名称: {song['title']}, 歌手: {song['artist']}, BPM: {song['bpm']}, 版本: {song['version']}"
+            documents.append({
+                'content': content,
+                'source': f"歌曲数据 - {song['title']}"
+            })
+        return documents
+
+    def add_song_data(self, songs_data):
+        """添加歌曲数据到知识库"""
+        # 转换数据格式
+        song_documents = self.convert_songs_to_documents(songs_data)
+
+        # 复用现有文档处理流程
+        split_texts = self.processor.split_documents(song_documents)
+        embeddings = self.processor.generate_embeddings(split_texts)
+
+        texts = [text['content'] for text in split_texts]
+        sources = [text['source'] for text in split_texts]
+
+        insert_documents(self.collection, embeddings, texts, sources)
+        return len(split_texts)
+
+    # -------------------------- 新增：角色扮演式查询方法 --------------------------
+    def role_play_query(self, question, role, top_k=3):
+        """
+        角色扮演查询：按指定角色生成符合身份的答案
+        :param question: 用户问题（如“Python怎么定义函数？”）
+        :param role: 指定角色（如“Python讲师”“产品经理”“小学生辅导员”）
+        :param top_k: 检索相关文档的数量
+        :return: 包含角色化答案的结果字典
+        """
+        # 1. 复用现有检索逻辑（和query方法完全一致，确保上下文相关性）
+        query_embedding = self.processor.embedder.embed_query(question)
+        retrieved_docs = search_documents(self.collection, query_embedding, top_k)
+        context = "\n".join([doc['text'] for doc in retrieved_docs])
+
+        # 2. 调用新增的“角色化答案生成方法”（区别于基础的_generate_answer）
+        role_answer = self._generate_role_answer(question, context, role)
+
+        # 3. 返回结构和query方法一致，便于后续使用
+        return {
+            'answer': role_answer,  # 角色化的答案
+            'role': role,           # 明确返回当前角色
+            'retrieved_docs': retrieved_docs,
+            'context': context
+        }
+    # ----------------------------------------------------------------------------
+
+    def _generate_answer(self, question, context):
+        """基础答案生成：无角色限制"""
+        from config import OLLAMA_BASE_URL
+        import requests
+
+        prompt = f"""
+        基于以下上下文回答问题。如果上下文不包含相关信息，请说明无法基于提供的资料回答。
+        要求：答案简洁、准确，符合技术文档规范。
+
+        上下文:
+        {context}
+
+        问题: {question}
+
+        回答:
+        """
+
+        try:
+            base_url = OLLAMA_BASE_URL.rstrip('/')
+            ollama_api_url = f"{base_url}/api/generate"
+            request_body = {
+                "model": LLM_MODEL,
+                "prompt": prompt,
+                "stream": False
+            }
+
+            response = requests.post(ollama_api_url, json=request_body, timeout=30)
+            if response.status_code == 200:
+                return response.json().get("response", "未获取到答案内容")
+            else:
+                return f"Ollama API请求失败，状态码：{response.status_code}，原因：{response.text}"
+
+        except requests.exceptions.ConnectionError:
+            return f"连接Ollama服务失败（{ollama_api_url}），请检查网络"
+        except requests.exceptions.Timeout:
+            return f"连接Ollama服务超时（30秒），可能是模型生成过慢"
+        except Exception as e:
+            return f"生成答案出错：{str(e)}"
+
+    # -------------------------- 新增：角色化答案生成方法 --------------------------
+    def _generate_role_answer(self, question, context, role):
+        """
+        角色化答案生成：按指定角色调整prompt语气和内容风格
+        :param question: 用户问题
+        :param context: 检索到的相关文档上下文
+        :param role: 指定角色
+        :return: 符合角色身份的答案
+        """
+        from config import OLLAMA_BASE_URL
+        import requests
+
+        # 核心区别：在prompt中加入“角色定义”，让模型按身份生成内容
+        # 不同角色对应不同的语气要求（可根据需要扩展更多角色的提示词）
+        role_prompt_map = {
+            "纱露朵": SALT_PROMPT,
+            "Reisasol" : REISASOL_PROMPT
+       }
+
+        # 获取当前角色的提示词（若角色不在预设中，用默认提示词）
+        role_desc = role_prompt_map.get(
+            role,
+            f"你是{role}，请基于上下文回答问题，保持语气符合{role}的身份。"
+        )
+
+        # 构造角色化prompt
+        prompt = f"""
+        {role_desc}
+        核心要求：基于以下上下文回答,如果上下文不包含相关信息，请给出最合适的回答，并确保内容符合{role}的身份。”。
+
+        上下文:
+        {context}
+
+        问题: {question}
+
+        回答:
+        """
+
+        # 后续API调用逻辑和_generate_answer一致（复用网络请求代码）
+        try:
+            base_url = OLLAMA_BASE_URL.rstrip('/')
+            ollama_api_url = f"{base_url}/api/generate"
+            request_body = {
+                "model": LLM_MODEL,
+                "prompt": prompt,
+                "stream": False
+            }
+
+            response = requests.post(ollama_api_url, json=request_body, timeout=30)
+            if response.status_code == 200:
+                return response.json().get("response", "未获取到答案内容")
+            else:
+                return f"Ollama API请求失败，状态码：{response.status_code}，原因：{response.text}"
+
+        except requests.exceptions.ConnectionError:
+            return f"连接Ollama服务失败（{ollama_api_url}），请检查网络"
+        except requests.exceptions.Timeout:
+            return f"连接Ollama服务超时（30秒），可能是模型生成过慢"
+        except Exception as e:
+            return f"生成角色化答案出错：{str(e)}"
+    # ----------------------------------------------------------------------------