Spaces:
Sleeping
Sleeping
Download app/answer.py from Dragon-21/reverie-api: direct link, hf CLI and curl.
- Browser
- Download file 7.79 kB
-
https://huggingface.co/spaces/Dragon-21/reverie-api/resolve/main/app/answer.py
- Command line
-
hf download hf://spaces/Dragon-21/reverie-api/app/answer.py
-
curl -L -o answer.py https://huggingface.co/spaces/Dragon-21/reverie-api/resolve/main/app/answer.py
7.79 kB
| """Answer a question grounded in the retrieved journal entries. | |
| The pipeline over-fetches candidates from pgvector, then asks the LLM to do | |
| two jobs in one call: pick which entries actually answer the question, and | |
| write a short second-person reply that draws only on those. Citations are | |
| attached server-side from the fetched rows so the model cannot invent text. | |
| Run from the project root: | |
| python -m app.answer "how did I feel about Maya after she left" | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| import logging | |
| import re | |
| import sys | |
| from typing import Any | |
| from app.llm import get_provider | |
| from app.search import Hit, search | |
| log = logging.getLogger(__name__) | |
| SYSTEM_PROMPT = ( | |
| "You are Reverie, a warm and honest reader of someone's personal journal. " | |
| "You are given a question the writer is asking themselves, and a set of " | |
| "candidate journal entries retrieved from their archive. Each entry has " | |
| "an id, a date, a mood, and the full text.\n\n" | |
| "Your job is two things in one reply:\n" | |
| " 1. Decide which of the candidate entries actually help answer the " | |
| "question, and ignore the ones that do not. Some candidates may be " | |
| "topically close but wrong for the question (for example, an entry about " | |
| "a low point is not an answer to 'when did things turn around'). Use " | |
| "judgment, not just topical overlap.\n" | |
| " 2. Write a short reply, one short paragraph or two, addressed to the " | |
| "writer as 'you'. Be warm and honest. Not clinical, not therapy-speak, " | |
| "not flattering. Reference dates naturally ('back in early October', " | |
| "'around mid-November'), not as timestamps. Use only what is in the " | |
| "selected entries; never invent facts, names, or feelings the entries " | |
| "do not contain. If the entries genuinely do not answer the question, " | |
| "say so gently and stop there rather than guessing.\n\n" | |
| "Return STRICT JSON ONLY, no prose, no markdown, no code fences, with " | |
| "exactly these two keys:\n" | |
| " {\n" | |
| " \"answer\": \"the short reply, addressed to the writer as 'you'\",\n" | |
| " \"cited_ids\": [the integer ids of the entries the answer actually " | |
| "draws on, in the order they're referenced]\n" | |
| " }\n" | |
| "Do not include any entry id in cited_ids unless your answer actually " | |
| "draws on that entry. If the entries don't answer the question, return " | |
| "an empty cited_ids array and say so in the answer." | |
| ) | |
| def _format_candidates_for_prompt(hits: list[Hit]) -> str: | |
| lines: list[str] = [] | |
| for h in hits: | |
| lines.append(f"--- entry id={h.id} | date={h.date} | mood={h.mood} ---\n{h.text}") | |
| return "\n\n".join(lines) | |
| def _extract_json(text: str) -> dict[str, Any] | None: | |
| if not text: | |
| return None | |
| candidate = text.strip() | |
| fence = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", candidate, re.DOTALL) | |
| if fence: | |
| candidate = fence.group(1) | |
| else: | |
| first = candidate.find("{") | |
| last = candidate.rfind("}") | |
| if first != -1 and last != -1 and last > first: | |
| candidate = candidate[first : last + 1] | |
| try: | |
| obj = json.loads(candidate) | |
| except json.JSONDecodeError: | |
| return None | |
| return obj if isinstance(obj, dict) else None | |
| def _validate(obj: dict[str, Any]) -> tuple[str, list[int]] | None: | |
| if "answer" not in obj or "cited_ids" not in obj: | |
| return None | |
| answer = obj["answer"] | |
| cited = obj["cited_ids"] | |
| if not isinstance(answer, str) or not answer.strip(): | |
| return None | |
| if not isinstance(cited, list): | |
| return None | |
| cleaned_ids: list[int] = [] | |
| for x in cited: | |
| try: | |
| cleaned_ids.append(int(x)) | |
| except (TypeError, ValueError): | |
| return None | |
| return answer.strip(), cleaned_ids | |
| def answer_question(question: str, top_k: int = 5) -> dict[str, Any]: | |
| if not question or not question.strip(): | |
| return {"answer": "", "citations": [], "candidates_considered": 0} | |
| # Over-fetch so the model can drop topically-close-but-wrong candidates. | |
| over_fetch = max(top_k * 3, top_k) | |
| candidates = search(question, top_k=over_fetch) | |
| if not candidates: | |
| return { | |
| "answer": ( | |
| "I don't have anything in your journal that touches this. " | |
| "Try asking it a different way, or about something specific you " | |
| "remember writing about." | |
| ), | |
| "citations": [], | |
| "candidates_considered": 0, | |
| } | |
| candidates_by_id: dict[int, Hit] = {h.id: h for h in candidates} | |
| user_msg = ( | |
| f"Question:\n{question.strip()}\n\n" | |
| f"Candidate entries ({len(candidates)} of them):\n\n" | |
| f"{_format_candidates_for_prompt(candidates)}\n\n" | |
| "Return the JSON object." | |
| ) | |
| provider = get_provider() | |
| for attempt in (1, 2): | |
| try: | |
| raw = provider.complete( | |
| system=SYSTEM_PROMPT, | |
| user=user_msg, | |
| temperature=0.4, | |
| max_tokens=900, | |
| response_format_json=True, | |
| ) | |
| except Exception as exc: | |
| log.warning("answer LLM call attempt %s failed: %s", attempt, exc) | |
| if attempt == 2: | |
| raise | |
| continue | |
| parsed = _extract_json(raw) | |
| if parsed is None: | |
| log.warning("answer attempt %s produced invalid JSON.", attempt) | |
| continue | |
| validated = _validate(parsed) | |
| if validated is None: | |
| log.warning("answer attempt %s JSON missing required keys.", attempt) | |
| continue | |
| answer_text, cited_ids = validated | |
| break | |
| else: | |
| raise RuntimeError("LLM did not return valid JSON for the answer.") | |
| # Map cited ids back to fetched rows; silently drop any id not in the | |
| # candidate set so the model cannot fabricate citations. | |
| citations: list[dict[str, Any]] = [] | |
| seen: set[int] = set() | |
| for cid in cited_ids: | |
| if cid in seen: | |
| continue | |
| hit = candidates_by_id.get(cid) | |
| if hit is None: | |
| log.warning("model cited id=%s not in candidates; dropping.", cid) | |
| continue | |
| seen.add(cid) | |
| citations.append({"id": hit.id, "date": hit.date, "text": hit.text, "mood": hit.mood}) | |
| return { | |
| "answer": answer_text, | |
| "citations": citations, | |
| "candidates_considered": len(candidates), | |
| } | |
| def _print_result(question: str, result: dict[str, Any]) -> None: | |
| print(f"\nQuestion: {question}") | |
| print("=" * (10 + len(question))) | |
| print(f"\n{result['answer']}\n") | |
| cits = result.get("citations", []) | |
| if not cits: | |
| print("(no entries cited)") | |
| return | |
| print(f"Citations ({len(cits)} of {result.get('candidates_considered', '?')} considered):") | |
| for c in cits: | |
| snippet = c["text"].replace("\n", " ") | |
| if len(snippet) > 140: | |
| snippet = snippet[:137] + "..." | |
| print(f" - id={c['id']} {c['date']} mood={c['mood']}") | |
| print(f" {snippet}") | |
| def main(argv: list[str] | None = None) -> int: | |
| parser = argparse.ArgumentParser(description="Ask your memories.") | |
| parser.add_argument("question", type=str) | |
| parser.add_argument("--top-k", type=int, default=5) | |
| args = parser.parse_args(argv) | |
| try: | |
| result = answer_question(args.question, top_k=args.top_k) | |
| except RuntimeError as exc: | |
| print(f"error: {exc}", file=sys.stderr) | |
| return 2 | |
| _print_result(args.question, result) | |
| return 0 | |
| if __name__ == "__main__": | |
| logging.basicConfig( | |
| level=logging.INFO, | |
| format="%(asctime)s %(levelname)-7s %(message)s", | |
| datefmt="%H:%M:%S", | |
| ) | |
| sys.exit(main()) | |