Udaan × Cognee — Giving Indian Sport a Memory That Never Forgets an Athlete

A Verified Athlete Passport powered by a Cognee memory layer.

Live frontend: udaan-tan.vercel.app ·Repos: frontend · backend

1. The Problem

Every AI application you have ever used shares one silent disability: amnesia. Close the tab, and the model forgets you exist. For a support chatbot, that is an annoyance. For an athlete’s career, it is fatal — because a career is, by definition, a thing that accumulates over years.

Now layer that onto the specific tragedy of Indian sport. India has 1.4 billion people and, outside cricket, keeps asking why it doesn’t win more Olympic medals. The honest answer is not a shortage of talent. It is a shortage of connective infrastructure — and it fails athletes at four separate points of their journey, all at once:

1. Discovery fails. Organized scouting is urban, expensive, and bottlenecked on a handful of human scouts. A genuinely fast child in a Tier-3/4 town is statistically invisible — even though ~1.5 million government schools each have a PE teacher who watches that child every single day with no tool to measure or escalate what they see.
2. Development fails. Good coaching is concentrated in cities. A self-coached kid ingrains bad technique — or an injury — with zero feedback loop.
3. Credibility fails. District results live on a paper scoresheet, if they are recorded at all. Age fraud is rampant. A real achievement carries no verifiable weight at the next level.
4. Inclusion fails worst of all. ~26–30 million Indians of sport-relevant age have disabilities, but para-sport participation is a tiny fraction of that — because athletes cannot find which sports fit their functional capability, and the few para-coaches who exist cannot find the athletes.

The unifying insight: these are not four problems needing four apps. They are four broken links in one chain — an athlete’s career — that has no connective tissue. There is no single, portable, verified identity an Indian athlete owns from their first playground sprint onward. And critically: even where digital tools exist, none of them remember.

The missing ingredient in Indian sport-tech is not another dashboard. It is memory.

2. The Solution

Udaan (उड़ान, “takeoff”) is one Verified Athlete Passport that follows an athlete from their first playground sprint to a state podium — and the thing that makes it intelligent is a memory layer built entirely on Cognee.

The passport grows across five lifecycle stages, all bound to a single verified identity:

• Discover — a teacher/parent films short standardized fitness tests → on-device pose estimation produces an age/sport percentile talent scorecard.
• Train — the athlete practices with real-time camera feedback and logs sessions → a skill-progression log, remembered across every session.
• Prove — the athlete competes; organizers log results in-app → tamper-evident, timestamped, age-verified records.
• Include — a para-athlete onboards via an accessibility-first flow → capability mapped to suitable sports, equipment, and verified para-coaches.
• Play — the athlete finds local pickup games and micro-leagues → community play plus informal performance signals.

The decisive design decision — and the reason this is a Cognee project, not just an app with an LLM bolted on:

Cognee is the brain. Groq just writes the sentence.

Every meaningful event in an athlete’s career is written to Cognee with remember(), which turns raw text into a knowledge graph + a vector index automatically. Every question is answered by first calling recall() for graph-aware context, then passing that context to Groq's Llama 3.3 70B for the final natural-language reply. Feedback is folded back in with improve(). And — uniquely — a guardian can erase a child's entire memory with forget().

3. Innovation

• A memory-native application, not a stateless chatbot. Continuity between sessions is not a hack — it is a first-class architectural property provided by Cognee’s persistent knowledge graph.
• The full memory lifecycle, in production. Most hackathon projects use only retrieval (RAG). Udaan uses all four Cognee operations — remember, recall, improve, forget — because a career needs to be stored, queried, corrected, and (legally) erased.
• Privacy as a primitive, not a policy page. Because we handle children’s data, India’s DPDP Act right-to-erasure is not optional. Cognee’s dataset-scoped forget() makes compliance a single API call.
• Multi-tenant memory for free. Cognee datasets (coach_{uid}, train_{uid}) gave us per-athlete isolation with nothing more than a string.
• Structural inclusion. The same passport, the same memory engine, serves an able-bodied sprinter and a para-athlete.
• Zero new hardware. The smartphone camera is the only sensor — deployable across 1.5 million Indian schools.

4. Features

A · Udaan Coach — the coach that remembers you

A personal AI career advisor. The athlete syncs their passport (remember), then chats — and every exchange is written back to memory, so context survives across sessions and devices. forget() implements guardian right-to-erasure.

