From 321a6483b9cd0b09e421fa5ccbe0273bfa005161 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=90=B4=E9=97=AE=E6=B6=B5?= <harry@Sileryde.local>
Date: Sat, 28 Mar 2026 22:04:34 +0800
Subject: [PATCH] =?UTF-8?q?Initial=20commit:=20=E6=85=A7=E7=9C=BC=E5=AA=92?=
 =?UTF-8?q?=E4=BD=93=E5=86=85=E5=AE=B9=E7=9C=9F=E5=AE=9E=E6=80=A7=E6=A3=80?=
 =?UTF-8?q?=E6=B5=8B=20API?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .env.example     |    2 +
 .gitignore       |   28 +
 README.md        |   57 ++
 main.py          | 1471 ++++++++++++++++++++++++++++++++++++++++++++++
 requirements.txt |    9 +
 5 files changed, 1567 insertions(+)
 create mode 100644 .env.example
 create mode 100644 .gitignore
 create mode 100644 README.md
 create mode 100644 main.py
 create mode 100644 requirements.txt

diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..48875ad
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,2 @@
+# DeepSeek API Key
+DEEPSEEK_API_KEY=your_api_key_here
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..91b8567
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,28 @@
+# Environment variables
+.env
+*.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+.venv/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Dependencies
+*.egg-info/
+dist/
+build/
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..1128147
--- /dev/null
+++ b/README.md
@@ -0,0 +1,57 @@
+# 慧眼 - 媒体内容真实性检测 API
+
+帮助老年人识别网络虚假信息的分析后端。
+
+## 功能
+
+- 支持微信公众号文章链接分析
+- 支持抖音视频内容分析
+- 支持纯文本内容分析
+- ARG（可接受性-相关性-充分性）逻辑分析框架
+- 网络搜索辅助验证（新闻类内容）
+- 实时调试输出
+
+## 安装
+
+```bash
+cd backend
+pip install -r requirements.txt
+```
+
+## 配置
+
+创建 `.env` 文件：
+
+```
+DEEPSEEK_API_KEY=你的DeepSeek_API密钥
+```
+
+## 运行
+
+```bash
+cd backend
+uvicorn main:app --host 0.0.0.0 --port 8000
+```
+
+## API 端点
+
+- `GET /` - API 状态
+- `GET /test` - 测试页面
+- `POST /analyze` - 分析内容
+
+## 请求示例
+
+```bash
+curl -X POST http://localhost:8000/analyze \
+  -H "Content-Type: application/json" \
+  -d '{"url": "https://mp.weixin.qq.com/s/xxx"}'
+```
+
+## 分析流程
+
+1. 提取系统时间
+2. 判断文章类型
+3. 网络搜索（新闻类）
+4. 建立逻辑链
+5. ARG 三重验证
+6. 最终判断
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..54e2a14
--- /dev/null
+++ b/main.py
@@ -0,0 +1,1471 @@
+import os
+import re
+from typing import Optional, List
+import asyncio
+import json
+
+import httpx
+from fastapi.responses import StreamingResponse, HTMLResponse
+from openai import OpenAI
+from bs4 import BeautifulSoup
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+try:
+    from f2.apps.douyin import DouyinAwemeIdFetcher, DouyinHandler
+    DOUYIN_AVAILABLE = True
+except ImportError:
+    DOUYIN_AVAILABLE = False
+
+load_dotenv()
+
+app = FastAPI(title="Media Filter API", description="Help elderly identify misleading content")
+
+# Allow cross-origin requests from mobile app
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize DeepSeek client (OpenAI-compatible)
+client = OpenAI(
+    api_key=os.getenv("DEEPSEEK_API_KEY"),
+    base_url="https://api.deepseek.com"
+)
+
+
+class AnalyzeRequest(BaseModel):
+    url: Optional[str] = None
+    text: Optional[str] = None  # Allow direct text input as fallback
+
+
+class AnalyzeResponse(BaseModel):
+    title: str
+    verdict: str  # "reliable", "caution", "misleading"
+    verdict_emoji: str
+    summary: str
+    details: str
+    original_text: str
+    article_type: str = ""
+    search_info: str = ""
+    debug_steps: list = []  # 存放所有 AI 原始输出
+
+
+class ChatMessage(BaseModel):
+    role: str  # "user" or "assistant"
+    content: str
+
+
+class ChatRequest(BaseModel):
+    messages: List[ChatMessage]
+    title: Optional[str] = None
+    original_text: Optional[str] = None
+    analysis_summary: Optional[str] = None
+    analysis_details: Optional[str] = None
+
+def search_web(query: str) -> str:
+    """联网搜索信息，使用 Jina AI 读取网页"""
+    try:
+        # 使用 Jina AI Reader 来读取新闻网站
+        # 先尝试读取 Bing 搜索结果
+        search_urls = [
+            f"https://www.bing.com/search?q={query}",
+            f"https://news.google.com/search?q={query}",
+        ]
+        
+        for search_url in search_urls:
+            try:
+                jina_url = f"https://r.jina.ai/{search_url}"
+                with httpx.Client(timeout=25.0) as http:
+                    resp = http.get(jina_url)
+                    if resp.status_code == 200:
+                        content = resp.text
+                        # 提取标题和内容
+                        lines = content.split('\n')
+                        results = []
+                        for line in lines[:20]:
+                            if line.strip() and len(line.strip()) > 10:
+                                results.append(line.strip())
+                        if results:
+                            return "\n".join(results[:10])
+            except Exception:
+                continue
+        
+        return "未能获取搜索结果"
+            
+    except Exception as e:
+        return f"搜索失败: {str(e)}"
+
+async def extract_wechat_article(url: str) -> dict:
+    """Extract content from WeChat Official Account article."""
+    headers = {
+        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.38"
+    }
+
+    async with httpx.AsyncClient(follow_redirects=True, timeout=30.0) as http_client:
+        response = await http_client.get(url, headers=headers)
+        response.raise_for_status()
+        html = response.text
+
+    soup = BeautifulSoup(html, "lxml")
+
+    # Extract title
+    title = ""
+    title_elem = soup.find("h1", class_="rich_media_title") or soup.find("h1")
+    if title_elem:
+        title = title_elem.get_text(strip=True)
+
+    # Extract main content
+    content = ""
+    content_elem = soup.find("div", class_="rich_media_content") or soup.find("div", id="js_content")
+    if content_elem:
+        # Get text, preserving some structure
+        content = content_elem.get_text(separator="\n", strip=True)
+
+    # Extract author/account name
+    author = ""
+    author_elem = soup.find("a", class_="weui-wa-hotarea") or soup.find("span", class_="rich_media_meta_nickname")
+    if author_elem:
+        author = author_elem.get_text(strip=True)
+
+    if not content:
+        raise HTTPException(status_code=400, detail="无法提取文章内容，请检查链接是否正确")
+
+    return {
+        "title": title or "未知标题",
+        "content": content[:8000],  # Limit content length for LLM
+        "author": author or "未知来源",
+    }
+
+
+async def extract_douyin_video(url: str) -> dict:
+    """Extract content from Douyin video."""
+    if not DOUYIN_AVAILABLE:
+        raise HTTPException(
+            status_code=400,
+            detail="Douyin支持尚未配置，请安装F2库"
+        )
+
+    try:
+        # Extract video ID from URL
+        video_id = DouyinAwemeIdFetcher.get_aweme_id(url)
+        if not video_id:
+            raise HTTPException(status_code=400, detail="无法识别抖音视频链接")
+
+        # Fetch video data
+        handler = DouyinHandler()
+        video_data = await handler.fetch_one_video(video_id)
+
+        # Extract description and comments
+        title = video_data.desc or "抖音视频"
+        content = video_data.desc or ""
+        author = video_data.author.nickname if video_data.author else "未知用户"
+
+        # TODO: Future enhancement - extract audio and transcribe for full content
+        if not content:
+            raise HTTPException(
+                status_code=400,
+                detail="无法提取视频内容，请检查链接是否有效"
+            )
+
+        return {
+            "title": title[:200],  # Limit title
+            "content": content[:8000],  # Limit content length for LLM
+            "author": author,
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=400,
+            detail=f"无法提取抖音视频内容: {str(e)}"
+        )
+
+
+def parse_logic_chain_to_tree(logic_chain_text: str) -> dict:
+    """将逻辑链文本解析为树形结构"""
+    tree = {
+        "nodes": {},  # 节点ID -> 节点内容
+        "edges": [],   # 边: [from_id, to_id, type]
+        "original_text": logic_chain_text
+    }
+    
+    lines = logic_chain_text.strip().split('\n')
+    node_counter = 0
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        # 提取依据
+        evidence_match = re.search(r'依据(\d+)[：:]\s*(.+)', line)
+        if evidence_match:
+            node_id = f"E{evidence_match.group(1)}"
+            node_content = evidence_match.group(2).strip()
+            tree["nodes"][node_id] = {"type": "evidence", "content": node_content}
+            continue
+        
+        # 提取结论（箭头后面的内容）
+        conclusion_match = re.search(r'→\s*(.+)', line)
+        if conclusion_match:
+            node_id = f"C{node_counter}"
+            node_content = conclusion_match.group(1).strip()
+            tree["nodes"][node_id] = {"type": "conclusion", "content": node_content}
+            node_counter += 1
+            
+            # 解析箭头左边的依据
+            arrow_left = line.split('→')[0].strip()
+            if '+' in arrow_left:
+                # A + B → C
+                sources = arrow_left.split('+')
+                for src in sources:
+                    src = src.strip()
+                    tree["edges"].append([src, node_id, "support"])
+            else:
+                # A → B
+                tree["edges"].append([arrow_left.strip(), node_id, "support"])
+    
+    return tree
+
+
+def arg_single_check(evidence: str, conclusion: str, arg_type: str, debug_steps: list, current_date: str, current_time: str) -> dict:
+    """
+    单独的 ARG 检查调用，每次 AI 调用只接收单一输入
+    arg_type: "acceptability" | "relevance" | "sufficiency"
+    """
+    
+    type_labels = {
+        "acceptability": "验证依据",
+        "relevance": "验证观点",
+        "sufficiency": "验证结论"
+    }
+    label = type_labels.get(arg_type, arg_type)
+    
+    prompts = {
+        "acceptability": f"""你是一个逻辑分析专家，只分析我提供的文本，不看任何其他内容。
+
+【系统时间】{current_date} {current_time}
+【分析任务】可接受性分析（判断依据本身是否可信）
+
+请分析以下依据的可接受性：
+---
+{evidence}
+---
+
+只回答以下格式（一行）：
+依据可接受性：[有效/无效] 理由：[不超过20字]""",
+        
+        "relevance": f"""你是一个逻辑分析专家，只分析我提供的文本，不看任何其他内容。
+
+【系统时间】{current_date} {current_time}
+【分析任务】相关性分析（判断依据是否能支持结论）
+
+请分析以下依据与结论的相关性：
+---
+依据：{evidence}
+结论：{conclusion}
+---
+
+只回答以下格式（一行）：
+观点支持性：[有效/无效] 理由：[不超过20字]""",
+        
+        "sufficiency": f"""你是一个逻辑分析专家，只分析我提供的文本，不看任何其他内容。
+
+【系统时间】{current_date} {current_time}
+【分析任务】充分性分析（判断依据是否足以支持结论）
+
+请分析以下依据对结论的充分性：
+---
+依据：{evidence}
+结论：{conclusion}
+---
+
+只回答以下格式（一行）：
+结论充分性：[有效/无效] 理由：[不超过20字]"""
+    }
+    
+    prompt = prompts.get(arg_type, prompts["acceptability"])
+    
+    response = client.chat.completions.create(
+        model="deepseek-chat",
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=150,
+    )
+    
+    result_text = response.choices[0].message.content or ""
+    
+    valid = "有效" in result_text
+    
+    debug_steps.append({
+        "step": f"[{'✓' if valid else '✗'}] {label}",
+        "prompt": f"依据：{evidence[:100]}...\n结论：{conclusion[:100] if conclusion else 'N/A'}...",
+        "response": result_text
+    })
+    
+    return {
+        "arg_type": arg_type,
+        "evidence": evidence,
+        "conclusion": conclusion,
+        "response": result_text,
+        "passed": valid,
+        "valid": valid
+    }
+
+
+def build_logic_chain_prompt(title: str, content: str, search_info: str, current_date: str, current_time: str, iteration: int = 0) -> str:
+    """生成建立逻辑链的 prompt"""
+    retry_note = ""
+    if iteration > 0:
+        retry_note = f"\n【注意】这是第{iteration+1}次尝试，请确保逻辑链满足ARG标准。"
+    
+    return f"""你是一个逻辑分析专家。请分析以下文章的论证结构，建立完整的逻辑链。
+
+【系统时间】{current_date} {current_time}{retry_note}
+
+文章标题：{title}
+{search_info}
+文章内容：
+{content}
+
+请按以下格式建立逻辑链（由依据指向结论）：
+1. 先列出所有【原始依据/事实】（文章中明确提到的事件、数据、声明等）
+2. 然后用箭头表示推理关系
+
+格式（必须严格遵守）：
+依据1：[具体事实/事件/数据]
+依据2：[具体事实/事件/数据]
+...
+依据N：[具体事实/事件/数据]
+依据1 + 依据2 → 中间结论1
+中间结论1 + 依据3 → 中间结论2
+...
+中间结论X → 最终结论
+
+重要：
+- 逻辑链必须完整，每个结论都要有依据支撑
+- 箭头表示"由...推出..."
+- 原始依据必须是文章中明确提到的内容
+- 中间结论是从原始依据推导出来的
+- 最终结论是文章的最终主张"""
+
+
+def analyze_with_llm(title: str, content: str, author: str) -> dict:
+    import datetime
+    current_datetime = datetime.datetime.now()
+    current_date = current_datetime.strftime("%Y年%m月%d日")
+    current_time = current_datetime.strftime("%H:%M:%S")
+    
+    debug_steps = []
+    
+    # 第0步：获取当前日期时间
+    debug_steps.append({
+        "step": "0. 当前系统时间",
+        "prompt": "",
+        "response": f"当前日期：{current_date}，当前时间：{current_time}"
+    })
+    
+    # 第一步：判断文章类型
+    type_check_prompt = f"""请判断以下文章属于哪种类型，只需要回答类型名称。
+
+文章标题：{title}
+来源账号：{author}
+文章内容（前500字）：{content[:500]}
+
+可选类型（只选一个）：
+- 新闻资讯
+- 健康养生
+- 金融投资
+- 情感心理
+- 生活常识
+- 娱乐八卦
+- 广告软文
+- 其他
+
+请直接回答类型名称，不要多余文字。"""
+
+    type_response = client.chat.completions.create(
+        model="deepseek-chat",
+        messages=[{"role": "user", "content": type_check_prompt}],
+        max_tokens=50,
+    )
+    article_type = type_response.choices[0].message.content or ""
+    
+    debug_steps.append({
+        "step": "1. 判断文章类型",
+        "prompt": type_check_prompt,
+        "response": article_type
+    })
+    
+    # 第二步：网络搜索（如果是新闻类）
+    need_search = any(keyword in article_type for keyword in ["新闻", "时事", "政治", "国际", "经济"])
+    search_info = ""
+    
+    if need_search:
+        keywords = re.findall(r'[\u4e00-\u9fa5a-zA-Z0-9]{2,15}', title)
+        stop_words = ["已经", "美国", "中国", "俄罗斯", "最新", "消息", "新闻", "报道", "关于", "对于"]
+        keywords = [k for k in keywords if k not in stop_words and len(k) > 2]
+        search_query = " ".join(keywords[:8])
+        
+        if search_query:
+            search_result = search_web(f"{current_date} {current_time} {search_query}")
+            if search_result and "失败" not in search_result:
+                search_info = f"\n\n【网络搜索结果】\n{search_result[:1500]}\n【搜索结束】\n"
+                debug_steps.append({
+                    "step": "2. 网络搜索",
+                    "prompt": f"【系统时间】{current_date} {current_time}，搜索关键词: {search_query}",
+                    "response": search_result[:500]
+                })
+    
+    # 第三步：建立逻辑链（可能需要多次迭代）
+    max_logic_iterations = 3
+    final_logic_chain = ""
+    logic_chain = ""
+    arg_results = []
+    logic_passed = False
+    
+    for iteration in range(max_logic_iterations):
+        logic_prompt = build_logic_chain_prompt(
+            title, content, search_info, current_date, current_time, iteration
+        )
+        
+        logic_response = client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": logic_prompt}],
+            max_tokens=1500,
+        )
+        
+        logic_chain = logic_response.choices[0].message.content or ""
+        
+        debug_steps.append({
+            "step": f"3.{iteration+1}. 建立逻辑链 (第{iteration+1}次)",
+            "prompt": logic_prompt,
+            "response": logic_chain
+        })
+        
+        # 解析逻辑链为树形结构
+        tree = parse_logic_chain_to_tree(logic_chain)
+        
+        # 添加逻辑链树形图到调试输出
+        tree_viz = "【逻辑链结构】\n"
+        for node_id, node in tree["nodes"].items():
+            tree_viz += f"{node_id} [{node['type']}]: {node['content'][:80]}...\n"
+        for edge in tree["edges"]:
+            tree_viz += f"  {edge[0]} → {edge[1]} ({edge[2]})\n"
+        
+        debug_steps.append({
+            "step": f"3.{iteration+1}. 逻辑链结构",
+            "prompt": "",
+            "response": tree_viz
+        })
+        
+        if not tree["nodes"]:
+            debug_steps.append({
+                "step": f"3.{iteration+1}. 解析失败",
+                "prompt": "",
+                "response": "无法解析逻辑链，重试中..."
+            })
+            continue
+        
+        # ARG 分析 - 每次单独调用 AI，每次只看当前内容
+        current_arg_results = []
+        all_checks_passed = True
+        
+        # 1. 先收集所有需要检查的项
+        check_items = []
+        
+        # 对每个节点检查可接受性
+        for node_id, node in tree["nodes"].items():
+            check_items.append({
+                "type": "acceptability",
+                "evidence": node["content"],
+                "conclusion": "",
+                "description": f"{node_id} ({node['type']}) 的可接受性"
+            })
+        
+        # 对每条边检查相关性
+        for edge in tree["edges"]:
+            source_id, target_id, edge_type = edge
+            if source_id in tree["nodes"] and target_id in tree["nodes"]:
+                source_content = tree["nodes"][source_id]["content"]
+                target_content = tree["nodes"][target_id]["content"]
+                
+                check_items.append({
+                    "type": "relevance",
+                    "evidence": source_content,
+                    "conclusion": target_content,
+                    "description": f"{source_id} → {target_id} 的相关性"
+                })
+        
+        # 对每个结论检查充分性（所有指向它的依据一起支持）
+        conclusion_sources = {}
+        for edge in tree["edges"]:
+            source_id, target_id, edge_type = edge
+            if target_id not in conclusion_sources:
+                conclusion_sources[target_id] = []
+            if source_id in tree["nodes"]:
+                conclusion_sources[target_id].append(tree["nodes"][source_id]["content"])
+        
+        for target_id, sources in conclusion_sources.items():
+            if len(sources) >= 1 and target_id in tree["nodes"]:
+                combined_evidence = " + ".join(sources)
+                target_content = tree["nodes"][target_id]["content"]
+                
+                check_items.append({
+                    "type": "sufficiency",
+                    "evidence": combined_evidence,
+                    "conclusion": target_content,
+                    "description": f"{' + '.join(list(conclusion_sources.keys())[:3])} → {target_id} 的充分性"
+                })
+        
+        # 执行所有检查
+        debug_steps.append({
+            "step": f"3.{iteration+1}. 开始ARG分析 (共{len(check_items)}项)",
+            "prompt": "",
+            "response": f"检查项：{', '.join([c['type'] for c in check_items])}"
+        })
+        
+        for i, check in enumerate(check_items):
+            result = arg_single_check(
+                evidence=check["evidence"],
+                conclusion=check["conclusion"],
+                arg_type=check["type"],
+                debug_steps=debug_steps,
+                current_date=current_date,
+                current_time=current_time
+            )
+            current_arg_results.append({
+                "check": check,
+                "result": result
+            })
+            
+            if not result["passed"]:
+                all_checks_passed = False
+        
+        # 如果所有检查都通过，逻辑链有效
+        if all_checks_passed:
+            logic_passed = True
+            final_logic_chain = logic_chain
+            arg_results = current_arg_results
+            break
+        else:
+            # 找出失败的检查
+            failed = [r for r in current_arg_results if not r["result"]["passed"]]
+            failed_info = "\n".join([
+                f"- {r['check']['type']}: {r['check']['description']} → {r['result']['response']}"
+                for r in failed[:3]
+            ])
+            
+            debug_steps.append({
+                "step": f"3.{iteration+1}. ARG检查未通过",
+                "prompt": "",
+                "response": f"失败项：\n{failed_info}\n\n正在重新建立逻辑链..."
+            })
+    
+    # 如果最终没有通过，返回最后一次的逻辑链
+    if not logic_passed and arg_results:
+        final_logic_chain = logic_chain
+    
+    # 第四步：结合 ARG 结果和搜索信息，给出最终判断
+    arg_summary = "\n".join([
+        f"[{r['check']['type'][:3].upper()}] {r['check']['description']}: {r['result']['response'][:50]} {'✓' if r['result']['passed'] else '✗'}"
+        for r in arg_results
+    ])
+    
+    # 统计通过率
+    total_checks = len(arg_results)
+    passed_checks = sum(1 for r in arg_results if r["result"]["passed"])
+    pass_rate = f"{passed_checks}/{total_checks}" if total_checks > 0 else "N/A"
+    
+    debug_steps.append({
+        "step": "4. ARG分析汇总",
+        "prompt": "",
+        "response": f"通过率：{pass_rate}\n{arg_summary[:500]}"
+    })
+    
+    final_prompt = f"""你是一位帮助老年人识别网络虚假信息的助手。请根据以下所有信息综合判断文章可信度。
+
+【重要】当前系统时间：{current_date} {current_time}
+
+文章标题：{title}
+来源账号：{author}
+文章类型：{article_type}
+{search_info}
+文章内容：
+{content}
+
+【ARG逻辑分析结果】
+{arg_summary}
+
+【ARG分析通过率】：{pass_rate}
+
+【重要判断原则】（必须遵守）
+1. 不要因为权威媒体没有报道就判定为假：很多真实信息可能不在新华社、央视等主流媒体发布
+2. 重点核实：逻辑是否自洽、论据是否可靠、是否有多个独立信源佐证
+3. 如果ARG分析通过率高（>70%），说明文章论证逻辑较严谨
+4. 如果ARG分析通过率低，说明文章论证存在明显问题
+5. 严禁自己获取或推断当前时间
+
+请综合以上所有信息判断可信度。
+
+回复格式：
+判定：[可信/需谨慎/不可信]
+简要说明：[一句话总结，不超过30字]
+详细分析：[具体分析，150-300字]"""
+
+    final_response = client.chat.completions.create(
+        model="deepseek-chat",
+        messages=[{"role": "user", "content": final_prompt}],
+        max_tokens=1024,
+    )
+
+    response_text = final_response.choices[0].message.content or ""
+    
+    debug_steps.append({
+        "step": "5. 最终判断",
+        "prompt": final_prompt,
+        "response": response_text
+    })
+    
+    return {
+        "debug_steps": debug_steps,
+        "final_response": response_text,
+        "arg_pass_rate": pass_rate,
+        "arg_summary": arg_summary
+    }
+
+
+@app.get("/")
+async def root():
+    return {"message": "Media Filter API - 帮助老年人识别网络虚假信息"}
+
+
+@app.get("/test")
+async def test_page():
+    return HTMLResponse("""<!DOCTYPE html>
+<html lang="zh">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>慧眼 - 信息真假识别</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --primary: #8B4513;
+            --primary-light: #A0522D;
+            --gold: #D4AF37;
+            --gold-light: #F4E4BA;
+            --cream: #FDF5E6;
+            --ink: #2C2C2C;
+            --ink-light: #5A5A5A;
+            --red-badge: #C41E3A;
+            --green-badge: #2E7D32;
+            --orange-badge: #E65100;
+            --shadow: rgba(139, 69, 19, 0.15);
+            --shadow-heavy: rgba(139, 69, 19, 0.25);
+        }
+        
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        
+        body {
+            font-family: 'Noto Sans SC', 'PingFang SC', 'Microsoft YaHei', sans-serif;
+            background: var(--cream);
+            min-height: 100vh;
+            position: relative;
+            overflow-x: hidden;
+        }
+        
+        body::before {
+            content: '';
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: 
+                radial-gradient(ellipse at 20% 20%, rgba(212, 175, 55, 0.08) 0%, transparent 50%),
+                radial-gradient(ellipse at 80% 80%, rgba(139, 69, 19, 0.06) 0%, transparent 50%),
+                url("data:image/svg+xml,%3Csvg viewBox='0 0 200 200' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='noise'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23noise)' opacity='0.03'/%3E%3C/svg%3E");
+            pointer-events: none;
+            z-index: 0;
+        }
+        
+        .bg-decoration {
+            position: fixed;
+            width: 400px;
+            height: 400px;
+            border: 1px solid rgba(212, 175, 55, 0.1);
+            border-radius: 50%;
+            pointer-events: none;
+            z-index: 0;
+        }
+        
+        .bg-decoration.top-right {
+            top: -100px;
+            right: -100px;
+            width: 300px;
+            height: 300px;
+        }
+        
+        .bg-decoration.bottom-left {
+            bottom: -150px;
+            left: -150px;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 40px 24px 60px;
+            position: relative;
+            z-index: 1;
+            display: flex;
+            gap: 24px;
+        }
+        
+        .main-content {
+            flex: 1;
+            min-width: 0;
+        }
+        
+        .debug-panel {
+            width: 480px;
+            flex-shrink: 0;
+            background: #0d0d0d;
+            border-radius: 12px;
+            padding: 16px;
+            color: #00ff00;
+            font-family: 'Courier New', monospace;
+            font-size: 11px;
+            line-height: 1.5;
+            max-height: 80vh;
+            overflow-y: auto;
+            position: sticky;
+            top: 20px;
+            transition: all 0.3s ease;
+            border: 1px solid #333;
+        }
+        
+        .debug-panel.fullscreen {
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            width: 100vw;
+            max-height: 100vh;
+            border-radius: 0;
+            z-index: 9999;
+            padding: 20px;
+        }
+        
+        .debug-panel-toggle {
+            background: #333;
+            color: #fff;
+            border: none;
+            padding: 4px 10px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 11px;
+            margin-left: 8px;
+        }
+        
+        .debug-panel-toggle:hover {
+            background: #555;
+        }
+        
+        .debug-panel h3 {
+            color: #fff;
+            margin: 0 0 12px 0;
+            font-size: 13px;
+            font-weight: normal;
+            display: flex;
+            align-items: center;
+        }
+        
+        .debug-output {
+            color: #ccc;
+            white-space: pre-wrap;
+            word-break: break-all;
+        }
+        
+        .debug-output .line {
+            margin-bottom: 8px;
+        }
+        
+        .debug-output .title {
+            color: #fff;
+            font-weight: bold;
+            margin-bottom: 2px;
+        }
+        
+        .debug-output .input {
+            color: #888;
+            margin-left: 8px;
+            border-left: 2px solid #444;
+            padding-left: 8px;
+            margin-bottom: 4px;
+        }
+        
+        .debug-output .output {
+            color: #00ff00;
+            margin-left: 8px;
+        }
+        
+        .debug-output .valid {
+            color: #00ff00;
+        }
+        
+        .debug-output .invalid {
+            color: #ff6666;
+        }
+        
+        .debug-output .separator {
+            color: #555;
+            margin: 8px 0;
+        }
+        
+        header {
+            text-align: center;
+            margin-bottom: 40px;
+            animation: fadeInDown 0.8s ease-out;
+        }
+        
+        @keyframes fadeInDown {
+            from { opacity: 0; transform: translateY(-20px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        
+        .logo {
+            display: inline-flex;
+            align-items: center;
+            gap: 12px;
+            margin-bottom: 8px;
+        }
+        
+        .logo-icon {
+            width: 56px;
+            height: 56px;
+            background: linear-gradient(135deg, var(--primary) 0%, var(--primary-light) 100%);
+            border-radius: 16px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 28px;
+            box-shadow: 0 8px 24px var(--shadow-heavy);
+        }
+        
+        .logo-text {
+            font-family: 'Noto Serif SC', serif;
+            font-size: 36px;
+            font-weight: 700;
+            color: var(--ink);
+            letter-spacing: 4px;
+        }
+        
+        .tagline {
+            font-size: 16px;
+            color: var(--ink-light);
+            letter-spacing: 2px;
+        }
+        
+        .card {
+            background: white;
+            border-radius: 24px;
+            padding: 32px;
+            box-shadow: 
+                0 4px 24px var(--shadow),
+                0 1px 2px rgba(0,0,0,0.04);
+            border: 1px solid rgba(212, 175, 55, 0.15);
+            position: relative;
+            overflow: hidden;
+            animation: fadeInUp 0.6s ease-out 0.2s both;
+        }
+        
+        .card::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            height: 4px;
+            background: linear-gradient(90deg, var(--gold), var(--primary), var(--gold));
+        }
+        
+        @keyframes fadeInUp {
+            from { opacity: 0; transform: translateY(20px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        
+        .input-section {
+            margin-bottom: 24px;
+        }
+        
+        .input-label {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 18px;
+            font-weight: 500;
+            color: var(--ink);
+            margin-bottom: 16px;
+        }
+        
+        .input-label-icon {
+            width: 28px;
+            height: 28px;
+            background: var(--gold-light);
+            border-radius: 8px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 14px;
+        }
+        
+        .textarea-wrapper {
+            position: relative;
+        }
+        
+        textarea {
+            width: 100%;
+            min-height: 180px;
+            padding: 20px;
+            border: 2px solid #E8E0D5;
+            border-radius: 16px;
+            font-size: 17px;
+            line-height: 1.7;
+            font-family: inherit;
+            resize: vertical;
+            transition: all 0.3s ease;
+            background: #FDFCFA;
+            color: var(--ink);
+        }
+        
+        textarea::placeholder {
+            color: #A99585;
+        }
+        
+        textarea:focus {
+            outline: none;
+            border-color: var(--gold);
+            box-shadow: 0 0 0 4px rgba(212, 175, 55, 0.15);
+            background: white;
+        }
+        
+        .analyze-btn {
+            width: 100%;
+            padding: 18px 32px;
+            background: linear-gradient(135deg, var(--primary) 0%, var(--primary-light) 100%);
+            color: white;
+            border: none;
+            border-radius: 16px;
+            font-size: 20px;
+            font-weight: 600;
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 12px;
+            transition: all 0.3s ease;
+            box-shadow: 0 8px 24px var(--shadow-heavy);
+            letter-spacing: 2px;
+        }
+        
+        .analyze-btn:hover:not(:disabled) {
+            transform: translateY(-2px);
+            box-shadow: 0 12px 32px var(--shadow-heavy);
+        }
+        
+        .analyze-btn:active:not(:disabled) {
+            transform: translateY(0);
+        }
+        
+        .analyze-btn:disabled {
+            opacity: 0.7;
+            cursor: not-allowed;
+            transform: none;
+        }
+        
+        .analyze-btn-icon {
+            font-size: 22px;
+        }
+        
+        .loading {
+            display: none;
+            text-align: center;
+            padding: 48px 24px;
+            background: rgba(244, 228, 186, 0.3);
+            border-radius: 16px;
+            margin: 24px 0;
+        }
+        
+        .loading.show {
+            display: block;
+            animation: pulse 1.5s ease-in-out infinite;
+        }
+        
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.7; }
+        }
+        
+        .loading-text {
+            font-size: 18px;
+            color: var(--primary);
+            margin-top: 16px;
+        }
+        
+        .loading-dots::after {
+            content: '';
+            animation: dots 1.5s steps(4, end) infinite;
+        }
+        
+        @keyframes dots {
+            0% { content: ''; }
+            25% { content: '.'; }
+            50% { content: '..'; }
+            75% { content: '...'; }
+        }
+        
+        .result {
+            display: none;
+            margin-top: 32px;
+            animation: slideIn 0.5s ease-out;
+        }
+        
+        .result.show {
+            display: block;
+        }
+        
+        @keyframes slideIn {
+            from { opacity: 0; transform: translateY(16px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        
+        .result-header {
+            text-align: center;
+            padding: 28px;
+            border-radius: 20px;
+            margin-bottom: 24px;
+            position: relative;
+            overflow: hidden;
+        }
+        
+        .result-header::after {
+            content: '';
+            position: absolute;
+            inset: 0;
+            background: linear-gradient(135deg, rgba(255,255,255,0.2) 0%, transparent 50%);
+            pointer-events: none;
+        }
+        
+        .result-header.reliable {
+            background: linear-gradient(135deg, #1B5E20 0%, #388E3C 100%);
+        }
+        
+        .result-header.caution {
+            background: linear-gradient(135deg, #E65100 0%, #F57C00 100%);
+        }
+        
+        .result-header.misleading {
+            background: linear-gradient(135deg, #B71C1C 0%, #C62828 100%);
+        }
+        
+        .verdict-emoji {
+            font-size: 56px;
+            margin-bottom: 8px;
+            display: block;
+            animation: bounceIn 0.6s ease-out;
+        }
+        
+        @keyframes bounceIn {
+            0% { transform: scale(0.5); opacity: 0; }
+            60% { transform: scale(1.1); }
+            100% { transform: scale(1); opacity: 1; }
+        }
+        
+        .verdict-text {
+            color: white;
+            font-size: 28px;
+            font-weight: 700;
+            letter-spacing: 4px;
+        }
+        
+        .result-card {
+            background: #FAF8F5;
+            border-radius: 16px;
+            padding: 24px;
+            margin-bottom: 16px;
+            border: 1px solid rgba(139, 69, 19, 0.1);
+        }
+        
+        .result-card-label {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 15px;
+            font-weight: 600;
+            color: var(--primary);
+            margin-bottom: 12px;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+        
+        .result-card-content {
+            font-size: 17px;
+            line-height: 1.8;
+            color: var(--ink);
+        }
+        
+        .result-card-content.summary {
+            font-size: 19px;
+            font-weight: 500;
+            color: var(--ink);
+            padding: 16px;
+            background: white;
+            border-radius: 12px;
+            border-left: 4px solid var(--gold);
+        }
+        
+        footer {
+            text-align: center;
+            margin-top: 40px;
+            padding: 24px;
+            color: var(--ink-light);
+            font-size: 14px;
+            opacity: 0.7;
+        }
+        
+        footer a {
+            color: var(--primary);
+            text-decoration: none;
+        }
+        
+        @media (max-width: 640px) {
+            .container { padding: 24px 16px 40px; }
+            .logo-text { font-size: 28px; }
+            .card { padding: 24px 20px; }
+            textarea { min-height: 150px; font-size: 16px; }
+            .analyze-btn { font-size: 18px; padding: 16px 24px; }
+            .verdict-text { font-size: 24px; }
+        }
+    </style>
+</head>
+<body>
+    <div class="bg-decoration top-right"></div>
+    <div class="bg-decoration bottom-left"></div>
+    
+    <div class="container">
+        <div class="main-content">
+        <header>
+            <div class="logo">
+                <div class="logo-icon">👁</div>
+                <span class="logo-text">慧眼</span>
+            </div>
+            <p class="tagline">帮助长辈辨别网络虚假信息</p>
+        </header>
+        
+        <main class="card">
+            <div class="input-section">
+                <label class="input-label">
+                    <span class="input-label-icon">✎</span>
+                    请输入要鉴别的内容
+                </label>
+                <div class="textarea-wrapper">
+                    <textarea id="content" placeholder="粘贴微信文章链接或输入需要鉴别的文字...
+例如：科学家发现，吃香蕉可以治愈癌症！"></textarea>
+                </div>
+            </div>
+            
+            <button id="analyzeBtn" class="analyze-btn" onclick="analyze()">
+                <span class="analyze-btn-icon">🔍</span>
+                开始分析
+            </button>
+            
+            <div id="loading" class="loading">
+                <div style="font-size: 40px; margin-bottom: 8px;">⏳</div>
+                <div class="loading-text">正在分析中<span class="loading-dots"></span></div>
+            </div>
+            
+            <div id="result" class="result">
+                <div id="verdict" class="result-header">
+                    <span id="verdictEmoji" class="verdict-emoji"></span>
+                    <div id="verdictText" class="verdict-text"></div>
+                </div>
+                
+                <div class="result-card">
+                    <div class="result-card-label">
+                        <span>📋</span> 简要说明
+                    </div>
+                    <div id="summary" class="result-card-content summary"></div>
+                </div>
+                
+                <div class="result-card">
+                    <div class="result-card-label">
+                        <span>📖</span> 详细分析
+                    </div>
+                    <div id="details" class="result-card-content"></div>
+                </div>
+                
+                <div class="result-card" id="analysisProcess" style="display:none;">
+                    <div class="result-card-label">
+                        <span>🔍</span> 分析过程
+                    </div>
+                    <div id="articleType" class="result-card-content" style="margin-bottom:12px;padding:12px;background:#f0f7ff;border-radius:8px;border-left:3px solid #2196F3;">
+                        <strong>文章类型：</strong><span></span>
+                    </div>
+                    <div id="searchInfo" class="result-card-content" style="display:none;margin-bottom:12px;padding:12px;background:#fff8e1;border-radius:8px;border-left:3px solid #FF9800;">
+                        <strong>网络搜索结果：</strong>
+                        <pre style="white-space:pre-wrap;word-wrap:break-word;margin-top:8px;font-size:14px;max-height:300px;overflow-y:auto;"></pre>
+                    </div>
+                </div>
+            </div>
+        </main>
+        
+        <footer>
+            <p>慧眼 · 守护长辈的数字生活</p>
+        </footer>
+        </div>
+        
+        <!-- 右侧调试面板 -->
+        <div class="debug-panel" id="debugPanel">
+            <h3>AI 调试输出 <button class="debug-panel-toggle" onclick="toggleDebugFullscreen()">全屏</button></h3>
+            <div class="debug-output" id="debugContent">等待分析...</div>
+        </div>
+    </div>
+    
+    <script>
+        function toggleDebugFullscreen() {
+            const panel = document.getElementById('debugPanel');
+            panel.classList.toggle('fullscreen');
+            const btn = panel.querySelector('.debug-panel-toggle');
+            btn.textContent = panel.classList.contains('fullscreen') ? '退出全屏' : '全屏';
+        }
+        
+        async function analyze() {
+            const content = document.getElementById('content').value.trim();
+            if (!content) {
+                alert('请输入要鉴别的内容');
+                return;
+            }
+            
+            const isUrl = content.startsWith('http://') || content.startsWith('https://');
+            const payload = isUrl ? { url: content } : { text: content };
+            
+            const btn = document.getElementById('analyzeBtn');
+            const loading = document.getElementById('loading');
+            const result = document.getElementById('result');
+            
+            btn.disabled = true;
+            btn.innerHTML = '<span class="analyze-btn-icon">⏳</span> 分析中...';
+            loading.classList.add('show');
+            result.classList.remove('show');
+            
+            document.getElementById('debugContent').textContent = '开始分析...\n';
+            
+            try {
+                const response = await fetch('/analyze', {
+                    method: 'POST',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify(payload)
+                });
+                
+                if (!response.ok) throw new Error('分析失败');
+                
+                const data = await response.json();
+                
+                const verdictEl = document.getElementById('verdict');
+                verdictEl.className = 'result-header ' + data.verdict;
+                document.getElementById('verdictEmoji').textContent = data.verdict_emoji;
+                
+                const verdictTexts = {
+                    'reliable': '信息可信',
+                    'caution': '需要谨慎',
+                    'misleading': '不可信'
+                };
+                document.getElementById('verdictText').textContent = verdictTexts[data.verdict] || data.verdict;
+                document.getElementById('summary').textContent = data.summary;
+                document.getElementById('details').textContent = data.details;
+                
+                const analysisProcess = document.getElementById('analysisProcess');
+                if (data.article_type || data.search_info) {
+                    analysisProcess.style.display = 'block';
+                    
+                    const articleTypeEl = document.getElementById('articleType');
+                    if (data.article_type) {
+                        articleTypeEl.querySelector('span').textContent = data.article_type;
+                        articleTypeEl.style.display = 'block';
+                    } else {
+                        articleTypeEl.style.display = 'none';
+                    }
+                    
+                    const searchInfoEl = document.getElementById('searchInfo');
+                    if (data.search_info && data.search_info.trim()) {
+                        searchInfoEl.querySelector('pre').textContent = data.search_info;
+                        searchInfoEl.style.display = 'block';
+                    } else {
+                        searchInfoEl.style.display = 'none';
+                    }
+                } else {
+                    analysisProcess.style.display = 'none';
+                }
+                
+                // 显示调试面板 - 纯文字输出
+                const debugContent = document.getElementById('debugContent');
+                if (data.debug_steps && data.debug_steps.length > 0) {
+                    let output = '';
+                    data.debug_steps.forEach(function(step) {
+                        output += '----------------------------------------\n';
+                        output += step.step + '\n';
+                        if (step.prompt) {
+                            output += '[输入]\n' + step.prompt + '\n';
+                        }
+                        output += '[输出]\n' + (step.response || '') + '\n';
+                    });
+                    output += '========================================\n';
+                    output += '分析完成\n';
+                    debugContent.textContent = output;
+                } else {
+                    debugContent.textContent = '无调试信息';
+                }
+                
+                result.classList.add('show');
+                result.scrollIntoView({behavior: 'smooth', block: 'start'});
+                
+            } catch (err) {
+                alert('分析失败: ' + err.message);
+            } finally {
+                btn.disabled = false;
+                btn.innerHTML = '<span class="analyze-btn-icon">🔍</span> 开始分析';
+                loading.classList.remove('show');
+            }
+        }
+    </script>
+</body>
+</html>""")
+
+
+@app.post("/analyze", response_model=AnalyzeResponse)
+async def analyze_content(request: AnalyzeRequest):
+    """Analyze content from URL or direct text input."""
+
+    if not request.url and not request.text:
+        raise HTTPException(status_code=400, detail="请提供文章链接或文字内容")
+
+    title = "用户输入内容"
+    content = ""
+    author = "未知"
+
+    if request.url:
+        # Check if it's a WeChat article URL
+        if "mp.weixin.qq.com" in request.url or "weixin.qq.com" in request.url:
+            article = await extract_wechat_article(request.url)
+            title = article["title"]
+            content = article["content"]
+            author = article["author"]
+        # Check if it's a Douyin video URL
+        elif "douyin.com" in request.url or "dy.com" in request.url:
+            video = await extract_douyin_video(request.url)
+            title = video["title"]
+            content = video["content"]
+            author = video["author"]
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail="目前仅支持微信公众号文章（mp.weixin.qq.com）和抖音视频（douyin.com）"
+            )
+    else:
+        content = request.text or ""
+
+    # Validate content is not empty
+    if not content:
+        raise HTTPException(status_code=400, detail="文章内容不能为空")
+
+    # Analyze with LLM
+    analysis = analyze_with_llm(title, content, author)
+
+    return AnalyzeResponse(
+        title=title,
+        verdict=analysis["verdict"],
+        verdict_emoji=analysis["verdict_emoji"],
+        summary=analysis["summary"],
+        details=analysis["details"],
+        original_text=content[:500] + "..." if len(content) > 500 else content,
+        article_type=analysis.get("article_type", ""),
+        search_info=analysis.get("search_info", ""),
+        debug_steps=analysis.get("debug_steps", []),
+    )
+
+
+@app.post("/chat/stream")
+async def chat_stream_endpoint(request: ChatRequest):
+    """
+    Stream chat response with reasoning and content.
+    Returns Server-Sent Events (SSE).
+    """
+
+    system_prompt = f"""
+    你是一位帮助老年人识别网络虚假信息的贴心助手"慧眼"。
+    你之前已经分析过这篇文章：
+    标题：{request.title or '未知'}
+    原文摘要：{request.original_text[:500] if request.original_text else '无'}
+
+    之前的分析结果：
+    {request.analysis_summary or '无'}
+    {request.analysis_details or '无'}
+
+    现在的任务是回答用户关于这篇文章的后续提问。
+    请保持语气亲切、耐心，像一位靠谱的晚辈在给长辈解释。
+    回答要通俗易懂，不要用复杂的术语。
+    如果是谣言，要温和但坚定地提醒长辈不要相信。
+
+    重要提示：
+    1. 直接回复用户的内容，不要在开头加"(温和地)"或"(认真地)"之类的语气描述。
+    2. 不要重复"你好"或自我介绍，直接针对问题回答。
+    """
+
+    llm_messages: list = [{"role": "system", "content": system_prompt}]
+    for msg in request.messages:
+        llm_messages.append({"role": msg.role, "content": msg.content})
+
+    async def event_generator():
+        try:
+            response = client.chat.completions.create(
+                model="deepseek-reasoner",
+                messages=llm_messages,  # type: ignore
+                max_tokens=2000,
+                stream=True,
+            )
+
+            for chunk in response:
+                delta = chunk.choices[0].delta
+
+                # Check for reasoning content (DeepSeek R1 specific)
+                if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
+                    data = json.dumps({"text": delta.reasoning_content}, ensure_ascii=False)
+                    yield f"event: reasoning\ndata: {data}\n\n"
+
+                # Check for standard content
+                if delta.content:
+                    data = json.dumps({"text": delta.content}, ensure_ascii=False)
+                    yield f"event: content\ndata: {data}\n\n"
+
+        except Exception as e:
+            error_data = json.dumps({"error": str(e)}, ensure_ascii=False)
+            yield f"event: error\ndata: {error_data}\n\n"
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..93c7a4b
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,9 @@
+fastapi>=0.115.0
+uvicorn>=0.32.0
+httpx>=0.27.0
+beautifulsoup4>=4.12.0
+lxml>=5.3.0
+python-dotenv>=1.0.0
+openai>=1.0.0
+pydantic>=2.9.0
+f2>=0.0.1.7