UberEats MCP Server Enhanced

A modern, production-ready Model Context Protocol (MCP) server for UberEats automation built with TypeScript, Redis, and enterprise-grade security features.

🚀 Features

Core Functionality

• MCP Protocol Compliance: Native MCP server with tools, resources, and prompts
• Session Management: Redis-backed sessions with JWT authentication
• n8n Integration: Seamless workflow orchestration with circuit breakers
• Type Safety: Full TypeScript implementation with strict mode
• Security: Input validation, rate limiting, encryption, and audit logging

Performance & Scalability

• Horizontal Scaling: Stateless design with Redis session storage
• Circuit Breakers: Fault tolerance for external services
• Connection Pooling: Efficient resource management
• Caching: Redis-based caching for optimal performance
• Monitoring: Built-in health checks and metrics

Developer Experience

• Hot Reload: Development mode with automatic restarts
• Comprehensive Logging: Structured logging with pino
• Error Handling: Centralized error management
• Code Quality: ESLint, Prettier, and TypeScript strict mode
• Documentation: Complete API documentation and examples

📋 Prerequisites

• Node.js 20.0.0 or higher
• Redis 7.0 or higher
• n8n workflow automation platform
• Docker (optional, for containerized deployment)

🛠 Installation

Option 1: Local Development

# Clone the repository
cd ubereats_mcp_server_enhanced

# Install dependencies
npm install

# Copy environment configuration
cp .env.example .env

# Edit configuration
nano .env

# Build the project
npm run build

# Start Redis (if not running)
redis-server

# Start the server
npm start

Option 2: Docker Deployment

# Copy environment configuration
cp .env.example .env

# Edit configuration for production
nano .env

# Start all services
docker-compose up -d

# View logs
docker-compose logs -f ubereats-mcp

⚙️ Configuration

Environment Variables

Create a .env file based on .env.example:

# Security (REQUIRED for production)
JWT_SECRET=your-super-secure-jwt-secret-key-change-in-production
SESSION_SECRET=your-session-secret-key-change-in-production
ENCRYPTION_KEY=your-32-character-encryption-key-change-this

# Redis Configuration
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=
REDIS_DB=0

# n8n Integration
N8N_BASE_URL=http://localhost:5678
N8N_API_KEY=

# Server Configuration
NODE_ENV=production
PORT=5001
LOG_LEVEL=info

MCP Client Configuration

Add to your Claude Desktop configuration:

{
  "mcpServers": {
    "ubereats": {
      "command": "node",
      "args": ["/path/to/ubereats_mcp_server_enhanced/dist/index.js"],
      "env": {
        "NODE_ENV": "production"
      }
    }
  }
}

🔧 Usage

MCP Tools

Login Tool

{
  "name": "ubereats_login",
  "arguments": {
    "username": "user@example.com",
    "password": "password",
    "manualMode": false
  }
}

Add Items Tool

{
  "name": "ubereats_add_items",
  "arguments": {
    "sessionId": "session-uuid",
    "restaurantName": "McDonald's",
    "items": [
      {
        "name": "Big Mac",
        "quantity": 2,
        "options": {
          "size": "large",
          "extras": ["cheese"]
        }
      }
    ]
  }
}

Set Address Tool

{
  "name": "ubereats_set_address",
  "arguments": {
    "sessionId": "session-uuid",
    "address": {
      "street": "123 Main St",
      "city": "Anytown",
      "state": "CA",
      "zipCode": "90210"
    }
  }
}

Checkout Tool

{
  "name": "ubereats_checkout",
  "arguments": {
    "sessionId": "session-uuid",
    "paymentMethodId": "saved_card_123",
    "tipAmount": 5.00
  }
}

MCP Resources

Health Check

URI: ubereats://health

Returns server health status, system metrics, and service availability.

Session Information

URI: ubereats://sessions

Returns information about active sessions and session counts.

Prompts

Quick Order

{
  "name": "quick_order",
  "arguments": {
    "restaurant": "Pizza Hut",
    "items": "Large pepperoni pizza, 2 liter Coke",
    "address": "123 Main St, Anytown, CA 90210"
  }
}

🏗 Architecture

System Overview

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   MCP Client    │◄──►│   MCP Server    │◄──►│   Redis Cache   │
│   (Claude)      │    │  (TypeScript)   │    │   (Sessions)    │
└─────────────────┘    └─────────────────┘    └─────────────────┘
                                │
                                ▼
                       ┌─────────────────┐    ┌─────────────────┐
                       │   n8n Server    │◄──►│   Playwright    │
                       │  (Workflows)    │    │  (Browser)      │
                       └─────────────────┘    └─────────────────┘

Component Details