POST /coach/remember · POST /coach/chat · POST /coach/feedback · DELETE /coach/forget/{uid}

B · Scout Copilot — institutional memory for talent scouts

A persistent field-observation log across all scouting sessions, districts, and seasons. A scout logs an observation (remember), then queries across the entire history (recall): "Who were the top three explosive athletes I flagged in Nadia district last year?"

POST /scout/log · POST /scout/search · DELETE /scout/clear

C · Include Advisor — a para-sport knowledge graph

On startup, a curated para-sport knowledge base (IPC classification codes, equipment specs, India’s Paralympic programs) is seeded into Cognee. A coach describes an athlete’s functional capability, and recall() traverses the graph from class → eligible sports → equipment, grounded in real codes like T54.

POST /include/ingest · POST /include/advise · DELETE /include/forget

D · Training Loop — continual learning

The AI remembers every session — drills, fatigue, injuries — and adapts. When an athlete rates a drill as harmful, improve() folds an instruction into the graph so future recommendations avoid it. No fine-tuning; just memory.

POST /train/log · POST /train/ask · POST /train/rate · DELETE /train/reset/{uid}

5. User Journey

Meet Meera, 15, a sprinter from a Kolkata municipal school.

Every stage writes to — or reads from — the same Cognee-backed passport. Meera’s knee injury noted in Train is remembered when her Coach later advises her on event selection. That cross-stage continuity is the product.

6. System Architecture

Udaan is a two-tier system: a static React frontend on Vercel, and a FastAPI backend on Hugging Face Spaces that wraps a Cognee memory layer. Cognee orchestrates two local stores (a knowledge graph and a vector index) and calls out to Groq and Gemini.

Key architectural principle: the LLM and embedding provider are swappable I/O. Cognee is the irreplaceable center. Swap Groq for another model tomorrow and the memory graph is untouched.

7. Workflow & Orchestration

Here is exactly what happens when Meera asks her AI Coach a question — the request path that ties Cognee and Groq together.

The subtle-but-crucial step is the last one: the conversation itself is written back with remember(). That is why the next session already knows what was discussed. Memory is not retrieved-and-discarded; it compounds.

8. Data Flow & State Management

A defining property of Udaan: the application layer is stateless. Neither FastAPI nor Groq holds any conversation state between requests. All continuity lives in Cognee’s knowledge graph — this is what makes the backend horizontally scalable and crash-safe.

Backend “state” = Cognee datasets:

• coach_{uid} — per-athlete coaching memory — remember · recall · improve · forget
• train_{uid} — per-athlete training history — remember · recall · improve · forget
• scout_sessions — shared scout field log — remember · recall · forget
• include_knowledge — global para-sport knowledge base — remember (seeded) · recall

The {uid}-scoped datasets are the entire multi-tenancy and privacy model — one athlete can never recall or erase another's memory.

9. Tech Stack

• Memory — Cognee 1.2.2 — knowledge graph + vector, full lifecycle, dataset multi-tenancy
• LLM — Groq (Llama 3.3 70B) — fast inference; powers generation and Cognee entity extraction
• Embeddings — Gemini gemini-embedding-001 (3072-dim) — high quality, remote (no local model RAM)
• Graph / Vector store — Cognee-managed (Kuzu / LanceDB) — automatic graph + semantic search
• Backend — FastAPI + Uvicorn (Python 3.11) — async, typed, auto-Swagger
• Frontend — React 18 + Vite + TypeScript + Tailwind — fast, modern, type-safe
• State (client) — Zustand — lightweight passport/UI state
• Frontend host — Vercel — git-push auto-deploy, CDN
• Backend host — Hugging Face Spaces (Docker, 16 GB free) — enough RAM for Cognee’s graph build

10. AI Deep Dive — Cognee + Groq + Gemini

This is the heart of the project. Three AI components, each with a distinct job.

10.1 Cognee — the memory engine

Cognee is not “a vector database.” When we call remember(text, dataset), Cognee runs a two-phase pipeline: cognee.add() ingests the text, then cognify() uses the LLM (Groq) to extract entities and relationships, builds them into a knowledge graph, and embeds the chunks into the vector index.

So a single training-log entry like “Meera did heavy plyometrics, reported knee pain” becomes graph nodes (Meera, plyometrics, knee pain) with typed edges (performed, caused) — plus vector embeddings. That is why recall() can answer relational questions that pure vector RAG would miss.

