Add Weaviate index builder Gradio app

Co-authored-by: Cursor <cursoragent@cursor.com>

HF_SPACE_SETUP.md

@@ -0,0 +1,106 @@
+# 在 Hugging Face Space 上构建 Weaviate 索引
+
+## 方案概述
+
+由于本地网络环境可能存在 SSL 连接问题，我们可以在 Hugging Face Space 上运行索引构建，利用 HF Space 更稳定的网络环境。
+
+## 步骤
+
+### 1. 准备 GenAICoursesDB Space
+
+如果你还没有创建这个 Space：
+
+1. 访问 https://huggingface.co/spaces
+2. 点击 "Create new Space"
+3. 设置：
+   - **Space name**: `GenAICoursesDB`（或你喜欢的名称）
+   - **SDK**: `Gradio`
+   - **Hardware**: `CPU basic`（足够使用）
+   - **Visibility**: `Public` 或 `Private`
+
+### 2. 上传代码和文件
+
+#### 方式 A：通过 Git（推荐）
+
+```bash
+# 克隆你的 Space（如果还没有）
+git clone https://huggingface.co/spaces/YOUR_USERNAME/GenAICoursesDB
+cd GenAICoursesDB
+
+# 从本地项目复制文件
+cp /path/to/AI_Agent_Clare-main/hf_space/GenAICoursesDB_space/app.py .
+cp /path/to/AI_Agent_Clare-main/hf_space/GenAICoursesDB_space/requirements.txt .
+cp /path/to/AI_Agent_Clare-main/hf_space/GenAICoursesDB_space/README.md .
+
+# 上传 GENAI COURSES（使用 Git LFS，因为文件可能很大）
+git lfs install
+git lfs track "GENAI COURSES/**"
+cp -r /path/to/AI_Agent_Clare-main/GENAI\ COURSES .
+
+git add .
+git commit -m "Add Weaviate index builder app"
+git push
+```
+
+#### 方式 B：通过 Web 界面上传
+
+1. 访问你的 Space 页面
+2. 点击 "Files" 标签
+3. 上传以下文件：
+   - `app.py`
+   - `requirements.txt`
+   - `README.md`
+   - `GENAI COURSES` 文件夹（可能需要压缩为 zip）
+
+### 3. 配置 Secrets
+
+访问 Space Settings → Secrets，添加：
+
+| Secret 名称 | 值 | 说明 |
+|------------|-----|------|
+| `OPENAI_API_KEY` | `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` | OpenAI API Key |
+| `WEAVIATE_URL` | `https://iydyvd4wqnekotfiftma.c0.us-west3.gcp.weaviate.cloud` | Weaviate Cloud REST 地址 |
+| `WEAVIATE_API_KEY` | `your-weaviate-api-key` | Weaviate API Key |
+| `WEAVIATE_COLLECTION` | `GenAICourses` | Collection 名称（可选，默认值） |
+| `EMBEDDING_PROVIDER` | `openai` | Embedding 提供商（可选，默认值） |
+
+### 4. 运行索引构建
+
+1. Space 会自动构建并启动
+2. 访问 Space 页面，你会看到 Gradio 界面
+3. 点击 "🚀 开始构建索引" 按钮
+4. 等待构建完成（可能需要 5-15 分钟）
+
+### 5. 验证结果
+
+构建完成后，界面会显示：
+```
+✅ 索引构建成功！
+当前 object count = [数量]
+```
+
+你也可以在 Weaviate Console 中验证：
+1. 访问你的 Weaviate Cloud Console
+2. 查看 `GenAICourses` collection
+3. 确认 object count 与构建结果一致
+
+## 优势
+
+✅ **网络稳定**: HF Space 的网络环境通常比本地更稳定  
+✅ **无需下载**: 直接在 HF Space 上完成 embedding 和上传  
+✅ **易于使用**: Gradio 界面，一键操作  
+✅ **实时进度**: 可以看到构建进度和状态  
+
+## 注意事项
+
+⚠️ **文件大小**: 如果 `GENAI COURSES` 文件夹很大（>1GB），建议使用 Git LFS  
+⚠️ **构建时间**: 768 个文档块大约需要 5-15 分钟  
+⚠️ **API 费用**: 使用 OpenAI API 会产生费用（约 $0.01-0.05）  
+
+## 后续步骤
+
+索引构建完成后，ClareVoice Space 就可以直接使用 Weaviate 进行检索了。确保 ClareVoice Space 的 Secrets 中也配置了：
+- `WEAVIATE_URL`
+- `WEAVIATE_API_KEY`
+- `WEAVIATE_COLLECTION`
+- `OPENAI_API_KEY`（用于检索时的 embedding）

