DAFi

Events from the connected DAFi user's school calendar: exams (EXAM), assignments (ASSIGNMENT), presentations (PRESENTATION) and others (OTHER), sorted by date. By default, the next 30 days starting today; `type: "EXAM"` restricts the result to upcoming exams, and `from`/`to` select another period, including the past. `eventDate` may be null for an undated event; when its time falls exactly on local midnight, no specific time was given for it (get_me's `timezone` is the user's local zone). `courseNames` and `noteIds` link the event to the subject(s)/note(s) it was extracted from — a `noteIds` entry is the id to read that note with get_note; both are empty when the event has no linked note (e.g. created manually). They can also disagree: `noteIds` excludes a note that was trashed (its id would be unusable), but `courseNames` does not, so a trashed note's subject can still show up with an empty `noteIds`: a non-empty `courseNames` with an empty `noteIds` means the event came from a note that is no longer readable, not that it has no linked note. `summary` counts every event in the period, before the `type` filter. Returns data from the connected user's DAFi account.

get_academic_events

Progress of the connected DAFi user: learning score and trend, quiz and flashcard results, number of notes generated and consulted, active-day streak, and recommended revisions before upcoming exams. `recommendations` only covers exams in the next 7 days that have notes attached (one row per exam: number of quizzes and flashcards not done yet): it is EMPTY when there is no such exam — that says nothing about weak points. Weak points are found in get_note (`concepts`, per note) and get_courses (`toReview`, notes still to review). `quizResults` gives one row per finished quiz (correct answers, total, score in %, id of the latest attempt) — flashcard results are in `results`. Each row also carries `noteId` (the note this quiz belongs to) and `quizLevel` (0-3: a note gets 4 difficulty levels generated together, same convention as get_note's `concepts[].quizLevel`) — rows sharing a `noteId` are quizzes of the same note, so the distinct `quizLevel` values among them are the levels attempted for that note (out of 4); rows with a null `noteId` are unrelated quizzes that belong to no single note. `lastAttemptAt` is the ISO date/time of the most recent attempt (a quiz can be retaken; correct/total are summed across every attempt, but this date and `quizInstanceId` point at the latest one only). `quizInstanceId` as an argument (the `quizInstanceId` of one `quizResults` row) returns the FULL DETAIL of that attempt instead, question by question, with the answer given, the correct answer and the explanation: in that case the rest of the response (learning, results, stats, engagement, recommendations, quizResults) comes back empty, to avoid extra DAFi calls. In that detail, a question never answered always has `isCorrect: null` and every `answers[].isGoodAnswer: null` — even after the attempt is finished, since a skipped question was never graded right or wrong. A question that WAS answered reveals both `isCorrect` and `isGoodAnswer` as soon as that question itself was answered, not only once the whole attempt finishes. Note: `learning.score` is a rolling 12-month average, independent of `period`; a `learning.monthlyTrend` of 0 means "not enough data to compare", not "no change". Progress cannot be filtered by subject. Returns data from the connected user's DAFi account.

get_student_progress

Profile of the connected DAFi user: username, name, language, time zone, school and education level. By default also returns `subscription`: the paid subscription and remaining quotas per feature (transcription, audiobook, chat, quiz, flashcards, note-taking). An empty `subscription.subscriptions` list means the free plan. For each feature, `limit` and `remaining` are -1 when it is unlimited; `hasAccess: null` means the quota is unavailable, and `subscription` itself is null if it could not be fetched at all — the profile is still returned in that case. With `includeSubscription` set to false, `subscription` is left out, which saves several DAFi calls. Returns data from the connected user's DAFi account.

get_me

Returns the DAFi identity of the user currently connected to this assistant. Returns data from the connected user's DAFi account.

dafi_whoami

The connected DAFi user's courses (subjects such as mathematics or history) and their notes. Without `courseId`: all courses, from most to least recently used. `noteCount` is the number of notes attached to the course, or null when DAFi does not provide it. `toReviewCount` is the figure of the "N to review" badge of the DAFi app for the course: a note stays to review until a quiz on it is finished without any mistake, or the last quiz level is done. It is computed by DAFi over every note attached to the course, so it can differ from the notes flagged `toReview` when reading one course (e.g. notes in the trash): it is the app's own figure, not a recount of the notes listed. With `courseId`: that one course and the list of its notes (titles only, no content) — each note has `toReview`: true when it is still to review, null when DAFi does not say. A note's content and its weak concepts are read with get_note. Returns data from the connected user's DAFi account.

get_courses

Reads one file from the connected DAFi user's library (a document or picture their notes were made from). A file `id` comes from search_documents, or from the `sources` of get_note. Two modes. `text` (default) returns the text DAFi extracted from the file, page by page (the whole text has a `[Page N]` line at the start of each page; with `page` it is that page's text alone, without the line), in slices of `maxChars` characters: when `text.nextOffset` is not null, it is the `offset` of the next slice, read with exactly the same arguments (the same `page` too, if one was passed) and only `offset` changed — `offset` counts characters of the selected text, so a different `page` addresses another part of the file. Mode `text` also gives the content of a scanned page or of a photo of handwriting: DAFi has already transcribed it. Mode `file` sends the file itself after the JSON: a picture as a JPEG preview (at most 1 600 px on its longest side, not the original), a PDF as is, but only when it is light enough. Mode `text` already gives the content of the file, and some assistants ask the user's permission before accepting a file. `inline.attached` says the file was SENT with this answer, not that the client displays it: clients differ (some show pictures but not PDFs, others the reverse). When `inline.attached` is false (`inline.reason`: `too_large`, `unsupported_type`, `not_ready`, `disabled`…), or when the client does not show the file, mode `text` gives its content instead. The file is never downloaded through a link. Also returns the file's metadata (name, origin, page count, summary, the kind of document DAFi recognised, and the notes that use it). `extractionStatus` tells how far the file has been read: `ready` = its text, summary and keywords are available; `pending`, `prepared`, `batched` and `processing` = still being read, so search and text may be incomplete for now; `failed` = it could not be read; `unsupported` = nothing readable can be extracted from this kind of file. Returns data from the connected user's DAFi account.

