Spaces:
Runtime error
Runtime error
| """The suggested templates in the Create report dialog: written by the AI from each post's stored ideas and topics, kept by a hash of | |
| what it read, prepared in the background as soon as ideas are extracted, and served at once whenever the dialog opens.""" | |
| import hashlib | |
| import logging | |
| import uuid | |
| from sqlalchemy import select | |
| from sqlalchemy.exc import IntegrityError | |
| from sqlalchemy.orm import Session | |
| from app.config import settings | |
| from app.llm import run | |
| from app.llm.provider import suggest_templates_lm | |
| from app.llm.signatures import SuggestReportTemplates | |
| from app.models import Document, Notebook, ReportTemplateCache | |
| from app.pipeline.generate import ideas_fresh | |
| from app.pipeline.material import max_posts | |
| from app.pipeline.passages import notebook_docs | |
| from app.services.jobs import create_job, pending_job | |
| log = logging.getLogger("notestack") | |
| SUGGEST_ITEMS = 4 # sources the AI reads to suggest templates | |
| SUMMARY_IDEAS = 3 # a post's stored ideas shown to the AI | |
| SUMMARY_CHARS = 350 # most characters of one post's summary | |
| WARM_NOTEBOOKS = 30 # notebooks prepared per run (the most recently changed) | |
| KEEP_PER_WORKSPACE = 10 # stored sets kept per workspace; the oldest go | |
| def summary(d: Document) -> str: | |
| """A post as the AI sees it when suggesting templates: its title, its topics and the key ideas already extracted from it (the | |
| ones the Mind Constellation and the topic map are built from), a few hundred characters at most.""" | |
| meta = d.metadata_json or {} | |
| ideas = [f"{i['label'].strip()}: {(i.get('note') or '').strip()}" for i in meta.get("ideas") or [] if (i.get("label") or "").strip()] | |
| tags = [t["name"] for t in meta.get("topics") or [] if t.get("name")][:3] | |
| head = d.title + (f"\nTopics: {', '.join(tags)}" if tags else "") | |
| return (head + "\n" + "\n".join(f"- {x}" for x in ideas[:SUMMARY_IDEAS]))[:SUMMARY_CHARS] | |
| def stable_order(docs: list[Document]) -> list[Document]: | |
| """The posts in an order that belongs to the posts, not to the selection: the same posts come first whenever they are picked. | |
| The templates are read from the first few, so ticking or unticking any other post gives the same input, the same key, and the | |
| templates kept for it (the ones prepared in the background for the whole notebook) are served at once, not written again.""" | |
| return sorted(docs, key=lambda d: hashlib.sha256(str(d.id).encode()).hexdigest()) | |
| def suggestion_items(material: dict[str, str], docs: list[Document]) -> list[str]: | |
| """What the AI reads: each post's stored summary when it has one (else the start of the post, as `material` holds it), or for | |
| chats their first exchange. At most SUGGEST_ITEMS, from the posts that come first in stable_order.""" | |
| if not docs: | |
| return list(material.values())[:SUGGEST_ITEMS] | |
| out = [] | |
| for d in stable_order(docs): | |
| item = summary(d) if ideas_fresh(d) else material.get(str(d.id)) | |
| if item: | |
| out.append(item) | |
| if len(out) == SUGGEST_ITEMS: | |
| break | |
| return out | |
| def cache_key(items: list[str], topic: str) -> str: | |
| return hashlib.sha256(("\x1f".join(items) + "\x1e" + (topic or "").strip()).encode()).hexdigest() | |
| def _clean(out: dict) -> list[dict]: | |
| seen, found = set(), [] | |
| for t in out.get("templates") or []: | |
| name, prompt = (t.get("name") or "").strip(), (t.get("prompt") or "").strip() | |
| if not name or not prompt or name.lower() in seen: | |
| continue | |
| seen.add(name.lower()) | |
| found.append({"id": f"suggested-{len(found) + 1}", "name": name[:60], | |
| "description": (t.get("description") or "").strip()[:200], "prompt": prompt[:1500]}) | |
| return found[:4] | |
| def suggest(db: Session, workspace_id: uuid.UUID, items: list[str], topic: str = "") -> list[dict]: | |
| """Four templates for these sources: the stored ones when the same sources were seen before, else written now (one AI call) and | |
| stored. A failed or empty answer is never stored. Never raises.""" | |
| if not items: | |
| return [] | |
| key = cache_key(items, topic) | |
| hit = db.scalar(select(ReportTemplateCache).where(ReportTemplateCache.workspace_id == workspace_id, ReportTemplateCache.key == key)) | |
| if hit and hit.templates: | |
| log.info("report templates: kept set served workspace=%s key=%s", workspace_id, key[:10]) | |
| return hit.templates | |
| log.info("report templates: no kept set, asking the model workspace=%s key=%s items=%d", workspace_id, key[:10], len(items)) | |
| try: | |
| out = run.predict(SuggestReportTemplates, db=db, workspace_id=workspace_id, lm=suggest_templates_lm(), items=items, | |
| topic=(topic or "").strip() or "(none)") | |
| except Exception: | |
| log.warning("template suggestions failed", exc_info=True) | |
| return [] | |
| templates = _clean(out) | |
| if templates: | |
| _store(db, workspace_id, key, templates) | |
| return templates | |
| def _store(db: Session, workspace_id: uuid.UUID, key: str, templates: list[dict]) -> None: | |
| try: | |
| row = db.scalar(select(ReportTemplateCache).where(ReportTemplateCache.workspace_id == workspace_id, ReportTemplateCache.key == key)) | |
| if row: | |
| row.templates = templates | |
| else: | |
| db.add(ReportTemplateCache(workspace_id=workspace_id, key=key, templates=templates)) | |
| db.commit() | |
| except IntegrityError: # another request stored the same set first | |
| db.rollback() | |
| return | |
| old = db.scalars(select(ReportTemplateCache).where(ReportTemplateCache.workspace_id == workspace_id) | |
| .order_by(ReportTemplateCache.updated_at.desc()).offset(KEEP_PER_WORKSPACE)).all() | |
| for row in old: | |
| db.delete(row) | |
| if old: | |
| db.commit() | |
| def queue_warmup(db: Session, workspace_id: uuid.UUID) -> None: | |
| """Have the templates for the workspace's notebooks prepared in the background (once at a time). Called when ideas have been | |
| extracted and when posts join a notebook, so they are ready before anyone opens the dialog.""" | |
| if settings.llm_api_key and not pending_job(db, workspace_id, "report_templates"): | |
| create_job(db, workspace_id, "report_templates", {}, max_attempts=2) | |
| def warm_workspace(db: Session, workspace_id: uuid.UUID) -> int: | |
| """Write and keep the templates of each recently changed notebook for the posts its dialog starts with (the newest ones, as the | |
| dialog ticks them), skipping a notebook whose posts have mostly no stored ideas yet (they are prepared once the ideas land) and | |
| any set already stored. Returns how many were written.""" | |
| from app.routers.videos import _excerpt, is_locked # the dialog's own preview of a post, so the keys match | |
| written = 0 | |
| for nb in db.scalars(select(Notebook).where(Notebook.workspace_id == workspace_id) | |
| .order_by(Notebook.updated_at.desc()).limit(WARM_NOTEBOOKS)): | |
| docs = [d for d in notebook_docs(db, nb.id) if not is_locked(d)][:max_posts()] | |
| if not docs or sum(1 for d in docs if ideas_fresh(d)) * 2 < len(docs): | |
| continue | |
| docs.sort(key=lambda d: d.published_at or d.created_at, reverse=True) | |
| each = 800 if len(docs) == 1 else 400 | |
| material = {str(d.id): "\n".join(p for p in (d.title or "", _excerpt(d.clean_text, each)) if p) for d in docs} | |
| items = suggestion_items(material, docs) | |
| key = cache_key(items, "") | |
| if items and not db.scalar(select(ReportTemplateCache.id).where(ReportTemplateCache.workspace_id == workspace_id, | |
| ReportTemplateCache.key == key)): | |
| written += bool(suggest(db, workspace_id, items, "")) | |
| return written | |