# 知识向量化示例
knowledge_items = [
    "微服务拆分时，优先按业务边界划分，而不是技术栈",
    "数据库连接池大小 = (核心数 × 2) + 有效磁盘数",
    "Redis主从切换时，需要优雅处理正在执行的命令"
]

# 转换为向量
embeddings = model.encode(knowledge_items)

# 存储到向量数据库
vector_db.upsert(
    ids=["knowledge_001", "knowledge_002", "knowledge_003"],
    embeddings=embeddings,
    metadatas=[
        {"source": "架构评审会议", "expert": "张工", "date": "2024-03-15"},
        {"source": "性能优化文档", "expert": "李工", "date": "2024-02-20"},
        {"source": "故障复盘", "expert": "王工", "date": "2024-01-10"}
    ]
)

def calculate_knowledge_risk(expert):
    risk_score = 0
    
    # 离职风险
    if expert.retirement_eligible:
        risk_score += 40
    if expert.has_job_offer:
        risk_score += 30
    if expert.tenure > 10:
        risk_score += 10  # 资深员工更难替代
    
    # 知识独占性
    unique_knowledge = len(expert.exclusive_domains)
    risk_score += unique_knowledge * 10
    
    # 文档化程度
    if expert.documentation_coverage < 0.3:
        risk_score += 20
    
    return risk_score

# 会议后自动处理
class MeetingCapture:
    def process(self, meeting_record):
        # 1. 语音转文字
        transcript = self.speech_to_text(meeting_record.audio)
        
        # 2. 提取关键信息
        key_points = self.llm_extract(
            prompt="提取以下会议中的关键决策、技术方案和 rationale",
            content=transcript
        )
        
        # 3. 识别专家发言
        expert_segments = self.identify_expert_segments(
            transcript, 
            known_experts=["张工", "李工"]
        )
        
        # 4. 存储到知识库
        for segment in expert_segments:
            self.store_knowledge(
                content=segment.content,
                expert=segment.speaker,
                context={
                    "meeting_id": meeting_record.id,
                    "timestamp": segment.timestamp,
                    "related_decisions": key_points
                }
            )

# 从PR评论中提取知识
class CodeReviewCapture:
    def extract(self, pull_request):
        comments = pull_request.get_comments()
        
        for comment in comments:
            # 识别有价值的评论
            if self.is_knowledge_rich(comment):
                knowledge_item = {
                    "content": comment.body,
                    "expert": comment.author,
                    "code_context": comment.diff_context,
                    "topic": self.classify_topic(comment),
                    "principle": self.extract_principle(comment)
                }
                
                # 向量化并存储
                embedding = self.embed(knowledge_item["content"])
                vector_db.upsert(
                    id=f"cr_{pull_request.id}_{comment.id}",
                    embedding=embedding,
                    metadata=knowledge_item
                )

# 知识图谱实体和关系
entities = {
    "Concept": ["微服务", "连接池", "Redis", "熔断机制"],
    "Person": ["张工", "李工", "王工"],
    "Project": ["支付系统", "用户服务"],
    "Technology": ["MySQL", "PostgreSQL", "Redis Cluster"],
    "Decision": ["微服务拆分", "数据库选型"]
}

relations = [
    ("张工", "expert_in", "微服务"),
    ("微服务", "related_to", "连接池"),
    ("连接池", "problematic_with", "Redis脑裂"),
    ("支付系统", "uses", "Redis Cluster"),
    ("微服务拆分", "decided_by", "张工")
]

# 多层次向量化
class KnowledgeEmbedding:
    def embed(self, knowledge_item):
        # 1. 原始文本向量（语义相似性）
        text_vector = self.text_encoder(knowledge_item.content)
        
        # 2. 概念向量（主题分类）
        concept_vector = self.concept_encoder(
            knowledge_item.concepts
        )
        
        # 3. 上下文向量（情境信息）
        context_vector = self.context_encoder(
            project=knowledge_item.project,
            technology=knowledge_item.technology,
            timestamp=knowledge_item.timestamp
        )
        
        # 4. 融合向量
        fused_vector = self.fuse(
            text_vector, 
            concept_vector, 
            context_vector
        )
        
        return fused_vector

