from langchain.text_splitter import RecursiveCharacterTextSplitter

# 推荐起始配置
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=400,          # 推荐起始值（tokens）
    chunk_overlap=50,         # 10-20%的重叠，保持连续性
    separators=["\n\n", "\n", ".", " ", ""],  # 层级分隔符
    length_function=len
)

import numpy as np
from sentence_transformers import SentenceTransformer

def semantic_chunk(text, threshold=0.85):
    """
    语义分块核心逻辑：
    1. 将文档切分为句子
    2. 计算相邻句子的语义相似度
    3. 当相似度低于阈值时，在此分割
    """
    model = SentenceTransformer('all-MiniLM-L6-v2')
    sentences = split_into_sentences(text)
    embeddings = model.encode(sentences)
    
    chunks = []
    current_chunk = [sentences[0]]
    
    for i in range(1, len(sentences)):
        similarity = cosine_similarity(
            embeddings[i-1], embeddings[i]
        )
        
        if similarity >= threshold:
            current_chunk.append(sentences[i])
        else:
            chunks.append(" ".join(current_chunk))
            current_chunk = [sentences[i]]
    
    if current_chunk:
        chunks.append(" ".join(current_chunk))
    
    return chunks

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever
from langchain_community.vectorstores import FAISS

# 1. 初始化稀疏检索器（BM25）
bm25_retriever = BM25Retriever.from_documents(documents)
bm25_retriever.k = 5

# 2. 初始化稠密检索器（向量存储）
faiss_vectorstore = FAISS.from_documents(documents, embedding_model)
faiss_retriever = faiss_vectorstore.as_retriever(
    search_kwargs={"k": 5}
)

# 3. 使用RRF（Reciprocal Rank Fusion）融合
# 权重配置：30%关键词，70%语义（可根据场景调整）
ensemble_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, faiss_retriever],
    weights=[0.3, 0.7]
)

def two_stage_retrieval(query, initial_k=50, final_k=10):
    """
    第一阶段：HNSW快速召回Top-K候选
    第二阶段：Cross-Encoder精排
    """
    
    # 阶段1：使用HNSW快速检索候选文档
    initial_results = vector_store.hnsw_search(
        query_vector=embed(query),
        k=initial_k
    )
    
    # 阶段2：使用Cross-Encoder重排序
    # Cohere/BGE-reranker等模型可显著提升排序质量
    reranked = reranker.rerank(
        query=query,
        documents=[r.content for r in initial_results],
        top_n=final_k
    )
    
    return reranked

# 使用Faiss的HNSW索引（分层可导航小世界图）
import faiss

# 创建HNSW索引
d = 1536  # 向量维度
M = 32     # 每个节点的连接数（影响精度/速度）
efConstruction = 200  # 构建时的搜索深度

index = faiss.IndexHNSWFlat(d, M)
index.hnsw.efConstruction = efConstruction

# 查询时设置搜索深度（影响精度/速度）
index.hnsw.efSearch = 128  # 推荐值64-256

# Rowen核心流程伪代码

def rowen_hallucination_mitigation(query, initial_response):
    """
    1. 一致性检测：评估模型响应的语义一致性
    2. 若不确定性高，激活外部检索修正
    3. 修复幻觉内容后输出最终答案
    """
    
    # 生成多个视角的响应（跨语言/跨模型）
    responses = generate_multiperspective(initial_response)
    
    # 计算一致性得分Z
    consistency_score = calculate_consistency(responses)
    
    if consistency_score < threshold:
        # 检测到可能的幻觉，触发检索增强
        evidence = retrieve_external_knowledge(query)
        corrected = repair_hallucination(initial_response, evidence)
        return corrected
    
    return initial_response

def verify_answer(answer, source_documents):
    """溯源校验，抑制幻觉 - 生产级实现"""
    verify_llm = ChatOpenAI(model_name="gpt-4", temperature=0.1)
    
    verify_prompt = f"""请作为校验员，核对以下回答的每一个结论，
确认是否能在检索结果中找到对应依据。

回答：{answer}

检索结果：{[doc.page_content for doc in source_documents]}

输出要求：
1. 逐句核对，每个结论标注"有依据"或"无依据"
2. 删除所有无依据的结论
3. 若全部有依据，保留原回答"""
    
    verified_answer = verify_llm.predict(verify_prompt)
    return verified_answer

from ragas import evaluate
from ragas.metrics import (
    faithfulness, 
    answer_relevancy,
    context_precision,
    context_recall
)

# 使用RAGAS框架进行自动化评估
result = evaluate(
    dataset=test_dataset,
    metrics=[
        faithfulness,          # 忠实度：答案是否基于上下文
        answer_relevancy,     # 答案相关性：回答是否切题
        context_precision,    # 上下文精确率
        context_recall        # 上下文召回率
    ]
)

# 多级缓存策略（LangChain v1.8 + Redis v7.0）

# 1. 启用查询缓存
cache_type = "redis"
cache_config = {
    "redis_url": "redis://localhost:6379",
    "ttl": 3600  # 缓存1小时
}

# 2. 嵌入缓存（避免重复计算）
embeddings = CacheBackedEmbeddings(
    from_bytesstore=RedisByteStore(),
    document_embedder=embedding_model
)

# 效果：生产环境查询延迟降低70%