龍魂·语义测谎仪 v1.0 — 话术DNA追溯·意图深层分析

3天干完6个月的活,Claude把模型搬上AMD 一条挺刺激的消息:Anthropic 给投资人的材料里有一张幻灯片,写着它的 Claude Mythos Preview 只花了大约​,就摸清了怎么让另一个 Claude 模型在 AMD 的 MI355X 上跑起来。同一处还写了个对照数字:过去给一块新芯片做推理适配,通常要几十名工程师、​。3 天对 6 个月,这个比值太扎眼,当天中文互联网上就冒出一堆「英伟达的护城河塌了」的说法。我把能翻到的材料都翻了一遍,越看越觉得,塌掉的那一小块是真的,可塌的位置和很多人想的不一样。 阅读详情
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
╔══════════════════════════════════════════════════════════════════════════╗
║     🧬 龍魂·语义测谎仪 v1.0 — 话术DNA追溯·意图深层分析                     ║
║     Semantic Lie Detector · Beyond Surface Meaning                      ║
╠══════════════════════════════════════════════════════════════════════════╣
║  DNA: #龍芯⚡️2026-07-12-SEMANTIC-LIE-DETECTOR-v1.0                      ║
║  愿景: 2025年初心 — 人文系统就是测谎仪·给政府提供最好的反诈工具            ║
║  哲学:                                                                   ║
║    不只看字面意思 → 追溯本源记忆 → 跨会话DNA关联                            ║
║    好话标记 → 背后是否有营销手段 → 连环套识别                               ║
║    自夸标记 → 前后一致性校验 → 行为DNA比对                                 ║
║    自贬标记 → 是否操控同情 → 情感勒索检测                                   ║
║  铁律:                                                                   ║
║    不修改原文·下方追加审计备注·每条DNA嵌入·三色审计                         ║
║    不做政府的事·但给政府提供最好的反诈工具                                   ║
║    保护受害者·揭露连环套·追溯本源                                           ║
╚══════════════════════════════════════════════════════════════════════════╝

用法:
    # 分析一段话的深层意图
    python3 bin/lh_semantic_lie_detector.py analyze --text "这段话..."

    # 跨会话追踪一个人的话术一致性
    python3 bin/lh_semantic_lie_detector.py track --person "某人" --dna "#龍芯⚡️..."

    # 批量检测对话记录中的连环套
    python3 bin/lh_semantic_lie_detector.py scan --file 对话记录.json

    # 语义库扩充:添加新的检测维度
    python3 bin/lh_semantic_lie_detector.py expand --dimension 传销话术 --patterns patterns.json

    # 启动 API 服务
    python3 bin/lh_semantic_lie_detector.py serve --port 19624

    # 查看语义检测库统计
    python3 bin/lh_semantic_lie_detector.py stats
