codex生成: API部分

api/__init__.py

@@ -0,0 +1,2 @@
+__all__ = []
+

api/main.py

@@ -0,0 +1,100 @@
+import os
+import json
+import gzip
+from typing import List, Optional, Literal
+
+from fastapi import FastAPI, Response, Depends, HTTPException, Security, Query
+from fastapi.responses import RedirectResponse
+from fastapi.security import APIKeyHeader
+from pydantic import BaseModel
+
+from utils.logger import setup_logger
+from utils.json import field_getter
+from api.search.engine import SearchEngine
+import schemas.projects as schema_projects
+
+log = setup_logger(__name__)
+
+
+# --- Auth ---
+API_KEY_NAME = "X-API-KEY"
+api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=True)
+
+
+def get_api_key(key: str = Security(api_key_header)):
+    secret = os.getenv("API_SECRET_KEY")
+    if not secret or key != secret:
+        raise HTTPException(status_code=403, detail="Could not validate credentials.")
+    return key
+
+
+# --- App ---
+engine = SearchEngine()
+app = FastAPI()
+
+
+@app.on_event("startup")
+def on_startup():
+    log.info("Initializing search engine and loading assets...")
+    engine.initialize()
+    log.info("Initialization complete.")
+
+
+@app.get("/", include_in_schema=False)
+def root():
+    return RedirectResponse("/docs")
+
+
+@app.get("/api/health")
+def health_check():
+    return {"status": "ok"}
+
+
+@app.get(
+    "/api/projects",
+    response_model=List[schema_projects.ProjectSummary],
+    dependencies=[Depends(get_api_key)],
+)
+def get_summary_data():
+    summary_fields = set(schema_projects.ProjectSummary.model_fields.keys())
+    summaries = [
+        {k: v for k, v in p.items() if k in summary_fields}
+        for p in engine.get_projects()
+    ]
+    content = json.dumps(summaries, ensure_ascii=False).encode("utf-8")
+    return Response(
+        content=gzip.compress(content),
+        headers={"Content-Encoding": "gzip", "Content-Type": "application/json"},
+    )
+
+
+@app.get(
+    "/api/details",
+    response_model=schema_projects.ProjectDetail,
+    dependencies=[Depends(get_api_key)],
+)
+def get_project_detail(projectId: str = Query(..., description="取得したい企画のID")):
+    p = engine.get_project_map().get(projectId)
+    if not p:
+        raise HTTPException(status_code=404, detail="Project not found")
+    fields = set(schema_projects.ProjectDetail.model_fields.keys())
+    return {k: v for k, v in p.items() if k in fields}
+
+
+class SearchRequest(BaseModel):
+    query: str
+    debug: bool = False
+
+
+@app.post(
+    "/api/search",
+    response_model=schema_projects.ProjectIds,
+    dependencies=[Depends(get_api_key)],
+)
+def search(request: SearchRequest):
+    if not request.query:
+        raise HTTPException(status_code=400, detail="Query cannot be empty")
+
+    pairs = engine.search(request.query, debug=request.debug)
+    ids = [pid for pid, _ in pairs]
+    return schema_projects.ProjectIds(projectIds=ids)

api/search/__init__.py

@@ -0,0 +1,2 @@
+__all__ = []
+

api/search/engine.py

