# Project export: À la Carte

This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small.

## Project metadata

- Hackathon: Cal Hacks 12.0
- Tagline: À la Carte bridges legacy restaurant management with next‑gen agent systems via the agentverse: delivering AI analytics, automation, and recommendations; reaching diners where they research today,
- Devpost: https://devpost.com/software/restaurai
- GitHub: not linked
- Demo: http://alacar.tech/
- Video: https://www.youtube.com/embed/Qdr3zuaL0jQ?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent
- Team: contributor stats unavailable

## Devpost submission (written by the team)

### Inspiration

Restaurants operate on thin margins. Wasted inventory, poor menu decisions, or missed customer feedback patterns directly impact profitability. The project essentially asks: "What if every restaurant had a team of AI specialists constantly monitoring operations and providing intelligent recommendations?" Instead of one monolithic AI, À la Carte uses specialized agents (inspired by agent frameworks like Fetch.ai's uAgents) - each expert in their domain. The inspiration came from watching small restaurant owners juggle spreadsheets, manually count inventory, and struggle to make data-driven decisions while competing against well-funded chains with entire analytics departments.

### What it does

À la Carte automates restaurant management using 6 autonomous AI agents that constantly monitor your business and provide smart recommendations. À la Carte also automatically integrates and updates your restaurant with the agentverse so that anyone without any technical knowledge can use fetch.ai's agentverse and asi:one to get up to date information on your menus, reviews, and staff, all in natural language! Real-time Operations Dashboard You open a web dashboard that shows: Real-time metrics from all 6 agents (inventory, menu, reviews, orders, reservations, staff) Intelligent alerts when something needs attention (low stock, negative review trends, underperforming menu items) Detailed reports you can click into for deep analysis The Six Specialized Agents 1. Inventory Agent Tracks real-time ingredient consumption across all dishes Analyzes historical usage patterns to predict when items will run out Generates AI-powered reorder suggestions with optimal quantities Alerts on low stock before it impacts service Multi-restaurant support with daily automated reports 2. Menu Agent Analyzes menu item performance (orders, revenue, profit margins) Identifies top-performing and underperforming dishes Tracks temporal ordering patterns (lunch vs. dinner trends) Provides LLM-powered recommendations for menu optimization Correlates ingredient costs with menu pricing for profit analysis 3. Review Agent Scrapes reviews from Google Places and Yelp automatically Performs sentiment analysis using Claude to extract key themes Identifies staff performance mentions (positive and negative) Monitors reputation trends and detects anomalies (health concerns, sudden rating drops) Segments customer feedback by category (food quality, service, ambiance) 4. Reservation Agent Manages table availability and booking states Optimizes seating arrangements based on party size Tracks reservation patterns to predict busy periods Integrates with order system for seamless table-to-kitchen flow 5. Order Agent Processes orders and manages kitchen tickets Tracks order lifecycle from placement to completion Updates menu availability based on real-time inventory Generates revenue analytics and order trends 6. Staff Agent Analyzes staff performance from review mentions Optimizes scheduling based on historical demand patterns Tracks labor costs vs. revenue Technical Architecture

### How we built it

Architecture & Design Decisions We built À la Carte as a microservices architecture with three layers: 1. Frontend Layer - React + TypeScript Dashboard Built with Vite for fast development and hot module replacement Tailwind CSS for responsive, modern UI design Lucide React icons for consistent visual language Real-time polling (30-second intervals) for agent metrics 2. Backend Core - FastAPI + MCP (Model Context Protocol) FastAPI for high-performance HTTP endpoints with automatic OpenAPI docs MCP (Model Context Protocol) for standardized agent communication ChromaDB vector database for persistent storage with event logging Managers pattern: IngredientManager, TableManager, OrderManager for separation of concerns Pydantic models for data validation and type safety 3. Agent Services Layer - Specialized Microservices Each agent runs as an independent uAgents-based service with: REST endpoints for synchronous queries (dashboard metrics) Chat protocol for natural language agent-to-agent communication Secure authentication via UUID-based secure_key per restaurant Daily automated reports generated on 24-hour intervals Key Implementation Details Multi-Agent Coordination: uAgents framework from Fetch.ai because: Built-in message protocols for agent communication REST endpoint support alongside agent-to-agent messaging Clean separation of concerns with modular analyzers (e.g., ConsumptionAnalyzer, LLMAnalyzer, ReportGenerator) Data Flow Pattern: Multi-Restaurant Support: Configuration stored in agents/restaurants.json with secure keys Each agent can analyze multiple restaurants independently Daily reports generated per restaurant with timestamp tracking Testing & Development: Generated synthetic test data for two real SF restaurants (Causwells, Cote Ouest Bistro) Comprehensive test suite for core restaurant operations Used ngrok for exposing local agents during development

### Challenges we ran into

1. Network Reliability Our biggest obstacle was unreliable, slow Wi-Fi. Because the system relied on real-time calls to: Anthropic's Claude API (sentiment analysis, recommendations) Google Places API (review scraping) Yelp API (additional reviews) Agent-to-agent communication across ports 2. uAgents Framework Learning Curve The uAgents framework from Fetch.ai didn't have extensive documentation for our specific use case: running HTTP REST endpoints alongside agent-to-agent messaging. Most examples focused on pure agent communication, but we needed: Public HTTP endpoints for the dashboard Agent protocols for inter-agent communication Secure authentication per restaurant 3. Cost & Performance Optimization We originally envisioned real-time predictive analytics with Claude analysis on every incoming review. This quickly became: Expensive: Running Claude analysis on hundreds of reviews across multiple restaurants Slow: Synchronous API calls blocked the request pipeline

### Accomplishments we're proud of

1. Built a Production-Grade Multi-Agent System 3 fully operational AI agents processing real restaurant data Real restaurants integrated (Causwells SF, Cote Ouest Bistro) Live API integrations with Google Places and Yelp using BrightData Persistent data storage with ChromaDB Professional UI/UX with React dashboard 2. Solved Real Restaurant Pain Points Inventory Agent prevents stockouts and reduces waste Menu Agent identifies underperforming dishes (direct profit impact) Review Agent surfaces customer issues before they become trends Multi-restaurant support means the system scales beyond single locations 3. Clean, Maintainable Codebase Despite the time pressure, we prioritized: Type safety (Pydantic models, TypeScript) Separation of concerns (managers, analyzers, generators) Modular design (new agents follow existing patterns) Comprehensive data models (Ingredient, MenuItem, Reservation, etc.) 5. Overcame Technical Hurdles Figured out uAgents framework Optimized LLM costs by 80% Integrated 4 external APIs (Claude, Google, Yelp, uAgents)

### What we learned

Technical Lessons 1. Multi-Agent Architecture Design Microservices work beautifully for specialized AI agents with different responsibilities Agent-to-agent communication requires standardized protocols (MCP was the right choice) State management is critical - we used ChromaDB for persistence and /data/ directory for report caching Authentication must be multi-tenant from day one (secure_key pattern saved us) 2. LLM Integration Best Practices Context size matters - truncate aggressively, the LLM doesn't need every field Prompt engineering is 80% of the work - clear instructions yield consistent outputs Batch processing is almost always better than real-time for analytics Caching LLM outputs (daily reports) reduces costs dramatically Fallbacks are essential when APIs are unreliable 3. Framework Selection Matters FastAPI was perfect for the MCP server (automatic docs, high performance) uAgents had a learning curve but provided powerful abstractions React + Vite made frontend development fast and enjoyable ChromaDB handled persistence elegantly without heavy database overhead

### What's next

1. Complete the Agent Suite Fully implement Order Agent with kitchen display integration Build out Staff Agent with scheduling optimization Add Delivery Agent for third-party platform monitoring (DoorDash, Uber Eats) 2. Enhanced Analytics Predictive demand forecasting using historical order data Menu engineering matrix (profitability vs. popularity quadrants) Customer segmentation (regulars, first-timers, high-spenders) Competitor benchmarking (compare your restaurant's ratings/reviews to nearby competitors) 3. Integrations POS system integrations (Square, Toast, Clover) for automatic order ingestion Supplier APIs for one-click reordering from ingredient suggestions Accounting software (QuickBooks) for profit/loss tracking Reservation platforms (OpenTable, Resy) for centralized booking Tech Stack Summary À la Carte: Giving every restaurant the AI team they deserve.

## README (from the GitHub repository)

No README available.

## Detected evidence (automated analysis)

No repository was indexed for this project. Claimed technologies below could not be checked against code.
- JavaScript (language) — claimed on Devpost, not found in the code
- LangChain (technology) — claimed on Devpost, not found in the code
- Python (language) — claimed on Devpost, not found in the code
- React (technology) — claimed on Devpost, not found in the code

## Codebase structure

No repository index available.

## Key source files

No repository index available; no source files included.