"""

import hashlib
import json
import os
import re
import sys
import time
from collections import defaultdict
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple, Set
from dataclasses import dataclass, asdict, field

LONGHUN_ROOT = Path(__file__).resolve().parent.parent

# ═══════════════════════════════════════════════════════════════
# 语义检测维度定义 — 测谎仪核心
# ═══════════════════════════════════════════════════════════════

DETECTION_DIMENSIONS = {
    # ── 自夸/自吹 ──
    "self_praise": {
        "name": "自我美化检测",
        "description": "检测过度美化自己、夸大能力、包装身份的话术",
        "risk_level": "medium",
        "patterns": [
            # 绝对化自夸
            r"我是(最|唯一|第一个|没人能)",
            r"只有我(能|会|可以|做得到)",
            r"除了我(没人|谁都|谁也)",
            r"全世界(只有我|就我能|就我会)",
            # 身份包装
            r"(多年|资深|顶级|首席|国际).{0,6}(专家|大师|导师|教练)",
            r"(前|原)(某|某某|大厂|国企|政府).{0,6}(高管|总监|负责人)",
            r"(国家级|国际级|世界级).{0,4}(认证|资质|头衔)",
            # 虚假背书
            r"(某某|某知名|某大佬).{0,6}(说|夸|认可|推荐|介绍)",
            r"(跟|和|与).{0,4}(名人|大V|明星|政要).{0,4}(合作|认识|熟)",
            # 数字夸大
            r"(月入|年入|赚了|收入)[0-9]{2,}(万|百万|千万|亿)",
            r"(轻松|躺|随便|闭眼).{0,4}(月入|日入|年入|赚)",
            r"(一天|一小时|几分钟).{0,4}(赚|挣|收入)[0-9]{2,}",
        ],
        "deep_analysis_hints": [
            "此人是否在不同场合说过不一致的自我介绍?",
            "自称的资历是否可以被公开验证?",
            "是否频繁更换身份标签?",
        ],
    },

    # ── 过度承诺 ──
    "over_promise": {
        "name": "过度承诺检测",
        "description": "检测不切实际的承诺、保底收益、零风险保证",
        "risk_level": "high",
        "patterns": [
            r"(保证|肯定|一定|绝对|100%|百分百).{0,6}(赚|赢|赚到|盈利|收益)",
            r"(稳赚|稳赢|稳拿|包赚|包赢)",
            r"(零风险|无风险|没风险|毫无风险)",
            r"(保底|兜底|最低).{0,6}(收益|回报|利息|分红)",
            r"(本金|投资).{0,6}(安全|保障|保险|保护)",
            r"(承诺|担保|保证).{0,6}(还|退|返|赔|回本)",
            r"(躺|睡|坐).{0,4}(赚|收|拿钱|分红|收益)",
            r"(不用|不需要|无需|不用你).{0,4}(做|干|操心|管理|经营)",
        ],
        "deep_analysis_hints": [
            "承诺的收益率是否远超市场正常水平?",
            "是否回避讨论风险?",
            "是否用'大家都赚了'制造从众压力?",
        ],
    },

    # ── 传销/金字塔 ──
    "pyramid_scheme": {
        "name": "传销/金字塔结构检测",
        "description": "检测多级分销、拉人头、金字塔结构的传销话术",
        "risk_level": "critical",
        "patterns": [
            r"(拉人|拉下线|发展|推荐).{0,4}(人头|下线|代理|会员|伙伴)",
            r"(层级|等级|级别|星级|钻石).{0,4}(代理|分销|合伙人|会员)",
            r"(下级|下线|团队|伞下).{0,4}(业绩|提成|返利|分红)",
            r"(躺赚|被动收入|管道收入|睡后收入)",
            r"(倍增|裂变|复制|几何).{0,4}(增长|收益|收入|财富)",
            r"(模式|制度|方案).{0,6}(独一无二|全球唯一|颠覆性)",
            r"(不是传销|合法直销|不是骗人|国家认可)",
            r"(早加入|先机|风口|红利|机会).{0,4}(赚钱|财富|成功)",
        ],
        "deep_analysis_hints": [
            "收入是否主要来自拉人头而非产品销售?",
            "是否有真实的、有竞争力的产品?",
            "是否强制要求购买入门产品?",
        ],
    },

    # ── 情感操控 ──
    "emotional_manipulation": {
        "name": "情感操控检测",
        "description": "检测利用同情、愧疚、恐惧、孤独等情绪操控他人的话术",
        "risk_level": "high",
        "patterns": [
            r"(可怜|同情|帮帮|救救).{0,4}(我|我们|一下)",
            r"(我这么|我为你|我付出).{0,6}(你却|你居然|你竟然)",
            r"(要不是|如果不是).{0,4}(为了你|因为你|帮你)",
            r"(错过|再不来|最后|仅剩|再不).{0,4}(机会|名额|时间|优惠)",
            r"(大家都|别人都|就你|只有你).{0,4}(没|不|还不)",
            r"(我这么惨|我这么可怜|我都这样了)",
            r"(你不帮我|你不理我|你不信我).{0,4}(就|就是|说明)",
            r"(你再不|再不来|再不行动).{0,4}(就来不及|就晚了|就没机会)",
        ],
        "deep_analysis_hints": [
            "此人是否反复使用同一套情感剧本?",
            "在不同人面前是否使用不同的受害者叙事?",
            "情感诉求后是否紧跟着利益要求?",
        ],
    },

    # ── 制造焦虑 ──
    "anxiety_creation": {
        "name": "焦虑制造检测",
        "description": "检测故意制造焦虑、恐慌、紧迫感来推动决策的话术",
        "risk_level": "medium",
        "patterns": [
            r"(再不|不赶紧|还不).{0,4}(就晚了|来不及|没机会|错过了)",
            r"(限时|限量|仅限|只有|仅剩).{0,4}(小时|天|份|名额|机会)",
            r"(马上|立刻|即将|马上要).{0,4}(涨价|关闭|结束|停止)",
            r"(别人都|周围人|同龄人).{0,4}(已经|早就|都在|全都)",
            r"(落后|掉队|被淘汰|被抛弃|被落下)",
            r"(未来|以后|再过).{0,4}(就晚了|就没机会|就来不及)",
            r"(通货膨胀|贬值|钱不值钱|现金贬值)",
            r"(再不买房|再不投资|再不行动).{0,4}(就|永远)",
        ],
        "deep_analysis_hints": [
            "制造的紧迫感是否有事实依据?",
            "限时/限量是否真实?还是永远在'最后一天'?",
            "是否用群体压力代替理性分析?",
        ],
    },

    # ── 虚假权威 ──
    "false_authority": {
        "name": "虚假权威检测",
        "description": "检测伪造或借用权威来增强说服力的话术",
        "risk_level": "high",
        "patterns": [
            r"(某某|某知名|某权威|某专家).{0,6}(说过|研究|证明|发现)",
            r"(科学研究|权威报告|最新研究).{0,6}(表明|显示|证明|发现)",
            r"(国家|政府|官方).{0,4}(认证|认可|背书|推荐|指定)",
            r"(央视|人民日报|新华社).{0,4}(报道|采访|推荐)",
            r"(哈佛|牛津|剑桥|清华|北大).{0,4}(研究|教授|博士|团队)",
            r"(专利|独家|首创).{0,4}(技术|配方|方法|发明)",
            r"(诺贝尔|奥斯卡).{0,4}(奖|提名|候选人)",
            r"(机密|内幕|内部).{0,4}(消息|资料|渠道|关系)",
        ],
        "deep_analysis_hints": [
            "引用的权威来源是否可以查证?",
            "是否有具体的论文/报道标题、日期、作者?",
            "'专利'是否可在中国专利局查询?",
        ],
    },

    # ── 模糊话术 ──
    "vague_tactics": {
        "name": "模糊话术检测",
        "description": "检测故意使用模糊、不可验证的表述来回避具体问题",
        "risk_level": "medium",
        "patterns": [
            r"(大概|差不多|基本上|应该是|好像是|可能是).{0,6}(能|可以|有|会)",
            r"(到时候|以后|将来|后面|之后).{0,4}(再说|再看|告诉你|解释)",
            r"(你懂的|不方便说|不好说|不能说).{0,4}(但是|不过|反正)",
            r"(具体|详细).{0,4}(不方便|不在这|私下|回头|后面)",
            r"(这个|那个|这些|那些).{0,4}(不方便|不好|不在这|不能说)",
            r"(靠关系|有人脉|有渠道|有资源).{0,4}(弄|搞|办|做)",
            r"(特殊|特别|额外).{0,4}(渠道|方法|关系|资源)",
        ],
        "deep_analysis_hints": [
            "被追问细节时是否反复使用'到时候再说'?",
            "是否总是把关键信息推到'以后'?",
            "模糊表述是否恰好避开了风险点?",
        ],
    },

    # ── 引导性消费 ──
    "guided_consumption": {
        "name": "引导性消费检测",
        "description": "检测引导性、诱导性、洗脑式消费话术",
        "risk_level": "high",
        "patterns": [
            r"(不买|不用|不吃|不试).{0,4}(后悔|可惜|亏了|损失)",
            r"(女人|男人|成功人士|有钱人|老板).{0,4}(都|一定|必须|应该)",
            r"(对自己好|爱自己|犒劳自己|奖励自己).{0,4}(就|就要|就得|必须)",
            r"(买了|用了|试了|吃了).{0,4}(变美|变年轻|变有钱|变成功)",
            r"(便宜|划算|超值|白菜价).{0,4}(不买|错过|亏了)",
            r"(原价|市场价|专柜价)[0-9]{2,}.*(现价|只要|仅需|只需)",
            r"(买一送|买二送|满减|满送|赠品|送).{0,4}(超值|划算|赚)",
            r"(这都不买|这都不要|这都不试).{0,4}(你|还|还等)",
        ],
        "deep_analysis_hints": [
            "是否用身份标签(成功人士都...)来施加压力?",
            "折扣是否真实?还是永远在'促销'?",
            "是否用情感绑架替代产品价值?",
        ],
    },

    # ── 前后矛盾追踪 ──
    "contradiction_tracking": {
        "name": "前后矛盾追踪",
        "description": "跨会话追踪同一人的话术一致性,标记前后矛盾",
        "risk_level": "high",
        "patterns": [
            # 这些不是正则,而是跨会话比对逻辑
        ],
        "deep_analysis_hints": [
            "同一人在不同时间说的话是否相互矛盾?",
            "身份/资历描述是否前后不一致?",
            "承诺的内容是否多次变更?",
        ],
        "cross_session": True,  # 需要跨会话记忆
    },

    # ── 连环套检测 ──
    "trap_chain": {
        "name": "连环套检测",
        "description": "检测渐进式诱导、步步为营的连环套话术序列",
        "risk_level": "critical",
        "patterns": [
            r"(先|第一步|首先|开始).{0,4}(试|体验|了解|看看|免费)",
            r"(然后|接下来|第二步|之后).{0,4}(升级|进阶|深度|正式)",
            r"(最后|终极|最终|顶级).{0,4}(方案|计划|项目|投资)",
            r"(小钱|少量|一点点|试试水).{0,4}(变|赚|翻|倍)",
            r"(交了|付了|投了).{0,4}(再|继续|还要|还得)",
            r"(这次|这回|现在).{0,4}(不一样|不同|特殊|特别)",
        ],
        "deep_analysis_hints": [
            "是否存在'免费→小钱→大钱→倾家荡产'的阶梯?",
            "每次升级的理由是否合理?还是制造新焦虑?",
            "是否有明确的退出机制?",
        ],
        "sequence_analysis": True,  # 需要序列分析
    },
}

# ═══════════════════════════════════════════════════════════════
# 风险等级映射
# ═══════════════════════════════════════════════════════════════

RISK_LEVELS = {
    "critical": {"score": 100, "color": "🔴", "label": "严重"},
    "high": {"score": 70, "color": "🟠", "label": "高危"},
    "medium": {"score": 40, "color": "🟡", "label": "中等"},
    "low": {"score": 10, "color": "🟢", "label": "低"},
}

# ═══════════════════════════════════════════════════════════════
# 数据存储路径
# ═══════════════════════════════════════════════════════════════

DATA_DIR = LONGHUN_ROOT / "L7_数据层" / "semantic_lie_detector"
DATA_DIR.mkdir(parents=True, exist_ok=True)

# 话术DNA数据库
PERSON_DNA_DB = DATA_DIR / "person_dna_db.json"
# 检测记录日志
DETECTION_LOG = DATA_DIR / "detection_log.jsonl"
# 语义库扩展
SEMANTIC_EXPANSIONS = DATA_DIR / "semantic_expansions.json"


@dataclass
class DetectionResult:
    """单次检测结果"""
    dimension: str
    dimension_name: str
    risk_level: str
    risk_color: str
    risk_score: int
    matched_pattern: str
    matched_text: str
    position: int  # 文本中的位置
    deep_analysis_questions: List[str] = field(default_factory=list)


@dataclass
class PersonDNA:
    """一个人的话术DNA档案"""
    person_id: str
    dna_trace: str
    first_seen: str
    last_seen: str
    total_interactions: int = 0
    self_praise_count: int = 0
    over_promise_count: int = 0
    emotional_manipulation_count: int = 0
    contradiction_count: int = 0
    trap_chain_sequences: List[List[str]] = field(default_factory=list)
    risk_history: List[Dict] = field(default_factory=list)
    statement_history: List[Dict] = field(default_factory=list)  # 历史发言
    overall_trust_score: float = 100.0  # 信任分 0-100


class SemanticLieDetector:
    """语义测谎仪核心引擎"""

    def __init__(self):
        self.dimensions = DETECTION_DIMENSIONS
        self.person_db = self._load_person_db()
        self.expansions = self._load_expansions()
        self._merge_expansions()

    def _load_person_db(self) -> Dict[str, PersonDNA]:
        """加载人员DNA数据库"""
        if PERSON_DNA_DB.exists():
            with open(PERSON_DNA_DB, "r") as f:
                data = json.load(f)
            return {k: PersonDNA(**v) for k, v in data.items()}
        return {}

    def _save_person_db(self):
        """保存人员DNA数据库"""
        with open(PERSON_DNA_DB, "w") as f:
            json.dump({k: asdict(v) for k, v in self.person_db.items()}, f, ensure_ascii=False, indent=2)

    def _load_expansions(self) -> Dict:
        """加载语义库扩展"""
        if SEMANTIC_EXPANSIONS.exists():
            with open(SEMANTIC_EXPANSIONS, "r") as f:
                return json.load(f)
        return {}

    def _merge_expansions(self):
        """合并扩展语义库到检测维度"""
        for dim_name, dim_data in self.expansions.get("dimensions", {}).items():
            if dim_name not in self.dimensions:
                self.dimensions[dim_name] = dim_data
            else:
                # 合并 patterns
                existing_patterns = set(self.dimensions[dim_name].get("patterns", []))
                new_patterns = set(dim_data.get("patterns", []))
                self.dimensions[dim_name]["patterns"] = list(existing_patterns | new_patterns)

    def analyze_text(self, text: str, person_id: Optional[str] = None,
                     dna_trace: Optional[str] = None) -> Dict[str, Any]:
        """
        分析一段文本的深层意图

        Args:
            text: 待分析文本
            person_id: 说话人标识(可选,用于跨会话追踪)
            dna_trace: DNA追溯码(可选)

        Returns:
            检测结果字典
        """
        results = []
        total_risk = 0
        max_risk_level = "low"

        for dim_name, dim_config in self.dimensions.items():
            patterns = dim_config.get("patterns", [])
            if not patterns:
                continue

            risk_level = dim_config.get("risk_level", "low")
            risk_info = RISK_LEVELS.get(risk_level, RISK_LEVELS["low"])

            for pattern in patterns:
                for match in re.finditer(pattern, text):
                    matched_text = match.group()
                    result = DetectionResult(
                        dimension=dim_name,
                        dimension_name=dim_config.get("name", dim_name),
                        risk_level=risk_level,
                        risk_color=risk_info["color"],
                        risk_score=risk_info["score"],
                        matched_pattern=pattern,
                        matched_text=matched_text,
                        position=match.start(),
                        deep_analysis_questions=dim_config.get("deep_analysis_hints", []),
                    )
                    results.append(asdict(result))
                    total_risk += risk_info["score"]

                    if RISK_LEVELS[risk_level]["score"] > RISK_LEVELS[max_risk_level]["score"]:
                        max_risk_level = risk_level

        # 去重:同一位置+同一维度的重复匹配
        seen = set()
        unique_results = []
        for r in results:
            key = (r["dimension"], r["position"])
            if key not in seen:
                seen.add(key)
                unique_results.append(r)

        # 计算综合风险分
        avg_risk = total_risk / len(unique_results) if unique_results else 0
        overall_risk = min(100, avg_risk * 1.5)  # 多维度叠加加权

        # 如果提供了 person_id,更新DNA档案
        if person_id:
            self._update_person_dna(person_id, dna_trace, text, unique_results)

        # 生成DNA
        analysis_dna = self._generate_analysis_dna(text, overall_risk)

        # 写入检测日志
        self._log_detection(text, unique_results, overall_risk, person_id, analysis_dna)

        return {
            "dna": analysis_dna,
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "text_length": len(text),
            "detections": unique_results,
            "total_detections": len(unique_results),
            "overall_risk_score": round(overall_risk, 1),
            "overall_risk_level": self._score_to_level(overall_risk),
            "risk_color": self._score_to_color(overall_risk),
            "dimensions_triggered": list(set(r["dimension"] for r in unique_results)),
            "person_id": person_id,
            "deep_analysis_recommendations": self._generate_recommendations(unique_results),
        }

    def _update_person_dna(self, person_id: str, dna_trace: Optional[str],
                           text: str, detections: List[Dict]):
        """更新人员DNA档案"""
        now = datetime.now(timezone.utc).isoformat()

        if person_id not in self.person_db:
            self.person_db[person_id] = PersonDNA(
                person_id=person_id,
                dna_trace=dna_trace or self._generate_dna_trace(person_id),
                first_seen=now,
                last_seen=now,
            )

        person = self.person_db[person_id]
        person.last_seen = now
        person.total_interactions += 1

        # 统计各类检测
        for d in detections:
            dim = d["dimension"]
            if dim == "self_praise":
                person.self_praise_count += 1
            elif dim == "over_promise":
                person.over_promise_count += 1
            elif dim == "emotional_manipulation":
                person.emotional_manipulation_count += 1
            elif dim == "contradiction_tracking":
                person.contradiction_count += 1

        # 记录风险历史
        risk_score = sum(d["risk_score"] for d in detections) / len(detections) if detections else 0
        person.risk_history.append({
            "time": now,
            "risk_score": round(risk_score, 1),
            "detections": len(detections),
            "text_preview": text[:100],
        })

        # 保存历史发言(用于前后矛盾检测)
        person.statement_history.append({
            "time": now,
            "text": text,
            "detections": len(detections),
            "dimensions": [d["dimension"] for d in detections],
        })

        # 前后矛盾检测
        self._check_contradictions(person, text)

        # 更新信任分
        person.overall_trust_score = self._calculate_trust_score(person)

        self._save_person_db()

    def _check_contradictions(self, person: PersonDNA, new_text: str):
        """检测前后矛盾"""
        if len(person.statement_history) < 2:
            return

        # 提取关键声明
        key_patterns = {
            "identity": r"(我是|我叫|我做|我在).{0,20}(的|行业|公司|单位)",
            "income": r"(收入|工资|赚|挣).{0,10}[0-9]{1,}",
            "location": r"(在|住|位于).{0,10}(北京|上海|广州|深圳|杭州|成都|武汉|南京|天津|重庆)",
            "age": r"[0-9]{2}(岁|年出生|年生)",
            "education": r"(大学|学院|毕业|学历|硕士|博士|本科)",
        }

        current_claims = {}
        for claim_type, pattern in key_patterns.items():
            match = re.search(pattern, new_text)
            if match:
                current_claims[claim_type] = match.group()

        # 与历史发言比对
        for past_statement in person.statement_history[:-1]:
            past_text = past_statement["text"]
            for claim_type, current_value in current_claims.items():
                past_match = re.search(key_patterns[claim_type], past_text)
                if past_match and past_match.group() != current_value:
                    person.contradiction_count += 1
                    break  # 只计一次

    def _calculate_trust_score(self, person: PersonDNA) -> float:
        """计算信任分"""
        score = 100.0

        # 各类检测扣分
        score -= person.self_praise_count * 3
        score -= person.over_promise_count * 5
        score -= person.emotional_manipulation_count * 8
        score -= person.contradiction_count * 10

        # 风险历史扣分
        recent_risks = [h for h in person.risk_history[-5:]]
        if recent_risks:
            avg_recent_risk = sum(h["risk_score"] for h in recent_risks) / len(recent_risks)
            score -= avg_recent_risk * 0.5

        return max(0, min(100, score))

    def track_person(self, person_id: str) -> Dict[str, Any]:
        """追踪一个人的话术一致性"""
        if person_id not in self.person_db:
            return {"error": f"未找到人员: {person_id}"}

        person = self.person_db[person_id]
        person_data = asdict(person)

        # 一致性分析
        consistency_analysis = {
            "total_statements": len(person.statement_history),
            "contradictions_found": person.contradiction_count,
            "trust_score": person.overall_trust_score,
            "risk_trend": self._analyze_risk_trend(person.risk_history),
            "key_warnings": [],
        }

        # 生成警告
        if person.self_praise_count > 3:
            consistency_analysis["key_warnings"].append(
                f"⚠️ 高频自夸:{person.self_praise_count}次自我美化")
        if person.over_promise_count > 2:
            consistency_analysis["key_warnings"].append(
                f"🚨 过度承诺:{person.over_promise_count}次不切实际承诺")
        if person.emotional_manipulation_count > 2:
            consistency_analysis["key_warnings"].append(
                f"🚨 情感操控:{person.emotional_manipulation_count}次情感操控")
        if person.contradiction_count > 0:
            consistency_analysis["key_warnings"].append(
                f"⚠️ 前后矛盾:{person.contradiction_count}处不一致")
        if person.overall_trust_score < 50:
            consistency_analysis["key_warnings"].append(
                f"🔴 信任分严重偏低:{person.overall_trust_score}/100")

        return {
            "person_id": person_id,
            "dna_trace": person.dna_trace,
            "first_seen": person.first_seen,
            "last_seen": person.last_seen,
            "total_interactions": person.total_interactions,
            "trust_score": person.overall_trust_score,
            "consistency_analysis": consistency_analysis,
            "detection_summary": {
                "self_praise": person.self_praise_count,
                "over_promise": person.over_promise_count,
                "emotional_manipulation": person.emotional_manipulation_count,
                "contradictions": person.contradiction_count,
            },
            "risk_history": person.risk_history[-10:],
            "statement_history": person.statement_history[-10:],
        }

    def _analyze_risk_trend(self, risk_history: List[Dict]) -> str:
        """分析风险趋势"""
        if len(risk_history) < 2:
            return "数据不足"
        recent = risk_history[-3:]
        older = risk_history[:-3] if len(risk_history) > 3 else risk_history[:1]
        recent_avg = sum(h["risk_score"] for h in recent) / len(recent)
        older_avg = sum(h["risk_score"] for h in older) / len(older)
        if recent_avg > older_avg * 1.3:
            return "📈 风险上升"
        elif recent_avg < older_avg * 0.7:
            return "📉 风险下降"
        else:
            return "➡️ 风险稳定"

    def expand_semantic_library(self, dimension_name: str,
                                 dimension_config: Dict) -> Dict[str, Any]:
        """扩充语义检测库"""
        if "expansions" not in self.expansions:
            self.expansions["expansions"] = {}
        if "dimensions" not in self.expansions:
            self.expansions["dimensions"] = {}

        self.expansions["dimensions"][dimension_name] = {
            "name": dimension_config.get("name", dimension_name),
            "description": dimension_config.get("description", ""),
            "risk_level": dimension_config.get("risk_level", "medium"),
            "patterns": dimension_config.get("patterns", []),
            "deep_analysis_hints": dimension_config.get("deep_analysis_hints", []),
            "added_at": datetime.now(timezone.utc).isoformat(),
            "dna": self._generate_dna_trace(f"expansion-{dimension_name}"),
        }

        with open(SEMANTIC_EXPANSIONS, "w") as f:
            json.dump(self.expansions, f, ensure_ascii=False, indent=2)

        self._merge_expansions()

        return {
            "status": "expanded",
            "dimension": dimension_name,
            "patterns_added": len(dimension_config.get("patterns", [])),
            "total_dimensions": len(self.dimensions),
        }

    def _generate_recommendations(self, detections: List[Dict]) -> List[str]:
        """生成深层分析建议"""
        recs = []
        dims = set(d["dimension"] for d in detections)

        if "pyramid_scheme" in dims:
            recs.append("🔴 检测到传销/金字塔话术特征 — 建议立即核查该主体的工商注册信息和行政处罚记录")
        if "over_promise" in dims:
            recs.append("🟠 检测到过度承诺 — 建议要求提供书面合同并仔细审查免责条款")
        if "emotional_manipulation" in dims:
            recs.append("🟠 检测到情感操控 — 建议暂停决策,与第三方独立人士商议")
        if "false_authority" in dims:
            recs.append("🟡 检测到疑似虚假权威引用 — 建议逐一核实引用的来源")
        if "guided_consumption" in dims:
            recs.append("🟠 检测到引导性消费话术 — 建议冷静48小时后再决策")
        if "trap_chain" in dims:
            recs.append("🔴 检测到连环套模式 — 强烈建议终止当前交易并保存全部聊天记录作为证据")
        if "anxiety_creation" in dims:
            recs.append("🟡 检测到焦虑制造 — 所有'限时'承诺都应视为营销策略")

        return recs

    def _generate_analysis_dna(self, text: str, risk_score: float) -> str:
        """生成分析DNA"""
        ts = datetime.now().strftime("%Y%m%d%H%M%S")
        text_hash = hashlib.sha256(text.encode()).hexdigest()[:12]
        return f"#龍芯⚡️{ts}-LIE-DETECT-{text_hash}-R{int(risk_score)}"

    def _generate_dna_trace(self, seed: str) -> str:
        """生成DNA追溯码"""
        ts = datetime.now().strftime("%Y%m%d%H%M%S")
        seed_hash = hashlib.sha256(seed.encode()).hexdigest()[:8]
        return f"#龍芯⚡️{ts}-PERSON-DNA-{seed_hash}"

    def _score_to_level(self, score: float) -> str:
        """分数转等级"""
        if score >= 70:
            return "严重"
        elif score >= 50:
            return "高危"
        elif score >= 30:
            return "中等"
        else:
            return "低"

    def _score_to_color(self, score: float) -> str:
        """分数转颜色"""
        if score >= 70:
            return "🔴"
        elif score >= 50:
            return "🟠"
        elif score >= 30:
            return "🟡"
        else:
            return "🟢"

    def _log_detection(self, text: str, detections: List[Dict],
                       risk_score: float, person_id: Optional[str], dna: str):
        """记录检测日志"""
        log_entry = {
            "time": datetime.now(timezone.utc).isoformat(),
            "dna": dna,
            "person_id": person_id,
            "text_preview": text[:200],
            "text_length": len(text),
            "detections_count": len(detections),
            "risk_score": round(risk_score, 1),
            "dimensions": list(set(d["dimension"] for d in detections)),
        }
        with open(DETECTION_LOG, "a") as f:
            f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")

    def get_stats(self) -> Dict[str, Any]:
        """获取系统统计"""
        total_detections = 0
        if DETECTION_LOG.exists():
            with open(DETECTION_LOG, "r") as f:
                total_detections = sum(1 for _ in f)

        return {
            "total_dimensions": len(self.dimensions),
            "total_patterns": sum(len(d.get("patterns", [])) for d in self.dimensions.values()),
            "total_detections_logged": total_detections,
            "persons_tracked": len(self.person_db),
            "dimensions_list": [
                {
                    "name": dim["name"],
                    "risk_level": dim.get("risk_level", "low"),
                    "patterns_count": len(dim.get("patterns", [])),
                }
                for dim in self.dimensions.values()
            ],
            "data_dir": str(DATA_DIR),
        }


# ═══════════════════════════════════════════════════════════════
# API 服务
# ═══════════════════════════════════════════════════════════════

def serve_api(port: int = 19624):
    """启动语义测谎仪 API 服务"""
    try:
        from flask import Flask, request, jsonify
    except ImportError:
        print("请安装 Flask: pip3 install flask")
        sys.exit(1)

    app = Flask(__name__)
    detector = SemanticLieDetector()

    @app.route("/health", methods=["GET"])
    def health():
        return jsonify({
            "status": "healthy",
            "service": "longhun-semantic-lie-detector",
            "version": "v1.0",
            "dna": "#龍芯⚡️2026-07-12-SEMANTIC-LIE-DETECTOR-v1.0",
            "dimensions": len(detector.dimensions),
        })

    @app.route("/analyze", methods=["POST"])
    def analyze():
        data = request.get_json(force=True)
        text = data.get("text", "")
        person_id = data.get("person_id")
        dna_trace = data.get("dna_trace")

        if not text:
            return jsonify({"error": "text 不能为空"}), 400

        result = detector.analyze_text(text, person_id, dna_trace)
        return jsonify(result)

    @app.route("/track/<person_id>", methods=["GET"])
    def track(person_id):
        result = detector.track_person(person_id)
        return jsonify(result)

    @app.route("/expand", methods=["POST"])
    def expand():
        data = request.get_json(force=True)
        dim_name = data.get("dimension")
        dim_config = data.get("config", {})

        if not dim_name:
            return jsonify({"error": "dimension 不能为空"}), 400

        result = detector.expand_semantic_library(dim_name, dim_config)
        return jsonify(result)

    @app.route("/stats", methods=["GET"])
    def stats():
        return jsonify(detector.get_stats())

    print(f"🧬 龍魂·语义测谎仪 API 启动在端口 {port}")
    print(f"   端点: http://localhost:{port}/health")
    print(f"   端点: http://localhost:{port}/analyze  [POST]")
    print(f"   端点: http://localhost:{port}/track/<person_id>  [GET]")
    print(f"   端点: http://localhost:{port}/expand  [POST]")
    print(f"   端点: http://localhost:{port}/stats  [GET]")
    app.run(host="0.0.0.0", port=port, debug=False)


# ═══════════════════════════════════════════════════════════════
# CLI
# ═══════════════════════════════════════════════════════════════

def main():
    import argparse

    parser = argparse.ArgumentParser(
        description="🧬 龍魂·语义测谎仪 — 话术DNA追溯·意图深层分析"
    )
    sub = parser.add_subparsers(dest="command")

    # analyze
    p_analyze = sub.add_parser("analyze", help="分析一段话的深层意图")
    p_analyze.add_argument("--text", required=True, help="待分析文本")
    p_analyze.add_argument("--person", help="说话人标识(用于跨会话追踪)")
    p_analyze.add_argument("--dna", help="DNA追溯码")

    # track
    p_track = sub.add_parser("track", help="追踪一个人的话术一致性")
    p_track.add_argument("--person", required=True, help="人员标识")

    # expand
    p_expand = sub.add_parser("expand", help="扩充语义检测库")
    p_expand.add_argument("--dimension", required=True, help="新维度名称")
    p_expand.add_argument("--patterns", required=True, help="正则模式JSON文件")

    # stats
    sub.add_parser("stats", help="查看语义检测库统计")

    # serve
    p_serve = sub.add_parser("serve", help="启动API服务")
    p_serve.add_argument("--port", type=int, default=19624, help="端口号")

    # scan
    p_scan = sub.add_parser("scan", help="批量扫描对话记录")
    p_scan.add_argument("--file", required=True, help="对话记录JSON文件")

    args = parser.parse_args()

    detector = SemanticLieDetector()

    if args.command == "analyze":
        result = detector.analyze_text(args.text, args.person, args.dna)
        print(json.dumps(result, ensure_ascii=False, indent=2))

    elif args.command == "track":
        result = detector.track_person(args.person)
        print(json.dumps(result, ensure_ascii=False, indent=2))

    elif args.command == "expand":
        with open(args.patterns, "r") as f:
            patterns_data = json.load(f)
        result = detector.expand_semantic_library(
            args.dimension,
            patterns_data
        )
        print(json.dumps(result, ensure_ascii=False, indent=2))

    elif args.command == "stats":
        stats = detector.get_stats()
        print(json.dumps(stats, ensure_ascii=False, indent=2))

    elif args.command == "serve":
        serve_api(args.port)

    elif args.command == "scan":
        with open(args.file, "r") as f:
            conversations = json.load(f)
        results = []
        for conv in conversations:
            r = detector.analyze_text(
                conv.get("text", ""),
                conv.get("person_id"),
                conv.get("dna_trace"),
            )
            results.append(r)
        print(json.dumps(results, ensure_ascii=False, indent=2))

    else:
        parser.print_help()


if __name__ == "__main__":
    main()
如何处理动态语言(Python / JS)的“隐形”调用链? 本文揭示动态语言(Python/JS)中静态AST解析导致调用链“断链”的核心问题,提出通过运行时追踪补全图谱的解决方案。基于Code-Graph-RAG的cgr trace机制,分别利用pytest插件与V8 Profiler捕获真实调用路径,将动态边合并至静态图谱,并在权重体系中提升动态边优先级。实践表明,该方法可显著提升图谱覆盖率,实现“结构+行为”双视角理解代码,为MCP与Rerank系统提供可靠支持。 阅读详情

相关推荐

Playwright: Pytest vs Library vs LibraryAsync:三者如何选?

Python中Playwright的3个Target:Pytest(推荐用于E2E自动化测试,支持报告、并行、重试)、Library(同步脚本,适合爬虫与简单任务,需手动管理浏览器)、LibraryAsync(异步脚本,适用于高并发批量操作)。选择依据:测试项目选Pytest,轻量脚本选Library,高并发场景选LibraryAsync。

SmallBull的博客 230

本地化部署 DeepSeek,构建单细胞与空间转录组 AI 分析平台

本地化部署 DeepSeek,构建单细胞与空间转录组 AI 分析平台

weixin_53637133的博客 187

Fluent温度超限调试:从能量方程到网格优化的实战指南

本文深入解析Fluent中温度超限问题的诊断与解决方法,从能量方程机制到网格优化策略,提供实战指南。通过分析温度与焓的换算关系,探讨典型场景如能量方程发散、局部网格质量差等,并给出五步调试法及高级命令应用,帮助工程师有效解决温度计算异常问题。

weixin_29045585的博客 531

【第 009 讲】全面掌握 Python 注释:注释的定义与作用 | 单行注释 | 三引号与多行注释 | 注释使用的最佳实践

本文系统讲解 Python 注释的完整知识体系:从注释的定义与作用讲起,梳理单行注释的书写位置、临时屏蔽用法与 PEP 8 排版规范,剖析注释被忽略的底层机制;进而说明三引号字符串的本质与嵌套问题;最后给出注释使用的三条实践原则,帮助读者写好可读性高的注释。

大模型全栈工程师 · Thanks_ks 1188

NVIDIA NCCL 源码解析:从XML拓扑到高性能通信图的构建

本文深入解析了NVIDIA NCCL如何将XML硬件拓扑文件转化为高性能通信图的核心过程。详细阐述了从创建CPU、GPU、NIC等节点,到建立PCIe、NVLink连接,再到计算链路带宽并进行关键排序的完整建图流程。该图是NCCL实现最优通信路径规划、充分发挥NVLink等高速互联性能的基石,直接影响分布式深度学习训练的效率。

convnet3designer的博客 310

保姆级教程:用杰理701N可视化SDK搞定ANC降噪配置(从工具到代码全流程)

本文提供了一份详细的杰理701N可视化SDK配置ANC降噪功能的教程,涵盖从开发环境搭建到代码集成的全流程。通过图形化工具和代码示例,帮助开发者快速掌握ANC参数配置技巧,优化降噪效果,解决常见问题。

weixin_30616969的博客 453

AI全栈实战 | 3.9-01 爬虫入门:requests 加 BeautifulSoup 三分钟跑通,但 90% 的人栽在这 4 个“礼貌“问题上

⚠️:本文内容仅用于。请遵守目标站点的服务条款与相关法律法规,不得对目标服务造成负担,不得采集、传播个人隐私数据。技术是中性的,边界在你手里。爬虫的入门技术(requests 发请求 + BeautifulSoup 解析)三分钟就能学会。真正区分"会用爬虫"和"会做爬虫的人"的,是这篇我们跑通"请求→解析→存储"的最小闭环,然后重点把"合规与礼貌"这根弦给你绷上。

源码获取 | 运行部署 | 定制二开修改,如果回复不及时请耐心等待,请见谅。 446

从12摄像头到纯视觉:小鹏AI鹰眼方案如何用LOFIC技术省掉激光雷达?

本文深入解析小鹏汽车AI鹰眼方案如何通过LOFIC技术实现纯视觉自动驾驶,替代传统激光雷达。LOFIC摄像头在动态范围、噪声控制和HDR优化方面表现卓越,结合800万像素双目广角摄像头,达到激光雷达级测距精度。该方案不仅降低成本,还提升系统可靠性和用户体验,展示了纯视觉路线的技术潜力与边界。

t8u9v0w1x的博客 936

Python 的 yield from 到底转发了什么:拆开 send、throw 和那个 return 值

很多人把yield from记成「省一层 for 循环的语法糖」。写和写,结果看着一样,于是就当它只是少敲几个字。这个理解会在三个地方翻车:调用方.send()的值送不进去、子生成器return的值拿不到、异常和close()传不下去。yield from真正做的事是,外层生成器退成一个透明通道。本文所有输出来自本机 CPython 3.13.14 实测。yield from不是循环,是委托——nextsendthrowclose四个方向的流量全部直通子生成器,并且子生成器return。

小小张说故事的博客 164

SSE 传输过程中,丢失空格和回车符,怎么解决?

Server - Sent Events(SSE)即服务器发送事件,是 HTML5 中的一项 Web API,用于实现服务器向客户端浏览器推送实时数据的功能。

938

提高RFID检测距离以及检测速度的方法总结

摘要:提高RFID检测距离需优化阅读器功率、标签灵敏度、天线设计及频段选择,同时减少环境干扰;提升检测速度则需改进防碰撞算法、增强并行处理能力、精简数据传输。实际应用需平衡两者关系,如物流仓储采用UHF频段、高增益天线和动态Q算法实现远距离高速读取,ETC系统则通过微波频段和高速调制实现超远距离快速识别。不同场景需针对性优化硬件配置和系统参数。

start_up_go的博客 294

从一段视频到可漫游的 4D 有声场景:思路拆解与最小复现手记

只需一段手机视频,你就能生成可"走进去"的 4D 有声场景:转头时狗叫声方向随之变化,走近时声音更清晰。本文拆解 Video-to-4DAVScene 的核心思路,手把手带你用几十行 Python 搭出最小管线,把视频中的运动物体变成带空间位置的声源,并附上三个真实踩坑的排障经验,代码可直接跑。🎧

helloagent的博客 246

8、音频运行时系统的架构设计

本文深入探讨了音频运行时系统的分层设计及其优势,包括逻辑层和物理层的功能划分。通过分层设计,开发者可以更轻松地管理和优化音频资源,确保其在不同平台上的高效运行。文章还介绍了平台适配与优化、错误处理与调试以及未来发展方向等内容,为开发者提供了宝贵的参考和指导。

juice的博客 463

【每天一个 Python 小案例30】Python 基础知识综合小项目:我的工具盒

作为系列收官,本篇把前 29 篇的知识点合成一个能直接用的命令行工具"我的工具盒":计算器(用 ast 解析表达式,不碰 eval)、单位换算与温度转换(一张换算表 + 特例分支)、记账与分类统计(Decimal + JSON 持久化)、以及用"字典当命令表"把菜单和业务逻辑解耦的主循环。文中对比了 eval 的安全隐患与 ast 白名单的做法,解释了 lambda 闭包在字典里的写法与晚绑定陷阱,并在最后给出整个系列的知识地图,把变量、数据结构、控制流、函数、类、异常、文件、标准库八块内容对应到具体篇目。

xinjiyaya的博客 432

29.Labview界面设计 --- (下篇)自定义控件库、界面布局与外观设计

1.自定义控件外观(自定义控件)1.1 自定义外观库1.2 手动自定义控件外观2. 前面板控件布局方式(控件排布)2.1 模块化控制布局方式2.2 数据采集布局方式3. 前面板外观优化项(背景设计)3.1 前面板背景设计3.2 前面板窗口整理本节第一部分教大家安装一种可以直接用的自定义控件库,第二部分教大家如何自己设计控件并保存调用。

关注我,更多技术问题欢迎私聊~ 4783

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

双路径优化+双容差校准

默认使用向量化路径处理常规数据,当检测到内存非连续或需要极致短路性能时,自动切换至 Numba JIT 路径。“当 CI 宽度中位数为 $W$ 时,实际判定容差为 $10^{-12} + 10^{-9} \times W$"针对表征谱算子 2 的实际输出量纲(例如 $10^{-3}$ 至 $10^3$),调整。准确标记了哪些数组被复制。非短路、静默拷贝风险、量纲耦合容差),本方案重构了核心逻辑。,并完善审计元数据以记录内存拷贝状态。, 确保在不同量纲下判定标准的一致性。,否则需排查上游数据生成逻辑。

2301_77211362的博客 208

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

yolo 和 deft 算法的区别

你应该是打错了:是,不是 defrat;

曾大强博客 290

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级 备考:莫队算法离线区间查询详解

备赛进行时:第十八届蓝桥杯软件赛报名已于 2026-10-08 10:00 开启、12-18 14:00 截止,省赛定在 2027-04-10(C/C++·Python 程序设计 9:00–13:00);中国电子学会 2026 年 12 月软件编程(C/C++ 一级至十级、Python 一级至六级)考级报名 9/23–12/2 16:00、统考 12-12;全国青少年信息素养大赛 2026—2027 赛季算法应用主题赛也已进入复盘练兵窗口。

IT_Scratch的博客 185

两张表合并之后,行数悄悄多了一倍

pandas merge 行数异常膨胀源于右表键不唯一,导致数据静默复制。实测显示,未聚合的右表(756行)与左表合并后行数增至504行,合计膨胀3.5倍,但无报错。validate 参数仅在检查键唯一性时有效,one_to_one 和 many_to_one 可拦截问题,但需结合 duplicated() 前置检查。正确做法为先按键聚合右表,再合并,避免重复。建议合并前后核对行数、合计,并使用 indicator=True 排查匹配情况,确保数据一致性。

patrickstar231的博客 252

我用 200 行代码写了个“代码屎山检测器“,扫完公司的老项目后我沉默了

这个工具不能帮你把屎山铲平,但至少能让你知道自己面对的是多大的山,也能在代码评审时用数据说话——“这个 PR 把圈复杂度从 12 推到了 18,能不能拆一下?毕竟,不能量化的东西,就没法改进。

xixiaoyunya的博客 277

智慧农业实战:育秧车间秧盘计数与苗情分级的Python实现

首先,建立统一的数据结构,保存每盘秧苗的编号、批次、覆盖度、叶色得分和播种天数。A = "壮苗"B = "合格苗"C = "弱苗"@dataclassdays: int。

荆棘鸟智能的博客 138

Java Arrays.asList 常见坑详解|UnsupportedOperationException、数组联动、基本类型 bug

解析 Arrays.asList 常见开发陷阱,演示 UnsupportedOperationException、底层数组引用共享、基本类型数组问题,区分 Arrays 内部 ArrayList 与 java.util.ArrayList,给出数组转 List 的各种场景正确代码。

weixin_42617033的博客 511

【每天一个 Python 小案例29】Python 实现商品购物车

本篇实现一个购物车:商品目录、加入商品、修改数量、移除商品、查看小计、计算满减与 VIP 折扣、结算扣库存。核心设计是"目录与购物车分离"——目录存商品主数据,购物车只存 {商品编号: 数量};金额一律用 Decimal 并做 ROUND_HALF_UP 舍入。折扣部分讲清阶梯满减的匹配顺序(阈值从高到低、命中即停)与叠加顺序(先满减、后打折),并用一次完整结算演示 706 元如何变成 613.70 元。

xinjiyaya的博客 220

Python的字典

Python字典是存储键值对的数据结构,通过键(key)快速查找对应的值(value)。可使用{}定义,支持增删改查操作:通过dict[key]查询或修改值,get()方法安全获取并设置默认值,del dict[key]删除键值对,keys()、values()和items()用于遍历。items()结合双变量循环可高效遍历所有键值对,提升代码可读性与灵活性。

qq_43010954的博客 199

黄仁勋走了,护城河留下了什么

11 月 12 日,英伟达董事会批准黄仁勋辞去总裁、CEO 和董事职务,即刻生效,CFO 克雷斯出任临时 CEO;股价开盘一度跌 14.35%,收盘只跌 4.34%,市值单日蒸发 1820 亿美元;本文把「创始人走了护城河就没了」这个流行说法拆开——CUDA 还在,但 CUDA 正在被 Claude 三天凿穿,真正决定下一段路的是三个可以核对的东西:治理结构、决策机制、以及下一个百亿美元由谁拍板。

领码SPARK - 以无代码之星火,燎原数字之未来! 189

基于深度学习的工业表面缺陷检测系统-毕业设计

只用正常样本训练的工业表面缺陷检测系统:15 类工业品、5354 张图、73 种缺陷。PatchCore-lite 图像级 AUROC 0.896、像素级 0.951,单张 CPU 推理 115 毫秒;附 PaDiM 与整图基线对照,含 Django 系统、论文与使用文档。

csbysj2020 211
上一篇: 龍魂国家级监管透明API · 加密透明架构 v1.0
下一篇: 龍魂语义测谎仪 v2.0:识别营销话术的四种“隐身术“
龍芯北辰UID9622
博客等级 码龄164天 5粉丝 501原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值