README.md

@@ -1,71 +1,95 @@
----
-title: GenAICoursesDB
-emoji: 🏆
-colorFrom: purple
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.5.1
-app_file: app.py
-pinned: false
----
+# Weaviate 索引构建工具（Hugging Face Space 版）
 
-本 Space 用 **LlamaIndex** 为 GENAI 课程资料构建向量数据库并提供问答界面。Embedding 可选 **OpenAI（付费）** 或 **Hugging Face 开源模型（免费）**。
+在 Hugging Face Space 上使用 OpenAI API 进行 embedding，并直接上传到 Weaviate Cloud。
 
-## 成本与免费方案
+## 🚀 快速开始
 
-- **OpenAI embedding**（`text-embedding-3-small`）：约 **$0.02 / 100 万 token**。你当前约 149 个文档块，粗算约 **几万 token**，建一次索引大约 **< 0.01 美元**（不到 1 美分）；之后每次提问只多一次短句 embedding，可忽略。
-- **免费方案**：在 Space 的 **Settings → Variables** 里添加 `EMBEDDING_PROVIDER` = `huggingface`，即用本地 **sentence-transformers** 做 embedding，**不花 OpenAI 钱**；提问时只返回检索到的原文（不调用 LLM）。可选变量 `HF_EMBEDDING_MODEL`（默认 `sentence-transformers/all-MiniLM-L6-v2`），可改为如 `BAAI/bge-small-en-v1.5` 等。
+### 1. 在 Hugging Face Space 中配置 Secrets
 
-## 为什么课程文件放 Dataset？
+访问你的 Space Settings → Secrets，添加以下环境变量：
 
-Hugging Face Spaces 对大二进制文件（如 `.pdf/.docx`）推送有限制，因此课程文件存放在 **Dataset**，
-Space 在启动时从 Dataset 下载课程目录后再构建/加载索引。
+- **`OPENAI_API_KEY`**: `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`
+- **`WEAVIATE_URL`**: 你的 Weaviate Cloud REST 地址（例如：`https://xxx.c0.us-west3.gcp.weaviate.cloud`）
+- **`WEAVIATE_API_KEY`**: 你的 Weaviate API Key
+- **`WEAVIATE_COLLECTION`**: Collection 名称（默认：`GenAICourses`）
+- **`EMBEDDING_PROVIDER`**: `openai` 或 `huggingface`（默认：`openai`）
 
-## 需要配置的 Secrets / Variables
+### 2. 上传 GENAI COURSES 文件夹
 
-- **OpenAI 方案**：`OPENAI_API_KEY`（Settings → Secrets）
-- **免费方案**：`EMBEDDING_PROVIDER` = `huggingface`（Settings → Variables），无需 API Key 即可建索引与检索
-- **可选**：`GENAI_COURSES_DATASET_ID`（默认：`claudqunwang/genai-courses-data`）
-- **可选**：`GENAI_COURSES_DATASET_SUBDIR`（默认：`GENAI COURSES`）
-- **可选**：`HF_EMBEDDING_MODEL`（免费方案时生效，默认：`sentence-transformers/all-MiniLM-L6-v2`）
-- **可选（方案 A）**：`INDEX_DATASET_ID`（预构建索引 Dataset，设置后启动时直接下载，无需 embedding）
+有两种方式：
 
-## 使用方式
+#### 方式 A：通过 Git LFS 上传（推荐）
 
-打开 Space 页面后直接提问即可。
+```bash
+# 在本地项目目录
+cd hf_space/GenAICoursesDB_space
 
-### 方案 A：预构建索引（启动快，无需每次 embedding）
+# 将 GENAI COURSES 复制到 Space 目录
+cp -r ../../GENAI\ COURSES .
 
-若配置了预构建索引，Space 启动时**直接下载索引**，几秒内就绪，不再做 embedding。
+# 提交并推送
+git add GENAI\ COURSES
+git commit -m "Add GENAI COURSES for indexing"
+git push
+```
 
-**步骤：**
+#### 方式 B：通过 HF Space 的文件上传功能
 
