response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[fetch_url_tool, search_policy_tool, calculate_tool],
    messages=[{"role": "user", "content": "营改增对小微企业有什么影响？"}]
)

# tools/pgvector_query.py
from claude_agent_sdk import tool

@tool(
    name="pgvector_query",
    description="在 PostgreSQL pgvector 知识库中检索相关文档",
    input_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "查询文本"},
            "top_k": {"type": "integer", "default": 5},
        },
        "required": ["query"],
    },
)
async def pgvector_query(query: str, top_k: int = 5) -> dict:
    """实际的检索逻辑"""
    embedding = await embed_text(query)
    results = await db.fetch("""
        SELECT id, title, content, 1 - (embedding <=> $1) AS score
        FROM policies
        ORDER BY embedding <=> $1
        LIMIT $2
    """, embedding, top_k)

    return {"results": [dict(r) for r in results]}

# mcp_servers/policy_server.py
from mcp.server import Server
from mcp.types import Tool

app = Server("policy-server")

@app.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(name="pgvector_query", description="...", input_schema={...}),
        Tool(name="policy_search_by_date", description="...", input_schema={...}),
        Tool(name="policy_compare", description="...", input_schema={...}),
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "pgvector_query":
        return await pgvector_query(**arguments)
    # ...

from claude_agent_sdk import Agent

agent = Agent(
    name="policy-assistant",
    skills=[
        "policy-retrieval",
        "policy-compare",
        "policy-rag",
        "site-analyze",
        "tag-selection",
    ],
    mcp_servers=[
        "policy-server",    # 政策检索 / 对比
        "crawler-server",   # 爬虫
        "asset-server",     # 资源处理
        "ingest-server",    # 数据入库
        "persist-server",   # 持久化
    ],
    max_turns=25,
    timeout_s=1800,  # 30 分钟
)

# 单次执行
result = await agent.run(
    user_query="营改增对小微企业有什么影响？",
    session_id="user_123_session_456",
)

# tests/test_policy_retrieval.py
async def test_retrieval_basic():
    agent = Agent(skills=["policy-retrieval"])
    result = await agent.run("增值税小微企业")
    assert len(result["results"]) > 0
    assert all(r["score"] > 0.7 for r in result["results"])

{
  "success": False,
  "error_message": "向量库连接超时",
  "fallback_suggestion": "切换到 BM25 检索"
}

from langgraph.graph import StateGraph

# 政策对比 DAG
compare_graph = StateGraph()

compare_graph.add_node("fetch_a", fetch_policy_a)
compare_graph.add_node("fetch_b", fetch_policy_b)
compare_graph.add_node("extract_diff", extract_diff_sections)
compare_graph.add_node("render", render_comparison_table)

compare_graph.add_edge("fetch_a", "extract_diff")
compare_graph.add_edge("fetch_b", "extract_diff")
compare_graph.add_edge("extract_diff", "render")
compare_graph.set_finish_point("render")

# 编译后作为 LangGraph 节点嵌入 Claude Agent
compiled = compare_graph.compile()

agent = Agent(
    skills=["policy-retrieval", "policy-rag"],
    custom_nodes={
        "policy_compare": compiled,  # ← LangGraph 嵌入 Agent
    },
)

# mcp_servers/crawler_server.py
from mcp.server import Server
from mcp.types import Tool, TextContent

app = Server("crawler-server")


@app.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="fetch_url",
            description="通过爬虫抓取 URL 的 HTML 内容",
            input_schema={
                "type": "object",
                "properties": {
                    "url": {"type": "string"},
                    "render_js": {"type": "boolean", "default": True},
                },
                "required": ["url"],
            },
        ),
        Tool(
            name="parse_html",
            description="从 HTML 中提取结构化数据（CSS selector）",
            input_schema={
                "type": "object",
                "properties": {
                    "html": {"type": "string"},
                    "selectors": {"type": "object"},
                },
                "required": ["html", "selectors"},
            },
        ),
    ]


