hermes-interviewer 0.1.0__py3-none-any.whl

hermes_interviewer/__init__.py

@@ -0,0 +1,11 @@
+"""Hermes Interviewer - AI 面试官核心库"""
+
+__version__ = "0.1.0"
+
+from .interviewer import InterviewerClient
+from .core.config import settings
+
+__all__ = ["InterviewerClient", "settings"]
+
+# 向后兼容
+Interviewer = InterviewerClient

hermes_interviewer/core/__init__.py

@@ -0,0 +1,12 @@
+"""核心模块"""
+
+from .config import settings
+from .llm import llm_generate, llm_generate_stream
+from .embed import embed
+
+__all__ = [
+    "settings",
+    "llm_generate",
+    "llm_generate_stream", 
+    "embed",
+]

hermes_interviewer/core/config.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    project_name: str = "LocalAI-Interviewer"
+    base_url: str = "http://localhost:8000"
+    api_prefix: str = "/api/v1"
+
+    data_dir: Path = Path(__file__).resolve().parent.parent.parent / "data"
+    db_path: Path = data_dir / "db" / "interview.db"
+    chroma_dir: Path = data_dir / "chroma_data"
+    upload_dir: Path = data_dir / "uploads"
+    # 生成简历时是否自动另存一份到系统桌面（本地工具默认开；测试用 APP_RESUME_SAVE_DESKTOP=0 关闭）
+    resume_save_desktop: bool = True
+
+    ollama_host: str = os.getenv("OLLAMA_HOST", "http://localhost:11434")
+    llm_model: str = "qwen2.5:7b"
+    embedding_model: str = "bge-m3"
+    embedding_dim: int = 1024
+
+    # 嵌入提供方：ollama（本地 Ollama）/ huggingface（本地 sentence-transformers）。默认 ollama，可在设置页运行时切换。
+    embedding_provider: str = "ollama"
+    huggingface_model: str = "BAAI/bge-m3"
+
+    # 文本生成提供方：ollama（本地）/ deepseek（API）。默认 ollama，可在设置页运行时切换。
+    llm_provider: str = "ollama"
+    deepseek_api_key: str = ""
+    deepseek_base_url: str = "https://api.deepseek.com"
+    deepseek_model: str = "deepseek-v4-flash"
+    deepseek_max_tokens: int = 4096
+    # 该网关默认会先输出一长段“思考”再作答，出题/评分/品鉴延迟高。
+    # 默认关闭思考以大幅提速（如需深度推理可设 APP_DEEPSEEK_DISABLE_THINKING=false）
+    deepseek_disable_thinking: bool = True
+
+    llm_timeout: float = 120.0
+    embed_timeout: float = 300.0
+    max_history_rounds: int = 3
+    default_max_rounds: int = 8
+    session_expire_hours: int = 2
+
+    chunk_size: int = 1500
+    chunk_overlap: int = 200
+
+    eval_weights_depth: float = 0.4
+    eval_weights_logic: float = 0.3
+    eval_weights_integrity: float = 0.3
+
+    allowed_extensions: set[str] = {
+        ".java", ".py", ".js", ".ts", ".go", ".md", ".yaml", ".yml", ".sql",
+        ".kt", ".scala", ".rs", ".c", ".cpp", ".h", ".cs", ".rb", ".php",
+    }
+    ignored_dirs: set[str] = {
+        ".git", "node_modules", "__pycache__", "target", "build", "dist",
+        ".idea", ".vscode", "venv", ".venv", "env", ".env",
+    }
+
+    model_config = {"env_prefix": "APP_", "env_file": ".env", "extra": "ignore"}
+
+
+settings = Settings()
+settings.data_dir.mkdir(parents=True, exist_ok=True)
+settings.db_path.parent.mkdir(parents=True, exist_ok=True)
+settings.chroma_dir.mkdir(parents=True, exist_ok=True)
+settings.upload_dir.mkdir(parents=True, exist_ok=True)

hermes_interviewer/core/embed.py