-1. **创建索引 Dataset**：在 [huggingface.co/datasets](https://huggingface.co/datasets) 点击 **Create new dataset**，名称如 `genai-courses-index`。
+1. 访问你的 Space 页面
+2. 点击 "Files" 标签
+3. 上传 `GENAI COURSES` 文件夹（可能需要压缩为 zip 后上传，然后在 Space 中解压）
 
-2. **本地构建并上传**（需有 `GENAI COURSES` 目录）：
-   ```bash
-   cd hf_space/GenAICoursesDB_space
-   # 设置与 Space 一致（推荐用免费 embedding）
-   export EMBEDDING_PROVIDER=huggingface
-   # 若用默认 Dataset，可设置 INDEX_DATASET_ID=你的用户名/genai-courses-index
-   python build_and_upload_index.py
-   ```
+### 3. 运行索引构建
 
-3. **Space 配置**：在 GenAICoursesDB Space → **Settings → Variables** 添加：
-   - `INDEX_DATASET_ID` = `你的用户名/genai-courses-index`
+1. 访问你的 Space 页面
+2. 在 Gradio 界面中：
+   - 选择是否清空旧索引（推荐勾选）
+   - 点击 "🚀 开始构建索引" 按钮
+   - 等待构建完成（可能需要几分钟）
 
-4. **重启 Space**：下次启动将从 Dataset 下载索引，无需重新 embedding。
+## 📋 功能说明
 
-**未配置预构建时**：首次启动或勾选“强制重建索引”会从课程 Dataset 下载并构建，耗时较长（需做 Embedding）。
+- ✅ 使用 OpenAI `text-embedding-3-small` 进行 embedding
+- ✅ 自动读取 `GENAI COURSES` 目录下的所有文档（.md, .pdf, .txt, .py, .ipynb, .docx）
+- ✅ 直接上传到 Weaviate Cloud（无需下载）
+- ✅ 实时显示构建进度
+- ✅ 自动验证索引构建结果
 
-## Clare 方案三：外部调用 retrieve 接口
+## 🔧 技术细节
 
-Clare 等应用可通过 `gradio_client` 调用本 Space 的 **retrieve** 接口，获取课程检索结果作为 RAG 上下文：
+- **Embedding 模型**: OpenAI `text-embedding-3-small`（1536 维）
+- **向量数据库**: Weaviate Cloud
+- **文档处理**: LlamaIndex SimpleDirectoryReader
+- **界面**: Gradio
 
-```python
-from gradio_client import Client
-client = Client("claudqunwang/GenAICoursesDB")
-chunks = client.predict("Module 7 Lab 6 主要讲什么？", api_name="/retrieve")
-```
+## ⚠️ 注意事项
+
+1. **文件大小限制**: Hugging Face Space 有文件大小限制，如果 `GENAI COURSES` 太大，可能需要使用 Git LFS
+2. **构建时间**: 768 个文档块大约需要 5-15 分钟，取决于网络速度
+3. **网络稳定性**: HF Space 的网络通常比本地更稳定，适合处理大量文档
+4. **成本**: 使用 OpenAI API 会产生费用，768 个文档块大约需要 $0.01-0.05（取决于文档长度）
+
+## 🐛 故障排除
+
+### 错误：课程目录不存在
+- 确保 `GENAI COURSES` 文件夹已上传到 Space 根目录
+- 检查文件夹名称是否正确（区分大小写）
+
+### 错误：OPENAI_API_KEY 未设置
+- 检查 Space Settings → Secrets 中是否已添加 `OPENAI_API_KEY`
+- 确保 Secret 名称完全匹配（区分大小写）
+
+### 错误：Weaviate 连接失败
+- 检查 `WEAVIATE_URL` 格式是否正确（应以 `https://` 开头）
+- 验证 `WEAVIATE_API_KEY` 是否有效
+- 确认网络连接正常
+
+### 构建成功但 object count = 0
+- 检查 Weaviate Console 中的 collection 名称是否匹配
+- 确认使用的是同一 Weaviate 集群和账号
+- 等待几秒钟后再次检查（可能有延迟）
+
+## 📚 相关文档
 
-在 Clare 中：设置环境变量 `GENAI_COURSES_SPACE=claudqunwang/GenAICoursesDB` 即可启用。
+- `build_weaviate_index.py`: 命令行版本的索引构建脚本（用于本地运行）
+- `app.py`: Gradio 应用（用于 HF Space）

app.py

@@ -1,331 +1,230 @@
+"""
+Hugging Face Space 应用：在 HF Space 上运行 Weaviate 索引构建
+使用 OpenAI API 进行 embedding，直接上传到 Weaviate Cloud
+"""
 import os
-from pathlib import Path
-from typing import Optional, Tuple
-
 import gradio as gr
-from dotenv import load_dotenv
-from huggingface_hub import HfApi, hf_hub_download
-from llama_index.core import (
-    Settings,
-    SimpleDirectoryReader,
-    StorageContext,
-    VectorStoreIndex,
-    load_index_from_storage,
-)
-from llama_index.embeddings.openai import OpenAIEmbedding
-
-
-load_dotenv()
-
-
-DATASET_ID = (os.getenv("GENAI_COURSES_DATASET_ID") or "claudqunwang/genai-courses-data").strip()
-DATASET_SUBDIR = (os.getenv("GENAI_COURSES_DATASET_SUBDIR") or "GENAI COURSES").strip()
+from pathlib import Path
+import threading
+import time
 
-# 方案 A：预构建索引 Dataset。若设置，Space 启动时直接下载加载，无需重新 embedding
-INDEX_DATASET_ID = (os.getenv("INDEX_DATASET_ID") or "claudqunwang/genai-courses-index").strip()
+# 从环境变量读取配置（HF Space Secrets）
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "").strip()
+WEAVIATE_URL = os.getenv("WEAVIATE_URL", "").strip()
+WEAVIATE_API_KEY = os.getenv("WEAVIATE_API_KEY", "").strip()
+WEAVIATE_COLLECTION = os.getenv("WEAVIATE_COLLECTION", "GenAICourses").strip()
+EMBEDDING_PROVIDER = os.getenv("EMBEDDING_PROVIDER", "openai").strip().lower()
 
