À la Carte - AI-Powered Restaurant Operations Suite

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

┌─────────────────────────────────────────────┐
│         React Dashboard (Port 3000)         │
│  Real-time metrics, alerts, detailed panels │
└──────────────────┬──────────────────────────┘
                   │ HTTP API
┌──────────────────▼──────────────────────────┐
│    FastAPI MCP Server (Port 8001)           │
│  Core restaurant logic + Agent orchestration│
└──┬────────┬─────────┬──────────────────────┘
   │        │         │
   │ HTTP   │ HTTP    │ HTTP
   │        │         │
┌──▼──┐  ┌─▼───┐  ┌─▼─────┐
│Inv  │  │Menu │  │Review │
│8004 │  │8006 │  │8003   │
└─────┘  └─────┘  └───────┘
     │      │        │
     └──────┴────────┘
            │
     ┌──────▼──────┐
     │  ChromaDB   │
     │ Persistence │
     └─────────────┘

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:

1. Frontend requests metrics/analytics
2. Backend MCP server receives request
3. MCP server queries relevant agent service(s)
4. Agents perform analysis (possibly calling Claude API)
5. Results cached in /data/ directory
6. Sanitized data returned to frontend

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 that 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 for À la Carte

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

Component	Technology
Backend	FastAPI + MCP
Agents	uAgents + Python
Database	ChromaDB
LLM	Anthropic Claude
Frontend	React + TypeScript
Styling	Tailwind CSS
APIs	Fetch.ai, Bright Data, Yelp, Vapi