DEV Community

Mark Cantimbuhan
Mark Cantimbuhan

Posted on

Mill: Local-First AI Ops & Sous-Chef for Meal Prep Side Hustlers

#hf26challenge #devchallenge #ai #opensource

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle Submission đź’¸

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

I built Mill — Local-First AI Ops & Sous-Chef for Meal Prep Side Hustlers.

Selling prepared meals (fitness preps, weekly family bowls, keto packages) is one of the most popular side hustles today. But behind every aesthetic meal container is operational chaos:

  1. Uncontrolled ingredient shrinkage: Buying food at retail, mismeasuring batch portions, and failing to account for seasoning oils eats up 15–20% of net margin.
  2. Stockout guesswork: You get a DM asking for 15 Teriyaki Chicken Bowls for Friday. Do you have enough chicken, jasmine rice, and honey garlic sauce in stock right now, or will you have to make an emergency grocery run?
  3. Kitchen multitasking meltdown: When you have 4 burners running, an oven preheating, and 50 containers to box, you can't be typing notes or checking spreadsheets. You need real-time multi-step guidance with timers that keep you on track.

Mill turns a laptop into an autonomous kitchen command center for food side hustlers.

Key Capabilities

  • Real-Time Pantry & Ingredient Audit Ledger: Tracks bulk items down to grams and milliliters with exact unit costs. Every manual adjustment, restock, or kitchen fulfillment deduction is recorded to an immutable audit trail.
  • Recipe Testing Lab & Margin Pricing: Calculates exact ingredient batch costs and suggests profitable selling prices based on target gross margins (70%+).
  • Visual Kanban Fulfillment Pipeline: Drag-and-drop order management across Upcoming, Preparing, and Completed. Moving an order card to Completed automatically calculates needed recipe ingredients and deducts them from inventory through the audit ledger.
  • Active Kitchen Prep Mode: Step-by-step checklist with auto-detected countdown timers (e.g. "Simmer for 15 minutes") and audio-visual cues so you never scorch a batch while packing containers.
  • Autonomous AI Sous-Chef via FastMCP: An AI assistant connected directly to the local SQLite database through 16 typed FastMCP tools. You can tell Mill: "Check if I have enough stock to cook 8 Honey Soy Chicken bowls", "Record an order for Sarah for Saturday", or "Adjust chicken breast inventory down by 500g", and it handles the database transactions autonomously.

Demo

Here is how you can run Mill locally in two steps:

# 1. Clone the repository
git clone https://github.com/JustCallMeMarko/mill.git
cd mill

# 2. Start the Backend (FastAPI + FastMCP + SQLite)
cd backend
cp .env.example .env
uv run mill-seed    # Seeds realistic pantry stock, recipes, and sample orders
uv run mill-api     # Starts API server on http://127.0.0.1:8000 (FastMCP mounted at /mcp)

# 3. Start the Frontend (React 19 + Tailwind + Vite)
cd ../frontend
bun install
bun dev             # Launches the dashboard on http://localhost:5173
Enter fullscreen mode Exit fullscreen mode

Open http://localhost:5173 in your browser. You can:

  • Drag orders across the Kanban pipeline to watch stock deduct automatically.
  • Switch to the Preparation tab to launch guided cooking timers and chat with the scoped AI Sous-Chef.
  • Use the AI Assistant tab to let Mill execute multi-step database adjustments via FastMCP tool calling.

Code

GitHub logo JustCallMeMarko / mill

Mill: AI Meal Prep Seller Assistant

Mill is a local-first, autonomous AI assistant built specifically for meal prep sellers and culinary entrepreneurs. It helps automate operations, calculate profitable prices, test new experimental recipes against the core menu, manage orders on an interactive Kanban pipeline, and guide cooking through step-by-step checklists with smart kitchen timers.

Key Features

  1. AI Chatbot with Model Context Protocol (FastMCP)

    • Powered by openai-agents connected to 16 local database tools.
    • Works with either OpenAI (gpt-4o-mini, etc.) or Ollama (e.g. llama3.1, qwen2.5) via standard OpenAI-compatible endpoints.
    • Adjusts stock, creates orders, inspects margins, and suggests recipes right from conversation.
    • Real-time Server-Sent Events (SSE) streaming with expandable tool-call activity cards.

  2. Ingredient & Pantry Inventory

    • Track ingredient quantities, units, and unit costs.
    • Automatic low-stock warnings when inventory drops below threshold.
    • Complete transactional audit ledger for restocks, kitchen adjustments, and order fulfillment.

  3. Recipes & Testing Lab

    • Maintain a distinction…
View on GitHub

Repository: https://github.com/JustCallMeMarko/mill

System Architecture 

