# 1. 注册 LangSmith（https://smith.langchain.com）并获取 API Key
# 2. 设置环境变量

export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_API_KEY=ls__your_api_key_here
export LANGCHAIN_PROJECT=my-rag-project  # 可选，默认 "default"

import os

os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "ls__your_api_key_here"
os.environ["LANGCHAIN_PROJECT"] = "my-rag-project"

# 之后的所有 LangChain 调用都会自动上报到 LangSmith
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o")
chain = ChatPromptTemplate.from_template("解释{concept}") | llm

# 这次调用会自动出现在 LangSmith 的 Traces 页面
result = chain.invoke({"concept": "向量数据库"})

RAG Chain (3.2s | 1,847 tokens | $0.009)
├── Retriever (0.4s)
│   └── VectorSearch
│       Input:  "什么是向量数据库？"
│       Output: [doc1, doc2, doc3, doc4]
├── PromptTemplate (0ms)
│   Input:  {question: "...", context: "doc1\ndoc2..."}
│   Output: [SystemMessage, HumanMessage]
└── ChatOpenAI (2.8s | 1,847 tokens)
    Input:  [SystemMessage("你是..."), HumanMessage("...")]
    Output: AIMessage("向量数据库是...")
    Tokens: prompt=1,243, completion=604
    Cost:   $0.009

from langsmith import Client

client = Client()

# 给某次运行打分
client.create_feedback(
    run_id="run_id_from_trace",   # 从 Trace 页面复制
    key="quality",
    score=0.8,                    # 0-1
    comment="回答准确，但语气稍显生硬"
)

# 标注为正面/负面
client.create_feedback(
    run_id="run_id_from_trace",
    key="user_rating",
    value="positive"  # 或 "negative"
)

from langsmith import Client
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langsmith.evaluation import evaluate, LangChainStringEvaluator

client = Client()

# 1. 创建评估数据集
dataset = client.create_dataset(
    dataset_name="rag-quality-v1",
    description="RAG 问答质量评估数据集"
)

# 添加测试案例
examples = [
    {
        "inputs": {"question": "LangChain 的 LCEL 是什么？"},
        "outputs": {"answer": "LCEL 是 LangChain Expression Language，用于声明式构建链..."}
    },
    {
        "inputs": {"question": "如何给 LangChain 添加记忆？"},
        "outputs": {"answer": "可以使用 ConversationBufferMemory 或 ChatMessageHistory..."}
    },
]

client.create_examples(
    inputs=[e["inputs"] for e in examples],
    outputs=[e["outputs"] for e in examples],
    dataset_id=dataset.id
)

# 2. 定义被评估的链
def rag_chain_fn(inputs: dict) -> dict:
    """待评估的 RAG 链"""
    chain = (
        ChatPromptTemplate.from_template("基于你的知识回答：{question}")
        | ChatOpenAI(model="gpt-4o")
        | StrOutputParser()
    )
    answer = chain.invoke(inputs)
    return {"answer": answer}

# 3. 定义评估器
# 使用 LangChain 内置的 QA 评估器
qa_evaluator = LangChainStringEvaluator("qa")

# 自定义评估器：检查关键词
from langsmith.evaluation import run_evaluator

@run_evaluator
def keyword_evaluator(run, example) -> dict:
    """检查关键词是否在回答中"""
    answer = run.outputs.get("answer", "")
    reference = example.outputs.get("answer", "")

    # 提取参考答案中的关键词（简化版）
    keywords = [w for w in reference.split() if len(w) > 3][:5]
    hits = sum(1 for kw in keywords if kw in answer)
    score = hits / len(keywords) if keywords else 0.0

    return {"key": "keyword_recall", "score": score}

# 4. 运行批量评估
results = evaluate(
    rag_chain_fn,
    data=dataset.name,
    evaluators=[qa_evaluator, keyword_evaluator],
    experiment_prefix="gpt-4o-baseline",
    num_repetitions=1
)

print(results.to_pandas())

from langchain import hub

# 从 Hub 拉取社区 Prompt（无需 LangSmith 账号）
rag_prompt = hub.pull("rlm/rag-prompt")
print(rag_prompt.messages[0].prompt.template)

# 从 Hub 拉取自己的 Prompt（需要登录）
my_prompt = hub.pull("my-username/customer-service-v2")

# 在链中使用
chain = my_prompt | llm | StrOutputParser()

# 推送 Prompt 到 Hub
from langchain_core.prompts import ChatPromptTemplate

new_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是专业的客服助手，版本 3.0"),
    ("human", "{question}")
])

hub.push("my-username/customer-service-v3", new_prompt)

from langsmith import traceable, Client
from langsmith.run_helpers import get_current_run_tree

# 方法 1：@traceable 装饰器
@traceable(name="custom-preprocessing", run_type="chain")
def preprocess_query(query: str) -> str:
    """自定义预处理逻辑"""
    # 清理、规范化、扩展查询
    cleaned = query.strip().lower()
    expanded = f"{cleaned} 相关内容 技术文档"  # 查询扩展
    return expanded

@traceable(name="rerank-results", run_type="retriever")
def rerank_documents(query: str, docs: list) -> list:
    """文档重排序（自定义逻辑）"""
    # 用关键词相关性重排
    scored_docs = [
        (doc, sum(1 for kw in query.split() if kw in doc.page_content))
        for doc in docs
    ]
    return [doc for doc, _ in sorted(scored_docs, key=lambda x: -x[1])]

# 方法 2：上下文管理器
from langsmith.run_helpers import langsmith_trace

def complex_pipeline(query: str) -> str:
    with langsmith_trace(name="query-expansion") as run:
        expanded_query = preprocess_query(query)
        run.metadata["expansion_ratio"] = len(expanded_query) / len(query)

    docs = retriever.invoke(expanded_query)

    with langsmith_trace(name="reranking") as run:
        reranked_docs = rerank_documents(query, docs)
        run.metadata["docs_before"] = len(docs)
        run.metadata["docs_after"] = len(reranked_docs)

    return generate_answer(query, reranked_docs)