GenerativeAI.study

An AI-assisted learning platform that organises age-appropriate lessons by subject. This implementation currently includes a .NET 8 REST API, an ASP.NET MVC web client, Azure Blob Storage with a local-development fallback, OpenAI Responses API integration, and automated API workflow tests.

Solution Overview

The platform connects a voice-controlled smart-glasses learning experience with the SmartGlasses.study Android application, the GenerativeAI.study API and web application, OpenAI-powered content generation, and Microsoft Azure infrastructure.

Projects

• src/GenerativeAI.Contracts: shared domain models and API request/response contracts
• src/GenerativeAI.Api: authentication, subjects, lessons, material generation, and progress endpoints
• src/GenerativeAI.Web: responsive MVC learning experience backed entirely by the API
• src/GenerativeAI.Tests: xUnit security and end-to-end API tests
• src/mobile: Kotlin/Jetpack Compose Android and smart-glasses companion client

When AzureBlobStorage:ConnectionString is configured, application data—including users, password hashes, refresh tokens, lessons, and progress—is persisted in Azure Blob Storage. Without it, local development falls back to App_Data/study-data.json.

Prerequisites

• A .NET SDK capable of targeting .NET 8. The repository pins SDK 9.0.314, which is installed in the current development environment.
• An OpenAI API key is required to generate facts. Browsing existing material works without one.

Run Locally

From the repository root, restore and verify the solution:

dotnet restore src/GenerativeAI.Study.sln
dotnet build src/GenerativeAI.Study.sln --no-restore
dotnet test src/GenerativeAI.Study.sln --no-restore

Start the API and web client in separate terminals:

dotnet run --project src/GenerativeAI.Api
dotnet run --project src/GenerativeAI.Web

Open http://localhost:5082. The API health endpoint is http://localhost:5081/health.

Local data is created in src/GenerativeAI.Api/App_Data/study-data.json and is ignored by Git. The API seeds Maths, Science, History, and an Algebra basics lesson on first run.

Configuration

Configuration is in each project's appsettings.json and can be overridden with user secrets or environment variables. Never commit production credentials.

dotnet user-secrets init --project src/GenerativeAI.Api
dotnet user-secrets set "OpenAI:ApiKey" "YOUR_KEY" --project src/GenerativeAI.Api
dotnet user-secrets set "JwtSettings:SecretKey" "A_LONG_RANDOM_SECRET" --project src/GenerativeAI.Api

Relevant sections are JwtSettings, OpenAI, Cors, and AzureBlobStorage. Configure secrets outside appsettings.json:

dotnet user-secrets set "OpenAI:ApiKey" "YOUR_OPENAI_KEY" --project src/GenerativeAI.Api
dotnet user-secrets set "AzureBlobStorage:ConnectionString" "YOUR_AZURE_STORAGE_CONNECTION_STRING" --project src/GenerativeAI.Api

The API creates the configured study-data container automatically. If the Azure connection string is absent, it uses local JSON storage; if the OpenAI key is absent, material generation returns 503 generation_unavailable.

API Surface

The API implements the authentication, subject, lesson, learning material, and progress routes from 3 - spec.md. State-changing subject routes require an admin token; topic creation, generation, and progress routes require an authenticated learner. Access tokens are HMAC-SHA256 signed and passwords use PBKDF2-SHA256 with per-password salts.

Tests

The test suite covers password hashing, signed-token validation/tampering, age groups, anonymous authorization, and the complete student workflow from registration through progress analytics. The first implementation milestone measures 78.4% line coverage for referenced application code.

Web Application

The responsive GenerativeAI.study web application provides subject discovery, learning statistics, topic management, generated fact review, progress tracking, and administrative actions through the same secured API used by the mobile client.

Subject dashboard	Topic and generated facts

Android App

The Android client uses Jetpack Compose, an OkHttp API client, Android Keystore AES-GCM token storage, automatic access-token refresh, manual dependency injection through StudyApp, and Meta's Wearables Device Access Toolkit (DAT). It includes registration/login, the complete flashcard workflow (topic creation, generation, review, study, questions, feedback, explanations, settings, and progress), topic/fact deletion, profile statistics, retryable offline states, and a connected smart-glasses quiz experience.

Mobile application

Topic dashboard	Multiple-choice quiz

The Android app defaults to the deployed Azure API. To use a locally running API from the emulator, add API_BASE_URL=http://10.0.2.2:5081/ to the ignored src/mobile/local.properties, then start the API before launching the app:

dotnet run --project src/GenerativeAI.Api --urls http://0.0.0.0:5081

Open src/mobile in Android Studio, or build from PowerShell:

$env:JAVA_HOME="C:\Program Files\Android\Android Studio\jbr"
$env:ANDROID_HOME="$env:LOCALAPPDATA\Android\Sdk"
cd src/mobile
.\gradlew.bat testDebugUnitTest assembleDebug