flowchart TD
    subgraph UI [Frontend - React 19 + Tailwind + dnd-kit]
        A1[Kanban Prep Pipeline]
        A2[Kitchen Prep & Timers]
        A3[Inventory & Audit Ledger]
        A4[AI Assistant Chat]
    end

    subgraph Server [Backend - FastAPI & Python 3.12]
        B1[REST API Endpoints]
        B2[SSE Streaming Engine]
        B3[FastMCP Tool Server - 16 Tools]
        B4[openai-agents Agent Runner]
    end

    subgraph Storage [Local Storage]
        C1[(SQLite: mill.db)]
        C2[Inventory Ledger]
    end

    subgraph LLM [Inference Layer]
        D1[Ollama / Local Open Weights: Gemma, Llama 3.2, Qwen]
        D2[Optional Cloud API: OpenAI]
    end

    UI -->|REST & SSE Events| B1
    A4 -->|SSE Stream| B2
    B1 --> C1
    B3 --> C1
    B3 --> C2
    B4 -->|Calls Tools| B3
    B4 -->|OpenAI-Compatible HTTP| D1
    B4 -.->|Fallback| D2

How I Built It

The Stack

  • Frontend: React 19, TypeScript, Tailwind CSS, Lucide icons, @dnd-kit (accessible, physics-based Kanban drag-and-drop), React Query, and responsive dark/light themes.
  • Backend: FastAPI, SQLite with SQLAlchemy 2.0, uvicorn, Server-Sent Events (SSE) streaming for real-time AI token generation.
  • Tool Protocol: FastMCP exposing 16 typed tools mounted directly at http://127.0.0.1:8000/mcp.
  • AI Agent Engine: Built with openai-agents connected to an OpenAI-compatible endpoint. Pointing OPENAI_BASE_URL to http://localhost:11434/v1 allows running open-weight models (like gemma, llama3.2, or qwen2.5) completely locally via Ollama with zero code changes.

Key Implementation Highlights

1. Immutable Audit Ledger on Kitchen Fulfillment

When a side hustler drags an order to the "Completed" column in the Kanban board, we don't just decrement a number in the database. Mill looks up each recipe's scaled ingredient lines, computes the deduction, and logs an audited transaction:

# In backend/src/mill/services/orders.py
for item in order.items:
    recipe = db.get(Recipe, item.recipe_id)
    if not recipe or recipe.servings_per_batch <= 0:
        continue
    scale = item.quantity / recipe.servings_per_batch
    for ing in recipe.ingredients:
        needed_qty = ing.quantity * scale
        inv_item = db.get(InventoryItem, ing.inventory_item_id)
        if inv_item:
            inv_item.quantity = max(0.0, inv_item.quantity - needed_qty)
            tx = InventoryTransaction(
                inventory_item_id=inv_item.id,
                change_amount=-needed_qty,
                reason=f"Order #{order.id} ({order.customer_name}) fulfilled",
            )
            db.add(tx)
Enter fullscreen mode Exit fullscreen mode

2. FastMCP Tool Execution

Rather than having an LLM hallucinate numbers or suggest recipes you cannot cook, Mill provides 16 specific FastMCP tools. As highlighted in community research on tool descriptions and accuracy, having explicit type hints and deterministic database operations keeps small local models from making reasoning errors.

@mcp.tool()
def check_recipe_feasibility(recipe_id: int, servings_to_cook: int) -> dict:
    """Check if there is sufficient stock in the pantry to cook a batch."""
    with SessionLocal() as db:
        return check_recipe_feasibility_service(db, recipe_id, servings_to_cook)
Enter fullscreen mode Exit fullscreen mode

3. Kitchen-Focused UX

Kitchen environments demand big tap targets, clear high-contrast buttons, and zero clutter. Every prep step with a duration (like "Bake for 25 minutes") automatically parses out the time and renders an interactive countdown timer.

Why Does Open Innovation Matter?

For a food side hustle, open innovation and local-first AI are not just nice-to-haves—they are the difference between a viable business and going in the red:

  1. Thin Margins Cannot Bear API Billing Surges: Food side hustles operate on tight 15–25% net margins. Paying per-token cloud API costs every time you ask your assistant to price a recipe or check stock burns profits. Running open-weight models locally via Ollama costs exactly $0 in ongoing API fees.
  2. Kitchen & Commissary Reliability: Commercial kitchens, basements, and food prep spaces often have terrible Wi-Fi. An assistant that needs cloud latency to check a substitution or toggle a timer will fail during a busy prep rush. Mill runs 100% locally on your machine.
  3. Customer Dietary & Health Data Privacy: Side hustlers collect customer delivery addresses, food allergies, and health goals. Storing this in local SQLite and processing it with local models ensures customer data never leaks to third-party model training pipelines.
  4. No Vendor Lock-In: Because Mill uses standard tool-calling contracts, sellers can run Gemma, Llama 3.2, Qwen 2.5, or whatever open-weight model fits their laptop's hardware.

Prize Categories

  • Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle (Main category)
  • Best Use of Gemma (Full local inference support via Ollama with MILL_MODEL=gemma)

Team

Solo — @justcallmemarko

Top comments (0)