Add /search_vector + OAuth-authed per-user feeds store

app.py

@@ -17,7 +17,7 @@ from typing import List, Optional
 import duckdb
 import httpx
 from cashews import cache
-from fastapi import FastAPI, HTTPException, Query
+from fastapi import FastAPI, Header, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
 from huggingface_hub import HfApi, hf_hub_download, list_repo_files, login
 from pydantic import BaseModel
@@ -591,6 +591,103 @@ async def embed_query_route(text: str = Query(min_length=3, max_length=200)):
     return {"embedding": embed_query(f"Instruct: {DS_TASK}\nQuery:{text}")}
 
 
+class VectorSearchReq(BaseModel):
+    repo_type: str
+    vector: List[float]
+    k: int = 20
+    exclude_ids: List[str] = []
+    include_embeddings: bool = False
+
+
+@app.post("/search_vector")
+async def search_vector(req: VectorSearchReq):
+    """KNN search with a caller-supplied (already 256-d, normalised) vector.
+
+    Powers relevance-feedback loops: refine a preference vector client-side
+    from votes, then pull fresh results for it. exclude_ids drops already-seen
+    items server-side so refinement surfaces new material.
+    """
+    if req.repo_type not in ("datasets", "models"):
+        raise HTTPException(status_code=422, detail="repo_type must be datasets|models")
+    if len(req.vector) != EMB_DIM:
+        raise HTTPException(status_code=422, detail=f"vector must be {EMB_DIM}-d")
+    table = "dataset_cards" if req.repo_type == "datasets" else "model_cards"
+    k = max(1, min(int(req.k), 100))
+    n = k + len(req.exclude_ids[:300])
+    raw = _knn(table, req.vector, n, "", COLS + (", emb" if req.include_embeddings else ""))
+    excl = set(req.exclude_ids[:300])
+    out = []
+    for row in raw:
+        emb_val = row[-2] if req.include_embeddings else None
+        (id_, summary, likes, downloads, param, task, license_, language, last_modified) = row[:9]
+        if id_ in excl:
+            continue
+        item = {"id": id_, "summary": summary, "likes": int(likes),
+                "downloads": int(downloads), "param_count": int(param),
+                "task": task, "license": license_, "language": language,
+                "last_modified": last_modified, "similarity": float(row[-1])}
+        if req.include_embeddings:
+            item["embedding"] = [float(x) for x in emb_val]
+        out.append(item)
+        if len(out) >= k:
+            break
+    return {"results": out}
+
+
+# --- per-user feeds store (OAuth token -> whoami -> one JSON doc per user) ---
+FEEDS_STORE_REPO = os.getenv("FEEDS_STORE_REPO", "davanstrien/hub-feeds-store")
+FEEDS_DOC_LIMIT = 300_000  # bytes
+
+
+@cache(ttl="10m", key="whoami:{token}")
+async def _resolve_user(token: str) -> str:
+    async with httpx.AsyncClient(timeout=10) as c:
+        r = await c.get("https://huggingface.co/api/whoami-v2",
+                        headers={"Authorization": f"Bearer {token}"})
+    if r.status_code != 200:
+        raise HTTPException(status_code=401, detail="Invalid or expired HF token")
+    name = r.json().get("name")
+    if not name:
+        raise HTTPException(status_code=401, detail="Could not resolve username")
+    return name
+
+
+async def _auth_user(authorization: str) -> str:
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Missing Bearer token")
+    return await _resolve_user(authorization[7:])
+
+
+@app.get("/feeds_store")
+async def feeds_load(authorization: str = Header(default=None)):
+    user = await _auth_user(authorization)
+    import json as _json
+    try:
+        path = hf_hub_download(FEEDS_STORE_REPO, f"users/{user}.json",
+                               repo_type="dataset", force_download=True)
+        with open(path) as f:
+            return {"user": user, "doc": _json.load(f)}
+    except Exception:
+        return {"user": user, "doc": None}
+
+
+class FeedsSaveReq(BaseModel):
+    doc: dict
+
+
+@app.put("/feeds_store")
+async def feeds_save(req: FeedsSaveReq, authorization: str = Header(default=None)):
+    user = await _auth_user(authorization)
+    import json as _json
+    payload = _json.dumps(req.doc).encode()
+    if len(payload) > FEEDS_DOC_LIMIT:
+        raise HTTPException(status_code=413, detail="Feeds doc too large")
+    HfApi().upload_file(path_or_fileobj=payload, path_in_repo=f"users/{user}.json",
+                        repo_id=FEEDS_STORE_REPO, repo_type="dataset",
+                        commit_message=f"feeds sync: {user}")
+    return {"ok": True, "user": user, "bytes": len(payload)}
+
+
 # --- suggest (autocomplete; old backend never implemented it — bonus) --------
 @app.get("/suggest/{repo_type}")
 @cache(ttl="1h", key="suggest:{repo_type}:{q}")