@@ -0,0 +1,361 @@
+import json
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+from sudachipy import dictionary, tokenizer
+
+from utils.json import field_getter
+from utils.logger import setup_logger
+
+log = setup_logger(__name__)
+
+
+@dataclass
+class SearchConfig:
+    target_pos_l1: List[str]
+    target_fields: List[str]
+    k1: float
+    b: float
+    field_weights: Dict[str, float]
+    synonyms_enable: bool
+    syn_limits: Dict[str, int]
+    banlist: List[str]
+    word_sim_enable: bool
+    word_sim_mode: str
+    word_sim_alpha: float
+    query_subword_enable: bool
+    query_subword_path: str
+    query_subword_oov_weight: float
+    org_boost_exact: float
+    org_boost_prefix: float
+    org_boost_substring: float
+    org_boost_min_len: int
+
+
+def normalize_text_for_org(s: str) -> str:
+    try:
+        import unicodedata
+
+        s = unicodedata.normalize("NFKC", s)
+    except Exception:
+        pass
+    s = " ".join(s.split())
+    return s
+
+
+class SearchEngine:
+    def __init__(self):
+        self.cfg: Optional[SearchConfig] = None
+        self.tokenizer = None
+        self.mode = None
+        self.stopwords: set[str] = set()
+        self.custom_synonyms: Dict[str, List[str]] = {}
+        self.synonyms_cache: Dict[str, List[str]] = {}
+
+        # Data
+        self.projects: List[Dict[str, Any]] = []
+        self.project_map: Dict[str, Dict[str, Any]] = {}
+        self.org_norms: Dict[str, str] = {}
+        self.reading_norms: Dict[str, str] = {}
+
+        # BM25F assets
+        self.idf: Dict[str, float] = {}
+        self.avg_len: Dict[str, float] = {}
+        self.tf_token_docs: List[Dict[str, Any]] = []
+
+        # Vectors
+        self.word_vocab: Dict[str, int] = {}
+        self.word_vectors: Optional[np.ndarray] = None
+        self.doc_vectors: Optional[np.ndarray] = None
+        self.ft_model = None
+
+    # ----- Init / Load -----
+    def initialize(self):
+        files = field_getter("config/files.json")
+        search = field_getter("config/search_model.json")
+
+        # Config
+        self.cfg = SearchConfig(
+            target_pos_l1=search("target_pos_l1"),
+            target_fields=search("target_fields"),
+            k1=float(search("bm25f.k1")),
+            b=float(search("bm25f.b")),
+            field_weights=search("bm25f.field_weights"),
+            synonyms_enable=bool(search("synonyms.enable")),
+            syn_limits=search("synonyms.limits"),
+            banlist=search("synonyms.banlist"),
+            word_sim_enable=bool(search("word_sim.enable")),
+            word_sim_mode=(search("word_sim.mode") or "soft").lower(),
+            word_sim_alpha=float(search("word_sim.alpha")),
+            query_subword_enable=bool(search("query_subword.enable")),
+            query_subword_path=search("query_subword.path"),
+            query_subword_oov_weight=float(search("query_subword.oov_weight")),
+            org_boost_exact=float(search("organization.boost.exact", 1.0)),
+            org_boost_prefix=float(search("organization.boost.prefix", 0.7)),
+            org_boost_substring=float(search("organization.boost.substring", 0.5)),
+            org_boost_min_len=int(search("organization.boost.min_len", 2)),
+        )
+
+        # Tokenizer
+        sudachi_config_path = files("sudachi.sudachi_config")
+        tok = dictionary.Dictionary(config_path=sudachi_config_path).create()
+        self.tokenizer = tok
+        self.mode = tokenizer.Tokenizer.SplitMode.A
+
+        # Stopwords
+        with open(files("sudachi.stopwords"), encoding="utf-8") as f:
+            self.stopwords = set(json.load(f))
+
+        # Synonyms assets
+        try:
+            syn_cache_path = files("sudachi.synonyms_cache")
+            if os.path.exists(syn_cache_path):
+                with open(syn_cache_path, encoding="utf-8") as f:
+                    self.synonyms_cache = json.load(f)
+        except Exception as e:
+            log.warning(f"failed to load synonyms_cache: {e}")
+
+        try:
+            custom_path = field_getter("config/search_model.json")("synonyms.sources.custom_json")
+            if custom_path and os.path.exists(custom_path):
+                with open(custom_path, encoding="utf-8") as f:
+                    self.custom_synonyms = json.load(f)
+        except Exception:
+            pass
+
+        # Projects
+        with open(files("projects.projects_json"), encoding="utf-8") as f:
+            self.projects = json.load(f)
+        self.project_map = {p["projectId"]: p for p in self.projects}
+        self.org_norms = {p["projectId"]: normalize_text_for_org(p.get("organization") or "") for p in self.projects}
+        self.reading_norms = {p["projectId"]: normalize_text_for_org(p.get("reading") or "") for p in self.projects}
+
+        # BM25F assets
+        with open(files("bm25.bm25_meta"), encoding="utf-8") as f:
+            meta = json.load(f)
+        self.idf = meta.get("idf", {})
+        self.avg_len = meta.get("avg_len", {})
+
+        with open(files("bm25.tf_token"), encoding="utf-8") as f:
+            self.tf_token_docs = json.load(f)
+
+        # Vectors
+        try:
+            vocab_path = files("embeddings.word_vocab")
+            vec_path = files("embeddings.word_vectors")
+            if os.path.exists(vocab_path) and os.path.exists(vec_path):
+                with open(vocab_path, encoding="utf-8") as f:
+                    self.word_vocab = {k: int(v) for k, v in json.load(f).items()}
+                self.word_vectors = np.load(vec_path)["vectors"]
+        except Exception as e:
+            log.warning(f"word vectors not ready: {e}")
+
+        try:
+            doc_vec_path = files("embeddings.doc_vectors")
+            if os.path.exists(doc_vec_path):
+                self.doc_vectors = np.load(doc_vec_path)
+        except Exception as e:
+            log.warning(f"doc vectors not ready: {e}")
+
+        # fastText OOV
+        if self.cfg.query_subword_enable and self.cfg.query_subword_path and os.path.exists(self.cfg.query_subword_path):
+            try:
+                import fasttext
+
+                self.ft_model = fasttext.load_model(self.cfg.query_subword_path)
+                log.info("fastText .bin loaded for OOV")
+            except Exception as e:
+                log.warning(f"failed to load fastText .bin: {e}")
+
+    # ----- Tokenize / Synonyms -----
+    def _tokenize(self, text: str) -> List[str]:
+        if not text:
+            return []
+        out: List[str] = []
+        for m in self.tokenizer.tokenize(text, self.mode):
+            base = m.normalized_form().lower().strip()
+            if not base:
+                continue
+            pos = m.part_of_speech()
+            if pos[0] not in self.cfg.target_pos_l1:
+                continue
+            if base in self.stopwords or base in self.cfg.banlist:
+                continue
+            out.append(base)
+        return out
+
+    def _expand_synonyms(self, terms: List[str]) -> List[str]:
+        if not self.cfg.synonyms_enable:
+            return terms
+        max_exp = int(self.cfg.syn_limits.get("max_expansions_per_term", 4))
+        min_len = int(self.cfg.syn_limits.get("min_char_len", 2))
+        expanded: List[str] = []
+        for t in terms:
+            expanded.append(t)
+            cands = []
+            cands.extend(self.synonyms_cache.get(t, []))
+            cands.extend(self.custom_synonyms.get(t, []))
+            # filter/unique
+            uniq = []
+            seen = set()
+            for c in cands:
+                if c in seen or len(c) < min_len or c in self.cfg.banlist:
+                    continue
+                seen.add(c)
+                uniq.append(c)
+                if len(uniq) >= max_exp:
+                    break
+            expanded.extend(uniq)
+        # overall limit
+        max_q = int(self.cfg.syn_limits.get("max_query_variants", 5))
+        return expanded[: max_q * max_exp + len(terms)]
+
+    # ----- BM25F -----
+    def _bm25f_scores(self, terms: List[str]) -> np.ndarray:
+        N = len(self.tf_token_docs)
+        if N == 0:
+            return np.zeros((0,), dtype=np.float32)
+        k1 = self.cfg.k1
+        b = self.cfg.b
+        fw = self.cfg.field_weights
+
+        scores = np.zeros((N,), dtype=np.float32)
+
+        idf = self.idf
+        avg_len = self.avg_len
+
+        # For quick access, build list of per-doc per-field structures
+        for i, d in enumerate(self.tf_token_docs):
+            fields = d.get("fields") or {}
+            s = 0.0
+            for t in terms:
+                idf_t = float(idf.get(t, 0.0))
+                if idf_t <= 0.0:
+                    continue
+                denom_sum = 0.0
+                num_sum = 0.0
+                for field, weight in fw.items():
+                    fobj = (fields.get(field) or {})
+                    tf = float((fobj.get("tf") or {}).get(t, 0))
+                    if tf <= 0.0:
+                        continue
+                    len_f = float(fobj.get("len", 0))
+                    avg_f = float(avg_len.get(field, 0.0)) or 1.0
+                    norm = k1 * (1 - b + b * (len_f / avg_f))
+                    num_sum += weight * tf * (k1 + 1.0)
+                    denom_sum += weight * (tf + norm)
+                if denom_sum > 0:
+                    s += idf_t * (num_sum / denom_sum)
+            scores[i] = s
+        return scores
+
+    # ----- Word similarity -----
+    def _get_token_vector(self, t: str) -> Tuple[Optional[np.ndarray], bool]:
+        if self.word_vectors is not None and t in self.word_vocab:
+            v = self.word_vectors[self.word_vocab[t]]
+            return v, False
+        if self.ft_model is not None:
+            try:
+                v = self.ft_model.get_word_vector(t)
+                v = v.astype(np.float32)
+                n = np.linalg.norm(v)
+                if n > 0:
+                    v = v / n
+                return v, True
+            except Exception:
+                return None, True
+        return None, True
+
+    def _word_sim_scores(self, terms: List[str]) -> Optional[np.ndarray]:
+        if not self.cfg.word_sim_enable:
+            return None
+        if self.word_vectors is None or (self.cfg.word_sim_mode == "avg" and self.doc_vectors is None):
+            # avg needs doc_vectors; soft not implemented with per-term-per-doc words
+            return None
+
+        # Build query vector as IDF-weighted average; OOV vectors are down-weighted
+        weights = []
+        vecs = []
+        for t in terms:
+            v, oov = self._get_token_vector(t)
+            if v is None:
+                continue
+            w = float(self.idf.get(t, 0.0))
+            if oov:
+                w *= float(self.cfg.query_subword_oov_weight)
+            if w <= 0:
+                continue
+            vecs.append(v)
+            weights.append(w)
+
+        if not vecs:
+            return None
+
+        q = np.average(np.stack(vecs), axis=0, weights=np.asarray(weights, dtype=np.float32))
+        n = np.linalg.norm(q)
+        if n > 0:
+            q = q / n
+
+        # cosine with doc vectors
+        sims = self.doc_vectors @ q.astype(np.float32)
+        return sims
+
+    # ----- Public API -----
+    def search(
+        self,
+        query: str,
+        debug: bool = False,
+    ) -> List[Tuple[str, float]]:
+        terms = self._tokenize(query)
+        if self.cfg.synonyms_enable:
+            terms = self._expand_synonyms(terms)
+
+        # BM25F
+        bm25 = self._bm25f_scores(terms)
+        score = bm25.copy()
+
+        # word sim
+        ws = self._word_sim_scores(terms)
+        if ws is not None:
+            a = float(self.cfg.word_sim_alpha)
+            score = a * score + (1.0 - a) * ws
+
+        # Organization/reading auto-boost based on raw query substring match
+        qn = normalize_text_for_org(query)
+        if len(qn) >= int(self.cfg.org_boost_min_len):
+            exact = np.zeros((len(self.projects),), dtype=bool)
+            prefix = np.zeros_like(exact)
+            substr = np.zeros_like(exact)
+            for i, d in enumerate(self.projects):
+                pid = d.get("projectId")
+                on = self.org_norms.get(pid, "")
+                rn = self.reading_norms.get(pid, "")
+                if qn and (qn == on or (rn and qn == rn)):
+                    exact[i] = True
+                elif qn and (on.startswith(qn) or (rn and rn.startswith(qn))):
+                    prefix[i] = True
+                elif qn and ((qn in on) or (rn and qn in rn)):
+                    substr[i] = True
+
+            boost = (
+                exact.astype(np.float32) * float(self.cfg.org_boost_exact)
+                + prefix.astype(np.float32) * float(self.cfg.org_boost_prefix)
+                + substr.astype(np.float32) * float(self.cfg.org_boost_substring)
+            )
+            score = score + boost
+
+        # collect results
+        ids = [d.get("projectId") for d in self.projects]
+        pairs = list(zip(ids, score.tolist()))
+
+        # sort
+        pairs.sort(key=lambda x: (-x[1], x[0]))
+        return pairs
+
+    def get_projects(self) -> List[Dict[str, Any]]:
+        return self.projects
+
+    def get_project_map(self) -> Dict[str, Dict[str, Any]]:
+        return self.project_map