-# Hugging Face Spaces 没有持久化磁盘时，每次重启可能需要重建索引
-PERSIST_DIR = Path(os.getenv("GENAI_INDEX_DIR") or "/tmp/genai_courses_index").resolve()
+# 课程文档路径（需要上传到 HF Space）
+SCRIPT_DIR = Path(__file__).resolve().parent
+COURSES_DIR = SCRIPT_DIR / "GENAI COURSES"
 
-# 可选：使用免费开源 embedding，不花 OpenAI 钱。设为 "huggingface" 时用本地 HF 模型
-EMBEDDING_PROVIDER = (os.getenv("EMBEDDING_PROVIDER") or "openai").strip().lower()
-HF_EMBEDDING_MODEL = (os.getenv("HF_EMBEDDING_MODEL") or "sentence-transformers/all-MiniLM-L6-v2").strip()
+# 全局状态
+build_status = {"running": False, "progress": "", "error": None, "result": None}
 
 
-def _setup_embed_model():
-    if EMBEDDING_PROVIDER == "huggingface":
-        try:
+def build_index_worker(clear_first: bool, progress_callback=None):
+    """后台工作线程：构建索引"""
+    global build_status
+    
+    try:
+        build_status["running"] = True
+        build_status["error"] = None
+        build_status["progress"] = "开始构建索引..."
+        
+        # 检查配置
+        if not OPENAI_API_KEY:
+            raise RuntimeError("请在 HF Space Settings → Secrets 中添加 OPENAI_API_KEY")
+        if not WEAVIATE_URL or not WEAVIATE_API_KEY:
+            raise RuntimeError("请在 HF Space Settings → Secrets 中添加 WEAVIATE_URL 和 WEAVIATE_API_KEY")
+        
+        # 检查课程目录
+        if not COURSES_DIR.exists():
+            raise FileNotFoundError(
+                f"课程目录不存在：{COURSES_DIR}\n"
+                "请将 GENAI COURSES 文件夹上传到 Space 的根目录"
+            )
+        
+        # 导入依赖
+        build_status["progress"] = "加载依赖库..."
+        from llama_index.core import SimpleDirectoryReader, VectorStoreIndex, Settings
+        from llama_index.core import StorageContext
+        from llama_index.vector_stores.weaviate import WeaviateVectorStore
+        import weaviate
+        from weaviate.classes.init import Auth
+        
+        # 设置 embedding
+        build_status["progress"] = "配置 embedding 模型..."
+        if EMBEDDING_PROVIDER == "openai":
+            from llama_index.embeddings.openai import OpenAIEmbedding
+            Settings.embed_model = OpenAIEmbedding(
+                model="text-embedding-3-small",
+                api_key=OPENAI_API_KEY,
+            )
+        else:
             from llama_index.embeddings.huggingface import HuggingFaceEmbedding
