Inspiration
I run a daily LLM job digest for myself that pulls from Jobindex, Jobnet and LinkedIn. The LLM scores each posting from one description. It has no memory of what I liked or dismissed, cannot tell that three boards list the same job, and cannot say why it gave a score. This entry is a synthetic prototype inspired by that digest, with a Relate graph as the missing memory. Disclosure: all code in this repo was first committed on 2026-11-20, during the contest; no code was copied from my earlier private Jobradar project, only the idea. No real data from my digest is included.
What it does
The same Data Engineer opening scores 95 on Jobindex and 60 on LinkedIn: I had already liked the earlier posting, a SIMILAR_TO edge links the two boards, and the repost is capped. Flip one verdict and two scores move (j05 45→80, j06 50→75), with the Relate path as evidence.
Before any scoring, six graph queries collect facts about a job: required skills and overlap with my profile, skills related to ones I have, my verdict on similar jobs at the same company, whether it is a repost of a job I already saw, and my own verdict on it. The score is a capped heuristic: itemised contributions, clamped to 0-100, with a 60-point cap on likely reposts, and every result carries the graph path that produced it, e.g. User -DISMISSED-> j05 -SIMILAR_TO-> j06.
- Keyless judge demo:
make demoranks 10 synthetic jobs fromjobradar.rland writesdocs/demo.htmlwith per-job score parts and paths. - Feedback replay:
make replay JOB=j05 VERDICT=LIKED(judges pick any job and LIKED/DISMISSED/SEEN) applies the verdict to a temporary copy and prints every score that moved with its evidence path. Default: j05 goes 45 to 80, similar listing j06 50 to 75 viaUser -LIKED-> j05 -SIMILAR_TO(0.8)-> j06; the other eight do not move. - Why a score:
make why JOB=j06prints itemised parts (+50 base, +10 skills, +5 related skills, -15 dismissed similar) and the graph path, read-only. - Hybrid retrieval (optional):
make similar JOB=j06builds a Relate vector index on a temporary copy and returns nearest jobs together with graph evidence (same company, SIMILAR_TO, my verdict). The embedding is a toy hashed bag-of-words, not a semantic model, and the fixture has no real descriptions, so its top hit for both curated pairs mostly reflects shared titles. It does not change scoring. - Scale check (optional):
make scale N=500times a seeded synthetic graph (500 jobs: about 1.3 s import, 0.3 s to rank all, on my laptop). Synthetic workload, not real-world evidence. - Real catalog (optional):
make realranks 50 real postings from the MIT-licensed Djinni dataset on a temporary graph; only the catalog is real (the profile is invented), and it has noSIMILAR_TOlinks, so repost detection and replay run on the synthetic fixture only.make real-evalcompares the scorer with labels from a fresh AI annotator for a fictional candidate (not real feedback, and judged mostly by skill fit): AUC 0.81 for our scorer versus 0.92 for a plain matched-skill count on the first 50 postings, and 0.98 versus 0.99 on a second, fresh 50 (labelled by another fresh AI annotator), so on that sample the two are nearly level. We also pre-registered a preference-aware scorer; it lost on the held-out sample (AUC 0.89), so it is not merged. All of this is one AI annotator and a fictional profile, not real users. - Optional read-only MCP:
relate serve --mcp stdio --read-only(scriptscripts/mcp-readonly.sh) exposesget_schemaandread_cypher; the README gives example questions and Cypher, one usingCYPHER 25 FILTER. Verified by calling the tools directly on a temporary copy, and in one Claude Code session; no other agent client was tested. - Full-text discovery:
make search QUERY=engineeruses Relate's SEARCH over a title index, drops jobs already seen, and ranks the rest by graph fit. - Optional LLM: with an OpenAI-compatible endpoint, the model sees only the graph facts. Its reply is reduced to score and explanation, and any job id or number it cites must exist in the facts, otherwise the deterministic scorer runs. This is a heuristic check, not a proof of faithfulness.
How I used Relate
The whole graph is one persistent file, jobradar.rl, opened in-process: no server, no signup. One file per user is easy to back up, commit, and inspect, so judges can query the exact store I used. Jobs, companies, skills, locations and my profile are nodes; AT, REQUIRES, IN, SIMILAR_TO, LIKED, DISMISSED, RELATED_TO and HAS_SKILL are edges. Feedback is stored as relationships, not a separate table, so the same graph answers both "what does this job need" and "what did I think of its neighbours". Values are bound as parameters, and reads use --read-only.
How I built it
Python importer (idempotent MERGE, never deletes), a cross-board duplicate heuristic, a facts module with the graph queries, a deterministic scorer, an HTML report, a SQLite adapter on a synthetic schema, and tests. Everything on the judge path runs without an API key.
AI use
The repo was written with AI coding agents under my direction, in the Pi coding-agent harness. Models: Anthropic Claude and OpenAI GPT (coding, review, AI-label annotators); Claude Code only as an MCP test client. An agent wrote most of the code, tests, fixtures and docs. A separate review agent audited the design and led to fixes (unvalidated LLM output, inconsistent fixtures, a scoring gap, repost-detection changes). I set the scope, approved each step and checked results. The optional LLM scoring path calls an OpenAI-compatible endpoint; the judge demo uses no model.
Relate capabilities, third-party tools
Relate v1.2.0 embedded single-file store, CLI (--read-only), Python client relate-db 1.2.0, Cypher with bound parameters, persisted full-text index and SEARCH, vector index (toy embedding, optional), read-only MCP server (optional). CI: GitHub Actions with the checksum-pinned Relate CLI. Python standard library and SQLite. License: MIT.
Third-party data and assets: the optional make real catalog is 50 postings from the Djinni Recruitment Dataset (lang-uk, Hugging Face, MIT licence; see DATA-NOTICES.md). All other data (jobs, profile, feedback) is synthetic and invented. The cover image and page use no third-party images or fonts. The video uses no music or third-party footage; it shows only my own terminal and the page. The AI-made labels for the 50 Djinni postings and the held-out 50 are labelled as AI output for a fictional candidate.
Evaluation and honest limits
- Ranking: on 6 author-labelled pairs the graph scorer wins 6/6 and a skill-overlap baseline 4/6. The labels share signals with the scorer, so this shows the baseline cannot see them, not general ranking quality.
- Duplicate identity: 5/6 on the original benchmark and 3/5 on held-out cases written after the rule was frozen. One pair is indistinguishable from observable fields; the rule also misses a multi-city repost and flags two different roles that need the same tools.
- The shipped store is 10 synthetic jobs and one profile. The optional 50-listing Djinni catalog has a synthetic profile and AI labels, so there is no real user feedback anywhere in this repo; and I make no production claims. SQLite stays the store for dedup and history in my private digest; Relate is the relationship memory.
Challenges
Making explanations trustworthy: the first version let the LLM forward arbitrary fields and ignored my own verdict on a job. Keeping the committed .rl reproducible from fixtures. Deciding not to tune duplicate detection against withheld labels.
What's next
Add posting text to improve duplicate identity, a "seen" event from the digest, vector search over job descriptions, and testing the MCP recipe with more agent clients (one Claude Code session so far).
Mapping to the criteria
- Relate and connected context: graph paths, RELATED_TO, SIMILAR_TO, feedback edges, SEARCH.
- Functionality: import, score, search, replay, eval, tests (26), CI.
- Usefulness: fewer reposts, preference memory, explanations.
- Documentation: README, pinned dependency,
maketargets, fresh-clone verified. - Creativity: feedback replay and personal-seen-history repost logic.