Mentra Glass MCP 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.

Related MCP server: EarSay MCP

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