Mentra Glass Server

A Model Context Protocol (MCP) server for controlling MentraOS smart glasses. Built with Bun, Mentra SDK, and MCP SDK.

Features

• MCP Support: Exposes tools to control glasses (Display, Audio, Input) via JSON-RPC.
• Multi-User: Supports multiple users via Bearer token authentication (email).
• Mentra Integration: Connects to Mentra Cloud as an AppServer.
• Docker Ready: Includes Dockerfile and Compose setup.

Architecture

MCP Client (Claude/Cursor) 
       ⬇️ JSON-RPC (HTTP)
   [MCP Server]
       ⬇️ Mentra SDK
   Mentra Cloud
       ⬇️
   Smart Glasses

Prerequisites

• Bun (v1.0+)
• Mentra Developer Account & API Key

Authentication

This server uses a secure token-based authentication system.

1. Start the Server (Locally or Deployed).
2. Open the Webview:
   • Local: http://localhost:3000/webview
   • Deployed: https://your-app.onrender.com/webview
3. Login: Sign in with your Mentra account.
4. Get Token: Copy the Access Token displayed on the screen.

Connecting to Clients

1. GitHub Copilot (VS Code)

Add the server to your MCP configuration file (usually ~/.config/github-copilot/mcp.json or via the VS Code command "MCP: Manage MCP Servers").

{
  "mcpServers": {
    "mentra-glasses": {
  "type": "sse",
  "url": "mcp url here",
  "headers": {
    "Authorization": "Bearer YOUR_ACCESS_TOKEN"
  }
  }
}

Note: Replace the URL and Token with your actual values.

2. Claude Desktop

Edit your configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "mentra-glass": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sse-client"],
      "env": {
        "MCP_SSE_URL": "http://localhost:3000/mcp",
        "MCP_SSE_HEADERS": "{\"Authorization\": \"Bearer YOUR_ACCESS_TOKEN\"}"
      }
    }
  }
}

3. Cursor

1. Go to Settings > Features > MCP.
2. Click + Add New MCP Server.
3. Name: mentra-glass
4. Type: SSE
5. URL: https://your-app.onrender.com/mcp?token=YOUR_ACCESS_TOKEN (Note: Cursor may not support custom headers yet, so we support passing the token via query parameter as a fallback)

Running Locally

# Start the server
bun run src/index.ts

# Watch mode
bun run dev

The server will start on http://localhost:3000.

• /mcp: MCP JSON-RPC endpoint
• /health: Health check
• /webview: Auth & Settings

Running with Docker

# Build & Run
docker compose up --build -d

Available Tools

• Display: glasses_display_text, glasses_clear_display
• Audio: glasses_speak
• Input: glasses_get_transcriptions, glasses_get_events
• System: glasses_status

Project Structure

• src/config: Environment configuration
• src/services: Core logic (Mentra SDK, Session Management)
• src/tools: MCP Tool definitions
• src/index.ts: Entry point

Deployment

Option 1: Render + Supabase (Recommended for Free Tier)

Best for indie devs. Uses Supabase for the database (since Render's free tier wipes local files) and Render for hosting.

1. Database: Follow SUPABASE_SETUP.md to create your Supabase project and get credentials.
2. Hosting:
   • Sign up at render.com.
   • Create a new Web Service.
   • Connect your GitHub repository.
   • Runtime: Docker.
   • Environment Variables:
     • SUPABASE_URL: Your Supabase URL.
     • SUPABASE_SERVICE_KEY: Your Supabase Service Role Key.
     • MENTRAOS_API_KEY: Your Mentra API Key.
     • PACKAGE_NAME: com.yourname.glassmcp.
     • PORT: 3000.

Option 2: Fly.io (Best for SQLite)

Allows you to keep using the local SQLite database by attaching a persistent volume.

1. Install flyctl.
2. Run fly launch.
3. Create a volume: fly volumes create mcp_data.
4. Update fly.toml to mount the volume to /app/mcp.sqlite.

Option 3: Self-Hosted (VPS)

Run standard Docker Compose on any server (DigitalOcean, Hetzner, Oracle Cloud).

docker compose up -d