Can Meta Ray‑Ban Glasses Become an AI Traffic Cop with Alibaba Cloud Serverless?

Background

A year ago the author purchased Meta Ray‑Ban glasses, which at the time lacked Chinese language support and an open SDK. In November 2025 Meta released the Device Access Toolkit, enabling community development. The GitHub project

https://github.com/Turbo1123/turbometa-rayban-ai/blob/main/README_EN.md

added a Chinese app and Baileian API, providing multimodal dialogue and calorie detection.

The author wondered whether the ready‑made turbometa-rayban-ai could be repurposed for traffic‑law enforcement: capture a license plate, run OCR, check a whitelist, and enforce odd‑even restrictions.

"Endpoint‑Control‑Cloud" Collaboration Framework

The system follows a three‑layer Client‑Brain‑Tools model, all hosted on Alibaba Cloud Function Compute (FC):

Client (Endpoint) : Meta glasses + a lightweight iOS app act as a thin relay, capturing frames and sending them to the cloud.

Brain : An FC function named AgentRun runs Baileian’s Qwen model, makes high‑level decisions (e.g., odd/even day, VIP vehicle) and selects which tool to invoke.

Tools : Additional FC functions implement concrete capabilities such as database queries, logging, and image storage.

Data flow:

See : Glasses capture the plate → Bluetooth → iOS app.

Upload : iOS extracts a frame, encodes it as Base64, and POSTs it to an FC gateway.

Think : The gateway injects the current date context, builds a prompt, and calls AgentRun.

Action : AgentRun selects a tool (e.g., check_whitelist, query_plate_history) which accesses MySQL or writes to SLS.

Speak : AgentRun returns a human‑readable reply; the iOS app converts it to speech and (planned) plays it on the glasses.

Client Development

The iOS client is deliberately minimal: it only forwards images and timestamps, avoiding any on‑device AI inference. It is built by forking the turbometa repository and adding a forwarding module compiled with Vibe Coding + Xcode.

Server‑Side Components (All on Alibaba Cloud Function Compute)

Entry Point : Authenticates requests, determines whether today is an odd or even date, and injects this context into the prompt.

AgentRun : Core decision engine powered by Baileian’s Qwen model. It records traffic, applies rule logic, and decides which tool to invoke.

Tools (Python Runtime) :

def handler(event, context):
    tool_name = json.loads(event).get('function')
    if tool_name == 'check_whitelist':
        return db.query("SELECT count(*) FROM whitelist WHERE plate=%s", plate)
    elif tool_name == 'log_illegal_notice':
        return sls.put_log(plate, image_base64, "violation")
    # ... other tools

Storage Layer :

SLS (Log Service) for event logs.

RDS MySQL for the whitelist database.

Prompt Engineering (Agent "Brain")

The system prompt encodes traffic‑law logic in natural language, making rule changes as simple as editing the prompt:

你是一个智能交通管控 Agent。
当前日期信息：{{current_date_info}} (例如：今天是单号)
处理流程：
1. 必须执行：先调用 `log_traffic_all` 记录流水。
2. 规则判断：单号日仅允许尾号单数通行；双号日仅允许尾号双数。
3. 违规处理：若违规，先调用 `check_whitelist`，若未报备再调用 `query_plate_history`，最后生成简短回复。

This data‑driven approach allows instant rule updates without redeploying code.

Why Use Agent Architecture + FaaS?

Decoupled Logic : Business rules live in the prompt, not hard‑coded in source.

Dynamic Orchestration : AgentRun decides at runtime which tools to invoke, skipping unnecessary steps (e.g., avoiding a database query when OCR fails).

Cost‑Effective Scaling : FC scales to zero when no vehicles are present and instantly spins up many instances during traffic peaks.

Tool‑as‑Function : Each backend capability (whitelist check, logging, OSS upload) is an independent function, matching micro‑service principles.

Implementation Highlights

All backend logic runs on Alibaba Cloud Function Compute, using native SDKs for RDS, SLS, OSS, and Redis. AgentRun calls Baileian’s Qwen model via the Baileian API.

Images are Base64‑encoded; blurry frames are dropped on the client to save bandwidth.

Future work includes GPU‑accelerated OCR in FC, Redis caching for duplicate plates, and streaming TTS for near‑instant voice feedback.

Key Code Snippets

Tool handler (deployed as an FC function):

# tools.py
import json

def handler(event, context):
    payload = json.loads(event)
    tool_name = payload.get('function')
    plate = payload.get('plate')
    image_base64 = payload.get('image')
    if tool_name == 'check_whitelist':
        return db.query("SELECT count(*) FROM whitelist WHERE plate=%s", plate)
    elif tool_name == 'log_illegal_notice':
        return sls.put_log(plate, image_base64, "violation")
    elif tool_name == 'query_plate_history':
        return db.query("SELECT * FROM history WHERE plate=%s AND ts > NOW() - INTERVAL 30 DAY", plate)
    # additional tools can be added here

Gateway entry (receives the iOS POST):

# main.py
import json
from datetime import datetime

def handler(event, context):
    # 1. Determine odd/even day
    is_odd = datetime.now().day % 2 != 0
    date_context = f"今天是{'单号' if is_odd else '双号'}"
    # 2. Extract image and timestamp from request
    body = json.loads(event['body'])
    image_base64 = body['image']
    # 3. Build prompt for AgentRun
    prompt = f"{date_context}，请处理这张车牌图片：{image_base64[:30]}..."
    # 4. Call AgentRun (Baileian API wrapper omitted for brevity)
    reply = call_agent_run(prompt)
    # 5. Return JSON response
    return {
        "statusCode": 200,
        "body": json.dumps({"voice_feedback": reply})
    }

Relevant URLs

Alibaba Cloud Function Compute: https://www.aliyun.com/product/fc

AgentRun service: https://www.aliyun.com/product/fc/agentrun

Alibaba Cloud Baileian (large model) service: https://www.aliyun.com/product/bailian

Log Service (SLS): https://www.aliyun.com/product/sls

RDS for MySQL: https://www.aliyun.com/product/rds/mysql

Object Storage Service (OSS): https://www.aliyun.com/product/oss

Redis KV Store: https://www.aliyun.com/product/kvstore

turbometa‑rayban‑ai GitHub repository: https://github.com/Turbo1123/turbometa-rayban-ai/blob/main/README_EN.md

Conclusion

The prototype demonstrates that a consumer‑grade AR device can be transformed into a smart traffic‑enforcement assistant using a lightweight client, an AI‑driven decision engine, and serverless functions. Although the demo currently runs on mock data, the architecture is ready for production‑grade enhancements such as GPU OCR, caching, and streaming voice feedback.