'commit'

dsRag/Config/Config.py

@@ -7,7 +7,7 @@ MYSQL_DB_NAME = "base_db"
 
 # Elasticsearch配置
 ES_CONFIG = {
-    #"hosts": "https://10.10.14.206:9200",
+    # "hosts": "https://10.10.14.206:9200",
     "hosts": "https://127.0.0.1:9200",
     "basic_auth": ("elastic", "jv9h8uwRrRxmDi1dq6u8"),
     "verify_certs": False,
@@ -27,3 +27,7 @@ JIEBA_CUSTOM_WORDS = ['文言虚词', '花呗']
 MODEL_PATH = "D:/Tencent_AILab_ChineseEmbedding/Tencent_AILab_ChineseEmbedding.txt"
 # 加载词向量模型时限制的词汇数量
 MODEL_LIMIT = 10000
+
+# NEO4J数据库配置
+NEO4J_URI = "bolt://localhost:7687"
+NEO4J_AUTH = ("neo4j", "DsideaL147258369")

dsRag/Neo4j/N0_ClearDb.py

@@ -0,0 +1,12 @@
+from Config.Config import *
+from Neo4j.Neo4jExecutor import *
+
+# 使用示例
+if __name__ == '__main__':
+    executor = Neo4jExecutor(
+        uri=NEO4J_URI,
+        auth=NEO4J_AUTH
+    )
+    # 清库
+    clear(executor.graph)
+    print("清库成功")

dsRag/Neo4j/N1_ReadZsd.py

@@ -0,0 +1,61 @@
+import json
+
+from Neo4j.Neo4jExecutor import *
+
+def json_to_cypher(data):
+    """将知识体系JSON转换为Cypher插入脚本"""
+    cypher = []
+    seen = set()
+
+    def process_node(node, parent_id=None):
+        nonlocal seen
+
+        node_id = node['value']
+        node_name = node['title'].replace("'", "''")
+
+        # 创建当前节点
+        if node_id not in seen:
+            cypher.append(f"MERGE (n:KnowledgePoint {{id: '{node_id}'}}) SET n.name = '{node_name}';")
+            seen.add(node_id)
+
+        # 创建父子关系
+        if parent_id:
+            cypher.append(f"""
+MATCH (parent:KnowledgePoint {{id: '{parent_id}'}}), 
+      (child:KnowledgePoint {{id: '{node_id}'}})
+MERGE (parent)-[:HAS_SUB_POINT]->(child);""")
+
+        # 递归处理子节点
+        if 'children' in node and not node['isLeaf']:
+            for child in node['children']:
+                process_node(child, parent_id=node_id)
+
+    # 处理根节点
+    for root in data['data']['tree']:
+        process_node(root)
+
+        # 处理根节点的父级关系（如果有）
+        if root.get('parentValue'):
+            cypher.append(f"MERGE (parent:KnowledgePoint {{id: '{root['parentValue']}'}});")
+            cypher.append(f"""
+MATCH (parent:KnowledgePoint {{id: '{root['parentValue']}'}}), 
+      (child:KnowledgePoint {{id: '{root['value']}'}})
+MERGE (parent)-[:HAS_SUB_POINT]->(child);""")
+
+    return '\n'.join(cypher)
+
+
+# 使用示例
+if __name__ == '__main__':
+    executor = Neo4jExecutor(
+        uri=NEO4J_URI,
+        auth=NEO4J_AUTH
+    )
+    # 清库
+    clear(executor.graph)
+
+    # 这里替换成你的JSON数据变量
+    with open('小学数学知识点体系.json', 'r',encoding='utf-8') as f:
+        your_json_data = json.load(f)
+    cypherText=json_to_cypher(your_json_data)
+    executor.execute_cypher_text(cypherText)

dsRag/Neo4j/N2_ReadXksy.py

@@ -0,0 +1,137 @@
+import json
+from Neo4j.Neo4jExecutor import *
+
+# Neo4j连接配置
+graph = Graph(NEO4J_URI, auth=NEO4J_AUTH)
+
+
+class Py2neoLoader:
+    def __init__(self):
+        self.node_cache = {}
+        self.tx = graph.begin()  # 初始化事务
+
+    def create_literacy_nodes(self, data):
+        try:
+            print("Received data structure keys:", data.keys())
+
+            # 创建核心素养节点
+            if "tree" in data and len(data["tree"]) > 0:
+                self._create_core_node(data["tree"][0])
+            else:
+                raise ValueError("Invalid data structure: missing 'tree' array")
+
+            # 创建关联体系节点（处理第二个节点）
+            if len(data["tree"]) > 1:
+                self._create_relation_system(data["tree"][1])
+            graph.commit(self.tx)  # 替换 self.tx.commit()
+            print(f"数据导入成功！共处理{len(self.node_cache)}个节点")
+        except Exception as e:
+            graph.rollback(self.tx)  # 替换 self.tx.rollback()
+            print("主流程错误:", str(e))
+            raise
+
+    def _create_core_node(self, node):
+        try:
+            core_node = Node("CoreLiteracy",
+                             title=node.get("title", "未命名节点"),
+                             value=node.get("value", "CORE_DEFAULT"),
+                             key=node.get("key", "ROOT_DEFAULT"))
+            self.tx.merge(core_node, "CoreLiteracy", "value")
+            self.node_cache[node.get("value")] = core_node
+            print(f"创建核心节点: {core_node}")
+
+            if "children" in node:
+                for child in node["children"]:
+                    self._create_child_node(child, core_node)
+        except Exception as e:
+            print(f"创建核心节点出错: {str(e)}")
+            print("问题节点数据:", node)
+            raise
+
+    def _create_child_node(self, node, parent):
+        try:
+            if "value" not in node:
+                node["value"] = f"AUTO_VALUE_{len(self.node_cache) + 1}"
+                print(f"为节点生成默认value: {node['value']}")
+
+            child_node = Node("LiteracyNode",
+                              title=node.get("title", "未命名子节点"),
+                              value=node["value"],
+                              key=node.get("key", ""),
+                              parentValue=node.get("parentValue", ""),
+                              preSkills=node.get("preSkills", []))
+            self.tx.merge(child_node, "LiteracyNode", "value")
+            self.node_cache[node["value"]] = child_node
+
+            if parent is not None:
+                rel = Relationship(parent, "HAS_SUB_NODE", child_node)
+                self.tx.merge(rel)
+                print(f"创建关系: {parent['value']} -> {child_node['value']}")
+
+            # 处理前置技能关系
+            for pre_skill in node.get("preSkills", []):
+                if pre_skill in self.node_cache:
+                    pre_node = self.node_cache[pre_skill]
+                    rel = Relationship(pre_node, "REQUIRES", child_node)
+                    self.tx.merge(rel)
+                else:
+                    print(f"警告: 前置技能节点 {pre_skill} 不存在")
+
+            # 递归处理子节点
+            if "children" in node:
+                for sub_child in node.get("children", []):
+                    self._create_child_node(sub_child, child_node)
+        except Exception as e:
+            print(f"创建子节点出错: {str(e)}")
+            print("问题节点数据:", node)
+            raise
+
+    def _create_relation_system(self, relation_system):
+        try:
+            # 创建关联体系根节点
+            sys_node = Node("RelationSystem",
+                            title=relation_system.get("title", "未命名关联体系"),
+                            value=relation_system.get("value", "REL_SYS_DEFAULT"),
+                            path=relation_system.get("path", []))
+            self.tx.merge(sys_node, "RelationSystem", "value")
+            print(f"创建关联体系节点: {sys_node}")
+
+            # 处理关联链
+            for chain in relation_system.get("children", []):
+                chain_node = Node("RelationChain",
+                                  title=chain.get("title", "未命名关联链"),
+                                  value=chain.get("value", f"CHAIN_{len(self.node_cache) + 1}"),
+                                  path=chain.get("path", []))
+                self.tx.merge(chain_node, "RelationChain", "value")
+                self.tx.merge(Relationship(sys_node, "HAS_CHAIN", chain_node))
+
+                # 处理路径关系
+                for path_str in chain.get("path", []):
+                    nodes = [n.strip() for n in path_str.replace("+", "→").split("→")]
+                    for i in range(len(nodes) - 1):
+                        source = self.node_cache.get(nodes[i])
+                        target = self.node_cache.get(nodes[i + 1])
+                        if source and target:
+                            rel = Relationship(source, "NEXT_STEP", target)
+                            self.tx.merge(rel)
+                        else:
+                            print(f"路径节点缺失: {nodes[i]}→{nodes[i + 1]}")
+        except Exception as e:
+            print(f"创建关联体系出错: {str(e)}")
+            print("问题数据:", relation_system)
+            raise
+
+
+if __name__ == "__main__":
+    try:
+        with open("小学数学学科素养点体系.json", 'r', encoding='utf-8') as f:
+            raw_data = json.load(f)
+            print("JSON文件加载成功，顶层键:", raw_data.keys())
+
+            if "data" not in raw_data:
+                raise ValueError("JSON缺少'data'字段")
+
+            loader = Py2neoLoader()
+            loader.create_literacy_nodes(raw_data["data"])
+    except Exception as e:
+        print("主程序错误:", str(e))

dsRag/Neo4j/N3_InputShiTi.py

@@ -0,0 +1,296 @@
+# -*- coding: utf-8 -*-
+"""
+数学题目分析系统 v6.3（稳定流式处理版）
+"""
+
+import re
+import json
+import hashlib
+import requests
+from py2neo import Graph
+from typing import Dict, List
+from Config import NEO4J_URI, NEO4J_AUTH, MODEL_API_URL, MODEL_API_KEY, MODEL_NAME
+
+
+# ================== 配置类 ==================
+class Config:
+    NEO4J_URI = NEO4J_URI
+    NEO4J_AUTH = NEO4J_AUTH
+    MODEL_API_URL = MODEL_API_URL
+    MODEL_API_KEY = MODEL_API_KEY
+    MODEL_NAME = MODEL_NAME
+    MAX_CONTENT_LENGTH = 500
+    STREAM_TIMEOUT = 30
+
+
+# ================== 知识图谱管理 ==================
+class KnowledgeManager:
+    def __init__(self):
+        self.graph = Graph(Config.NEO4J_URI, auth=Config.NEO4J_AUTH)
+        self._verify_connection()
+        self.knowledge_map = self._load_knowledge()
+        self.literacy_map = self._load_literacy()
+        print("✅ 知识库加载完成")
+        print(f"有效知识点({len(self.knowledge_map)}个): {list(self.knowledge_map.keys())[:3]}...")
+        print(f"有效素养点({len(self.literacy_map)}个): {list(self.literacy_map.keys())[:3]}...")
+
+    def _verify_connection(self):
+        """安全连接验证"""
+        try:
+            self.graph.run("RETURN 1 AS test")
+            print("✅ Neo4j连接验证成功")
+        except Exception as e:
+            print(f"❌ Neo4j连接失败: {str(e)}")
+            raise
+
+    def _load_knowledge(self) -> Dict[str, str]:
+        """安全加载知识点"""
+        records = self.graph.run("MATCH (n:KnowledgePoint) WHERE n.name IS NOT NULL RETURN n.id, n.name").data()
+        return {rec['n.name'].strip(): rec['n.id'] for rec in records if rec['n.name'] and rec['n.name'].strip()}
+
+    def _load_literacy(self) -> Dict[str, str]:
+        """安全加载素养点"""
+        records = self.graph.run("MATCH (n:LiteracyNode) WHERE n.title IS NOT NULL RETURN n.value, n.title").data()
+        return {rec['n.title'].strip(): rec['n.value'] for rec in records if rec['n.title'] and rec['n.title'].strip()}
+
+    def store_analysis(self, question_id: str, content: str,
+                       knowledge: List[str], literacy: List[str]):
+        """增强存储方法"""
+        tx = self.graph.begin()
+        try:
+            # 创建/更新题目节点
+            tx.run("""
+                MERGE (q:Question {id: $id})
+                SET q.content = $content, q.updateTime = timestamp()
+                """, {"id": question_id, "content": content})
+
+            # 关联知识点
+            valid_kp = []
+            for name in knowledge:
+                clean_name = name.strip()
+                if kp_id := self.knowledge_map.get(clean_name):
+                    tx.run("""
+                        MATCH (q:Question {id: $qid}), (kp:KnowledgePoint {id: $kpid})
+                        MERGE (q)-[r:REQUIRES_KNOWLEDGE]->(kp)
+                        SET r.lastUsed = timestamp()
+                        """, {"qid": question_id, "kpid": kp_id})
+                    valid_kp.append(clean_name)
+
+            # 关联素养点
+            valid_lp = []
+            for title in literacy:
+                clean_title = title.strip()
+                if lit_id := self.literacy_map.get(clean_title):
+                    tx.run("""
+                        MATCH (q:Question {id: $qid}), (lp:LiteracyNode {value: $lpid})
+                        MERGE (q)-[r:DEVELOPS_LITERACY]->(lp)
+                        SET r.lastUsed = timestamp()
+                        """, {"qid": question_id, "lpid": lit_id})
+                    valid_lp.append(clean_title)
+
+            self.graph.commit(tx)
+            print(f"✅ 存储成功 - 知识点: {valid_kp}, 素养点: {valid_lp}")
+        except Exception as e:
+            self.graph.rollback(tx)
+            print(f"❌ 存储失败: {str(e)}")
+
+
+# ================== 大模型客户端 ==================
+class StreamLLMClient:
+    def __init__(self, kg: KnowledgeManager):
+        self.kg = kg
+        self.base_url = Config.MODEL_API_URL
+        self.headers = {
+            "Authorization": f"Bearer {Config.MODEL_API_KEY}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+
+    def analyze_problem(self, content: str) -> dict:
+        """增强的流式分析"""
+        try:
+            prompt = self._build_prompt(content)
+            response = self._send_request(prompt)
+            return self._process_stream(response)
+        except Exception as e:
+            print(f"🔴 分析失败: {str(e)}")
+            return {}
+
+    def _build_prompt(self, content: str) -> str:
+        """构建精准提示词"""
+        return f"""请严格按以下要求分析数学题目：
+1. 知识点必须完全匹配以下列表中的名称（不要新增或修改）：
+{self.kg.knowledge_map.keys()}
+
+2. 素养点必须完全匹配以下列表中的名称：
+{self.kg.literacy_map.keys()}
+
+3. 返回严格JSON格式：
+{{
+    "problem_types": ["题型"],
+    "knowledge_points": ["匹配的知识点"],
+    "literacy_points": ["匹配的素养点"]
+}}
+
+题目内容：{content}"""
+
+    def _send_request(self, prompt: str):
+        """发送API请求"""
+        return requests.post(
+            f"{self.base_url}/chat/completions",
+            headers=self.headers,
+            json={
+                "model": Config.MODEL_NAME,
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": 0.1,
+                "stream": True
+            },
+            timeout=Config.STREAM_TIMEOUT,
+            stream=True
+        )
+
+    def _process_stream(self, response) -> dict:
+        """可靠的流式处理"""
+        full_content = ""
+        try:
+            for chunk in response.iter_lines():
+                if chunk:
+                    decoded = chunk.decode('utf-8').strip()
+                    if decoded.startswith('data:'):
+                        json_str = decoded[5:].strip()
+                        if json_str == "[DONE]":
+                            break
+                        try:
+                            data = json.loads(json_str)
+                            if content := data['choices'][0]['delta'].get('content'):
+                                full_content += content
+                        except:
+                            continue
+
+            # 调试日志
+            print(f"原始响应内容：\n{full_content}")
+
+            # 提取有效JSON
+            json_str = re.search(r'\{[\s\S]*\}', full_content).group()
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            print(f"⚠️ JSON解析失败，原始内容：{full_content}")
+            return {}
+        except Exception as e:
+            print(f"流处理异常：{str(e)}")
+            return {}
+
+
+# ================== 核心引擎 ==================
+class ProblemAnalyzer:
+    def __init__(self, content: str):
+        self.original = content
+        self.content = self._preprocess(content)
+        self.question_id = hashlib.sha256(content.encode()).hexdigest()[:12]
+        self.kg = KnowledgeManager()
+        self.llm = StreamLLMClient(self.kg)
+
+    def _preprocess(self, text: str) -> str:
+        """文本预处理"""
+        return re.sub(r'[^\w\u4e00-\u9fa5]', '', text)[:Config.MAX_CONTENT_LENGTH]
+
+    def execute(self):
+        """执行分析流程"""
+        print(f"\n🔍 分析题目: {self.original[:50]}...")
+
+        analysis = self.llm.analyze_problem(self.original)
+        if not analysis:
+            print("⚠️ 大模型分析失败")
+            return
+
+        print("\n📊 分析结果:")
+        print(f"  题型: {analysis.get('problem_types', [])}")
+        print(f"  知识点: {analysis.get('knowledge_points', [])}")
+        print(f"  素养点: {analysis.get('literacy_points', [])}")
+
+        self.kg.store_analysis(
+            question_id=self.question_id,
+            content=self.content,
+            knowledge=analysis.get('knowledge_points', []),
+            literacy=analysis.get('literacy_points', [])
+        )
+
+
+# ================== 查询接口 ==================
+def query_question(question_id: str):
+    try:
+        graph = Graph(Config.NEO4J_URI, auth=Config.NEO4J_AUTH)
+        result = graph.run("""
+            MATCH (q:Question {id: $id})
+            OPTIONAL MATCH (q)-[:REQUIRES_KNOWLEDGE]->(kp)
+            OPTIONAL MATCH (q)-[:DEVELOPS_LITERACY]->(lp)
+            RETURN q.content AS content,
+                   collect(kp.name) AS knowledge,
+                   collect(lp.title) AS literacy
+        """, id=question_id).data()
+
+        if result:
+            data = result[0]
+            print(f"\n🔍 查询结果（ID: {question_id}）")
+            print(f"内容: {data['content']}")
+            print(f"知识点: {data['knowledge']}")
+            print(f"素养点: {data['literacy']}")
+        else:
+            print("未找到相关题目")
+    except Exception as e:
+        print(f"查询错误: {str(e)}")
+
+
+# ================== 测试执行 ==================
+if __name__ == '__main__':
+    test_cases = [
+        # 基础运算类
+        "小明用50元买了3本笔记本，每本8元，还剩多少钱？",  # 知识点：四则运算应用 素养点：数学运算能力
+
+        # 几何问题
+        "一个长方形花坛长5米，宽3米，四周铺1米宽的小路，求小路面积？",  # 知识点：面积计算 素养点：空间观念
+
+        # 统计概率
+        "某班30人，数学成绩90分以上占1/5，80-89分占1/3，求80分以下人数？",  # 知识点：分数运算 素养点：数据分析
+
+        # 典型应用题
+        "甲乙两车相距300公里，甲车速度60km/h，乙车40km/h，几小时后相遇？",  # 知识点：相遇问题 素养点：数学建模
+
+        # 方程应用
+        "鸡兔同笼，头共10个，脚共28只，问鸡兔各多少？",  # 知识点：二元一次方程 素养点：代数思维
+
+        # 比例问题
+        "配制农药药液，药粉和水的比例是3:100，现有水500kg，需要多少药粉？",  # 知识点：比例应用 素养点：量化分析
+
+        # 函数图像
+        "某物体做匀加速运动，初速度2m/s，加速度0.5m/s²，写出速度v与时间t的关系式",  # 知识点：一次函数 素养点：数形结合
+
+        # 立体几何
+        "圆柱形水桶底面半径0.4米，高1.2米，求它的容积（π取3.14）",  # 知识点：圆柱体积 素养点：空间想象
+
+        # 概率统计
+        "掷两个骰子，点数和为7的概率是多少？",  # 知识点：概率计算 素养点：数据预测
+
+        # 工程问题
+        "甲队单独完成工程需20天，乙队需30天，两队合作需要多少天？",  # 知识点：工程问题 素养点：模型构建
+
+        # 最优化问题
+        "用20米篱笆围矩形菜地，怎样围面积最大？最大面积是多少？",  # 知识点：二次函数 素养点：优化思想
+
+        # 利率问题
+        "本金10000元，年利率3.5%，存3年到期本息合计多少？",  # 知识点：单利计算 素养点：金融素养
+
+        # 数列问题
+        "等差数列首项5，公差3，求第10项的值",  # 知识点：等差数列 素养点：模式识别
+
+        # 测量问题
+        "在比例尺1:5000的地图上，2cm线段代表实际距离多少米？",  # 知识点：比例尺应用 素养点：单位换算
+
+        # 逻辑推理
+        "A说B在说谎，B说C在说谎，C说AB都在说谎，问谁在说真话？"  # 知识点：逻辑推理 素养点：批判性思维
+    ]
+
+    for q in test_cases:
+        print("\n" + "=" * 60)
+        analyzer = ProblemAnalyzer(q)
+        analyzer.execute()

dsRag/Neo4j/N4_PrintShiTi.py

@@ -0,0 +1,61 @@
+from py2neo import Graph
+import json
+from Config import *
+
+def query_all_questions():
+    # Neo4j连接配置
+    neo4j_config = {
+        "uri": NEO4J_URI,  # 从Config导入
+        "auth": NEO4J_AUTH  # 从Config导入
+    }
+
+    # 初始化图数据库连接
+    graph = Graph(**neo4j_config)
+
+    try:
+        # 获取所有试题ID
+        question_ids = graph.run(
+            "MATCH (q:Question) RETURN q.id AS question_id"
+        ).data()
+
+        results = []
+
+        # 遍历每个试题
+        for record in question_ids:
+            qid = record['question_id']
+            # 修改查询部分
+            data = graph.run("""
+                    MATCH (q:Question {id: $qid})
+                    OPTIONAL MATCH (q)-[:REQUIRES_KNOWLEDGE]->(kp:KnowledgePoint)
+                    OPTIONAL MATCH (q)-[:DEVELOPS_LITERACY]->(lp:LiteracyNode)
+                    RETURN 
+                        q.content AS content,
+                        collect(DISTINCT {id: kp.id, name: kp.name}) AS knowledge_points,
+                        collect(DISTINCT {id: lp.value, title: lp.title}) AS literacy_points
+                """, qid=qid).data()
+
+            if data:
+                result = {
+                    "question_id": qid,
+                    "content": data[0]['content'],
+                    "knowledge_points": data[0]['knowledge_points'],
+                    "literacy_points": data[0]['literacy_points']
+                }
+                results.append(result)
+
+                # 增强版输出展示
+                print(f"\n{'=' * 40} 题目详情 {'=' * 40}")
+                print(f"📚 试题ID: {qid}")
+                print(f"📝 内容全文: {result['content']}")  # 新增完整内容输出
+                print(f"🔍 内容摘要: {result['content'][:50]}...")  # 保留摘要显示
+                print(f"🧠 知识点: {[kp['name'] for kp in result['knowledge_points']]}")
+                print(f"🆔 知识点ID: {[kp['id'] for kp in result['knowledge_points']]}")
+                print(f"🌟 素养点: {[lp['title'] for lp in result['literacy_points']]}")
+                print(f"🔢 素养点ID: {[lp['id'] for lp in result['literacy_points']]}")
+                print('=' * 90)
+    except Exception as e:
+        print(f"❌ 查询失败: {str(e)}")
+
+
+if __name__ == '__main__':
+    query_all_questions()

dsRag/Neo4j/Neo4jExecutor.py

@@ -0,0 +1,107 @@
+import re
+from Config import *
+from py2neo import Graph, Node, Relationship, Subgraph
+from typing import List, Tuple
+
+def clear(db):
+    # 清空数据
+    db.run("MATCH (n) DETACH DELETE n")
+
+    # 分步删除约束和索引
+    try:
+        # 删除约束
+        constraints = db.run("SHOW CONSTRAINTS YIELD name").data()
+        for constr in constraints:
+            db.run(f"DROP CONSTRAINT `{constr['name']}`")
+
+        # 删除索引
+        indexes = db.run("SHOW INDEXES YIELD name, type WHERE type <> 'LOOKUP'").data()
+        for idx in indexes:
+            db.run(f"DROP INDEX `{idx['name']}`")
+    except Exception as e:
+        print(f"删除操作失败: {e}")
+
+
+def create_subgraph(db: Graph, nodes: List[Node], relations: List[Tuple[Node, str, Node]]) -> None:
+    """统一创建子图"""
+    subgraph = Subgraph(
+        nodes=nodes,
+        relationships=[Relationship(start, rel_type, end) for start, rel_type, end in relations]
+    )
+    db.create(subgraph)
+
+def tx_create(db: Graph, nodes: List[Node], relations: List[Tuple[Node, str, Node]]) -> None:
+    """事务方式创建数据"""
+    try:
+        tx = db.begin()
+        subgraph = Subgraph(
+            nodes=nodes,
+            relationships=[Relationship(start, rel_type, end) for start, rel_type, end in relations]
+        )
+        tx.create(subgraph)
+        db.commit(tx)
+    except Exception as e:
+        db.rollback(tx)
+        print(f"事务操作失败: {str(e)}")
+        raise
+
+class Neo4jExecutor:
+    def __init__(self, uri, auth):
+        self.graph = Graph(uri, auth=auth)
+
+    # 新增文本执行方法
+    def execute_cypher_text(self, cypher_text: str) -> dict:
+        """直接执行Cypher文本"""
+        stats = {'total': 0, 'success': 0, 'failed': 0}
+        try:
+            statements = re.split(r';\s*\n', cypher_text)
+            statements = [s.strip() for s in statements if s.strip()]
+
+            stats['total'] = len(statements)
+
+            for stmt in statements:
+                try:
+                    self.graph.run(stmt)
+                    stats['success'] += 1
+                except Exception as e:
+                    stats['failed'] += 1
+                    print(f"执行失败: {stmt[:50]}... \n错误: {str(e)[:100]}")
+
+            return stats
+        except Exception as e:
+            print(f"执行失败: {stmt[:100]}... \n完整错误: {str(e)}")  # 原为str(e)[:100]
+            return stats
+
+    def execute_cypher_file(self, file_path: str) -> dict:  # 确保方法名称正确
+        """执行Cypher文件"""
+        stats = {'total': 0, 'success': 0, 'failed': 0}
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                cypher_script = f.read()
+                statements = re.split(r';\s*\n', cypher_script)
+                statements = [s.strip() for s in statements if s.strip()]
+
+                stats['total'] = len(statements)
+
+                for stmt in statements:
+                    try:
+                        self.graph.run(stmt)
+                        stats['success'] += 1
+                    except Exception as e:
+                        stats['failed'] += 1
+                        print(f"执行失败: {stmt[:50]}... \n错误: {str(e)[:100]}")
+
+                return stats
+
+        except Exception as e:
+            print(f"文件错误: {str(e)}")
+            return stats
+
+
+def init():
+    executor = Neo4jExecutor(
+        uri=NEO4J_URI,
+        auth=NEO4J_AUTH
+    )
+    # 清库
+    clear(executor.graph)

dsRag/Neo4j/小学数学学科素养点体系.json

@@ -0,0 +1,160 @@
+{
+  "status": 200,
+  "data": {
+    "tree": [
+      {
+        "children": [
+          {
+            "title": "数感培养",
+            "value": "MATH_LITERACY_01",
+            "key": "NUM_SENSE",
+            "children": [
+              {
+                "title": "数量感知基础（1-2年级）",
+                "value": "SUB_01",
+                "key": "NUM_BASIC",
+                "parentValue": "MATH_LITERACY_01",
+                "preSkills": []
+              },
+              {
+                "title": "数运算直观（3-4年级）",
+                "value": "SUB_02",
+                "key": "NUM_OPERATION",
+                "parentValue": "MATH_LITERACY_01",
+                "preSkills": ["SUB_01"]
+              },
+              {
+                "title": "数关系抽象（5-6年级）",
+                "value": "SUB_03",
+                "key": "NUM_RELATION",
+                "parentValue": "MATH_LITERACY_01",
+                "preSkills": ["SUB_02"]
+              }
+            ]
+          },
+          {
+            "title": "空间观念",
+            "value": "MATH_LITERACY_02",
+            "key": "SPACE_CONCEPT",
+            "children": [
+              {
+                "title": "图形辨识（1-2年级）",
+                "value": "SUB_04",
+                "key": "SHAPE_ID",
+                "parentValue": "MATH_LITERACY_02",
+                "preSkills": []
+              },
+              {
+                "title": "空间方位（3-4年级）",
+                "value": "SUB_05",
+                "key": "SPACE_ORIENT",
+                "parentValue": "MATH_LITERACY_02",
+                "preSkills": ["SUB_04"]
+              },
+              {
+                "title": "几何推理（5-6年级）",
+                "value": "SUB_06",
+                "key": "GEOM_REASON",
+                "parentValue": "MATH_LITERACY_02",
+                "preSkills": ["SUB_05"]
+              }
+            ]
+          },
+          {
+            "title": "运算思维",
+            "value": "MATH_LITERACY_03",
+            "key": "OPERATION_THINK",
+            "children": [
+              {
+                "title": "算法理解（1-2年级）",
+                "value": "SUB_07",
+                "key": "ALGORITHM",
+                "parentValue": "MATH_LITERACY_03",
+                "preSkills": ["SUB_01"]
+              },
+              {
+                "title": "运算策略（3-4年级）",
+                "value": "SUB_08",
+                "key": "STRATEGY",
+                "parentValue": "MATH_LITERACY_03",
+                "preSkills": ["SUB_07"]
+              },
+              {
+                "title": "灵活运算（5-6年级）",
+                "value": "SUB_09",
+                "key": "FLEX_CALC",
+                "parentValue": "MATH_LITERACY_03",
+                "preSkills": ["SUB_08"]
+              }
+            ]
+          },
+          {
+            "title": "数据意识",
+            "value": "MATH_LITERACY_04",
+            "key": "DATA_LITERACY",
+            "children": [
+              {
+                "title": "简单统计（3-4年级）",
+                "value": "SUB_10",
+                "key": "BASIC_STATS",
+                "parentValue": "MATH_LITERACY_04",
+                "preSkills": ["SUB_02"]
+              },
+              {
+                "title": "数据分析（5-6年级）",
+                "value": "SUB_11",
+                "key": "DATA_ANALYSIS",
+                "parentValue": "MATH_LITERACY_04",
+                "preSkills": ["SUB_10"]
+              }
+            ]
+          },
+          {
+            "title": "建模能力",
+            "value": "MATH_LITERACY_05",
+            "key": "MODELING",
+            "children": [
+              {
+                "title": "问题数学化（4-5年级）",
+                "value": "SUB_12",
+                "key": "PROBLEM_TRANS",
+                "parentValue": "MATH_LITERACY_05",
+                "preSkills": ["SUB_08", "SUB_05"]
+              },
+              {
+                "title": "模型构建（5-6年级）",
+                "value": "SUB_13",
+                "key": "MODEL_BUILD",
+                "parentValue": "MATH_LITERACY_05",
+                "preSkills": ["SUB_12"]
+              }
+            ]
+          }
+        ],
+        "title": "数学核心素养",
+        "value": "CORE_LITERACY",
+        "key": "ROOT"
+      },
+      {
+        "title": "素养关联体系",
+        "children": [
+          {
+            "title": "基础素养链",
+            "value": "CHAIN_01",
+            "path": ["SUB_01 → SUB_02 → SUB_03 → SUB_07 → SUB_08 → SUB_09"]
+          },
+          {
+            "title": "空间素养链",
+            "value": "CHAIN_02",
+            "path": ["SUB_04 → SUB_05 → SUB_06 → SUB_12"]
+          },
+          {
+            "title": "综合应用链",
+            "value": "CHAIN_03",
+            "path": ["SUB_09 + SUB_06 → SUB_13"]
+          }
+        ]
+      }
+    ]
+  }
+}

dsRag/Neo4j/文档.txt

@@ -0,0 +1,30 @@
+# Neo4J下载安装
+https://blog.csdn.net/weixin_44455665/article/details/141463014
+
+解压缩到：D:\neo4j-community-5.26.2\bin
+# 安装服务
+cd D:\neo4j-community-5.26.2\bin
+neo4j windows-service install
+neo4j start
+
+打开 conf/neo4j.conf 文件，修改以下配置：
+# 允许远程连接
+server.default_listen_address=0.0.0.0
+
+# 访问
+http://10.10.21.20:7474
+neo4j
+DsideaL4r5t6y7u
+
+密码默认：neo4j
+
+# 停止服务
+neo4j stop
+neo4j windows-service uninstall
+
+
+# 通过python操作neo4j
+https://blog.csdn.net/sinat_20471177/article/details/134056788
+
+# 提示词
+生成小学数学的所有知识点和能力点，我需要保存到cypher的脚本，如果过多无法一次性输出就只输出两个年级或三个年级的，我再追问后返回其余部分