Huuli Search

# # app.py # import os # import re # import textwrap # from typing import List, Dict, Any, Tuple # from datetime import datetime # from fastapi import FastAPI, Request # from fastapi.responses import HTMLResponse # # --- ColBERT / PLAID --- # from pylate import models, indexes, retrieve # # ================== Config ================== # MODEL_PATH = "/home/astgpu3/workspace/bolorjinbat/LFM2-ColBERT-350M" # DOCS_FOLDER = "huuli_docs" # .txt files used only for showing text # INDEX_FOLDER = "huuli_index_storage_v2" # existing index folder # INDEX_NAME = "huuli_index_v2" # existing index name # PREVIEW_LEN = 300 # TOPK = 5 # CHUNK_CHARS = 800 # fallback for non-structured files # # Where to log all questions + answers # ANSWERS_DIR = "/home/astgpu3/workspace/bolorjinbat/LFM2-ColBERT-350M/answers" # ANSWERS_FILE = os.path.join(ANSWERS_DIR, "huuli_test_data.txt") # # ============================================ # # --------- Globals loaded at startup --------- # app = FastAPI(title="Huuli Search (FastAPI)") # MODEL = None # INDEX = None # RETRIEVER = None # DOC_MAP: Dict[str, str] = {} # doc_id -> full text to display # RE_BLOCK = re.compile( # r"ID:\s*(?P.+?)\s*" # r"Number:\s*(?P.+?)\s*" # r"Header:\s*(?P

