Spaces:
Sleeping
Sleeping
File size: 7,794 Bytes
a72b630 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 | """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())
|