I Built RecallixAI So Meetings Don’t Forget What Happened

Tanishq — Tue, 29 Sep 2026 18:04:04 +0000

Most meeting tools can record what was said. I wanted RecallixAI to remember what actually matters after the meeting—commitments, decisions, unresolved questions, and follow-ups.

How RecallixAI works

RecallixAI connects four main components:

Chrome extension captures Google Meet captions.
FastAPI backend manages meetings, notes, and sessions.
Gemini converts transcripts and notes into structured meeting outcomes.
Hindsight stores and retrieves long-term meeting memory.

The basic flow is:

Capture → Analyze → Remember → Recall → Act

The browser extension stays intentionally lightweight:

async function pushCaptionToBackend(speaker, text) {
await fetch(${API_BASE_URL}/api/stream/caption, {
method: "POST",
headers: {"Content-Type": "application/json"},
body: JSON.stringify({
meeting_id: getMeetingId(),
speaker,
text,
timestamp: new Date().toISOString()
})
});
}

The backend owns the actual meeting state rather than putting business logic inside the extension.

Why Hindsight matters

I deliberately separated temporary meeting state from long-term memory.

During a meeting, I need the current transcript and notes. Afterward, I need answers to questions like:

"What did Sarah and I agree on last time?"

That is where Hindsight on GitHub becomes important.

Instead of treating every transcript as something to search later, RecallixAI extracts useful information first:

class MeetingAnalysis(BaseModel):
summary: str
promises_by_us: List[str]
promises_by_them: List[str]
missed_or_pending_followups: List[str]
note_discrepancies: List[str]

That information is then retained in Hindsight:

self.client.retain(
bank_id=bank_id,
content=content,
context=context,
document_id=doc_id,
metadata=metadata
)

Before the next meeting, I can recall that context:

result = hindsight_service.recall_prep_context(
user_id=req.user_id,
attendee_email=req.attendee_email
)

The Hindsight documentation was useful here because it treats memory as more than basic transcript retrieval. The system can retain relevant knowledge and recall it later in the context of a new interaction. This is the same distinction described in agent memory.

A simple example

Suppose I promise to send pricing information by Thursday, while my notes accidentally say Friday.

RecallixAI can identify that discrepancy, store the commitment in Hindsight, and surface it before my next conversation with that person.

The important part isn't the summary.

It's the continuity.

What I learned
Memory should be designed around future questions, not just stored data.
Live state and long-term memory should be separate systems.
LLM output needs a structured contract before other services consume it.
Good memory depends on what you retain. Storing everything creates noise.
Automation should follow understanding. First determine what happened, then trigger actions.

The architecture is deliberately simple:

Google Meet → FastAPI → Gemini → Hindsight → Meeting preparation → Actions

I don't want RecallixAI to remember everything.

I want it to remember the things that change what happens next.

DEV Community: Tanishq

I Built RecallixAI So Meetings Don’t Forget What Happened