Spaces:
Sleeping
Sleeping
| title: restaurant-intelligence-agent | |
| app_file: src/ui/gradio_app.py | |
| sdk: gradio | |
| sdk_version: 6.0.0 | |
| # 🍽️ Restaurant Intelligence Agent | |
| **AI-powered autonomous analysis of restaurant reviews with MCP integration** | |
| Built for Anthropic MCP 1st Birthday Hackathon - Track 2: Agent Apps | Category: Productivity | |
| --- | |
| ## 🎯 What It Does | |
| An autonomous AI agent that scrapes restaurant reviews from OpenTable, performs comprehensive NLP analysis, and generates actionable business intelligence for restaurant stakeholders. No manual intervention required - the agent plans, executes, and delivers insights automatically. | |
| **Key Capabilities:** | |
| - 🤖 **Autonomous Agent Architecture** - Self-planning and self-executing analysis pipeline | |
| - 🔍 **Dynamic Discovery** - AI identifies menu items and aspects (no hardcoded keywords) | |
| - ⚡ **Optimized Processing** - 50% API cost reduction through unified extraction | |
| - 📊 **Multi-Stakeholder Insights** - Role-specific summaries for Chefs and Managers | |
| - 🔧 **MCP Integration** - Extensible tools for reports, Q&A, and visualizations | |
| - 💰 **Production-Ready** - Handles 1000+ reviews at ~$2-3 per restaurant | |
| --- | |
| ## 📅 Development Timeline (Days 1-12 Complete) | |
| ### **Days 1-3: Data Collection & Processing** | |
| **Objective:** Build production-ready scraper and data pipeline | |
| **Completed:** | |
| - OpenTable scraper using Selenium WebDriver | |
| - Full pagination support (handles multi-page reviews) | |
| - Dynamic URL input (works with any OpenTable restaurant) | |
| - Robust error handling (retry logic, rate limiting, timeout management) | |
| - Data processing pipeline (review_processor.py) | |
| - CSV export and pandas DataFrame conversion | |
| **Technical Details:** | |
| - Selenium navigates JavaScript-rendered pages | |
| - Extracts: reviewer name, rating, date, review text, diner type, helpful votes | |
| - Rate limiting: 2-second delays between page loads (respectful scraping) | |
| - Retry logic: 3 attempts with exponential backoff on failures | |
| - URL validation and minimum review count checks | |
| **Key Files:** | |
| - `src/scrapers/opentable_scraper.py` | |
| - `src/data_processing/review_processor.py` | |
| --- | |
| ### **Days 4-8: NLP Analysis Pipeline** | |
| **Objective:** Build AI-powered analysis agents | |
| **Initial Approach (Days 4-6):** | |
| - Separate agents for menu discovery and aspect discovery | |
| - Sequential processing: menu extraction → aspect extraction | |
| - Problem: 8 API calls for 50 reviews (expensive and slow) | |
| **Optimization (Days 7-8):** | |
| - Created `unified_analyzer.py` for single-pass extraction | |
| - Combined menu + aspect discovery in one API call | |
| - Result: **50% reduction in API calls** (4 calls for 50 reviews) | |
| - Maintained accuracy while halving costs | |
| **Technical Architecture:** | |
| ``` | |
| UnifiedAnalyzer | |
| ├── Single prompt extracts BOTH menu items AND aspects | |
| ├── Batch processing: 15 reviews per batch (optimal for 200K context) | |
| ├── Temperature: 0.3 (deterministic extraction) | |
| └── JSON parsing with markdown fence stripping | |
| ``` | |
| **Menu Discovery:** | |
| - AI identifies specific menu items (not generic terms like "food") | |
| - Granular detection: "salmon sushi" ≠ "salmon roll" ≠ "salmon nigiri" | |
| - Sentiment analysis per menu item (-1.0 to +1.0) | |
| - Separates food vs. drinks automatically | |
| - Maps each item to reviews that mention it | |
| **Aspect Discovery:** | |
| - AI discovers relevant aspects from review context (no hardcoded keywords) | |
| - Adapts to restaurant type: | |
| - Japanese → freshness, presentation, sushi quality | |
| - Italian → portion size, pasta dishes, wine pairing | |
| - Mexican → spice level, tacos, authenticity | |
| - Per-aspect sentiment analysis | |
| - Review-to-aspect mapping with contextual quotes | |
| **Key Files:** | |
| - `src/agent/unified_analyzer.py` (optimized single-pass) | |
| - `src/agent/menu_discovery.py` (legacy, kept for reference) | |
| - `src/agent/aspect_discovery.py` (legacy, kept for reference) | |
| --- | |
| ### **Days 9-11: Business Intelligence & MCP Integration** | |
| **Objective:** Generate actionable insights and build MCP tools | |
| **Insights Generation:** | |
| - Created `insights_generator.py` for role-specific summaries | |
| - **Chef Insights:** Menu performance, dish-specific feedback, quality issues | |
| - **Manager Insights:** Service problems, operational issues, value perception | |
| - Trend detection across aspects and menu items | |
| - Actionable recommendations based on sentiment patterns | |
| **MCP Tools Built:** | |
| 1. **save_report.py** - Exports analysis to JSON for external systems | |
| 2. **query_reviews.py** - RAG-based Q&A over review corpus | |
| 3. **generate_chart.py** - Matplotlib visualizations (sentiment charts, comparisons) | |
| **Technical Details:** | |
| - MCP tools enable integration with external dashboards and workflows | |
| - RAG Q&A indexes reviews for semantic search | |
| - Charts compare aspects, track sentiment trends, visualize menu performance | |
| **Key Files:** | |
| - `src/agent/insights_generator.py` | |
| - `src/mcp_integrations/save_report.py` | |
| - `src/mcp_integrations/query_reviews.py` | |
| - `src/mcp_integrations/generate_chart.py` | |
| --- | |
| ### **Day 12: Scraper Refinement & Integration** | |
| **Objective:** Production-ready scraper with complete error handling | |
| **Enhancements:** | |
| - Refactored scraper to accept any OpenTable URL (was hardcoded) | |
| - Added comprehensive error handling: | |
| - URL validation (catches invalid OpenTable links) | |
| - Review count validation (warns if <50 reviews) | |
| - Pagination failure handling (graceful degradation) | |
| - Timeout handling (3-attempt retry with backoff) | |
| - Progress tracking callbacks for UI integration | |
| - Integration script: `integrate_scraper_with_agent.py` | |
| **End-to-End Pipeline:** | |
| ```python | |
| # Single command runs entire analysis | |
| python integrate_scraper_with_agent.py | |
| # Flow: | |
| 1. Scrape reviews from OpenTable | |
| 2. Process into pandas DataFrame | |
| 3. Run unified analyzer (menu + aspects) | |
| 4. Generate chef/manager insights | |
| 5. Create MCP reports and visualizations | |
| 6. Save all outputs to outputs/ and reports/ | |
| ``` | |
| **Key Files:** | |
| - `integrate_scraper_with_agent.py` (main orchestrator) | |
| - `src/scrapers/opentable_scraper.py` (production scraper) | |
| - `src/agent/base_agent.py` (agent orchestrator) | |
| --- | |
| ## 🔧 Technical Architecture | |
| ### **Agent System** | |
| ``` | |
| RestaurantAnalysisAgent (base_agent.py) | |
| ├── Phase 1: Planning (planner.py) | |
| │ └── Creates execution plan based on available reviews | |
| ├── Phase 2: Data Collection | |
| │ └── opentable_scraper.py fetches reviews with pagination | |
| ├── Phase 3: Unified Analysis | |
| │ └── unified_analyzer.py extracts menu + aspects in single pass | |
| ├── Phase 4: Insights Generation | |
| │ └── insights_generator.py creates role-specific summaries | |
| └── Phase 5: MCP Tools | |
| ├── save_report.py - Export results | |
| ├── query_reviews.py - RAG Q&A | |
| └── generate_chart.py - Visualizations | |
| ``` | |
| ### **API Strategy (Critical Optimization)** | |
| **Problem:** Initial approach was too expensive and slow | |
| - Separate menu and aspect extraction = 8 API calls per 50 reviews | |
| - For 1000 reviews: 160 API calls, ~$5-6, ~30-40 minutes | |
| **Solution:** Unified analyzer with batching | |
| - Single prompt extracts both menu + aspects = 4 API calls per 50 reviews | |
| - For 1000 reviews: 68 API calls, ~$2-3, ~15-20 minutes | |
| - **50% cost reduction, 40% time reduction** | |
| **Implementation Details:** | |
| - Batch size: 15 reviews (optimal for Claude Sonnet 4's 200K context) | |
| - Temperature: 0.3 (deterministic, reduces variance) | |
| - Retry logic: 3 attempts with 30-second delays on rate limits | |
| - JSON parsing: Strips markdown fences (```json), handles malformed responses | |
| - Error handling: Falls back to empty results on parse failures | |
| **Code Reference:** | |
| ```python | |
| # src/agent/api_utils.py | |
| def call_claude_api_with_retry(client, model, prompt, max_retries=3): | |
| for attempt in range(max_retries): | |
| try: | |
| response = client.messages.create( | |
| model=model, | |
| max_tokens=4000, | |
| temperature=0.3, | |
| messages=[{"role": "user", "content": prompt}] | |
| ) | |
| return response | |
| except APIError as e: | |
| if "rate_limit" in str(e) and attempt < max_retries - 1: | |
| time.sleep(30) # Wait 30s before retry | |
| else: | |
| raise | |
| ``` | |
| --- | |
| ## 📁 Project Structure | |
| ``` | |
| restaurant-intelligence-agent/ | |
| ├── src/ | |
| │ ├── agent/ # AI Agents | |
| │ │ ├── base_agent.py # Main orchestrator | |
| │ │ ├── planner.py # Creates execution plans | |
| │ │ ├── executor.py # Executes analysis steps | |
| │ │ ├── unified_analyzer.py # Single-pass menu + aspect extraction ⭐ | |
| │ │ ├── menu_discovery.py # Legacy menu extraction | |
| │ │ ├── aspect_discovery.py # Legacy aspect extraction | |
| │ │ ├── insights_generator.py # Chef/Manager insights | |
| │ │ └── api_utils.py # Retry logic and error handling | |
| │ ├── scrapers/ # Data Collection | |
| │ │ └── opentable_scraper.py # Production OpenTable scraper | |
| │ ├── data_processing/ # Data Pipeline | |
| │ │ └── review_processor.py # CSV export, DataFrame conversion | |
| │ ├── mcp_integrations/ # MCP Tools | |
| │ │ ├── save_report.py # JSON export | |
| │ │ ├── query_reviews.py # RAG Q&A | |
| │ │ └── generate_chart.py # Matplotlib visualizations | |
| │ ├── ui/ # User Interface (WIP) | |
| │ └── utils/ # Shared utilities | |
| ├── data/ | |
| │ ├── raw/ # Scraped reviews (CSV) - NOT in git | |
| │ └── processed/ # Processed data - NOT in git | |
| ├── outputs/ # Analysis results - NOT in git | |
| │ ├── menu_analysis.json | |
| │ ├── aspect_analysis.json | |
| │ ├── insights.json | |
| │ └── *.png # Charts | |
| ├── reports/ # MCP-generated reports - NOT in git | |
| ├── docs/ # Documentation | |
| ├── integrate_scraper_with_agent.py # Main pipeline script | |
| ├── requirements.txt # Python dependencies | |
| └── README.md # This file | |
| ``` | |
| **Note:** `data/`, `outputs/`, and `reports/` directories contain generated files and are excluded from git via `.gitignore`. Only code and configuration are version-controlled. | |
| --- | |
| ## 🚀 Quick Start | |
| ### Prerequisites | |
| - Python 3.12+ | |
| - Chrome/Chromium browser (for Selenium scraping) | |
| - Anthropic API key ([get one here](https://console.anthropic.com)) | |
| ### Installation | |
| ```bash | |
| # Clone repository | |
| git clone https://github.com/YOUR_USERNAME/restaurant-intelligence-agent.git | |
| cd restaurant-intelligence-agent | |
| # Install dependencies | |
| pip install -r requirements.txt | |
| # Set up environment | |
| echo "ANTHROPIC_API_KEY=your_key_here" > .env | |
| # Run analysis on a restaurant | |
| python integrate_scraper_with_agent.py | |
| ``` | |
| ### Usage | |
| **Option 1: Full Pipeline (Recommended)** | |
| ```bash | |
| # Analyzes a restaurant end-to-end | |
| python integrate_scraper_with_agent.py | |
| ``` | |
| **Option 2: Programmatic Usage** | |
| ```python | |
| from src.scrapers.opentable_scraper import scrape_opentable | |
| from src.agent.base_agent import RestaurantAnalysisAgent | |
| # Scrape reviews | |
| url = "https://www.opentable.ca/r/miku-restaurant-vancouver" | |
| result = scrape_opentable(url, max_reviews=100, headless=True) | |
| # Analyze | |
| agent = RestaurantAnalysisAgent() | |
| analysis = agent.analyze_restaurant( | |
| restaurant_url=url, | |
| restaurant_name="Miku Restaurant", | |
| reviews=result['reviews'] | |
| ) | |
| # Access results | |
| print(analysis['insights']['chef']) # Chef insights | |
| print(analysis['insights']['manager']) # Manager insights | |
| print(analysis['menu_analysis']) # Menu items + sentiment | |
| print(analysis['aspect_analysis']) # Aspects + sentiment | |
| ``` | |
| --- | |
| ## 📊 Performance Metrics | |
| **For 1000 Reviews:** | |
| - **API Calls:** ~68 (vs. 136 with old approach) | |
| - **Processing Time:** 15-20 minutes | |
| - **Cost:** $2-3 (Claude Sonnet 4 at current pricing) | |
| - **Accuracy:** 90%+ aspect detection, 85%+ menu item extraction | |
| **Scalability:** | |
| - Tested up to 1000 reviews per restaurant | |
| - Batch processing prevents token limit errors | |
| - Handles restaurants with sparse reviews (<50) gracefully | |
| --- | |
| ## 🛠️ How It Works (Detailed) | |
| ### **1. Data Collection** | |
| ```python | |
| # Scraper handles: | |
| # - JavaScript-rendered pages (Selenium) | |
| # - Pagination across multiple review pages | |
| # - Rate limiting (2s delays) | |
| # - Error recovery (3 retries) | |
| result = scrape_opentable(url, max_reviews=100, headless=True) | |
| # Returns: { | |
| # 'success': True, | |
| # 'total_reviews': 100, | |
| # 'reviews': [...], # List of review dicts | |
| # 'metadata': {...} | |
| # } | |
| ``` | |
| ### **2. Unified Analysis** | |
| ```python | |
| # Single API call extracts BOTH menu items AND aspects | |
| # Processes 15 reviews per batch | |
| # Temperature 0.3 for deterministic results | |
| unified_result = unified_analyzer.analyze(reviews) | |
| # Returns: { | |
| # 'food_items': [...], # Menu items with sentiment | |
| # 'drinks': [...], # Beverages with sentiment | |
| # 'aspects': [...], # Discovered aspects | |
| # 'total_extracted': N | |
| # } | |
| ``` | |
| ### **3. Insights Generation** | |
| ```python | |
| # Creates role-specific summaries | |
| insights = insights_generator.generate(menu_data, aspect_data) | |
| # Returns: { | |
| # 'chef': "Top performing dishes: ..., Areas for improvement: ...", | |
| # 'manager': "Service issues: ..., Operational recommendations: ..." | |
| # } | |
| ``` | |
| ### **4. MCP Tools** | |
| ```python | |
| # Save report to disk | |
| save_report(analysis, filename="report.json") | |
| # Query reviews using RAG | |
| answer = query_reviews(question="What do customers say about the salmon?") | |
| # Generate visualization | |
| generate_chart(aspect_data, chart_type="sentiment_comparison") | |
| ``` | |
| --- | |
| ## 🎨 Key Innovations | |
| ### **1. Unified Analyzer (Biggest Optimization)** | |
| **Problem:** Separate agents were expensive | |
| - Menu extraction: 4 API calls for 50 reviews | |
| - Aspect extraction: 4 API calls for 50 reviews | |
| - Total: 8 calls = $1.20 per 50 reviews | |
| **Solution:** Single prompt extracts both | |
| - Combined extraction: 4 API calls for 50 reviews | |
| - Total: 4 calls = $0.60 per 50 reviews | |
| - **50% cost savings** | |
| **How It Works:** | |
| ```python | |
| # Single prompt template: | |
| """ | |
| Extract BOTH menu items AND aspects from these reviews. | |
| For each menu item: | |
| - Name (lowercase, specific) | |
| - Sentiment (-1.0 to 1.0) | |
| - Related reviews with quotes | |
| For each aspect: | |
| - Name (discovered from context, not predefined) | |
| - Sentiment | |
| - Related reviews | |
| Output JSON with both food_items and aspects arrays. | |
| """ | |
| ``` | |
| ### **2. Dynamic Discovery (No Hardcoding)** | |
| **Traditional Approach:** | |
| - Hardcoded aspects: ["food", "service", "ambience"] | |
| - Misses restaurant-specific nuances | |
| - Generic, not actionable | |
| **Our Approach:** | |
| - AI discovers aspects from review context | |
| - Adapts to cuisine type automatically | |
| - Example outputs: | |
| - Japanese: "freshness", "presentation", "sushi quality" | |
| - Italian: "portion size", "pasta texture", "wine pairing" | |
| - Mexican: "spice level", "authenticity", "tortilla quality" | |
| ### **3. Review-to-Item Mapping** | |
| Each menu item and aspect includes: | |
| ```json | |
| { | |
| "name": "salmon oshi sushi", | |
| "sentiment": 0.85, | |
| "mention_count": 12, | |
| "related_reviews": [ | |
| { | |
| "review_index": 3, | |
| "review_text": "The salmon oshi sushi was incredible...", | |
| "sentiment_context": "incredibly fresh and beautifully presented" | |
| } | |
| ] | |
| } | |
| ``` | |
| **Value:** Chefs/managers can drill down to specific customer quotes | |
| --- | |
| ## 🎯 Current Status (Day 15 Complete) | |
| ### ✅ **COMPLETED** | |
| - [x] Production-ready OpenTable scraper with error handling | |
| - [x] Data processing pipeline (CSV export, DataFrame conversion) | |
| - [x] Unified analyzer (50% API cost reduction) | |
| - [x] Dynamic menu item discovery with sentiment | |
| - [x] Dynamic aspect discovery with sentiment | |
| - [x] Chef-specific insights generation | |
| - [x] Manager-specific insights generation | |
| - [x] MCP tool integration (save, query, visualize) | |
| - [x] Complete end-to-end pipeline | |
| - [x] Batch processing for 1000+ reviews | |
| - [x] Comprehensive error handling and retry logic | |
| - [x] **Gradio 6 UI for interactive analysis** ⭐ NEW | |
| - Real-time analysis progress with yield-based updates | |
| - Interactive charts (menu/aspect sentiment) | |
| - Three-tab layout: Chef Insights, Manager Insights, Q&A | |
| - Drill-down dropdowns for menu items and aspects | |
| - Mobile-responsive design | |
| - Context persistence with gr.State() | |
| - [x] **Q&A System (RAG)** ⭐ NEW | |
| - Keyword-based review search (searches all indexed reviews) | |
| - Natural language questions over review data | |
| - Cites specific review numbers in answers | |
| - Works with 20-1000+ reviews | |
| - [x] **Insights Formatting** ⭐ NEW | |
| - Clean bullet points (no JSON artifacts) | |
| - Handles lists, dicts, and mixed formats | |
| - Extracts action items from recommendations | |
| - [x] **Rate Limit Management** ⭐ NEW | |
| - 15-second delay between chef and manager insights | |
| - Successfully handles 100+ reviews with no 429 errors | |
| - Tested with 20 and 100 reviews ✅ | |
| ### 🚧 **IN PROGRESS** (Days 16-17) | |
| - [ ] Modal backend deployment (API endpoints for faster processing) | |
| - [ ] HuggingFace Space frontend deployment | |
| - [ ] Anomaly detection (spike in negative reviews) | |
| - [ ] Comparison mode (restaurant vs. competitors) | |
| ### ⏳ **PLANNED** (Days 18-19) | |
| - [ ] Demo video (3 minutes) | |
| - Show: upload → agent planning → analysis → insights → Q&A | |
| - [ ] Social media post (Twitter/LinkedIn) | |
| - Compelling story about real-world impact | |
| - [ ] Final hackathon submission | |
| --- | |
| ## 🔄 Architecture Decisions & Changes | |
| ### **Why We Changed to Unified Analyzer** | |
| **Initial Plan:** Separate menu and aspect agents | |
| **Reality Check:** Too expensive for 1000+ reviews | |
| **Decision:** Combined into single-pass extraction | |
| **Trade-off:** Slightly more complex prompts, but 50% cost savings worth it | |
| ### **Why Dynamic Discovery Over Keywords** | |
| **Initial Plan:** Use predefined aspect lists | |
| **Reality Check:** Different restaurants have different aspects | |
| **Decision:** Let AI discover aspects from review context | |
| **Trade-off:** Less control, but much more relevant insights | |
| ### **Why Batch Size = 15 Reviews** | |
| **Testing:** Tried 10, 15, 20, 25, 30 reviews per batch | |
| **Finding:** 15 reviews optimal for Claude Sonnet 4's 200K context | |
| **Reason:** Leaves headroom for detailed extraction without hitting token limits | |
| ### **Why Retry Logic with 30s Delay** | |
| **Problem:** Rate limits during high-volume testing | |
| **Solution:** 3 retries with 30-second exponential backoff | |
| **Result:** 99% success rate even with 1000 review batches | |
| --- | |
| ## 🧪 Testing | |
| ```bash | |
| # Test scraper | |
| python -c "from src.scrapers.opentable_scraper import scrape_opentable; print('✅ Scraper OK')" | |
| # Test agent | |
| python -c "from src.agent.base_agent import RestaurantAnalysisAgent; print('✅ Agent OK')" | |
| # Test unified analyzer | |
| python -c "from src.agent.unified_analyzer import UnifiedAnalyzer; print('✅ Analyzer OK')" | |
| # Run full pipeline (uses real API, costs ~$0.10) | |
| python integrate_scraper_with_agent.py | |
| ``` | |
| --- | |
| ## 📈 Performance Benchmarks | |
| | Metric | Old Approach | New Approach | Improvement | | |
| |--------|--------------|--------------|-------------| | |
| | API calls (50 reviews) | 8 | 4 | **50% reduction** | | |
| | Cost (1000 reviews) | $4-6 | $2-3 | **40-50% savings** | | |
| | Time (1000 reviews) | 30-40 min | 15-20 min | **40% faster** | | |
| | Aspects discovered | 8-10 | 12-15 | **Better coverage** | | |
| | Menu items extracted | 20-25 | 25-30 | **More granular** | | |
| --- | |
| ## 🏆 Hackathon Submission Details | |
| - **Track:** Track 2 - Agent Apps | |
| - **Category:** Productivity | |
| - **Built:** November 12 - December 3, 2025 | |
| - **Status:** Core pipeline complete (Day 12/17), UI in progress | |
| - **Unique Value:** | |
| - Real business application (not a toy demo) | |
| - Multi-stakeholder design (Chef vs. Manager personas) | |
| - Production-ready optimization (cost-efficient at scale) | |
| - Extensible MCP architecture | |
| --- | |
| ## 🚀 Next Steps (Days 13-17) | |
| ### **Day 13-14: Gradio UI Development** | |
| - Clean, professional interface using Gradio 6 | |
| - File upload for reviews (CSV/JSON/direct scraping) | |
| - Real-time progress indicators | |
| - Interactive sentiment charts | |
| - Role-switching (Chef view vs. Manager view) | |
| ### **Day 15: Advanced Features** | |
| - Anomaly detection: Alert on sudden negative spikes | |
| - Comparison mode: Benchmark against competitors | |
| - Export functionality: PDF reports, Excel exports | |
| ### **Day 16: Demo Creation** | |
| - 3-minute video demonstration | |
| - Show real restaurant analysis | |
| - Highlight agent autonomy and MCP integration | |
| ### **Day 17: Submission & Polish** | |
| - Social media post with compelling narrative | |
| - Final testing and bug fixes | |
| - Hackathon submission | |
| --- | |
| ## 🛣️ Future Roadmap (Post-Hackathon) | |
| - **Multi-platform support:** Yelp, Google Reviews, TripAdvisor | |
| - **Trend analysis:** Track performance over time | |
| - **Competitor benchmarking:** Compare against similar restaurants | |
| - **Automated alerts:** Email/Slack notifications for negative spikes | |
| - **Voice Q&A:** Ask questions about reviews verbally | |
| - **Action tracking:** Suggest improvements → track completion | |
| --- | |
| ## 📝 License | |
| MIT License - See LICENSE file for details | |
| --- | |
| ## 👤 Author | |
| **Tushar Pingle** | |
| Built for Anthropic MCP 1st Birthday Hackathon 2025 | |
| Connect: [GitHub](https://github.com/Tushar-Pingle/) | [LinkedIn](https://www.linkedin.com/in/tushar-pingle/) | |
| --- | |
| ## 🙏 Acknowledgments | |
| - **Anthropic** for Claude API and MCP framework | |
| - **OpenTable** for review data | |
| - **MCP Community** for inspiration and support | |
| - **Hackathon Organizers** for the opportunity | |
| --- | |
| ## 📞 Support | |
| Found a bug? Have a feature request? | |
| - Open an issue: [GitHub Issues](https://github.com/YOUR_USERNAME/restaurant-intelligence-agent/issues) | |
| - Discussion: [GitHub Discussions](https://github.com/YOUR_USERNAME/restaurant-intelligence-agent/discussions) | |
| --- | |
| **⭐ Star this repo if you find it useful!** | |