RecallAI: A Tutor That Remembers the Learner, Not Just the Chat
*Built for Graph Hacks: Context for AI Agents by WeMakeDevs and FalkorDB · Track 2: Agent Memory and Coordination*
A student asks an AI tutor for help with recursion. The answer may be technically correct, but will it remember that this student struggled with recursion yesterday, prefers small examples, and has since moved on to generators?
Most chatbots start each session with little more than the current conversation. RecallAI takes a different approach: it gives each learner a persistent, explainable memory graph, so tutoring can build on what the student has already shared.
## The idea: learning is connected
A learner’s difficulty is rarely an isolated fact. Trouble with recursion may point to a gap in functions or variables. A preference for short examples should shape the explanation. And when a student says they have mastered a topic, the tutor should update its understanding.
A flat list of notes can store these facts, but it does not naturally express how they connect. RecallAI uses FalkorDB to represent those relationships directly and let the tutor traverse them when it prepares an answer.
## What RecallAI remembers
RecallAI extracts a small set of learning memories from a student’s messages:
- **What they are learning** (`LEARNS`)
- **Where they are stuck** (`STRUGGLES_WITH`)
- **How they prefer to learn** (`PREFERS`)
- **What they want to achieve** (`GOAL`)
Each memory belongs to a student and can connect to a curriculum concept. Concepts link to prerequisites through `REQUIRES` relationships. That lets the tutor move from a learner’s question to the foundational topics that may help answer it.
For example, if a student asks about recursion, the graph can connect the student’s expressed struggle to the recursion concept, then follow prerequisite links toward functions and variables. The tutor can use that context to explain foundations first and adapt examples to the learner’s stated preference.
## FalkorDB is part of the reasoning loop
The graph is not a dashboard added after the answer. It participates in the tutoring flow:
1. The backend identifies relevant learning memories from the student’s message.
2. It saves or updates those memories in the student’s FalkorDB graph.
3. It retrieves active memories and follows relevant curriculum prerequisites.
4. It passes that context to the tutor model to shape the response.
5. The interface can show the graph evidence behind the answer.
RecallAI creates a separate graph for each demo student, using a `recallai_<user_id>` namespace. Conversation transcripts are handled separately; Supabase is used for chat history, while the learning memories and curriculum relationships live in FalkorDB.
## Memory should change as the learner changes
Persistent memory is only useful if it can be corrected. When a student says, “I no longer struggle with recursion, but generators confuse me,” RecallAI can resolve the old struggle and record the new one. In a later chat, it can retrieve the active generator difficulty and the learner’s preferences without relying on the previous conversation being open.
That creates a simple but important distinction: a chat transcript records what was said; the graph helps the tutor carry forward what remains useful.
## Making the answer inspectable
Personalization can feel unsettling when the system cannot explain itself. RecallAI’s evidence view exposes the paths used for retrieval, including whether a fact came from the student or from the curated curriculum. A learner can inspect why a memory was considered and which prerequisite connections informed the response.
The goal is not to claim that every model decision is perfectly explainable. It is to make the graph context used by the application visible and understandable.
## Built for a hackathon, documented for a fresh start
RecallAI combines a Python and FastAPI backend, the official FalkorDB Python client, and a React interface built with Vite. The tutor model is configurable, with Gemini set as the default and OpenAI or Groq provider support in the project. A curated 15-concept Python syllabus supplies the prerequisite structure.
The repository includes local setup instructions, a graph schema, Cypher query notes, and a demo walkthrough. The demo follows a student from sharing a difficulty and learning preference, through a prerequisite-aware explanation, to correcting a memory and returning in a new chat.
## What we learned
The graph model made us be precise about what “memory” means. A student’s expressed difficulty is different from a curriculum fact; both should have clear provenance. A resolved struggle should not be treated as active forever. And retrieval evidence should be returned as part of the system’s work, not reconstructed from the final answer afterward.
We also kept the project’s scope honest. RecallAI currently demonstrates one tutor agent with persistent learner memory and graph-based retrieval; it does not demonstrate peer-agent handoffs. Automated frontend and extraction checks passed in the recorded finalization pass, while the complete backend integration suite still needs a reachable FalkorDB instance for verification in that environment. These are useful next steps, alongside evaluating how well graph context improves learning outcomes with real learners.
## Try RecallAI
The project is designed to run locally with Docker, FalkorDB, the FastAPI backend, and the Vite frontend. The repository’s README walks through configuration and startup, and its demo script shows the memory and evidence flow step by step.
**Project:** [RecallAI source repository](https://github.com/lovishsingla00001-hub/Graph_hacks_hackathon)
**Hackathon:** [Graph Hacks: Context for AI Agents](https://www.wemakedevs.org/hackathons/falkordb)
RecallAI’s core idea is straightforward: when an AI tutor can remember a learner’s progress and follow the relationships between concepts, it can give help that is more continuous, more relevant, and easier to inspect.
Comments
Post a Comment