DEV Community: Shikhar Goel

Turning My Twitch Follow Graph Into Agent Memory (Twitch x Cognee)

Shikhar Goel — Sat, 31 Oct 2026 18:26:51 +0000

This is my Mergetober hackathon entry for the Twitch connector (proposed in cognee#6489).

I follow a few dozen Twitch channels, and a surprising amount of what I "know" lives in their VODs — conference talks, deep-dive coding sessions, speedrun history. Twitch's own search is famously bad at "which of my channels streamed about Rust last month, and what was that VOD where they rebuilt their parser?"

So I connected the follow graph to cognee: the channels I follow, each channel's description and current category, and their VODs and clips become searchable memory.

Connecting

Register a free app at dev.twitch.tv/console, mint a user token with user:read:follows (the README walks the one-click flow), and:

import cognee
from cognee_community_connector_twitch import twitch_source

await cognee.remember(
    twitch_source(client_id, access_token),
    dataset_name="twitch",
    primary_key="id",
    write_disposition="merge",
    max_rows_per_table=0,
)

answers = await cognee.recall(
    "Which of the channels I follow recently streamed about Rust, and what were those VODs about?",
    datasets=["twitch"],
)

Design notes

Full re-list + diff. Each sync re-lists follows and each channel's VODs/clips (paginated), then diffs against the previous run: unfollowing a channel forgets the channel and all its stored VOD/clip documents; a VOD that expired is forgotten too. The diff drives _deleted hard-delete rows that orphan cleanup physically removes.
Stable rows under churn. view_count is deliberately excluded from rendered content — view counts change constantly, and including them would re-process every VOD on every sync. A VOD's row is byte-identical until its title or description changes. Durations parse from Helix's PT2H14M33S into something a human and an LLM both read (2h 14m 33s).
Graph linking. Every VOD and clip row carries a channel:<login> node set, so a channel's content stays connected in the graph.
Verified against the docs, not memory: /channels takes repeated broadcaster_id params and does not return descriptions — channel descriptions live on the user object, so they're fetched from batched GET /users. Details like this are why you check the reference.
Limits. Ratelimit-Remaining is honoured; a wait over 60s stops the run cleanly with nothing lost. max_channels (default 25) bounds big follow lists, and a channels= filter syncs a subset.

Verified so far

The connector runs end-to-end today: the full suite passes (every Helix endpoint verified against the official docs), including delivery tests that drive a real dlt pipeline and prove an unfollowed channel — and its VODs and clips — physically disappears after the _deleted tombstones.

$ uv run pytest tests/ -q
55 passed in 3.94s

I'll add numbers from my own follow list here as the syncs run.

Honest limitations

No live-chat history — Helix doesn't expose it.
The clips endpoint returns a view-count top-list (~1000 clips), so a clip falling out of the top listing is forgotten even if it still exists. Documented, not hidden.
VODs expire on Twitch's schedule; the connector treats that as a deletion, which is the correct memory semantics.

The connector is at packages/connector/twitch/ in cognee-community PR #600 — 55 tests, every endpoint verified against dev.twitch.tv, delivery tests proving unfollow/expiry physically removes documents from a real dlt pipeline.

An Agent That Knows What I Watched, When, and Where I Left Off (Trakt x Cognee)

Shikhar Goel — Sat, 31 Oct 2026 18:24:43 +0000

This is my Mergetober hackathon entry for the Trakt connector (proposed in cognee#6488).

Trakt is the quiet layer that has tracked everything I've watched for years — scrobbled automatically from my media setup, every episode with a timestamp. It's the closest thing I have to a ground-truth viewing record, and until now it was write-only memory: tracked, stored, never used.

This connector makes it agent-readable. With cognee, "which show was I bingeing in March?", "what episode did I last watch of Severance?" and "what's rated highly on my watchlist but never watched?" become answerable from my actual history.

Connecting

Trakt's official OAuth PIN flow, walked through in the README: create a free app at trakt.tv/oauth/applications, run the built-in helper, paste the PIN once:

from cognee_community_connector_trakt import trakt_pin_flow, trakt_source
import cognee

trakt_pin_flow(client_id, client_secret)   # prints a URL, asks for the PIN, saves the token

await cognee.remember(
    trakt_source(client_id, access_token),
    dataset_name="trakt",
    primary_key="id",
    write_disposition="merge",
    max_rows_per_table=0,
)

answers = await cognee.recall(
    "What shows was I watching recently, and where did I leave off?",
    datasets=["trakt"],
)

What gets remembered — and how it stays cheap

Movies, episodes and shows I've watched (dates, play counts, titles), my ratings, my watchlist and my lists — one document each, with show:<slug> and list:<slug> node sets so episodes link to their show and lists link to their members in the graph, no LLM required.
Incremental by section, not by everything. Trakt exposes /sync/last_activities — one timestamp per section of your history. The connector stores those and re-pulls only what moved. An idle account costs one request per sync. Within a changed section it re-lists fully and upserts via merge, so unchanged rows keep their content hash and are never re-processed.
Ratings don't get lost. A movie you rated but never watched still becomes a document. Unwatching a rated movie converts its document rather than deleting it — the cross-section forget-on-delete only tombstones a key when no section claims it.
Token hygiene and limits. The client refreshes expired tokens itself, honours Retry-After, and a rate-limit wait longer than 60 seconds stops the run cleanly with nothing confirmed — the next sync resumes. The token never appears in a repr, log or error.

Verified so far

The connector runs end-to-end today: the full suite passes (every endpoint verified against the official Trakt API contract), including a delivery test that drives a real dlt pipeline and proves an item removed from history physically disappears after the _deleted tombstone.

$ uv run pytest tests/ -q
42 passed in 3.87s

I'll add numbers from my own history here as the syncs run — including the one-request idle sync.

Honest limitations

Watched-show payloads don't carry episode ids, so the connector resolves them per-show from the seasons endpoint once (documented fallback if a show is delisted).
Rate limits are real (500 GETs / 5 min per app); big first syncs page through and stop cleanly rather than hammering.
History privacy: this is your full viewing record going into your own cognee dataset — keep the dataset private.

The connector is at packages/connector/trakt/ in cognee-community PR #599, with 42 tests (every endpoint verified against the official Trakt API contract) and delivery tests proving physical deletion on unwatched items.

My AI Now Remembers Every Film I've Watched — and What I Thought of It (Letterboxd x Cognee)

Shikhar Goel — Sat, 31 Oct 2026 18:24:30 +0000

This is my Mergetober hackathon entry for the Letterboxd connector (proposed in cognee#6487).

Letterboxd is where I've logged every film I've watched for years — with ratings, diary entries, rewatch notes and the occasional review I'm proud of. It's a rich, personal dataset sitting behind a social UI that can't do anything except show it back to me chronologically.

This connector pipes the official Letterboxd export into cognee, so an agent can actually answer questions over my film history: "what did I think of Denis Villeneuve's filmography?", "which noirs did I log while studying noir?", "how many times have I rewatched Parasite?"

One ZIP, zero credentials

Letterboxd has no public API, but every member can export everything (Settings → Import & Export → Export). The connector takes the ZIP — or an extracted folder — and that's the entire setup:

import cognee
from cognee_community_connector_letterboxd import letterboxd_source

await cognee.remember(
    letterboxd_source("letterboxd_export.zip"),
    dataset_name="letterboxd",
    primary_key="id",
    write_disposition="merge",
    max_rows_per_table=0,
)

answers = await cognee.recall(
    "Which films did I rate highest, and what did I think of them?",
    datasets=["letterboxd"],
)

What gets remembered

One document per film, merged across watched.csv, ratings.csv, reviews.csv and diary.csv — my rating rendered as stars (the 10-point scale becomes half-star precision, so 7.5 → ★★★½), my full review text, and a date-ordered watch timeline with rewatch markers and tags.
One document per list, with the ordered roster — so "my favourite slow cinema" list is itself a memorable object.
Graph links for free: every film row carries node-set keys for the lists it belongs to and its decade, so films connect across lists and eras without any LLM extraction.

Incremental + forget-on-delete

Rows are keyed by the stable public film URI and rendered deterministically, so re-exporting and re-running upserts only what changed (an edited review touches exactly one row). And it works in both directions: films or lists present last time but gone from the new export are emitted as hard-delete markers, and cognee's orphan cleanup physically removes them from the graph and vector stores. The memory tracks the library, not a stale snapshot of it.

The parser matches columns by name and ignores unknown ones, so Letterboxd adding columns to future exports won't break it. The only fatal error is a missing watched.csv.

Verified so far

The connector runs end-to-end today: the full suite passes against fixtures mirroring the real CSV shapes (rewatches, tags, list rosters), and the delivery tests drive a real dlt pipeline where an edited review updates its row in place and a deleted film or list physically disappears after the _deleted tombstone.

$ uv run pytest tests/ -q
39 passed in 5.11s

I'll add numbers from my own export here as the syncs run.

Honest limitations

Exports are snapshots: edits/removals are detected on the next export + sync.
Older exports don't include the watchlist.
No half-star diary ratings before 10-point conversion existed — handled by the same conversion.

The connector lives at packages/connector/letterboxd/ in cognee-community PR #598 — 39 tests against the real CSV shapes (rewatches, tags, list rosters, tolerant parsing) plus delivery tests proving edits upsert and deletions physically disappear.

I Gave My AI a Memory of Every Book I've Read (Goodreads x Cognee)

Shikhar Goel — Sat, 31 Oct 2026 18:24:09 +0000

This is my Mergetober hackathon entry for the Goodreads connector (PR, proposed in cognee#6486).

I've tracked my reading on Goodreads since 2016. Nine years of data: every book, every rating, every half-finished review I typed into a phone at 1am. It's the most complete record of what I've learned and felt that I own — and it's completely inert. Goodreads won't answer a question for me. It certainly won't tell my AI assistant what I thought of Thinking, Fast and Slow or which books on systems design I've already absorbed.

So I built the missing pipe: a cognee connector that turns a Goodreads library export into agent memory.

Why an export parser and not an API

Goodreads retired its public API in 2020. The library export (Settings → Import/Export → "Export Library") is the only supported access path left — and it's actually a better one for this use case: one file, everything in it, no rate limits, no OAuth. The connector takes the CSV path, no credentials:

import cognee
from cognee_community_connector_goodreads import goodreads_source

await cognee.remember(
    goodreads_source("goodreads_library_export.csv"),
    dataset_name="goodreads",
    primary_key="id",
    write_disposition="merge",   # required: see below
    max_rows_per_table=0,
)

answers = await cognee.recall(
    "Which books did I read about distributed systems, and what did I think of them?",
    datasets=["goodreads"],
)

What actually ends up in memory

Every book becomes one document: title, author, year, ISBN, shelves, status (read / currently reading / to-read), average rating — and the interesting part, my per-read timeline. Goodreads exports re-reads as repeated Date Read / My Rating / My Review columns; the connector zips them into a sorted timeline, so a book I read twice keeps both dates, both ratings and both reviews, HTML stripped. Books also link in the graph by shelf and author via node sets — no LLM extraction needed to know that two books share a shelf.

The two design decisions that matter

Incremental sync via merge. Re-export and re-run: only books whose content changed get re-processed, because rows are rendered deterministically (no ingestion timestamps) and keyed by Goodreads' global book id. An unchanged library costs nothing.

Forget-on-delete. Remove a book from your Goodreads library, re-export, re-sync — the connector diffs the new export against the previous one and emits a hard-delete marker, and cognee's orphan cleanup removes it from the graph and the vector stores. Your agent's memory of your library tracks your actual library, in both directions.

Verified so far

The connector runs end-to-end today: the full suite passes against fixtures that mirror the real export format, and the delivery tests drive a real dlt pipeline where an edited review updates its row in place and a removed book physically disappears from the destination after the _deleted tombstone.

$ uv run pytest tests/ -q
34 passed in 2.86s

I'll add numbers from my own library export here as the syncs run.

Honest limitations

The export is a snapshot: removals and edits are only detected when you re-export.
Switching to a different account's export merges by book id (Goodreads ids are global).
No reading-position data for "currently reading" books — Goodreads doesn't export it.

The connector is at packages/connector/goodreads/ in cognee-community PR #597, with 34 tests against the real export format (re-read columns, ="ISBN" escaping, footer junk, UTF-8 BOM) and delivery tests that prove edits upsert and deletions physically disappear. Try it: uv add cognee-community-connector-goodreads once it merges.