ClaraCare

AI companion that calls seniors daily, detects cognitive changes, and gives families peace of mind via a real-time wellness dashboard.

Comment

ClaraCare: The AI Companion for Aging in Place

💡 The Inspiration

We live in a fast-paced world. Our generation is constantly on the move, juggling demanding careers, young families, and relentless schedules. Yet, our most quietly pervasive worry is often miles away: our aging parents.

Over 40% of seniors experience chronic loneliness, but statistics don't capture the daily guilt of an adult child who realizes it's been three days since they called home. We know AI will never replace a child's love, nor can it replace human medical care. If someone is having a genuine medical issue, human intervention is the only answer.

But what about the days in between? What about the mundane Tuesday mornings?

We built ClaraCare not as a caretaker replacement, but as a bridge, a way for our generation to keep a gentle, loving, daily pulse on our parents amidst our busy lives. A tool to ensure they never feel forgotten, and to give us the peace of mind that today, Mom is doing just fine.

⚙️ What It Does

ClaraCare is a voice-native, low-latency AI companion that bridges the gap between elder independence and family peace of mind:

Feature What Happens
Daily Check-ins Clara calls your loved one (or they call her) for a warm, empathetic conversation. She remembers past chats, asks about their day, and provides genuine daily companionship.
Invisible Cognitive Monitoring Post-call, Clara's engine analyzes the transcript for subtle trends - memory inconsistencies, word-finding difficulty, repetition patterns, and mood shifts, without ever making the senior feel like they're taking a test.
Actionable Family Alerts If Clara detects a potential concern (repeated stories, mood shifts, confusion) or a senior says "tell my daughter to call me," it's instantly routed as a push alert to the family dashboard.
Medication Tracking Clara dynamically confirms medication adherence during natural conversation, logging responses silently via LLM Function Calling.
PDF Cognitive Reports One-click, paginated PDF reports of cognitive trends over time - ready to hand directly to a primary care physician.

Zero onboarding for the senior. They just pick up the phone. That's it.

🛠 How We Built It - Technical Architecture

We architected ClaraCare for extreme low latency, production-grade scalability, and robust data privacy.

Voice Pipeline (Sub-500ms Latency)

  • Twilio WebSockets + FastAPI: Raw telephony media (audio/x-mulaw) streams via WebSocket directly into our async Python engine, bypassing traditional telephony latency.
  • Deepgram Voice Agent API: Powers the real-time conversation with sub-500ms round-trip latency. Clara sounds like a real human, not a buffering robot.
  • LLM Function Calling: As Clara chats naturally, she silently triggers backend functions (log_medication_check, trigger_alert, escalate_to_family), turning conversation into structured data without breaking the flow.

Cognitive Intelligence Engine

  • Deepgram Text Intelligence APIs: Post-call, we run Summarization, Topic Extraction, and Sentiment Analysis to transform a 15-minute rambling conversation into a concise cognitive health pulse-check.
  • Custom Elder Care Pipeline: We engineered a proprietary grounding validator that prevents LLM hallucinations in health summaries, enforces standardized reporting formats, and detects nuanced cognitive inconsistencies across multiple conversations rather than relying on basic keyword matching.
  • You.com Search API: Gives Clara real-time world knowledge (weather, nostalgic historical facts, current events) to keep conversations engaging and grounded in reality, preventing hallucination.

Data & CMS

  • Sanity Headless CMS: Patient profiles, medication schedules, family contacts, and alert histories stored as structured documents with GROQ queries. Live Function Calling writes insights back in real-time.
  • Foxit Document Generation API: Aggregated weekly cognitive data is fed into dynamic HTML templates, then rendered by Foxit into polished, paginated PDF "Cognitive Health Digests" for physicians.

Frontend & Deployment

  • Next.js 16 + React 19 Dashboard: Production-grade, glassmorphic UI with Plus Jakarta Sans typography, responsive Recharts trend visualization, and full PWA capabilities.
  • Akamai Linode Kubernetes Engine (LKE): Entire backend containerized in Docker and deployed on LKE for high availability and pod-level security isolation of sensitive conversational data.

🚧 Challenges We Ran Into

  1. Empathy vs. Interrogation Balance: Clara needs health data without ruining the conversation. We solved this with LLM Function Calling , the model chats naturally while silently logging JSON payloads to the backend.

  2. Barge-In Handling: Seniors talk over the AI constantly. We built complex thread management with buffer-clearing logic between Twilio and Deepgram to handle interruptions gracefully.

  3. Hallucination Prevention: Out-of-the-box LLMs generate generic summaries. We built a custom grounding validator and safe fallback summary builder that ensures every summary is factually anchored to what was actually said.

  4. Alert Sensitivity Tuning: Our initial "Change in Conversation Pattern" detector had too many false positives. We refined it to require substantive multi-word phrases, same-topic contradiction matching, and minimum turn thresholds.

🏆 Accomplishments We're Proud Of

  • Built a voice-first AI companion that requires zero technical onboarding for elderly users - they simply pick up the phone.
  • Developed a custom "Elder Care Analysis" pipeline that detects nuanced memory inconsistencies across multiple conversations, not just single keywords
  • Deployed the entire stack to production on Akamai LKE, this is not a demo, it's a live product processing real calls
  • Achieved sub-500ms voice latency, making Clara feel like a real person on the phone

📚 What We Learned