-            return HuggingFaceEmbedding(model_name=HF_EMBEDDING_MODEL)
-        except Exception as e:
-            raise RuntimeError(
-                f"无法加载 Hugging Face 免费 embedding（{HF_EMBEDDING_MODEL}）：{e!r}\n"
-                "请确认已安装: pip install llama-index-embeddings-huggingface sentence-transformers"
+            Settings.embed_model = HuggingFaceEmbedding(
+                model_name="sentence-transformers/all-MiniLM-L6-v2"
             )
-    return OpenAIEmbedding(model="text-embedding-3-small")
-
-
-Settings.embed_model = _setup_embed_model()
-
-
-def _ensure_openai_key():
-    """仅在使用 OpenAI embedding 或默认 query 引擎时需要。"""
-    if EMBEDDING_PROVIDER == "huggingface":
-        return  # 建索引用 HF，不强制要求 OpenAI Key
-    key = (os.getenv("OPENAI_API_KEY") or "").strip()
-    if not key:
-        raise RuntimeError("OPENAI_API_KEY 未设置。请到 Space: Settings → Secrets 添加 OPENAI_API_KEY；或设置 EMBEDDING_PROVIDER=huggingface 使用免费 embedding。")
-
-
-def _get_courses_dir() -> Path:
-    """
-    从 Dataset 下载课程文件到本地临时目录，并返回实际目录路径。
-    这里**完全绕开 snapshot_download**，避免某些环境下出现的
-    “No files found ... GENAI COURSES” 之类缓存异常。
-
-    实现思路：
-    1. 用 HfApi.list_repo_files 列出 Dataset 中的所有文件路径；
-    2. 过滤出属于 DATASET_SUBDIR 下的文件；
-    3. 通过 hf_hub_download 逐个拉到 /tmp/genai_courses_data，并还原子目录结构。
-    """
-    api = HfApi()
-    try:
-        all_files = api.list_repo_files(repo_id=DATASET_ID, repo_type="dataset")
-    except Exception as e:
-        raise RuntimeError(f"无法列出 Dataset 文件（{DATASET_ID}）：{e!r}")
-
-    if not all_files:
-        raise RuntimeError(f"Dataset {DATASET_ID!r} 为空，请确认上传了课程文件。")
-
-    # 归一化子目录名，兼容空格/大小写差异
-    sub_norm = "".join(DATASET_SUBDIR.strip().lower().split("/")).replace(" ", "")
-
-    def _belongs_to_subdir(path: str) -> bool:
-        # path 形如 "GENAI COURSES/Module 1/...docx"
-        if "/" not in path:
-            return False
-        top = path.split("/", 1)[0]
-        top_norm = "".join(top.strip().lower().split("/")).replace(" ", "")
-        return top_norm == sub_norm
-
-    course_files = [p for p in all_files if _belongs_to_subdir(p)]
-    if not course_files:
-        raise RuntimeError(
-            "在 Dataset 中没有找到课程子目录。\n"
-            f"- Dataset: {DATASET_ID!r}\n"
-            f"- 期望子目录: {DATASET_SUBDIR!r}\n"
-            f"- 实际顶层内容示例: {[p.split('/',1)[0] for p in all_files[:20]]!r}"
+        
+        # 连接 Weaviate
+        build_status["progress"] = "连接 Weaviate Cloud..."
+        url = WEAVIATE_URL
+        if not url.startswith("http"):
+            url = "https://" + url
+        
+        client = weaviate.connect_to_weaviate_cloud(
+            cluster_url=url,
+            auth_credentials=Auth.api_key(WEAVIATE_API_KEY),
         )
-
-    local_root = Path("/tmp/genai_courses_data")
-    local_root.mkdir(parents=True, exist_ok=True)
-
-    for rel_path in course_files:
-        # 将文件下载到对应的本地路径（保持目录结构）
-        local_path = local_root / rel_path
-        local_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        if not client.is_ready():
+            raise RuntimeError("Weaviate 连接失败")
+        
         try:
-            downloaded = hf_hub_download(
-                repo_id=DATASET_ID,
-                repo_type="dataset",
-                filename=rel_path,
-                local_dir=str(local_root),
-                local_dir_use_symlinks=False,
+            # 清空旧 collection（如果需要）
+            if clear_first:
+                build_status["progress"] = f"删除旧 collection: {WEAVIATE_COLLECTION}..."
+                try:
+                    if hasattr(client.collections, "delete"):
+                        client.collections.delete(WEAVIATE_COLLECTION)
+                        build_status["progress"] = "旧 collection 已删除"
+                except Exception as e:
+                    if "404" not in str(e) and "not found" not in str(e).lower():
+                        build_status["progress"] = f"删除旧 collection 时警告: {e}"
+            
+            # 读取文档
+            build_status["progress"] = f"读取课程目录: {COURSES_DIR}..."
+            reader = SimpleDirectoryReader(
+                input_dir=str(COURSES_DIR),
+                recursive=True,
+                required_exts=[".md", ".pdf", ".txt", ".py", ".ipynb", ".docx"],
             )
-        except Exception as e:
-            print(f"[download] failed for {rel_path}: {e!r}")
-            continue
-        # hf_hub_download 已经写入 local_dir 下对应文件，这里确保路径存在
-        _ = downloaded
-
-    courses_dir = local_root / DATASET_SUBDIR
-    if not courses_dir.exists():
-        # 有些情况下 DATASET_SUBDIR 大写/空格不完全一致，再做一次自动探测
-        candidates = [p for p in local_root.iterdir() if p.is_dir()]
-        if candidates:
-            # 选第一个目录作为课程根目录（因为我们只往属于该子目录的文件里写）
-            courses_dir = candidates[0]
-
-    if not courses_dir.exists():
-        raise FileNotFoundError(
-            "课程目录下载失败，请检查 Dataset 结构。\n"
-            f"- Dataset: {DATASET_ID!r}\n"
-            f"- 期望子目录: {DATASET_SUBDIR!r}\n"
-            f"- 本地根目录: {str(local_root)!r}"
-        )
-
-    return courses_dir
-
-
-def _download_and_load_prebuilt_index() -> Tuple[bool, Optional["VectorStoreIndex"]]:
-    """方案 A：从 INDEX_DATASET_ID 下载预构建索引并加载到 PERSIST_DIR。成功返回 True。"""
-    if not INDEX_DATASET_ID:
-        return False, None
-    try:
-        import shutil
-        if PERSIST_DIR.exists():
-            shutil.rmtree(PERSIST_DIR)
-        PERSIST_DIR.mkdir(parents=True, exist_ok=True)
-        from huggingface_hub import snapshot_download
-        snapshot_download(
-            repo_id=INDEX_DATASET_ID,
-            repo_type="dataset",
-            local_dir=str(PERSIST_DIR),
-            local_dir_use_symlinks=False,
-        )
-        storage_context = StorageContext.from_defaults(persist_dir=str(PERSIST_DIR))
-        idx = load_index_from_storage(storage_context)
-        print(f"[index] 已从预构建索引加载: {INDEX_DATASET_ID}")
-        return True, idx
+            documents = reader.load_data()
+            build_status["progress"] = f"已加载 {len(documents)} 个文档块"
+            
+            # 创建 vector store
+            build_status["progress"] = "创建 Weaviate vector store..."
+            vector_store = WeaviateVectorStore(
+                weaviate_client=client,
+                index_name=WEAVIATE_COLLECTION,
+            )
+            storage_context = StorageContext.from_defaults(vector_store=vector_store)
+            
+            # 构建索引（这会自动进行 embedding 并上传）
+            build_status["progress"] = f"正在 embedding 并上传到 Weaviate (collection={WEAVIATE_COLLECTION})...\n这可能需要几分钟时间，请耐心等待..."
+            index = VectorStoreIndex.from_documents(
+                documents,
+                storage_context=storage_context,
+            )
+            
+            # 等待 batch 提交完成
+            time.sleep(3)
+            
+            # 验证
+            build_status["progress"] = "验证索引..."
+            coll = client.collections.get(WEAVIATE_COLLECTION)
+            agg = coll.aggregate.over_all(total_count=True)
+            n = agg.total_count
+            
+            build_status["result"] = f"✅ 索引构建成功！\n当前 object count = {n}"
+            build_status["progress"] = build_status["result"]
+            
+        finally:
+            client.close()
+            
     except Exception as e:
-        print(f"[index] 预构建索引加载失败: {repr(e)}")
-        return False, None
-
-
-def get_index(force_rebuild: bool = False) -> VectorStoreIndex:
-    _ensure_openai_key()
-
-    if PERSIST_DIR.exists() and not force_rebuild:
-        try:
-            storage_context = StorageContext.from_defaults(persist_dir=str(PERSIST_DIR))
-            index = load_index_from_storage(storage_context)
-            return index
-        except Exception as e:
-            print(f"[index] load failed, rebuilding: {repr(e)}")
-
-    # 方案 A：优先尝试从预构建索引 Dataset 下载
-    if not force_rebuild and INDEX_DATASET_ID:
-        ok, idx = _download_and_load_prebuilt_index()
-        if ok and idx is not None:
-            return idx
-        if PERSIST_DIR.exists():
-            try:
-                import shutil
-                shutil.rmtree(PERSIST_DIR)
-            except Exception:
-                pass
-        PERSIST_DIR.mkdir(parents=True, exist_ok=True)
-
-    courses_dir = _get_courses_dir()
-    print(f"[index] building from: {courses_dir}")
-
-    reader = SimpleDirectoryReader(
-        input_dir=str(courses_dir),
-        recursive=True,
-        required_exts=[".md", ".pdf", ".txt", ".py", ".ipynb", ".docx"],
+        build_status["error"] = str(e)
+        build_status["progress"] = f"❌ 错误: {str(e)}"
+    finally:
+        build_status["running"] = False
+
+
+def start_build(clear_first: bool):
+    """启动索引构建"""
+    global build_status
+    
+    if build_status["running"]:
+        return "⚠️ 索引构建正在进行中，请等待完成..."
+    
+    # 重置状态
+    build_status = {"running": False, "progress": "", "error": None, "result": None}
+    
+    # 启动后台线程
+    thread = threading.Thread(
+        target=build_index_worker,
+        args=(clear_first,),
+        daemon=True
     )
-    documents = reader.load_data()
-    print(f"[index] loaded {len(documents)} docs/chunks, embedding now...")
-
-    index = VectorStoreIndex.from_documents(documents)
-    PERSIST_DIR.mkdir(parents=True, exist_ok=True)
-    index.storage_context.persist(persist_dir=str(PERSIST_DIR))
-    return index
-
-
-INDEX: VectorStoreIndex | None = None
-INDEX_ERR: str | None = None
-
-
-def warmup():
-    global INDEX, INDEX_ERR
-    try:
-        INDEX = get_index(force_rebuild=False)
-        INDEX_ERR = None
-    except Exception as e:
-        INDEX = None
-        INDEX_ERR = repr(e)
-
-
-warmup()
-
-
-def _retrieve_nodes(question: str, top_k: int = 5) -> list:
-    """内部：用 Retriever 检索，返回 Node 列表。Clare 调用 retrieve_chunks 时复用。"""
-    global INDEX, INDEX_ERR
-    if not question or not question.strip():
-        return []
-    if INDEX is None:
-        try:
-            INDEX = get_index(force_rebuild=False)
-            INDEX_ERR = None
-        except Exception as e:
-            INDEX = None
-            INDEX_ERR = repr(e)
-    if INDEX is None:
-        return []
-    retriever = INDEX.as_retriever(similarity_top_k=top_k)
-    return retriever.retrieve(question)
-
-
-def ask(question: str, rebuild: bool) -> str:
-    global INDEX, INDEX_ERR
-    if not question or not question.strip():
-        return "请先输入一个问题。"
-
-    if rebuild or INDEX is None:
-        try:
-            INDEX = get_index(force_rebuild=True)
-            INDEX_ERR = None
-        except Exception as e:
-            INDEX = None
-            INDEX_ERR = repr(e)
-
-    if INDEX is None:
-        return f"索引不可用：{INDEX_ERR or 'unknown error'}"
-
-    # 使用免费 HuggingFace embedding 时，用 Retriever 直接检索，不创建 QueryEngine，避免触发 Settings.llm（无需安装 llama-index-llms-openai）
-    if EMBEDDING_PROVIDER == "huggingface":
-        nodes = _retrieve_nodes(question, top_k=5)
-        parts = [node.get_content() for node in nodes]
-        return "---\n\n".join(parts) if parts else "未检索到相关内容。"
-    qe = INDEX.as_query_engine()
-    resp = qe.query(question)
-    return str(resp)
-
-
-def retrieve_chunks(question: str, top_k: int = 5) -> str:
-    """
-    仅检索，不生成回答。供 Clare 等外部调用：返回检索到的课程片段，作为 RAG context。
-    Gradio api_name="retrieve" 暴露此接口。
-    """
-    nodes = _retrieve_nodes(question, top_k=top_k)
-    parts = [node.get_content() for node in nodes]
-    return "\n\n---\n\n".join(parts) if parts else ""
-
-
-def status_md() -> str:
-    emb_line = f"- **Embedding**: `{EMBEDDING_PROVIDER}` (免费)" if EMBEDDING_PROVIDER == "huggingface" else f"- **Embedding**: OpenAI (付费)"
-    idx_src = f"- **索引来源**: 预构建 `{INDEX_DATASET_ID}`" if INDEX_DATASET_ID else "- **索引来源**: 运行时构建"
-    if INDEX is not None:
-        return (
-            "✅ **Index ready**\n\n"
-            f"- **Dataset**: `{DATASET_ID}`\n"
-            f"- **Subdir**: `{DATASET_SUBDIR}`\n"
-            f"{idx_src}\n"
-            f"{emb_line}\n"
-            f"- **Index dir**: `{str(PERSIST_DIR)}`\n"
+    thread.start()
+    
+    return "🚀 索引构建已启动，请查看下方进度..."
+
+
+def get_progress():
+    """获取当前进度"""
+    if build_status["running"]:
+        return build_status["progress"] or "处理中..."
+    elif build_status["error"]:
+        return f"❌ 错误: {build_status['error']}"
+    elif build_status["result"]:
+        return build_status["result"]
+    else:
+        return "等待开始..."
+
+
+# Gradio 界面
+with gr.Blocks(title="Weaviate 索引构建工具") as app:
+    gr.Markdown("""
+    # 🔍 Weaviate 索引构建工具
+    
+    在 Hugging Face Space 上使用 OpenAI API 进行 embedding，并直接上传到 Weaviate Cloud。
+    
+    ## 配置要求
+    
+    请在 **Settings → Secrets** 中添加以下环境变量：
+    - `OPENAI_API_KEY`: OpenAI API Key（用于 embedding）
+    - `WEAVIATE_URL`: Weaviate Cloud REST 地址
+    - `WEAVIATE_API_KEY`: Weaviate API Key
+    - `WEAVIATE_COLLECTION`: Collection 名称（默认: GenAICourses）
+    - `EMBEDDING_PROVIDER`: openai 或 huggingface（默认: openai）
+    
+    ## 使用步骤
+    
+    1. 确保已将 `GENAI COURSES` 文件夹上传到 Space 根目录
+    2. 点击下方按钮开始构建索引
+    3. 等待构建完成（可能需要几分钟）
+    """)
+    
+    with gr.Row():
+        clear_first = gr.Checkbox(
+            label="清空旧索引后重建",
+            value=True,
+            info="如果勾选，会先删除旧的 collection 再重建"
         )
-    return (
-        "⚠️ **Index not ready**\n\n"
-        f"- **Dataset**: `{DATASET_ID}`\n"
-        f"- **Subdir**: `{DATASET_SUBDIR}`\n"
-        f"{idx_src}\n"
-        f"{emb_line}\n"
-        f"- **Index dir**: `{str(PERSIST_DIR)}`\n\n"
-        f"Error: `{INDEX_ERR or 'unknown'}`"
+        build_btn = gr.Button("🚀 开始构建索引", variant="primary", size="lg")
+    
+    progress_output = gr.Textbox(
+        label="构建进度",
+        lines=10,
+        interactive=False,
+        value="等待开始..."
     )
-
-
-with gr.Blocks() as demo:
-    gr.Markdown("# 📚 GENAI COURSES 向量知识库（Dataset 版）")
-    gr.Markdown(
-        "说明：课程文件不放在 Space 仓库里，而是放在 Dataset；Space 启动时会从 Dataset 下载并构建索引。"
+    
+    # 自动刷新进度
+    app.load(
+        fn=get_progress,
+        inputs=[],
+        outputs=progress_output,
+        every=2,  # 每2秒刷新一次
     )
-
-    status = gr.Markdown(value=status_md())
-
-    with gr.Row():
-        question = gr.Textbox(label="问题", placeholder="例如：Module 7 的 Lab 6 主要讲什么？")
-        rebuild = gr.Checkbox(label="强制重建索引（慢，会重新做 Embedding）", value=False)
-
-    out = gr.Markdown(label="回答")
-    btn = gr.Button("提问")
-    btn.click(fn=ask, inputs=[question, rebuild], outputs=out).then(fn=status_md, inputs=None, outputs=status)
-
-    # Clare 调用：仅检索，不生成回答。gradio_client 用 api_name="retrieve" 调用
-    with gr.Accordion("API（Clare 等外部��用）", open=False):
-        api_question = gr.Textbox(label="检索问题", placeholder="输入问题，返回检索到的课程片段")
-        api_out = gr.Textbox(label="检索结果（原始文本）", lines=8)
-        api_btn = gr.Button("Retrieve")
-    api_btn.click(
-        fn=retrieve_chunks,
-        inputs=[api_question],
-        outputs=api_out,
-        api_name="retrieve",
+    
+    build_btn.click(
+        fn=start_build,
+        inputs=[clear_first],
+        outputs=progress_output,
     )
 
 
 if __name__ == "__main__":
-    demo.launch()
-
+    app.launch()

requirements.txt

@@ -1,7 +1,6 @@
 gradio>=5.0.0
 python-dotenv>=1.0.0
 openai>=1.44.0
-huggingface_hub>=0.23.0
 
 llama-index-core>=0.10.0
 llama-index-embeddings-openai>=0.1.0
@@ -9,7 +8,11 @@ llama-index-embeddings-openai>=0.1.0
 llama-index-embeddings-huggingface>=0.1.0
 sentence-transformers>=2.2.0
 
-# Readers for common course files
+# Weaviate Cloud 向量库
+llama-index-vector-stores-weaviate>=0.2.0
+weaviate-client>=4.0.0
+
+# Readers for common course files（仅 build_weaviate_index.py 需要）
 pypdf
 python-docx
 nbformat