.+?)\s*" # r"Content:\s*(?P.+?)(?=\nID:|\Z)", # flags=re.DOTALL # ) # DIVIDER_RE = re.compile(r"^\s*-{3,}\s*$", flags=re.MULTILINE) # def _normalize_spaces(s: str) -> str: # return " ".join(s.split()) # def _read_file(fname: str) -> str: # p = os.path.join(DOCS_FOLDER, fname) # if not os.path.isfile(p): # return "" # try: # return open(p, "r", encoding="utf-8").read().strip() # except Exception: # return "" # def _shorten_filename_for_index(fname: str) -> str: # """ # 'gpt-data-collector.huuli_zui.txt' -> 'huuli_zui.txt' # (keeps compatibility with index ids) # """ # if not fname.endswith(".txt"): # return fname # stem = fname[:-4] # short_stem = stem.split(".")[-1] if "." in stem else stem # return short_stem + ".txt" # def _slug(s: str) -> str: # # safe slug for ids (avoid spaces and slashes) # s = re.sub(r"\s+", "_", s.strip()) # s = s.replace("/", "_") # return s # def _parse_records(raw: str) -> List[Dict[str, str]]: # """ # Parse structured records and drop '-----' divider lines. # Returns list of dicts with id, number, header, content. # """ # if not raw: # return [] # # remove divider lines to avoid garbage inside content # cleaned = DIVIDER_RE.sub("\n", raw) # recs = [] # for m in RE_BLOCK.finditer(cleaned): # recs.append({ # "id": m.group("id").strip(), # "number": m.group("number").strip(), # "header": m.group("header").strip(), # "content": m.group("content").strip(), # }) # return recs # def _group_by_number_prefix(records: List[Dict[str, str]], fname: str # ) -> List[Tuple[str, str]]: # """ # Merge CONTIGUOUS records that share the same Number (prefix). # Example: Number '1.5' appearing across multiple records (7,8,9 points) # will be combined into a single display group, then the next different # Number starts a new group. # Returns list of (group_id, group_text). # """ # groups: List[Tuple[str, str]] = [] # if not records: # return groups # def group_id(number: str, idx: int) -> str: # # ID looks like: __numgrp___group_ # return f"{fname}__numgrp_{_slug(number)}__group_{idx}" # current_number = None # current_parts: List[str] = [] # gi = 0 # def flush(): # nonlocal gi, current_parts, current_number # if current_parts: # gid = group_id(current_number or "UNKNOWN", gi) # groups.append((gid, "\n\n".join(current_parts).strip())) # gi += 1 # current_parts = [] # for rec in records: # num = rec.get("number", "").strip() # # when Number changes, close previous group # if current_number is None or num != current_number: # flush() # current_number = num # block_lines = [] # if rec.get("id"): block_lines.append(f"ID: {rec['id']}") # if num: block_lines.append(f"Number: {num}") # if rec.get("header"): block_lines.append(f"Header: {rec['header']}") # if rec.get("content"): # block_lines.append(f"Content: {rec['content']}") # current_parts.append("\n".join(block_lines)) # flush() # return groups # def load_doc_map(folder_path: str = DOCS_FOLDER, # chunk_chars: int = CHUNK_CHARS) -> Dict[str, str]: # """ # Build a map {doc_id: full_text_for_display}. # Priority: # 1) If file is structured, create NUMBER-GROUPED doc ids: # '__numgrp___group_' # Also add a second key using the shortened file name for index compatibility. # 2) If not structured, fall back to naive chunks ('__chunk_i'). # We ALSO keep per-record ids ('__rec_i') for backward compatibility. # """ # doc_map: Dict[str, str] = {} # if not os.path.isdir(folder_path): # print(f"⚠️ DOCS folder not found: {os.path.abspath(folder_path)}") # return doc_map # for fname in sorted(os.listdir(folder_path)): # if not fname.endswith(".txt"): # continue # base = fname # base_short = _shorten_filename_for_index(base) # try: # raw = open(os.path.join(folder_path, fname), "r", encoding="utf-8").read().strip() # except Exception as e: # print(f"⚠️ Read error {fname}: {e}") # continue # records = _parse_records(raw) # if records: # # ---- 1) store per-record (compat) ---- # for i, rec in enumerate(records): # content_clean = _normalize_spaces(rec.get("content", "")) # if not content_clean: # continue # doc_map[f"{base}__rec_{i}"] = content_clean # doc_map[f"{base_short}__rec_{i}"] = content_clean # # ---- 2) store grouped-by-number for display/index ---- # groups = _group_by_number_prefix(records, base) # for gid, gtxt in groups: # gtxt_clean = _normalize_spaces(gtxt) # if not gtxt_clean: # continue # # with long name # doc_map[gid] = gtxt_clean # # with short name to match index doc ids that might use shortened base # gid_short = gid.replace(base, base_short, 1) # doc_map[gid_short] = gtxt_clean # continue # # Not structured -> fallback to naive wrap # chunks = textwrap.wrap(raw, width=chunk_chars, break_long_words=False) or [raw] # for i, c in enumerate(chunks): # text_clean = _normalize_spaces(c.strip()) # if not text_clean: # continue # doc_map[f"{base}__chunk_{i}"] = text_clean # doc_map[f"{base_short}__chunk_{i}"] = text_clean # print(f"[INFO] DOC_MAP ready with {len(doc_map)} entries") # return doc_map # # ------------- Model + Index ---------------- # def load_model_and_index(): # print("[1] Loading model…") # model = models.ColBERT(model_name_or_path=MODEL_PATH) # if getattr(model, "tokenizer", None) and model.tokenizer.pad_token is None: # model.tokenizer.pad_token = model.tokenizer.eos_token # index_root = os.path.abspath(INDEX_FOLDER) # if not os.path.isdir(index_root): # raise FileNotFoundError( # f"Index folder not found: {index_root}\nCheck INDEX_FOLDER/INDEX_NAME." # ) # print("[2] Opening existing PLAID index…") # idx = indexes.PLAID(index_folder=INDEX_FOLDER, index_name=INDEX_NAME, override=False) # if hasattr(idx, "load"): # idx.load() # ret = retrieve.ColBERT(index=idx) # return model, idx, ret # # ---------- Fallback extractors (compat) ---------- # def _extract_text_by_rec(fname: str, rec_idx: int) -> str: # full = _read_file(fname) or _read_file(_shorten_filename_for_index(fname)) # records = _parse_records(full) # if 0 <= rec_idx < len(records): # return _normalize_spaces(records[rec_idx].get("content", "")) # return "" # def _extract_text_by_chunk(fname: str, chunk_idx: int) -> str: # full = _read_file(fname) or _read_file(_shorten_filename_for_index(fname)) # chunks = textwrap.wrap(full, width=CHUNK_CHARS, break_long_words=False) or [full] # if 0 <= chunk_idx < len(chunks): # return _normalize_spaces(chunks[chunk_idx].strip()) # return "" # def _text_for_docid(doc_id: str) -> str: # """ # Lookup order: # 1) DOC_MAP (handles __numgrp_, __rec_, __chunk_ with short/long names) # 2) Reconstruct (best-effort) for __rec_ and __chunk_ # (reconstruction for __numgrp_ is not needed if DOC_MAP is loaded, # because we generate ids at startup deterministically). # """ # if not doc_id: # return "" # t = DOC_MAP.get(doc_id) # if t: # return t # # Fallback reconstruction for legacy ids: # if "__rec_" in doc_id: # fname, idx = doc_id.split("__rec_") # try: # return _extract_text_by_rec(fname, int(idx)) # except Exception: # return "" # if "__chunk_" in doc_id: # fname, idx = doc_id.split("__chunk_") # try: # return _extract_text_by_chunk(fname, int(idx)) # except Exception: # return "" # return "" # # ---------------- Search ------------------- # def search(q: str, topk: int = TOPK) -> List[Dict[str, Any]]: # q_emb = MODEL.encode([q], batch_size=1, is_query=True, show_progress_bar=False) # hits = RETRIEVER.retrieve(queries_embeddings=q_emb, k=topk)[0] # results = [] # for rank, h in enumerate(hits, start=1): # doc_id = h.get("id") # score = h.get("score") # full_text = _text_for_docid(doc_id) # preview = full_text[:PREVIEW_LEN] # results.append({ # "rank": rank, # "score": float(score) if isinstance(score, (int, float)) else score, # "doc_id": doc_id, # "preview": preview, # "full": full_text # }) # return results # # ---------- Persist answers ---------- # def save_answers(question: str, results: List[Dict[str, Any]]): # os.makedirs(ANSWERS_DIR, exist_ok=True) # ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # lines = [] # lines.append("=".ljust(80, "=")) # lines.append(f"TIMESTAMP: {ts}") # lines.append(f"QUESTION : {question}") # lines.append(f"TOPK : {len(results)}") # for r in results: # lines.append("-".ljust(80, "-")) # lines.append(f"Rank : {r['rank']}") # lines.append(f"Score: {r['score']}") # lines.append(f"DocID: {r['doc_id']}") # lines.append("Preview:") # lines.append(r["preview"]) # lines.append("") # lines.append("Full:") # lines.append(r["full"]) # lines.append("\n") # with open(ANSWERS_FILE, "a", encoding="utf-8") as f: # f.write("\n".join(lines)) # # ------------------- UI ------------------- # HTML_PAGE = """ # # # # # Huuli Search # # # # # #
#
#
# # # #
#
TOPK={{ topk }} · Preview first; click Continue to show the whole text.
#
#
#
#
# {% if q and not results %} #
No results.
# {% endif %} # {% for r in results %} #
#
#
Rank: {{ r.rank }}
#
Score: {{ '%.6f' % r.score if r.score is number else r.score }}
#
#
DocID: {{ r.doc_id }}
#
# {{ r.preview }}{% if r.full|length > r.preview|length %}…{% endif %} #
# #
{{ r.full }}
#
# {% endfor %} #
#
# # # """ # from jinja2 import Environment, BaseLoader, select_autoescape # JINJA_ENV = Environment( # loader=BaseLoader(), # autoescape=select_autoescape(['html', 'xml']) # ) # @app.get("/", response_class=HTMLResponse) # async def home(request: Request, q: str = "", topk: int = TOPK): # results = search(q, topk) if q.strip() else [] # if q.strip(): # save_answers(q, results) # template = JINJA_ENV.from_string(HTML_PAGE) # return template.render(q=q, topk=topk, results=results) # # -------------- Startup -------------- # @app.on_event("startup") # def _startup(): # global MODEL, INDEX, RETRIEVER, DOC_MAP # os.makedirs(ANSWERS_DIR, exist_ok=True) # DOC_MAP = load_doc_map(DOCS_FOLDER, CHUNK_CHARS) # MODEL, INDEX, RETRIEVER = load_model_and_index() # print(f"✅ Ready. Open http://localhost:8010") # print(f"📝 Logging to: {ANSWERS_FILE}") # # -------------- Entrypoint -------------- # if __name__ == "__main__": # import uvicorn # uvicorn.run(app, host="0.0.0.0", port=8010) # app.py # app.py # app.py import os from typing import List import torch from fastapi import FastAPI, HTTPException, Query from pydantic import BaseModel from pylate import models # ====== CONFIG ====== MODEL_PATH = "/home/astgpu3/workspace/bolorjinbat/LFM2-ColBERT-350M" # ==================== app = FastAPI(title="LFM2-ColBERT Embedding API") MODEL = None # will be loaded on startup # ---------- Pydantic models ---------- class EmbedRequest(BaseModel): text: str class EmbedResponse(BaseModel): text: str dimension: int embedding: List[float] # ---------- Model loading ---------- def load_model(): print(f"[1] Loading ColBERT model from: {MODEL_PATH}") if not os.path.isdir(MODEL_PATH): raise RuntimeError(f"MODEL_PATH does not exist: {MODEL_PATH}") model = models.ColBERT(model_name_or_path=MODEL_PATH) # Fix pad_token if missing if getattr(model, "tokenizer", None) and model.tokenizer.pad_token is None: model.tokenizer.pad_token = model.tokenizer.eos_token print("[2] Model ready.") return model # ---------- Embedding helper (with pooling) ---------- def embed_text(text: str) -> List[float]: """ Encode the text into a single embedding vector (1D list of floats). Handles different shapes from MODEL.encode by mean-pooling if needed. """ text = text.strip() if not text: return [] emb = MODEL.encode( [text], batch_size=1, is_query=True, show_progress_bar=False, ) # Ensure we have a torch tensor if isinstance(emb, torch.Tensor): t = emb else: t = torch.tensor(emb) # Possible shapes: # - [batch, tokens, dim] # - [batch, dim] # - [tokens, dim] # - [dim] if t.ndim == 3: # [1, tokens, dim] -> mean over tokens -> [1, dim] -> [dim] t = t.mean(dim=1)[0] elif t.ndim == 2: # Either [1, dim] or [tokens, dim] if t.shape[0] == 1: # [1, dim] -> [dim] t = t[0] else: # [tokens, dim] -> mean over tokens -> [dim] t = t.mean(dim=0) elif t.ndim == 1: # already [dim] pass else: raise ValueError(f"Unexpected embedding shape from model.encode: {t.shape}") return t.tolist() # ---------- API endpoints ---------- @app.post("/embed", response_model=EmbedResponse) async def embed_post(req: EmbedRequest): """ POST /embed Body: {"text": "your text here"} Returns: {"text": "...", "dimension": ..., "embedding": [...]} """ if not req.text.strip(): raise HTTPException(status_code=400, detail="text must not be empty") vec = embed_text(req.text) return EmbedResponse( text=req.text, dimension=len(vec), embedding=vec, ) @app.get("/embed", response_model=EmbedResponse) async def embed_get(q: str = Query("", description="Text to embed")): """ GET /embed?q=your+text+here Returns the same structure as POST /embed. """ if not q.strip(): raise HTTPException(status_code=400, detail="q must not be empty") vec = embed_text(q) return EmbedResponse( text=q, dimension=len(vec), embedding=vec, ) # ---------- Startup hook ---------- @app.on_event("startup") def _startup(): global MODEL MODEL = load_model() print("✅ Embedding API ready.") # ---------- Entrypoint ---------- if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8092)