10.2 recall() — graph-aware retrieval

recall() uses Cognee's SearchType.INSIGHTS — graph traversal combined with semantic similarity — returning the top-N context chunks. It falls back to plain vector search if graph search fails, so retrieval is always robust.

10.3 Groq (Llama 3.3 70B) — the writer

lib/groq_agent.py builds a chat completion: a persona system prompt + the retrieved Cognee context + optional turn history + the user message. Groq's speed makes the coach feel real-time, and it does double duty — also driving Cognee's cognify() entity extraction via the OpenAI-compatible endpoint.

10.4 Gemini — the embedder

Embeddings run through Gemini’s gemini-embedding-001 (3072 dimensions) — remote, so no local model weights consume server RAM (a deliberate choice after the deployment memory constraints in §17).

10.5 improve() — continual learning without fine-tuning

When an athlete rates a drill harmful, we don’t retrain anything. We remember() a structured feedback note with an explicit instruction ("do NOT recommend this drill again"). It connects to the relevant node in the graph, and future recall() calls surface it — so behavior adapts from a single human signal.

11. Impact

• Discovery at national scale, zero new hardware. 1.5M schools already have a PE teacher and a phone.
• A career that compounds. An athlete owns a continuous, verified record that remembers their injuries, progress, and results.
• Fraud-resistant credibility. Age-verified, tamper-evident results attack youth-sport age fraud.
• Inclusion made structural. The same passport serves ~26–30M Indians with disabilities.
• A template beyond sport. The memory-native, erasable, multi-tenant architecture applies to education, pediatric health, skilling.

12. Real-World Use Cases

1. The rural PE teacher films a district-meet sprint; the pose AI flags a top-percentile 13-year-old who’d never be seen.
2. The SAI scout covering 40 districts recalls every explosive athlete they rated 4+/5 last season — instantly.
3. The self-coached teenager gets an AI coach that remembers her last injury and adjusts her plan.
4. The para-athlete’s parent gets a grounded shortlist of suitable sports, equipment, and India-specific programs.
5. The guardian who changes their mind taps “Delete” — and every trace of their child is gone in one call.

The moat is not any single screen — it is the verified, relational, erasable memory that Cognee makes possible.

13. Comparison

Where a generic fitness app, a plain LLM chatbot, and a vector-RAG app fall short — and Udaan × Cognee delivers:

• Remembers across sessions — fitness app ❌, chatbot ❌, vector-RAG partial; Udaan ✅ via the knowledge graph.
• Understands relationships — all others ❌ (vector-only); Udaan ✅ via graph traversal.
• Learns from feedback — all others ❌; Udaan ✅ via improve().
• Per-user memory isolation — fitness app partial, chatbot ❌, vector-RAG manual; Udaan ✅ via datasets.
• Right-to-erasure (DPDP) — all others ❌ or hard; Udaan ✅ via forget().
• Talent discovery pipeline — none of the others; Udaan ✅.
• Para-sport inclusion — none of the others; Udaan ✅.

The moat is not any single screen — it is the verified, relational, erasable memory that Cognee makes possible.

14. Scalability

• Stateless app tier. All state lives in Cognee, so FastAPI instances scale horizontally — no sticky sessions.
• Dataset sharding. Per-athlete datasets partition naturally as volume grows.
• Model-provider elasticity. Groq and Gemini are API calls — capacity scales with the provider.
• Federated, partner-led onboarding. School → district → state academy → para-committee, mirroring Khelo India.
• Self-improving benchmarks. The talent-percentile model improves automatically as participation grows.

15. Responsible AI and Ethics

• Right to erasure by design. forget(dataset) deletes an athlete's entire graph + vectors — DPDP compliance as a primitive.
• Data minimization. Pose estimation runs on-device; we store derived metrics, not raw footage.
• Guardian consent gates. High-percentile profiles are surfaced to verified scouts only with consent.
• Honest capability claims. “Directionally reliable percentile flags,” not lab-grade biomechanics; the coach never substitutes for medical clearance.
• Classification humility. Include Advisor reminds users that official para-classification must be done by a certified IPC classifier.
• Bias awareness. Percentile tables are versioned across age/gender/sport archetypes, aimed at surfacing rural and overlooked talent.

16. Evaluation Criteria Alignment