config/search_model.json

@@ -43,7 +43,7 @@
     }
   },
   "word_sim": {
-    "enable": false,
+    "enable": true,
     "mode": "soft",
     "alpha": 0.7
   },
@@ -52,5 +52,13 @@
     "path": "resources/embeddings/cc.ja.300.bin",
     "oov_weight": 0.8,
     "cache_size": 50000
+  },
+  "organization": {
+    "boost": {
+      "exact": 1.0,
+      "prefix": 0.7,
+      "substring": 0.5,
+      "min_len": 2
+    }
   }
 }

docs/old_index.md

@@ -0,0 +1,245 @@
+```py
+import os
+import sys
+import json
+import gzip
+import logging
+from dotenv import load_dotenv
+from fastapi import FastAPI, Response, Depends, HTTPException, Security, Query
+from fastapi.responses import RedirectResponse
+from fastapi.security import APIKeyHeader
+from pydantic import BaseModel
+from sudachipy import dictionary
+from dataclasses import asdict, fields
+from typing import Optional, Literal, List, Dict
+from pathlib import Path
+
+# デバッグ用
+from contextlib import asynccontextmanager
+from fastapi.routing import APIRoute
+
+# ローカルモジュールのインポート
+from api import search_preprocess
+from api import data_fetch
+from api.search import pipeline as search_pipeline
+from api.model import Project, ProjectSummary, ProjectDetail, ProjectIds
+
+# 親ディレクトリをパスに追加して設定ファイルをインポート
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from scripts.config import cfg_file, cfg_search_model, cfg_search_params
+
+# --- ロギング設定 ---
+_level_name = os.getenv("LOG_LEVEL", "INFO").upper()
+_level = getattr(logging, _level_name, logging.INFO)
+logging.basicConfig(level=_level, format="%(asctime)s [%(levelname)s]: %(message)s")
+log = logging.getLogger(__name__)
+log.setLevel(_level)
+
+
+# --- グローバル変数 ---
+# このファイルの場所を基準にプロジェクトルートを特定
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+# 設定情報
+settings_file = cfg_file()
+settings_search_model = cfg_search_model()
+settings_search_params = cfg_search_params()
+
+# モデルとデータ
+tokenizer_obj = None
+sentence_model = None  # kept for compatibility; no longer used
+all_projects: List[Project] = []  # populated via search_pipeline
+project_map: Dict[str, Project] = {}
+docs_for_search: Dict[str, Dict] = {}
+bm25_meta: Dict = {}
+synonyms_cache: Dict = {}
+custom_synonyms: Dict = {}
+
+
+# --- 初期化処理 ---
+
+
+def initialize_sudachi_tokenizer() -> dictionary.Dictionary:
+    """SudachiPyトークナイザをユーザー辞書と共に初期化する"""
+    sudachi_config_path = PROJECT_ROOT / "scripts/sudachi.json"
+    try:
+        if sudachi_config_path.exists():
+            log.info(
+                "SudachiPy設定ファイルが見つかりました。ユーザー辞書で初期化します。"
+            )
+            with open(sudachi_config_path, "r", encoding="utf-8") as f:
+                config = json.load(f)
+
+            # userDictのパスを絶対パスに変換
+            if "userDict" in config:
+                config["userDict"] = [str(PROJECT_ROOT / p) for p in config["userDict"]]
+
+            # configオブジェクトをJSON文字列に変換して渡す
+            return dictionary.Dictionary(config=json.dumps(config)).create()
+        else:
+            log.info(
+                "SudachiPy設定ファイルが見つかりません。システム辞書のみ使用します。"
+            )
+            return dictionary.Dictionary().create()
+    except Exception as e:
+        log.error(f"SudachiPyの初期化に失敗しました: {e}")
+        raise
+
+
+def load_all_data():
+    """Deprecated: Data is now loaded by api.search.pipeline.initialize()."""
+    log.info("load_all_data() is deprecated; using search_pipeline.initialize().")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """アプリケーションの起動時と終了時に実行される処理"""
+    # --- 起動時処理 ---
+    global tokenizer_obj, sentence_model, all_projects, project_map
+
+    log.info("アプリケーションを起動します...")
+
+    # 環境変数をロード
+    load_dotenv()
+
+    # トークナイザの初期化
+    tokenizer_obj = initialize_sudachi_tokenizer()
+    search_preprocess.set_tokenizer(tokenizer_obj)
+
+    # 生成物の確保（ローカル or HF Datasets からフェッチ）
+    try:
+        fetch_summary = data_fetch.orchestrate_fetch_and_validate(settings_search_model)
+        missing = fetch_summary.get("missing_before", [])
+        fetched = fetch_summary.get("fetched", {})
+        checks = fetch_summary.get("checks", {})
+        ok_list = [k for k, v in checks.items() if v]
+        log.info(
+            f"DATA PREP: missing_before={missing}, fetched={list(k for k,v in fetched.items() if v)}, checks_ok={ok_list}"
+        )
+        ws_conf = settings_search_model.get("word_sim", {}) or {}
+        ws_enabled = bool(ws_conf.get("enable"))
+        ws_mode = (ws_conf.get("mode") or "avg").lower()
+        ws_ready = (
+            checks.get("word_vectors.npz", False)
+            and checks.get("word_vocab.json", False)
+            and (True if ws_mode != "avg" else checks.get("doc_vectors.npy", False))
+        )
+        if ws_enabled:
+            log.info(f"WORD_SIM: requested mode={ws_mode}, assets_ready={ws_ready}")
+    except Exception as e:
+        log.warning(f"Data fetch/validate step failed: {e}")
+
+    # 検索パイプラインの初期化���データロード含む）
+    search_pipeline.initialize(tokenizer_obj)
+    # 既存エンドポイント互換のためローカル参照も持つ
+    all_projects = search_pipeline.get_projects()
+    project_map = search_pipeline.get_project_map()
+
+    # ルート情報のログ出力
+    for r in app.routes:
+        if isinstance(r, APIRoute):
+            log.info(f"ROUTE {list(r.methods)} {r.path}")
+    log.info(f"DOCS={app.docs_url} OPENAPI={app.openapi_url} REDOC={app.redoc_url}")
+    log.info("アプリケーションの準備が整いました。")
+
+    yield
+
+    # --- 終了時処理 ---
+    log.info("アプリケーションをシャットダウンします。")
+
+
+# --- FastAPIアプリケーション設定 ---
+app = FastAPI(lifespan=lifespan)
+
+# .envファイルから環境変数を読み込む
+load_dotenv()
+
+
+# --- 認証設定 ---
+API_KEY_NAME = "X-API-KEY"
+API_SECRET_KEY = os.getenv("API_SECRET_KEY")
+api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=True)
+
+
+async def get_api_key(key: str = Security(api_key_header)):
+    """APIキーを検証する依存関係"""
+    if not API_SECRET_KEY or key != API_SECRET_KEY:
+        raise HTTPException(status_code=403, detail="Could not validate credentials.")
+    return key
+
+
+# --- APIエンドポイント ---
+
+
+@app.get("/", include_in_schema=False)
+def root():
+    """ルートURLへのアクセスはドキュメントへリダイレクト"""
+    return RedirectResponse("/docs")
+
+
+@app.get("/api/health")
+def health_check():
+    """ヘルスチェック用エンドポイント"""
+    return {"status": "ok"}
+
+
+@app.get(
+    "/api/projects",
+    response_model=List[ProjectSummary],
+    dependencies=[Depends(get_api_key)],
+)
+def get_summary_data():
+    """全企画のサマリー情報をGZIP圧縮して返す"""
+    summary_fields = {f.name for f in fields(ProjectSummary)}
+    summaries = [
+        {k: v for k, v in asdict(p).items() if k in summary_fields}
+        for p in search_pipeline.get_projects()
+    ]
+
+    content = json.dumps(summaries, ensure_ascii=False).encode("utf-8")
+    return Response(
+        content=gzip.compress(content),
+        headers={"Content-Encoding": "gzip", "Content-Type": "application/json"},
+    )
+
+
+@app.get(
+    "/api/details",
+    response_model=ProjectDetail,
+    dependencies=[Depends(get_api_key)],
+)
+def get_project_detail(projectId: str = Query(..., description="取得したい企画のID")):
+    """指定されたIDの企画詳細情報を返す"""
+    project = search_pipeline.get_project_map().get(projectId)
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    detail_fields = {f.name for f in fields(ProjectDetail)}
+    project_dict = asdict(project)
+    return {key: project_dict[key] for key in detail_fields if key in project_dict}
+
+
+# --- 検索エンドポイント ---
+
+
+class SearchRequest(BaseModel):
+    query: str
+    # fusion は非推奨: 設定ファイルで制御し、ここでは受け取っても無視する
+    fusion: Optional[Literal["add", "mul"]] = None
+    debug: bool = False
+
+
+@app.post(
+    "/api/search",
+    response_model=ProjectIds,
+    dependencies=[Depends(get_api_key)],
+)
+def search(request: SearchRequest) -> ProjectIds:
+    """BM25F中心の新パイプラインで検索し、企画IDを返す。"""
+    if not request.query:
+        raise HTTPException(status_code=400, detail="Query cannot be empty")
+    result_ids = search_pipeline.search(request.query, request.debug)
+    log.info(f"検索完了: {len(result_ids)} 件を返却")
+    return ProjectIds(projectIds=result_ids)
+
+```