@@ -0,0 +1,132 @@
+"""统一嵌入客户端：支持 Ollama 和 HuggingFace (sentence-transformers) 两种后端。
+
+- 运行时通过 llm_config 的 embedding_provider 字段切换。
+- HuggingFace 模式使用 sentence-transformers 加载模型，首次加载较慢，后续从缓存读取。
+- Ollama 模式复用原有 /api/embed 接口。
+- 所有调用方（indexing_service, resume_service 等）统一使用本模块的 embed() 函数。
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import httpx
+
+from .config import settings
+
+logger = logging.getLogger(__name__)
+
+_hf_model = None  # lazy-loaded SentenceTransformer instance
+
+
+def _get_embedding_provider() -> str:
+    try:
+        from .llm_config import get_llm_settings
+        return get_llm_settings().embedding_provider
+    except Exception:
+        return "ollama"
+
+
+def _get_hf_model_name() -> str:
+    try:
+        from .llm_config import get_llm_settings
+        return get_llm_settings().huggingface_model
+    except Exception:
+        return "BAAI/bge-m3"
+
+
+async def embed(texts: list[str]) -> list[list[float]]:
+    """统一嵌入接口，根据 embedding_provider 自动路由。"""
+    provider = _get_embedding_provider()
+    if provider == "huggingface":
+        return await _embed_huggingface(texts)
+    return await _embed_ollama(texts)
+
+
+async def _embed_ollama(texts: list[str]) -> list[list[float]]:
+    """通过 Ollama /api/embed 生成嵌入向量。"""
+    model = settings.embedding_model
+    url = f"{settings.ollama_host}/api/embed"
+    payload = {"model": model, "input": texts}
+    timeout = settings.embed_timeout
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        resp = await client.post(url, json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+    embeddings = data.get("embeddings", [])
+    if not embeddings:
+        logger.warning("Ollama embed 返回空结果，model=%s, input_len=%d", model, len(texts))
+    return embeddings
+
+
+async def _embed_huggingface(texts: list[str]) -> list[list[float]]:
+    """通过本地 HuggingFace sentence-transformers 模型生成嵌入向量。"""
+    global _hf_model
+    import asyncio
+    import functools
+
+    model_name = _get_hf_model_name()
+
+    if _hf_model is None:
+        logger.info("Loading HuggingFace embedding model: %s (首次加载较慢)...", model_name)
+        try:
+            _hf_model = await asyncio.to_thread(_load_hf_model, model_name)
+            logger.info("HuggingFace embedding model loaded: %s", model_name)
+        except Exception:
+            logger.exception("Failed to load HuggingFace embedding model: %s", model_name)
+            raise
+
+    try:
+        result = await asyncio.to_thread(_hf_model.encode, texts, normalize_embeddings=True)
+        embeddings = [vec.tolist() for vec in result]
+        return embeddings
+    except Exception:
+        logger.exception("HuggingFace embedding failed, model=%s", model_name)
+        raise
+
+
+def _load_hf_model(model_name: str):
+    """在线程中加载 sentence-transformers 模型。"""
+    from sentence_transformers import SentenceTransformer
+    return SentenceTransformer(model_name, trust_remote_code=True)
+
+
+async def health_check() -> dict[str, Any]:
+    """检测当前嵌入后端是否可用。"""
+    provider = _get_embedding_provider()
+    if provider == "huggingface":
+        return await _health_huggingface()
+    return await _health_ollama()
+
+
+async def _health_ollama() -> dict[str, Any]:
+    try:
+        url = f"{settings.ollama_host}/api/tags"
+        async with httpx.AsyncClient(timeout=5) as client:
+            resp = await client.get(url)
+            resp.raise_for_status()
+        return {"ok": True, "provider": "ollama", "message": "Ollama 可连接"}
+    except Exception as e:
+        return {"ok": False, "provider": "ollama", "message": f"Ollama 不可达: {e}"}
+
+
+async def _health_huggingface() -> dict[str, Any]:
+    global _hf_model
+    import asyncio
+
+    model_name = _get_hf_model_name()
+    try:
+        if _hf_model is None:
+            _hf_model = await asyncio.to_thread(_load_hf_model, model_name)
+        # quick encode test
+        await asyncio.to_thread(_hf_model.encode, ["test"], normalize_embeddings=True)
+        return {"ok": True, "provider": "huggingface", "model": model_name, "message": f"HuggingFace {model_name} 就绪"}
+    except Exception as e:
+        return {"ok": False, "provider": "huggingface", "model": model_name, "message": f"HuggingFace 模型不可用: {e}"}
+
+
+def reload_model() -> None:
+    """强制重新加载 HuggingFace 模型（切换模型后调用）。"""
+    global _hf_model
+    _hf_model = None

hermes_interviewer/core/evaluator.py

@@ -0,0 +1,215 @@
+"""评估系统"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Optional
+
+from .config import settings
+from .llm import llm_generate
+
+logger = logging.getLogger(__name__)
+
+# 评估维度权重
+DEFAULT_WEIGHTS = {
+    "depth": 0.4,
+    "logic": 0.3,
+    "integrity": 0.3,
+}
+
+
+async def evaluate_answer(
+    question: str,
+    answer: str,
+    context: str = "",
+    difficulty: str = "medium",
+) -> dict[str, Any]:
+    """
+    评估候选人回答
+    
+    Args:
+        question: 面试问题
+        answer: 候选人回答
+        context: 参考上下文（代码片段等）
+        difficulty: 难度（easy/medium/hard/hell）
+    
+    Returns:
+        评估结果
+    """
+    system = """你是一位资深技术面试官。请从三个维度评估候选人的回答：
+1. 技术深度（depth）：是否涉及底层原理、源码级理解、性能考量
+2. 逻辑清晰度（logic）：回答是否条理清晰、有理有据
+3. 解决方案完整性（integrity）：是否覆盖边界条件、异常处理、可扩展性
+
+请严格按以下JSON格式返回评分（不要包含任何其他文字）：
+{"depth": <1-10>, "logic": <1-10>, "integrity": <1-10>, "comment": "<50字以内的评价>"}"""
+    
+    prompt = f"""面试问题：{question}
+
+候选人回答：
+{answer}
+
+参考上下文：
+{context}
+
+请评估该回答质量。"""
+    
+    response = await llm_generate(prompt, system)
+    result = _parse_json(response)
+    
+    if result:
+        # 归一化分数
+        depth = _to_score(result.get("depth", 5))
+        logic = _to_score(result.get("logic", 5))
+        integrity = _to_score(result.get("integrity", 5))
+        
+        # 计算加权平均
+        weights = settings.eval_weights_depth, settings.eval_weights_logic, settings.eval_weights_integrity
+        overall = depth * weights[0] + logic * weights[1] + integrity * weights[2]
+        
+        return {
+            "depth": depth,
+            "logic": logic,
+            "integrity": integrity,
+            "overall": round(overall, 1),
+            "comment": result.get("comment", ""),
+        }
+    
+    return {
+        "depth": 5.0,
+        "logic": 5.0,
+        "integrity": 5.0,
+        "overall": 5.0,
+        "comment": "评估失败",
+    }
+
+
+async def evaluate_intro(introduction: str) -> dict[str, Any]:
+    """
+    评估自我介绍
+    
+    Args:
+        introduction: 候选人自我介绍
+    
+    Returns:
+        评估结果
+    """
+    system = """你是一位资深技术面试官。候选人刚刚做完自我介绍，请从以下三个维度点评：
+1. 表达清晰度（clarity）：条理是否清楚、重点是否突出
+2. 内容充实度（substance）：是否讲清了背景、项目经历、技术栈
+3. 岗位匹配度（fit）：介绍内容是否贴合目标岗位
+
+请严格按以下JSON格式返回评分（不要包含任何其他文字）：
+{"clarity": <1-10>, "substance": <1-10>, "fit": <1-10>, "comment": "<评语>"}"""
+    
+    prompt = f"""候选人自我介绍：
+{introduction}
+
+请评估该自我介绍质量。"""
+    
+    response = await llm_generate(prompt, system)
+    result = _parse_json(response)
+    
+    if result:
+        return {
+            "clarity": _to_score(result.get("clarity", 5)),
+            "substance": _to_score(result.get("substance", 5)),
+            "fit": _to_score(result.get("fit", 5)),
+            "comment": result.get("comment", ""),
+        }
+    
+    return {
+        "clarity": 5.0,
+        "substance": 5.0,
+        "fit": 5.0,
+        "comment": "评估失败",
+    }
+
+
+async def generate_report(
+    history: list[dict],
+    scores: list[dict],
+) -> dict[str, Any]:
+    """
+    生成面试报告
+    
+    Args:
+        history: 面试对话历史
+        scores: 各轮评分
+    
+    Returns:
+        评估报告
+    """
+    system = """你是面试评估专家。请根据面试对话历史生成一份评估报告。
+返回JSON格式：
+{
+    "overall_score": <总分1-10>,
+    "strengths": ["优势1", "优势2"],
+    "weaknesses": ["不足1", "不足2"],
+    "suggestions": ["建议1", "建议2"],
+    "summary": "综合评价"
+}"""
+    
+    # 计算平均分
+    avg_scores = {}
+    if scores:
+        for key in ["depth", "logic", "integrity"]:
+            values = [s.get(key, 5) for s in scores if key in s]
+            avg_scores[key] = sum(values) / len(values) if values else 5.0
+    
+    history_text = "\n".join([
+        f"{'面试官' if h['role'] == 'assistant' else '候选人'}: {h['content']}"
+        for h in history
+    ])
+    
+    prompt = f"""面试历史：
+{history_text}
+
+平均得分：{json.dumps(avg_scores, ensure_ascii=False)}
+
+请生成评估报告。"""
+    
+    response = await llm_generate(prompt, system)
+    result = _parse_json(response)
+    
+    if result:
+        return result
+    
+    return {
+        "overall_score": 5.0,
+        "strengths": [],
+        "weaknesses": [],
+        "suggestions": [],
+        "summary": "报告生成失败"
+    }
+
+
+def _parse_json(text: str) -> Optional[dict]:
+    """从文本中解析JSON"""
+    if not text:
+        return None
+    
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+    
+    start = text.find("{")
+    end = text.rfind("}")
+    if start != -1 and end > start:
+        try:
+            return json.loads(text[start:end + 1])
+        except json.JSONDecodeError:
+            pass
+    
+    return None
+
+
+def _to_score(value: Any, default: float = 5.0) -> float:
+    """转换为1-10的分数"""
+    try:
+        score = float(value)
+    except (TypeError, ValueError):
+        return default
+    return max(1.0, min(10.0, score))