The debug APK is generated at src/mobile/app/build/outputs/apk/debug/app-debug.apk.

The Meta DAT artifacts are hosted in GitHub Packages. Supply a GitHub personal access token with read:packages permission as either GITHUB_TOKEN or github_token in the ignored src/mobile/local.properties file:

github_token=YOUR_GITHUB_TOKEN

Run on a physical Android device

1. Use an Android 10 or newer device with the Meta AI app installed and a supported pair of Meta glasses linked to it.

2. Enable Developer Mode for the glasses in the Meta AI app. For this development build, the DAT application ID and client token are both configured as 0.

3. Enable Android Developer options and USB debugging, connect the phone by USB, and accept the debugging prompt.

4. Find the development machine's LAN IPv4 address (for example, with ipconfig). The phone and development machine must be on the same network.

5. Add the following machine-specific setting to the ignored src/mobile/local.properties file, using the development machine's address:

   API_BASE_URL=http://192.168.1.100:5081/
   

6. Start the API on all network interfaces with the command above. If Windows asks, allow port 5081 through the firewall for the private network.

7. Open src/mobile in Android Studio, let Gradle sync, select the connected device, and click Run app.

8. Open Profile in the app. Complete Meta AI registration if prompted, then select Connect glasses. The profile and quiz screens display the current connection state.

API_BASE_URL can also be supplied as a Gradle property (-PAPI_BASE_URL=...) or an environment variable. local.properties takes precedence over the environment variable and remains uncommitted.

Smart-glasses quiz experience

MetaGlassesSession implements registration, device discovery, connection, and disconnection through Meta DAT. CompanionGlassesSession remains available as a local implementation of the same GlassesSession contract.

When glasses are connected and the learner starts a multiple-choice quiz, the app:

1. Reads the question and labelled answer choices through the glasses speakers.
2. Says Listening, switches from the A2DP media profile to Bluetooth SCO, and listens for an answer through the glasses microphone.
3. Accepts a spoken option letter or matching answer text exactly like a tap in the mobile interface.
4. Says Correct, or says Incorrect followed by the correct answer.
5. Advances automatically and repeats the sequence for the next question.

All spoken playback is sequenced through A2DP for consistent quality and volume. SCO is enabled only for recognition. Voice interaction fails closed when a glasses SCO input is unavailable: the application must never substitute the phone microphone. Android's RECORD_AUDIO permission is still required to use the platform speech recognizer, even though the selected input is the glasses microphone.

An ongoing microphone foreground service and partial wake lock keep an active glasses quiz running when the display turns off. The notification makes this background microphone use visible to the learner. Leaving the quiz intentionally stops its active voice controller, but the question order, current question, selected answer, and score remain in memory. The Topic page then presents Continue Quiz to resume the same position.

Required Android permissions include Bluetooth connection, audio recording, foreground service/microphone, wake lock, and Internet access. Android 11 and newer also require manifest visibility declarations for installed speech-recognition and text-to-speech services.

See the Meta Wearables DAT Android repository and Meta Wearables developer documentation for supported devices, current SDK requirements, registration, and firmware compatibility.

Why SmartGlasses.study Is a Strong Educational Tool

SmartGlasses.study combines generated study material with active recall in a form that can fit naturally into a learner's day. Instead of requiring constant attention to a phone, it can present a question, accept a spoken answer, give immediate corrective feedback, and move to the next prompt hands-free.

This experience is valuable because it supports:

• Active recall: learners retrieve an answer instead of only rereading material.
• Immediate feedback: misconceptions are corrected at the moment an answer is given.
• Short, repeatable sessions: a quiz can be used while walking, doing household tasks, or taking a study break, when it is safe to do so.
• Reduced screen dependence: audio-first interaction can make revision less visually demanding and more accessible for some learners.
• Continuity across phone and glasses: learners can answer by voice or touch, leave temporarily, and continue the same quiz from the Topic page.
• Age-appropriate personalisation: generated lessons and questions can be adapted to the learner's subject, age group, and desired difficulty.

Smart glasses are attracting growing interest because they combine familiar eyewear with speakers, microphones, cameras, AI assistants, and increasingly capable displays. Their value is broader than any single feature: the same hands-free interface can support learning, accessibility, navigation, translation, communication, field work, guided maintenance, first-person capture, and contextual assistance.

Education is a particularly natural use case. A wearable can deliver prompts without continually pulling the learner back to a screen, while voice interaction makes recall practice conversational. SmartGlasses.study demonstrates this direction with a focused and practical workflow rather than treating the glasses as a second phone display.

The experience should be used with situational awareness. Learners should not use quizzes when spoken prompts could distract them from driving, cycling, operating equipment, or navigating unsafe surroundings.