@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "fetch_url":
        url = arguments["url"]
        render_js = arguments.get("render_js", True)

        # 调用实际的爬虫
        async with crawler_semaphore:
            html = await crawler.fetch(url, render_js=render_js)
        return [TextContent(type="text", text=html)]

    elif name == "parse_html":
        # 解析逻辑
        from bs4 import BeautifulSoup
        soup = BeautifulSoup(arguments["html"], "html.parser")
        result = {}
        for key, selector in arguments["selectors"].items():
            elements = soup.select(selector)
            result[key] = [el.get_text(strip=True) for el in elements]
        return [TextContent(type="text", text=json.dumps(result))]

# config/skill_permissions.yaml
policy-retrieval:
  mcp_servers: [policy-server]
  tools: [pgvector_query, policy_search_by_date]

policy-compare:
  mcp_servers: [policy-server]
  tools: [pgvector_query, policy_compare]

site-analyze:
  mcp_servers: [crawler-server, policy-server]
  tools: [fetch_url, parse_html, pgvector_query]

crawler-skill:
  mcp_servers: [crawler-server, asset-server, ingest-server, persist-server]
  tools: [fetch_url, parse_html, download_asset, submit_policy, write_run_log]

from langsmith import traceable

@traceable(name="agent.session")
async def run_agent_session(session_id, query):
    # 自动 trace：每次 Skill 选择、Tool 调用、Token 消耗、延迟
    return await agent.run(query, session_id=session_id)

test_cases = [
    {
        "query": "营改增对小微企业的影响",
        "expected_skills": ["policy-retrieval", "policy-rag"],
        "expected_doc_ids": ["doc_001", "doc_003"],
        "expected_citation_accuracy": 0.9,
    },
    # ... 199 more
]

async def evaluate_agent(agent, test_cases):
    results = []
    for case in test_cases:
        result = await agent.run(case["query"])

        # 1. Skill 选择准确率
        skill_accuracy = compute_skill_accuracy(
            result["skills_used"], case["expected_skills"]
        )

        # 2. 引用准确率
        citation_accuracy = compute_citation_accuracy(
            result["citations"], case["expected_doc_ids"]
        )

        # 3. Ragas 评估
        ragas_score = await ragas_evaluate(result, case)

        results.append({
            "skill_accuracy": skill_accuracy,
            "citation_accuracy": citation_accuracy,
            "ragas_faithfulness": ragas_score["faithfulness"],
        })

    return aggregate_metrics(results)

async def execute_with_fallback(query, task_type):
    # 第 1 层：Agent（智能但慢 + 贵）
    try:
        return await agent.run(query)
    except AgentError:
        pass

    # 第 2 层：RAG 检索 + LLM 直接生成
    try:
        docs = await vector_search(query, top_k=5)
        context = "\n".join([d.content for d in docs])
        return await llm.complete(
            prompt=f"基于以下上下文：\n{context}\n\n回答：{query}"
        )
    except LLMError:
        pass

    # 第 3 层：纯检索结果（无 LLM 加工）
    docs = await vector_search(query, top_k=3)
    return {
        "answer": "未找到精确答案，以下是相关政策原文：",
        "documents": docs,
    }

import oss2
from dataclasses import dataclass

@dataclass
class UploadResult:
    url: str          # 签名 URL，Qwen-VL 直接消费
    object_key: str   # OSS 内部 key
    expire_at: int    # 过期时间戳


class VideoUploader:
    def __init__(self, access_key, secret_key, endpoint, bucket_name):
        auth = oss2.Auth(access_key, secret_key)
        self.bucket = oss2.Bucket(auth, endpoint, bucket_name)

    def upload(self, local_path: str, ttl: int = 3600) -> UploadResult:
        object_key = f"videos/{self._hash(local_path)}{Path(local_path).suffix}"
        # 简单上传（适合 <5GB）
        self.bucket.put_object_from_file(object_key, local_path)
        # 签名 URL（Qwen-VL 用）
        url = self.bucket.sign_url('GET', object_key, ttl)
        return UploadResult(
            url=url,
            object_key=object_key,
            expire_at=int(time.time()) + ttl,
        )

