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

Related MCP server: MCP Production

📋 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.