class ExpertKnowledgeBot:
    def answer(self, query):
        # 1. 查询向量化
        query_vector = self.embed(query)
        
        # 2. 语义检索
        candidates = vector_db.search(
            query_vector,
            top_k=10,
            filters={
                "expert": self.identify_relevant_experts(query),
                "date": "> 2023-01-01"  # 只检索近两年知识
            }
        )
        
        # 3. 重排序（考虑权威性、时效性）
        ranked = self.rerank(candidates, query)
        
        # 4. 生成回答（RAG）
        context = self.build_context(ranked[:5])
        answer = self.llm_generate(
            query=query,
            context=context,
            prompt="基于以下专家知识，回答用户问题。标注知识来源和时间。"
        )
        
        return {
            "answer": answer,
            "sources": [c.metadata for c in ranked[:5]],
            "confidence": self.calculate_confidence(ranked)
        }

class DecisionSupport:
    def analyze(self, proposed_decision):
        # 查找类似历史决策
        similar_decisions = self.find_similar_decisions(
            proposed_decision
        )
        
        # 提取相关经验教训
        lessons = self.extract_lessons_learned(similar_decisions)
        
        # 识别潜在风险
        risks = self.identify_risks(
            proposed_decision,
            historical_failures
        )
        
        # 生成建议
        recommendation = self.generate_recommendation(
            similar_decisions,
            lessons,
            risks
        )
        
        return {
            "recommendation": recommendation,
            "similar_cases": similar_decisions,
            "lessons_learned": lessons,
            "potential_risks": risks
        }

# 知识过期检测
class KnowledgeFreshness:
    def check(self, knowledge_item):
        # 技术知识半衰期（ empirically 2-3年）
        if knowledge_item.technology:
            half_life = 2.5  # years
        # 架构原则相对稳定
        elif knowledge_item.type == "architectural_principle":
            half_life = 5.0
        # 故障案例长期有效
        elif knowledge_item.type == "incident_lesson":
            half_life = 10.0
        
        age = (datetime.now() - knowledge_item.timestamp).years
        freshness = 0.5 ** (age / half_life)
        
        if freshness < 0.3:
            return "STALE", "需要专家验证"
        elif freshness < 0.7:
            return "AGING", "建议更新"
        else:
            return "FRESH", "正常"

# 多维度质量评估
class KnowledgeQuality:
    def evaluate(self, knowledge_item):
        scores = {
            # 准确性：专家验证、实际应用效果
            "accuracy": self.check_accuracy(knowledge_item),
            
            # 完整性：是否有足够上下文
            "completeness": self.check_completeness(knowledge_item),
            
            # 相关性：被检索和引用的频率
            "relevance": self.check_usage(knowledge_item),
            
            # 可追溯性：是否有明确来源
            "traceability": self.check_source(knowledge_item)
        }
        
        overall_score = sum(scores.values()) / len(scores)
        return overall_score, scores

# 1. 会议数据接入
from meeting_capture import MeetingProcessor

processor = MeetingProcessor(
    source="feishu",  # 或 "zoom", "teams"
    auto_process=True
)

# 2. 代码审查数据接入
from code_review_capture import PRProcessor

pr_processor = PRProcessor(
    github_token=os.getenv("GITHUB_TOKEN"),
    repos=["company/core-platform", "company/frontend"]
)

# 3. 故障数据接入
from incident_capture import IncidentProcessor

incident_processor = IncidentProcessor(
    source="pagerduty",  # 或 "jira"
    extract_lessons=True
)

from vector_store import KnowledgeVectorDB

# 初始化向量数据库
vdb = KnowledgeVectorDB(
    provider="pinecone",
    index_name="company-knowledge",
    dimension=3072  # text-embedding-3-large
)

# 处理并存储知识
for knowledge_item in captured_knowledge:
    # 生成嵌入
    embedding = embedding_model.encode(
        knowledge_item.content,
        task_type="retrieval_document"
    )
    
    # 存储
    vdb.upsert(
        id=knowledge_item.id,
        vector=embedding,
        metadata={
            "content": knowledge_item.content,
            "expert": knowledge_item.expert,
            "source": knowledge_item.source,
            "timestamp": knowledge_item.timestamp,
            "concepts": knowledge_item.concepts
        }
    )

from knowledge_bot import ExpertBot

# 初始化专家知识助手
bot = ExpertBot(vector_db=vdb)

# 使用示例
response = bot.answer(
    query="微服务拆分时应该考虑哪些因素？",
    expert_filter=["张工", "李工"],  # 可选：限定专家
    date_filter="> 2023-01-01"       # 可选：时间范围
)

print(response.answer)
print("来源：")
for source in response.sources:
    print(f"- {source.expert} ({source.date}): {source.context}")