Use of Cognee (the headline criterion). Udaan uses the complete Cognee lifecycle — remember, recall, improve, forget — across four features, with dataset multi-tenancy and graph-aware retrieval. Cognee is the architectural center, not RAG-with-extra-steps.

Innovation. A national verified athlete-identity layer that treats memory as the missing infrastructure — and makes erasure a feature.

Impact/feasibility. Zero new hardware; buildable by a small team on open libraries; addresses the largest possible base.

Technical execution. On-device CV + a Cognee memory backend + a tamper-evident ledger, wired into a polished React frontend and a Dockerized FastAPI service.

17. Trade-offs

• Groq over a frontier model — chosen for speed; Cognee makes it swappable, so it’s reversible.
• Gemini embeddings over local FastEmbed — remote embeddings meant no model weights in memory (after hitting RAM limits).
• Hugging Face Spaces over Render — Render’s free 512 MB tier OOM’d during Cognee’s graph build; HF Spaces’ free 16 GB gave 30× the headroom.
• Windows MAX_PATH fix — Cognee’s deep default storage path exceeded Windows’ 260-char limit; we redirected its storage root to a short path.
• Re-seeding on boot vs persistent disk — the knowledge base re-seeds on startup: simpler and stateless, at the cost of a slower cold start.

18. Project Complexity Tiers

The Cognee memory layer (Tiers 2–3) is the working, demonstrable core; Tier 4 items are the roadmap the same architecture unlocks.

19. Installation & Setup

Backend

git clone https://github.com/rohanjain1648/udaan-backend
cd udaan-backend
cp .env.example .env          # fill in GROQ + GEMINI keys
pip install -r requirements.txt
uvicorn main:app --port 8000  # Swagger → http://localhost:8000/docs

Frontend

git clone https://github.com/rohanjain1648/UDAAN
cd UDAAN
npm install
npm run dev                   # http://localhost:5173 (auto-connects to :8000)

Deploy — Frontend to Vercel (auto-deploy on push); Backend to Hugging Face Spaces (Docker, port 7860) with keys added as Space secrets.

20. Why This Will Win

1. It uses Cognee the way Cognee is meant to be used — a memory layer with a full lifecycle, not swappable-for-Postgres vector search.
2. The forget() story is unforgettable. Tying children’s-data erasure to a Cognee primitive is a concrete, ethical differentiator.
3. Depth on one idea. One verified identity across a whole career — depth + vision.
4. Real, deployed, demoable. Live frontend, live API, Swagger docs, working end-to-end demo.
5. A cause with scale. 1.4 billion people, a genuine national problem.

21. Future Scope

• On-device pose estimation in production (MediaPipe BlazePose) for the Discover scorecard.
• The Prove hash-chain ledger (permissioned Merkle/SHA-256) for tamper-evident results at scale.
• Aadhaar-based age verification via a compliant KYC provider (with guardian consent).
• Temporal reasoning in Cognee — querying an athlete’s progress over time.
• Scout dashboard with regional + sport-archetype filtering.
• Offline-first mobile app; multilingual coach across Indian languages.

22. FAQ

Is Cognee just a vector database here? No — it builds a knowledge graph (entities + typed relationships) alongside the vector index, and we use graph-aware retrieval.

Why Groq and not GPT-4/Claude? Speed for a live demo, and cost. Cognee makes the LLM swappable.

How is per-athlete privacy enforced? Through Cognee datasets (coach_{uid}) — cross-access is impossible by construction.

What happens on forget()? cognee.forget(dataset) deletes all graph nodes, edges, and vectors for that dataset — DPDP right-to-erasure.

Does it need special hardware? No — a smartphone camera is the only sensor.

23. Lessons Learned

• Memory changes the product category. When continuity became a Cognee property, “chatbot” became “career companion.” Architecture is product.
• The full lifecycle is underrated. Adding improve() and forget() unlocked continual learning and legal compliance — four lines of Cognee each.
• Deployment constraints are design signals. The Render OOM and Windows MAX_PATH failure taught us real infra lessons.
• Datasets are a privacy architecture. One string per athlete gave us multi-tenancy and erasure.
• Ground every claim. Deferring injuries to a doctor and classification to an IPC classifier made the product more trustworthy and more honest.

Udaan × Cognee — Indian sport never had a memory. Now it has one, built on Cognee: from a village sprint to a national podium, one passport that never forgets an athlete… until she asks it to.