Building ClaraCare taught us to orchestrate cutting-edge AI (Deepgram real-time voice, LLM Function Calling, You.com grounding) with legacy infrastructure (PSTN phone lines via Twilio). We learned that technology is most powerful when it becomes invisible to the user - transforming a complex AI orchestration engine into a simple, comforting phone call.

We also learned the critical difference between "AI that impresses engineers" and "AI that comforts a 78-year-old grandmother." The latter is infinitely harder.

🚀 What's Next for ClaraCare

  • Expanded Accessibility: Introducing multilingual capabilities to serve diverse and underserved aging populations in their native languages.
  • Holistic Health Tracking: Fusing our conversational cognitive insights with wearable biometrics (e.g., Apple HealthKit) to correlate vocal biomarkers with physical health data like heart rate and mobility.
  • Clinical Integration: Developing a HIPAA-compliant provider portal with secure, live dashboards that empower geriatricians and care teams to proactively monitor patient cohorts at scale.
  • Scalable B2B Distribution: B2B licensing to assisted living facilities - Expanding our go-to-market strategy through enterprise licensing for assisted living facilities and home-care agencies via a predictable SaaS subscription model.

🎙️ Deepgram: The "Voice Operator" (Autonomous Agent)

ClaraCare isn't just a friendly chatbot, she's an autonomous agent operating in the real world via the Deepgram Voice Agent API.

Our breakthrough was deep Function Calling integration. As Clara converses with an elderly patient, she runs background logic in real-time:

Patient Says... Clara's Hidden Action
"Yes, I took my pills this morning" Triggers log_medication_check → updates Sanity backend
"Can you tell my daughter to call me?" Fires trigger_alert → sends push notification to family dashboard
"I've been feeling really down lately" Flags escalate_mood_concern → creates a medium-severity alert with suggested actions

She acts as a fully autonomous voice operator, converting natural spoken conversation into real-world database mutations, push alerts, and clinical data - all without the patient ever knowing.

API used: Deepgram Voice Agent API with Function Calling

☁️ Akamai: Most Creative Open-Source Solution on Linode

ClaraCare's entire backend runs natively on Akamai's Linode Kubernetes Engine (LKE).

We chose LKE over simpler PaaS solutions because elder care demands:

  • 99.9%+ uptime - a missed daily call erodes trust
  • Pod-level security isolation - conversational health data requires strict boundaries
  • Dynamic scaling - concurrent phone sessions scale horizontally

Our deployment uses:

  • Docker-containerized FastAPI engine with multi-stage builds for minimal image size
  • Kubernetes rolling updates with zero-downtime deployments
  • TLS termination via cert-manager + Let's Encrypt
  • Public GitHub repository with full deployment instructions

Infrastructure: Linode Kubernetes Engine (LKE) · Docker · kubectl rolling deployments

📄 Foxit: Document Automation Hackathon

While dashboards are great for daily monitoring, doctors need standardized paperwork. We built a complete "generate → process → deliver" pipeline:

Input: Aggregated cognitive metrics from Deepgram (topics, sentiment, mood scores) + medication logs from Sanity
Generate: Dynamic HTML template populated with the patient's 7-day or 30-day cognitive data
Output: Polished, paginated PDF "Cognitive Health Digest" via Foxit APIs, ready for a geriatrics appointment

Families click one button on the dashboard → receive a professional medical report they can hand to their loved one's doctor.

APIs used: Foxit Document Generation API + Foxit PDF Services API

🔍 You.com: Intelligent Applications with APIs

To make Clara truly comforting, she can't just run off a static LLM prompt, she needs real-time grounding in the real world.

We integrated the You.com Search API to give Clara temporal intelligence:

  • Weather grounding: "It looks like it's going to be a beautiful 72° day in San Jose today!"
  • Nostalgic anchoring: When a senior mentions the 1960s, Clara can reference real historical events
  • Hallucination prevention: Any external information Clara introduces is sourced, cited, and accurate

This makes conversations feel deeply personal and localized, not generic AI filler.

API used: You.com Search API (Web Search + RAG endpoints)

🗄️ Sanity: Feature Only Structured Content Makes Possible

ClaraCare demonstrates exactly what structured content unlocks that flat databases cannot.

Our Sanity schema maps complex medical relationships:

Schema Relationship Feature It Unlocks
patient references familyContacts[] One-to-many "Show all alerts for this patient, resolved by this family member"
conversation references patient + contains extractedTopics[] Structured array "Show me every conversation where Mom mentioned 'garden' across 30 days"
alert references conversation + patient Cross-document "This medication concern was detected in Tuesday's 3:30 PM call - here's the transcript"
callSchedule embedded in patient Inline object Dynamic scheduling: Clara calls at the right time for the patient's timezone

Without structured content, you'd need hand-maintained CSV files for each of these features.
With Sanity, they're just GROQ queries.

During live calls, our Python backend fires GROQ queries to hydrate the LLM with the patient's profile. After calls, extracted insights write back to Sanity via the Mutation API, feeding the Next.js dashboard in real-time via Sanity's MCP Server.

Tools used: Sanity CMS · GROQ queries · Mutation API · MCP Server

  • AI Disclosure: Our project utilizes Deepgram for voice-to-text/LLM agent functionality, You.com for web grounding, and OpenAI/Gemini models for specific analytical pipelines. Code generation tools (GitHub Copilot) were utilized to assist with syntax and boilerplate development.

Built With

Share this project:

Updates