Classroom Memory Cognee Cloud mastery graphs
connecting

track b / best use of cognee cloud

Every student. One memory. A school that remembers.

Content apps give a class a syllabus. Cognee gives it a memory. Classroom Memory gives the teacher a plan. Each student gets a private Cognee Cloud memory; the teacher reads across all of them and gets told what to teach next, and why.

close the laptop. the memory stays.

Pick a student and start a quiz. Every answer reshapes their knowledge graph, live.

mastery
--
-- mastered -- learning -- gaps -- rusty
quiz terminal
press start to begin
The quiz walks the prerequisite graph and asks only what you are ready to learn.
mastery graph
today
gap learning mastered rusty bigger circle = higher mastery · arrows = prerequisites

many private memories. one teacher reading across them.

The easy way to use a memory layer is one big graph. But a classroom is the opposite: every student is a private, isolated Cognee Cloud dataset, and the teacher reads across all of them. That is a multi-tenant problem, impossible on a single local instance. This is what the Cloud is for.

ask the class multi-dataset recall
teaching plan graph-reasoned
reading the class memory graph…
    intervention
    No review assigned yet. Use "assign" beside a class gap to create a targeted review list.
    students
    class heat map
    class is red class is mixed class has mastered color = class-average mastery per concept · click a student to inspect
    00students
    --biggest gap
    --class red

    about the project

    a school that remembers.

    Classroom Memory gives every student an isolated Cognee Cloud memory and gives the teacher a live map of what the whole class is forgetting. It is built like a reusable classroom product, not a one-off demo: deterministic curriculum, enrollable students, cloud verification, and a clear production path.

    01

    the unsolved problem

    In India and much of the world, one teacher faces 40 to 60 students. Personal attention is mathematically impossible, so gaps stay invisible until exams, and each year's gaps compound into the next. EdTech shipped videos and question banks: content at scale. What was never built is memory at scale: a system that knows what each individual child knows.

    02

    the idea

    Hold each student's knowledge as a real memory: a graph of concepts with mastery weights that rise with correct answers, decay with neglect, and live in Cognee Cloud so they survive every device and every session.

    03

    the product

    An adaptive quiz that targets your frontier, an ask box answered from your own memory graph, and a teacher heat map that reads across every student's dataset to say what to teach next. Add a student and the same workflow starts from a blank memory.

    functional architecture

    every student. one Cognee Cloud tenant.

    The browser holds zero learning state. The backend scores mastery and walks the curriculum graph. SQLite keeps the exact classroom ledger, while Cognee Cloud stores long-term student memory, class memory, recall surfaces, learning traces, and teacher interventions.

    1. actstudents answer, ask, reset, enroll, import curriculum; teachers ask, plan, assign
    2. reasonFastAPI validates input, walks prerequisites, scores mastery, and ranks teaching priorities
    3. rememberSQLite stores exact state; Cognee stores student memory, class graph, sessions, traces
    4. returnUI receives graph state, next step, reports, class plan, answer sources, and provenance
    01 browser

    Student + teacher UI

    Student mastery, quiz, ask box, report card, timeline, graph inspector, class ask, teaching plan, roster setup, curriculum import, and review assignment.

    no browser statevis-networkstudent pageteacher page
    REST API /quiz · /ask · /student · /class · /teacher · /curriculum
    02 FastAPI backend

    Provider + graph reasoning engine

    Validates requests, selects frontier concepts, scores quiz answers, builds report data, ranks graph-reasoned teaching plans, and keeps demo/cloud modes behind one response shape.

    app.pyDemoProviderCloudProviderasync SDK bridge
    exact mastery state weights, timestamps, rosters, seeded datasets, interventions
    Cognee memory ops serve · remember · recall · session memory · node sets · forget
    03A SQLite ledger

    Mastery ledger

    Durable exact state for the classroom: students, concept weights, update timestamps, retired flags, seeded datasets, tenant metadata, and intervention assignments.

    mastery_ledger.sqlitestudentsmasteryinterventions
    03B Cognee Cloud tenant

    Hosted classroom memory

    Cognee stores private student datasets, a dense class graph, session-memory quiz attempts, progress snapshots, report-card recall context, and teacher intervention memory.

    student_aliceclass_graphclass_interventions curriculumprogressmastery-traceteaching-plan
    response back to UI next step, graph colors, reports, teaching plan, answer sources, class gaps, provenance
    04 usable classroom output

    What changes for users

    Students see what to learn next and why. Teachers see the class heat map, a graph-reasoned lesson plan, targeted review lists, and per-student drill-down.

    student graphtimelinereport cardteacher plan class heat mapreview list
    quiz answerFastAPI updates SQLite weights, writes session memory, and emits mastery traces when concepts turn green
    student ask + reportCognee recall reads the student's dataset and returns grounded answers or a report card
    teaching planBackend ranks ready class gaps by prerequisite readiness and downstream unlock value, then writes the plan to class memory
    class askTeacher questions use the dense class_graph or fall back to multi-dataset recall across student memories
    assign reviewTeacher action persists an intervention in SQLite and writes a teacher-intervention memory to Cognee
    setup + resetRoster setup creates fresh student memories; reset clears local state and calls Cognee forget(dataset)

    why cognee cloud

    not a database. a memory that follows you.

    Isolation per student plus a teacher reading across datasets is a multi-tenant hosted memory problem. A local, single-user instance cannot build this view.

    01

    remember()

    Seeds each student's dataset with the curriculum and writes a trace every time a concept is mastered.

    ~9s ingest, verified live
    02

    recall()

    The ask box answers from the student's own cloud graph, with dataset provenance attached.

    ~7s warm, verified live
    03

    improve()

    Mastery follows Cognee's feedback weight design, applied app side. Cloud does not expose remote improve() yet; the provider boundary is ready for it.

    feedback_weight semantics
    04

    forget()

    Retire a mastered concept, or reset a transfer student with a real dataset deletion on the tenant.

    ~2s delete, verified live

    not a staged demo

    a planned product. already working.

    This is not just three hardcoded students and a pretty graph. It has the minimum product spine a school would need: enrollment, isolated memories, repeatable curriculum files, deterministic assessment, teacher aggregation, cloud verification, and a clean path to production storage and auth.

    01

    enroll anyone

    Add a student with one click. Their memory is a brand new Cognee Cloud dataset, created on their first question and readable from any device, forever.

    + enroll
    02

    curricula are files

    The Python course is a plain JSON file: concepts, prerequisite edges, questions, and answer keys. Adding a new subject is adding a file, not writing code.

    curriculum/python.json
    03

    provable, not claimed

    A one-command script asserts the full memory lifecycle against the live tenant, with timings, and exits non-zero if anything is fake.

    python backend/verify_cloud.py
    04

    production path

    The current app is useful for pilots. The next production steps are straightforward: database-backed mastery ledger, school auth, curriculum upload, and native Cloud improve when exposed.

    pilot today -> production next

    execution quality

    built to be reused. not rebuilt.

    The project separates product behavior from cloud plumbing, which is what makes it credible beyond a hackathon screen recording.

    01

    same API shapes

    DemoProvider and CloudProvider return identical JSON. The frontend does not care whether it is offline or backed by Cognee Cloud.

    provider pattern
    02

    teacher moat

    The teacher view is not a dashboard pasted on top. It reads across isolated student memories with one multi-dataset recall path.

    datasets=[student_*]
    03

    testable lifecycle

    The demo-mode smoke test covers quiz progression, decay, retire/reset, class ask, enrollment, and invalid student guards.

    backend/test_demo.py
    04

    honest limits

    The site names what is cloud-native today and what is planned. That makes the project stronger, not weaker: judges can trust the claims.

    no overclaiming

    cloud console proof

    record the tenant. show the receipts.

    For the final video, show Cognee Cloud itself, not only this app. Open the tenant console and capture the datasets plus the latest activity from curriculum seeding, mastery traces, and teacher interventions.

    01

    student datasets

    Show `student_alice`, `student_bob`, and `student_cara` in the Cloud console. These prove the per-student isolation boundary.

    dataset per student
    02

    curriculum nodes

    Open one student dataset and show the curriculum memory seeded with `remember()` and NodeSet tags.

    curriculum node_set
    03

    mastery trace

    Master a concept in the quiz, then show the new trace activity written into that student's dataset.

    mastery-trace
    04

    class action

    Assign review from the teacher view and show the `class_interventions` dataset entry.

    teacher-intervention

    demo flow

    two minutes. a memory you can watch learn.

    OpenAlice's graph is all red. She is new.
    QuizFour answers. One node goes red, amber, green, live.
    ReloadOpen it on a phone. Same memory. The only state is Cognee Cloud.
    DecayAge +30d. Old knowledge visibly rusts, like real memory.
    TeachThe class heat map says: 70% red on recursion. Teach that next.
    EnrollAdd yourself. Your own memory starts existing. Try it.