get_file

Reads one course note of the connected DAFi user. Only the note id is required: everything is returned by default (summary, key takeaways, course outline, academic events and the full course). The full course can be long, so it is returned in slices of `maxChars` characters (most notes fit in a single slice) — when `fullCourse.nextOffset` is not null, it is the `offset` of the next slice, read with another get_note call. Older notes have no structured sections: their whole text is returned in `fullCourse` (`contentFormat` is then "legacy"). `sections` restricts the reading on purpose, e.g. without `full_course` for a quick overview. Also returns `concepts`: the notions practised in the quizzes the user finished on this note, weakest score first (score, correct/wrong answers, `quizLevel`) — these are the user's weak points on this note. Empty when no quiz has been finished on the note, not when nothing is weak. Each notion appears once, with its MOST RECENT figure: `quizLevel` (0 = first quiz level) tells which quiz produced it. A notion that later quizzes did not ask again keeps its older figure, which is the one "last measured at level N", not the user's current level; two different notions that share the same label are merged into one. `contentTruncatedByPlan` is true when the user's plan only gives access to part of the course. Also returns `academicEvents`: the deadlines extracted from this note's own content (`date`/`time` are local, as written in the course, not a UTC instant), each with the `id` of the matching calendar entry — get_academic_events is the source of truth for the live calendar, since the student may have edited or deleted the event there since this note was generated. Empty when the note mentions no deadline. Also returns `sources` by default: what the note was created from and enriched with (audio file, document, image, YouTube video, text), with the file name or URL and the date, which tells where a course comes from. A document or image source carries a `fileId`, the id get_file takes to read that file's text or get the file itself. `includeSources` set to false skips that extra call. `sources` is null if it could not be fetched at all — the rest of the note is still returned in that case. With `includeSourceFiles` set to true, each document/image source gets a `file` (name, page count, summary, extraction status…) and the light files (pictures as a JPEG preview, small PDFs) are sent with the answer after the JSON, a few at most and in the order of `sources` (each attachment is captioned with its `fileId`); `file.attached` says whether one was SENT, not that the client displays it (some clients show pictures but not PDFs, others the reverse, and some ask the user's permission first); get_file in mode `text` reads the text of a file. `file.notAttachedReason` says why one was not sent (get_file reads such a file). The files are sent only with the first slice (`offset` 0): a later slice of the course does not attach them again. `includeSourceFiles` is false by default because it downloads files. The note id comes from search_notes or get_courses. Returns data from the connected user's DAFi account.

get_note

Searches the files in the connected DAFi user's library: the documents (PDF) and pictures they made their notes from (course handouts, slides, photos of the board or of handwritten pages…), and files they will add later. This is a KEYWORD search, not a semantic one: it looks at each file's name, summary and keywords and at its text (the text layer of a PDF, or the text read from a picture or a scanned page), ignoring accents and letter case, tolerating small typos; a file is returned when it contains all the words (spread over its name, summary, keywords and text), and words of a single character are ignored, so a query needs at least one word of two characters or more. If DAFi's search engine is unavailable, or has not indexed the files yet, a simpler search on the name, summary and keywords only answers, without `matches`: an empty result then does not prove that no document mentions a term. With `query`, each file comes with `matches`: its best passage (`snippet`) and the `page` it is on (a null page means the hit is on the name, summary or keywords), best match first. Without `query`, returns the most recent files. `noteId` lists the files one note was made from, and `courseId` (from get_courses) restricts the result to one course. This tool returns metadata and passages, never the file itself: a file's `id` is read with get_file, which returns its text or the file. `extractionStatus` tells how far the file has been read: `ready` = its text, summary and keywords are available; `pending`, `prepared`, `batched` and `processing` = still being read, so search and text may be incomplete for now; `failed` = it could not be read; `unsupported` = nothing readable can be extracted from this kind of file. Results come in pages of `limit` files: when `hasMore` is true, the next page is the same request with the `limit` returned in the result and `page` set to `nextPage`. `total` is the number of files matching the filters. Returns data from the connected user's DAFi account.

search_documents

Searches the connected DAFi user's course notes and returns the matching notes without their content: a note is read with get_note. This is a KEYWORD search, not a semantic one, and it returns whole notes, not passages. It looks at each note's title and at its whole text (summary, key takeaways, course outline, full course and the user's own annotations) — not at the source files (PDF, audio, video) the note was made from. Matching ignores accents and letter case, so a word typed with or without its accents finds the same notes. Without `query`, returns the most recent notes. Results come in pages of `limit` notes: when `hasMore` is true, the following notes are the same request with the same `query`, the `limit` returned in the result and `page` set to `nextPage`. Changing `limit` between pages skips or repeats notes. In rare cases (a transient error while checking) `hasMore` can be true although the next page is empty. When `hasMore` is true but `nextPage` is null, the last page this tool can serve was reached; only a narrower query reaches further notes. Returns data from the connected user's DAFi account.

search_notes