• MCP Server: TypeScript server implementing MCP protocol
• Session Service: Redis-backed session management with JWT
• n8n Service: Workflow orchestration with circuit breakers
• Tools: MCP tools for UberEats operations
• Resources: Information endpoints for monitoring
• Prompts: Pre-defined interaction templates

🔒 Security Features

Authentication & Authorization

• JWT token-based session management
• Session validation on all protected operations
• Secure session storage with Redis TTL

Input Validation

• Zod schema validation for all inputs
• XSS protection and sanitization
• SQL injection prevention (Redis NoSQL)

Rate Limiting

• Per-endpoint rate limiting
• Global rate limiting
• Configurable limits and windows

Data Protection

• AES-256 encryption for sensitive data
• Secure cookie handling
• Password exclusion from logs and storage

Monitoring & Auditing

• Comprehensive audit logging
• Security event tracking
• Performance monitoring

📊 Monitoring & Observability

Health Checks

# Check server health
curl http://localhost:5001/health

# Docker health check
docker-compose ps

Logging

• Structured JSON logging with pino
• Configurable log levels
• Request/response logging with sensitive data redaction

Metrics

• Redis connection health
• n8n service availability
• Circuit breaker status
• Session statistics

🧪 Testing

# Run tests
npm test

# Run tests with coverage
npm run test:coverage

# Run tests in watch mode
npm run test:watch

# Lint code
npm run lint

# Format code
npm run format

# Type check
npm run type-check

MCP Inspector

The MCP Inspector is a powerful debugging tool that allows you to test and interact with your MCP server directly. It provides a web-based interface to:

• Test MCP tools with custom parameters
• View available resources and prompts
• Monitor server responses and errors
• Validate MCP protocol compliance

Running the MCP Inspector

# Build the project first
npm run build

# Start the MCP Inspector
npm run inspector

# Or run directly with npx
npx @modelcontextprotocol/inspector dist/index.js

This will start a web interface (typically at http://localhost:5173) where you can:

1. Test Tools: Call any registered tool (login, add_items, set_address, checkout) with custom parameters
2. View Resources: Access health check and session information resources
3. Test Prompts: Try the quick_order and reorder prompts with different parameters
4. Debug Issues: See detailed request/response logs and error messages

Inspector Usage Tips

• Environment Setup: Ensure Redis and n8n are running before testing tools
• Tool Testing: Start with the login tool to establish a session, then test other tools
• Error Debugging: Check the inspector console for detailed error messages
• Schema Validation: The inspector validates input schemas automatically

The inspector is essential for development and debugging, allowing you to test the MCP server independently of Claude Code integration.

🚀 Deployment

Production Deployment

1. Environment Setup

# Set production environment variables
export NODE_ENV=production
export JWT_SECRET="your-production-jwt-secret"
export SESSION_SECRET="your-production-session-secret"
export ENCRYPTION_KEY="your-production-encryption-key"

2. Database Setup

# Start Redis
docker run -d --name redis -p 6379:6379 redis:7-alpine

# Or use managed Redis (AWS ElastiCache, etc.)

3. Application Deployment

# Build application
npm run build

# Start with PM2 (recommended)
pm2 start dist/index.js --name ubereats-mcp

# Or use Docker
docker-compose up -d

Kubernetes Deployment

See k8s/ directory for Kubernetes manifests (coming soon).

🐛 Troubleshooting

Common Issues

Server Won't Start

# Check Node.js version
node --version  # Should be >= 20.0.0

# Check environment variables
npm run check-env

# Check Redis connection
redis-cli ping

Authentication Errors

# Verify JWT secret is set
echo $JWT_SECRET

# Check session in Redis
redis-cli get "ubereats:session:your-session-id"

n8n Integration Issues

# Test n8n connectivity
curl http://localhost:5678/health

# Check circuit breaker status
curl http://localhost:5001/api/circuit-breakers

Debug Mode

# Enable debug logging
export LOG_LEVEL=debug
export ENABLE_DEBUG=true

# Start server
npm run dev

🤝 Contributing

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Commit changes: git commit -m 'Add amazing feature'
4. Push to branch: git push origin feature/amazing-feature
5. Open a Pull Request

Development Guidelines

• Follow TypeScript strict mode
• Write tests for new features
• Update documentation
• Use conventional commits
• Ensure code passes linting

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Model Context Protocol by Anthropic
• n8n for workflow automation
• Redis for session management
• TypeScript for type safety

📞 Support

• Create an issue for bug reports
• Use discussions for questions
• Check the troubleshooting guide first

---

Note: This is an enhanced version of the original Flask-based UberEats MCP server, rebuilt with modern technologies and enterprise-grade features.