class SmartSplitter:
    MAX_DURATION = 6840  # 2 小时硬上限，留 5% buffer = 6840 秒

    def split(self, video_path: str) -> List[VideoChunk]:
        meta = self.get_metadata(video_path)

        # 1️⃣ 优先：按 MP4 章节切
        if meta.get('chapters'):
            return self.split_by_chapters(video_path)

        # 2️⃣ 次选：按静音段切
        if self._has_dense_silence(video_path):
            return self.split_by_silence(video_path)

        # 3️⃣ 兜底：按固定时长切
        return self.split_by_duration(video_path, chunk_seconds=6300)

class ASRService:
    def __init__(self):
        self.model = AutoModel(
            model="paraformer-zh",       # 中文 SOTA
            vad_model="fa-zh",           # 语音活动检测
            punc_model="ct-punc",        # 加标点
            spk_model="cam++",           # 说话人分离（多人课堂）
        )

    def transcribe(self, video_path: str) -> List[dict]:
        """返回带时间戳的转写结果"""
        audio_path = self.extract_audio(video_path)
        result = self.model.generate(
            audio_path,
            batch_size_s=300,    # 5 分钟一批
            return_timestamp=True,
        )
        return self._format_result(result)

    def extract_audio(self, video_path: str) -> str:
        """从视频中提取 16kHz 单声道 wav"""
        audio_path = str(Path(video_path).with_suffix('.wav'))
        subprocess.run([
            'ffmpeg', '-y', '-i', video_path,
            '-vn', '-acodec', 'pcm_s16le',
            '-ac', '1', '-ar', '16000',
            audio_path,
        ], check=True)
        return audio_path

class VideoUnderstandingPipeline:
    def __init__(self, qwen_client, asr_service, llm_client, max_concurrent=5):
        self.qwen = qwen_client
        self.asr = asr_service
        self.llm = llm_client
        self.semaphore = asyncio.Semaphore(max_concurrent)

    async def process(self, video_path: str, prompt: str) -> dict:
        # 1. 上传 OSS
        upload = self.uploader.upload(video_path)

        # 2. 切片
        chunks = self.splitter.smart_split(video_path)

        # 3. 并发处理（视觉 + 听觉并行）
        visual_tasks = [self._process_visual(c, prompt) for c in chunks]
        asr_result = self.asr.transcribe(video_path)  # 一次性转写

        visual_results = await asyncio.gather(*visual_tasks)

        # 4. 聚合（视觉摘要 + 语音文本 → 完整课程笔记）
        final = await self._aggregate(visual_results, asr_result, prompt)
        return final

    async def _aggregate(self, visual_results, asr_segments, prompt):
        """LLM 二次聚合：把分段摘要合并为完整理解"""
        sorted_visual = sorted(visual_results, key=lambda r: r.chunk_index)

        context_parts = []
        for vr in sorted_visual:
            ts_start = self._format_ts(vr.start_time)
            ts_end = self._format_ts(vr.end_time)
            context_parts.append(f"""
## 时间段 {ts_start} - {ts_end}

### 画面内容
{vr.visual_summary}

### 讲师讲解（ASR 转写）
{self._get_asr_for_range(asr_segments, vr.start_time, vr.end_time)}
""")

        context = "\n".join(context_parts)

        aggregate_prompt = f"""以下是按时间顺序排列的课程分段理解结果。
请合并为一份完整的、结构化的课程讲义，包含：
1. 课程主题与目标
2. 核心知识点（按时间顺序）
3. 关键概念定义
4. 课堂示例与演示
5. 课后要点总结

{prompt}

分段内容：
{context}
"""
        return await self.llm.completion(aggregate_prompt)

from celery import Celery

app = Celery('video_tasks', broker='redis://localhost:6379/0')

@app.task(bind=True, max_retries=3)
def process_video_task(self, video_id: str, prompt: str):
    try:
        pipeline = VideoUnderstandingPipeline(...)
        result = asyncio.run(pipeline.process(...))
        VideoResult.objects.filter(id=video_id).update(
            status='completed', result=result,
        )
        return result
    except Exception as exc:
        self.retry(exc=exc, countdown=60)