Smart Inventory. Generative Recipes. Social Cooking.

MOCC is a cloud-native application designed to revolutionize kitchen management. By leveraging Artificial Intelligence, Computer Vision, and Real-Time Connectivity, MOCC allows users to manage their inventory, minimize food waste, and discover personalized recipes.

MOCC Home Screen Dashboard

MOCC is built on a modern, polyglot architecture:

• Framework: Flutter (Mobile & Web Support).
• State Management: flutter_riverpod for reactive and testable state.
• Navigation: go_router for declarative routing and deep linking.
• API Client: graphql_flutter with robust caching and offline support.
• Auth: msal_auth / msal_js for Microsoft Entra ID integration.
• Localization: easy_localization for multi-language support.

• Runtime: Go 1.22+ containerized with Docker.
• API: GraphQL server using 99designs/gqlgen.
• Hosting: Azure Container Apps (ACA) with KEDA auto-scaling (Scale-to-Zero).
• Security: Keyless access to Azure resources via Managed Identities.

• Runtime: Python 3.12 on Azure Functions (Flex Consumption).
• AI & ML:
  • Azure AI Document Intelligence for converting receipts to structured data.
  • Azure OpenAI (GPT-4o) for generative recipe creation.
  • Azure Content Safety for moderating social posts.
• Triggers: Event Grid blobs, Timers, and Storage Queues.

• IaC: Entirely managed via Bicep templates.
• Gateway: Azure API Management (Consumption) as the single entry point.
• Database: Azure Cosmos DB (NoSQL) with auto-scaling (400 RU/s cap).
• Caching: Azure Redis Cache for session and data caching.
• Real-Time: Azure SignalR Service and Notification Hubs (Firebase FCM).

A quick overview of the repository organization:

MOCC/
├── app/                  # Frontend (Flutter)
│   ├── lib/              # Dart source code
│   └── web/              # Web configuration
├── backend/              # Backend (Go + GraphQL)
│   ├── graph/            # GraphQL schema & resolvers
│   ├── internal/         # Business logic
│   └── server.go         # API Entrypoint
├── functions/            # Azure Functions (Python)
│   ├── services/         # AI & Event logic
│   └── function_app.py   # Triggers definition
├── infrastructure/       # Infrastructure as Code (Bicep)
│   ├── modules/          # Resources definitions
│   └── scripts/          # Deployment scripts
└── documentation/        # Diagrams and assets

A high-level structural overview of the cloud-native solution, illustrating the interaction between the Flutter Frontend, the API Gateway, and the underlying microservices hosted on Azure Container Apps and Functions.

Visualizes the event-driven architecture where Azure Functions orchestrate complex tasks like receipt OCR processing (Document Intelligence), recipe generation (OpenAI GPT-4), and content moderation, triggered by Event Grid events from Blob Storage.

MOCC uses a Zero-Trust approach. Services communicate via Managed Identities and RBAC assignments (e.g., Storage Blob Data Contributor) without hardcoded secrets.

1. Azure CLI: Logged in to your target subscription.
2. GitHub Account: For CI/CD workflows.
3. Firebase Project: An active Firebase project with google-services.json generated.
4. Tools: Docker, Go, Flutter, Node.js installed locally for development.

Deploy the entire stack (Infrastructure, Functions, Policies, Frontend) using the master script.

Windows (Batch):

.\infrastructure\scripts\DeployAll.bat

Note: For infrastructure-only updates, use DeployMain.bat.

The CI/CD pipelines depend on strict configuration. Add the following Repository Secrets to your GitHub repo:

Since the Azure Static Web App (SWA) URL is generated dynamically upon creation, you must whitelist it in your Entra ID App Registration to allow authentication redirects.

1. Go to the Azure Portal > Static Web Apps.
2. Copy the URL of the deployed mocc-swa (e.g., https://purple-moss-012345.azurestaticapps.net).
3. Go to Entra ID > App Registrations > Your Client App > Authentication.
4. Under Single-page application, Add the following Redirect URIs:
   • https://<your-swa-url>
   • https://<your-swa-url>/auth.html (Required for popup auth flows)

Note: Without this step, users will encounter AADSTS50011 errors during login on the Web version.

Ensure the following tools are installed:

• Docker: For running containerized dependencies (Redis).
• Go 1.22+: For the backend API.
• Flutter: For the frontend application.
• Python 3.12+: For Azure Functions.
• Azure CLI (az): Managed identity and login.
• Azure Functions Core Tools (func): For running functions locally.
• Azurite: For emulating Azure Storage.

MOCC requires storage and caching emulators for local runs.

Azure Storage (Azurite)

# Install via NPM if needed: npm install -g azurite
azurite --silent --location .azurite --debug .azurite/debug.log

Redis Cache

docker run --name redis -p 6379:6379 -d redis

Go API Server (Port 8080)

cd backend
go mod tidy
go run server.go

Azure Functions (Port 7071)

cd functions
# Create a python virtual environment if first time
# python -m venv .venv
# .venv\Scripts\activate
# pip install -r requirements.txt
func start

cd app
flutter pub get
flutter run -d chrome

You can trigger local Azure Functions (e.g., Recipe Generation) by simulating Event Grid webhooks without deploying to Azure.

1. Ensure your Function App is running locally on port 7071.
2. Edit functions/simulate_event.ps1 to set your target userId and filename.
3. Run the simulation script:

./functions/simulate_event.ps1

This sends a mock Microsoft.Storage.BlobCreated event to http://localhost:7071/runtime/webhooks/EventGrid, triggering the function logic.

Developed with ❤️ for MOCC.