Imagine this scenario

You're in a meeting. Someone says "Should we use the new Glean embedding model?" — and instantly, a card slides in on the right side of your screen showing the relevant internal docs about that exact topic.

Nobody searched for anything. Nobody opened a new tab. The app listened to the conversation and surfaced what everyone needed, right when they needed it.

That's the Knowledge Context feature

This branch adds ~5,100 lines of new code that make Eridanus understand what people are talking about in real time and proactively surface relevant company knowledge.

Here's the quick version of what the system does:

The crew behind the curtain

Think of this like a newsroom. Each person has a specialty, and they pass information along a chain until a story is ready to publish.

Where they live in the code

End-to-end data flow

Imagine someone in your meeting says "Should we switch from Jest to Vitest?" — here's the exact path that sentence takes through the system.

The WebSocket Hub: the mail room

When the Hub receives a final (non-partial) transcript segment, it does two things simultaneously: broadcasts the text to other participants for their transcript view, and forwards it to the knowledge pipeline.

// Feed final segments to the knowledge pipeline
if c.Hub.knowledgePipeline != nil {
    c.Hub.knowledgePipeline.OnSegment(c.SessionID, KnowledgeSegment{
        Speaker:  seg.SpeakerName,
        Text:     seg.OriginalText,
        Language: seg.OriginalLanguage,
        IsFinal:  true,
    })
}

The Pipeline: traffic control

The Pipeline is the conductor. It first checks if the utterance is worth analyzing, then updates the conversation state, and only triggers a search when the topic has genuinely changed.

func (p *Pipeline) OnSegment(sessionID string, seg Segment) {
    // Pre-filter: skip short or filler-heavy utterances
    if !isSubstantive(seg.Text) {
        return
    }

    ctx, cancel := context.WithTimeout(context.Background(), llmTimeout)
    defer cancel()

    if err := p.tracker.Update(ctx, sessionID, seg); err != nil {
        return
    }

    if !p.tracker.HasChangedSignificantly(sessionID) {
        return
    }

    p.tracker.AckBroadcast(sessionID)
    p.scheduleSearch(sessionID)
}

The rolling window

Think of the StateTracker like a court stenographer with a photographic memory — but they only remember the last 20 sentences. As new sentences come in, old ones scroll off. This "rolling window" is the raw material the LLM uses to understand what's happening.

What the LLM extracts

From that messy conversation, the LLM produces a structured JSON snapshot called the ConversationState:

Topic change detection: not just string matching

How does the system know when the conversation has moved to a genuinely new topic? It uses Jaccard similarity on content words — filtering out common words like "the", "is", "what" — to compare the new topic against ALL previously shown topics.

func wordSimilarity(a, b string) float64 {
    setA := contentWordSet(strings.ToLower(a))
    setB := contentWordSet(strings.ToLower(b))
    if len(setA) == 0 && len(setB) == 0 {
        return 1
    }

    intersection := 0
    for w := range setA {
        if setB[w] {
            intersection++
        }
    }

    union := len(setA)
    for w := range setB {
        if !setA[w] { union++ }
    }
    return float64(intersection) / float64(union)
}

The four lines of defense

Surfacing information in a live meeting is high-stakes. Show something irrelevant, and people start ignoring the feature. Show too often, and it becomes noise. The system has four layers of protection, like a building with a bouncer, a metal detector, an ID check, and a guest list.

The filler filter: first line of defense

func isSubstantive(text string) bool {
    trimmed := strings.TrimSpace(text)
    if len(trimmed) < minCharCount {
        return false
    }

    words := strings.Fields(strings.ToLower(trimmed))
    if len(words) < minWordCount {
        return false
    }

    fillerCount := 0
    for _, w := range words {
        clean := strings.Trim(w, ".,!?;:'\"")
        if fillerWords[clean] {
            fillerCount++
        }
    }

    return float64(fillerCount)/float64(len(words)) <= maxFillerRatio
}

Trigger detection: what makes a good search

Beyond topic changes, the system also detects specific signals in speech that suggest a knowledge search would be useful. Think of it like a journalist's instinct for a story — certain phrases are red flags that mean "someone needs information."