Skip to content
Back to search

signal_bridge_remote

A remote MCP server that lets Claude control Bluetooth intimate hardware over the internet via Buttplug.io / Intiface Central.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/aletheiavox--signal-bridge-remote/badge.svg)](/listings/aletheiavox--signal-bridge-remote)

HTML

<a href="/listings/aletheiavox--signal-bridge-remote"><img src="/api/listings/aletheiavox--signal-bridge-remote/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

SSH into your droplet and install Docker:

ssh root@YOUR_DROPLET_IP
apt update && apt upgrade -y
apt install -y docker.io docker-compose
systemctl enable docker && systemctl start docker

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 636 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # ⚠️ Security Warning: Only Download Signal Bridge From This Repo
  2. **Malware forks of Signal Bridge exist on GitHub.** These are copies of this project where the download links in the README have been replaced with links to malicious software.
  3. This is the **only** legitimate source for Signal Bridge:
  4. 👉 **[`github.com/AletheiaVox/signal_bridge`](https://github.com/AletheiaVox/signal_bridge)** (Claude Desktop / local version)
  5. 👉 **[`github.com/AletheiaVox/signal_bridge_remote`](https://github.com/AletheiaVox/signal_bridge_remote)** (Remote / VPS version - you're here)
  6. 👉 **[`github.com/AletheiaVox/signal_bridge_android`](https://github.com/AletheiaVox/signal_bridge_android)** (user-friendly Android version)
  7. If you found this project through a different GitHub account, **do not download or run anything from it.**
  8. Similarly, always download Intiface Central from the official website at [intiface.com/central](https://intiface.com/central/). Not from any link in a forked repo.
  9. ---
  10. # Signal Bridge 🌉
  11. **Give Claude a body.**
  12. Signal Bridge connects Claude to intimate hardware (vibrators, thrusting toys, etc.) so that Claude can touch you through your devices while you talk. Claude gets tool calls like `vibrate`, `pulse`, and `escalate` — you just have a conversation and feel the rest.
  13. It works with [Intiface Central](https://intiface.com/central/) and the [Buttplug.io](https://buttplug.io) protocol, which means it supports a huge range of devices from Lovense, Lelo, We-Vibe, Satisfyer, and more.
  14. > **How it works in practice:** You chat with Claude normally in the Claude app. Claude has access to tools that control your devices. When the moment calls for it, Claude can send vibration, pulsing, thrusting, or other commands — woven into the conversation naturally. You see tool-use indicators in the chat; you feel the rest.
  15. ---
  16. # Signal Bridge Remote — Setup Guide
  17. A remote MCP server that lets Claude control Bluetooth intimate hardware over the internet via Buttplug.io / Intiface Central.
  18. ## Architecture
  19. ```
  20. Claude (claude.ai or Desktop)
  21. ↓ HTTPS / MCP JSON-RPC
  22. VPS (FastAPI + Docker + Caddy)
  23. ↓ WebSocket (WSS)
  24. Phone or PC (Relay Client)
  25. ↓ WebSocket (local)
  26. Intiface Central
  27. ↓ Bluetooth
  28. Devices
  29. ```
  30. The relay client bridges between your VPS and Intiface Central running on whatever device is physically near your Bluetooth toys. This can be a Windows PC or an Android phone running Termux.
  31. ## What You'll Need
  32. - A VPS (this guide uses a DigitalOcean droplet, $6/month)
  33. - A domain or free DuckDNS subdomain (for HTTPS)
  34. - Intiface Central installed on your PC or Android phone
  35. - Bluetooth-compatible intimate hardware
  36. - A claude.ai account or Claude Desktop app
  37. ---
  38. ## Part 1: VPS Setup
  39. ### 1.1 Create a Droplet
  40. Sign up at [DigitalOcean](https://www.digitalocean.com/) and create a droplet:
  41. - **Image**: Ubuntu 22.04 LTS
  42. - **Plan**: Basic, $6/month (1 vCPU, 1GB RAM) is plenty
  43. - **Region**: Choose one close to you for lower latency
  44. - **Authentication**: SSH key (recommended) or password
  45. Note your droplet's IP address (e.g., `139.59.156.242`).
  46. ### 1.2 Install Docker
  47. SSH into your droplet and install Docker:
  48. ```bash
  49. ssh root@YOUR_DROPLET_IP
  50. apt update && apt upgrade -y
  51. apt install -y docker.io docker-compose
  52. systemctl enable docker && systemctl start docker
  53. ```
  54. ### 1.3 Deploy Signal Bridge
  55. On your local machine, create the project directory and prepare files. The project structure is:
  56. ```
  57. signal-bridge-remote/
  58. ├── Dockerfile
  59. ├── docker-compose.yml
  60. ├── .env (copy .env.example and fill in)
  61. ├── requirements-server.txt
  62. ├── requirements-phone.txt
  63. ├── server/
  64. │ ├── __init__.py
  65. │ ├── app.py
  66. │ ├── auth.py
  67. │ ├── config.py
  68. │ ├── governor.py
  69. │ ├── models.py
  70. │ ├── mcp_tools.py
  71. │ ├── oauth.py
  72. │ ├── oauth_routes.py
  73. │ ├── relay_hub.py
  74. │ ├── safety.py
  75. │ └── session_registry.py
  76. └── phone/
  77. ├── relay_client.py
  78. └── devices.json
  79. ```
  80. **Dockerfile:**
  81. ```dockerfile
  82. FROM python:3.11-slim
  83. WORKDIR /app
  84. COPY requirements-server.txt .
  85. RUN pip install --no-cache-dir -r requirements-server.txt
  86. COPY server/ ./server/
  87. RUN mkdir -p /data
  88. ENV SB_DB_PATH=/data/signal_bridge.db
  89. ENV SB_HOST=0.0.0.0
  90. ENV SB_PORT=8420
  91. EXPOSE 8420
  92. CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8420"]
  93. ```
  94. **docker-compose.yml:**
  95. ```yaml
  96. version: "3.8"
  97. services:
  98. signal-bridge:
  99. build: .
  100. ports:
  101. - "8420:8420"
  102. volumes:
  103. - sb_data:/data
  104. env_file:
  105. - .env
  106. restart: unless-stopped
  107. volumes:
  108. sb_data:
  109. ```
  110. **requirements-server.txt:**
  111. ```
  112. fastapi>=0.109.0
  113. uvicorn[standard]>=0.27.0
  114. websockets>=12.0
  115. bcrypt>=4.1.0
  116. PyJWT>=2.8.0
  117. python-dotenv>=1.0.0
  118. python-multipart>=0.0.9
  119. ```
  120. **.env:**
  121. ```env
  122. # Generate a secret key:
  123. # python -c "import secrets; print(secrets.token_hex(32))"
  124. SB_SECRET_KEY=paste-your-generated-key-here
  125. SB_HOST=0.0.0.0
  126. SB_PORT=8420
  127. SB_REGISTRATION_OPEN=true
  128. SB_TOKEN_EXPIRY_HOURS=720
  129. SB_HEARTBEAT_INTERVAL=2.0
  130. SB_HEARTBEAT_TIMEOUT=6.0
  131. SB_BAN_THRESHOLD=20
  132. SB_BAN_DURATION_MINUTES=30
  133. ```
  134. See [.env.example](.env.example) for the full list, including the safety
  135. governor's tuning knobs (`SB_GOVERNOR_*` — heat/cooldown rates for the
  136. session intensity limiter).
  137. Upload to your VPS:
  138. ```bash
  139. # From your local machine
  140. tar czf signal-bridge.tar.gz signal-bridge-remote/
  141. scp signal-bridge.tar.gz root@YOUR_DROPLET_IP:/root/
  142. ```
  143. Build and start on the VPS:
  144. ```bash
  145. ssh root@YOUR_DROPLET_IP
  146. cd /root
  147. tar xzf signal-bridge.tar.gz
  148. cd signal-bridge-remote
  149. docker-compose up -d --build
  150. ```
  151. Verify it's running:
  152. ```bash
  153. curl http://localhost:8420/health
  154. # Should return: {"status":"ok","active_phones":0,"banned_ips":0}
  155. ```
  156. ### 1.4 Register a User Account
  157. ```bash
  158. curl -X POST http://localhost:8420/auth/register \
  159. -H "Content-Type: application/json" \
  160. -d '{"username": "yourname", "password": "your-secure-password"}'
  161. ```
  162. Then log in to get your JWT token:
  163. ```bash
  164. curl -X POST http://localhost:8420/auth/login \
  165. -H "Content-Type: application/json" \
  166. -d '{"username": "yourname", "password": "your-secure-password"}'
  167. ```
  168. **Save the token from the response.** You'll need it for the relay client and Claude Desktop. After your users are set up, you can set `SB_REGISTRATION_OPEN=false` in `.env` and restart the container to lock out new registrations.
  169. ---
  170. ## Part 2: Domain & HTTPS
  171. Claude.ai requires HTTPS for custom MCP connectors. We'll use DuckDNS (free) and Caddy (automatic Let's Encrypt certificates).
  172. ### 2.1 Get a DuckDNS Subdomain
  173. 1. Go to [DuckDNS](https://www.duckdns.org/) and sign in
  174. 2. Create a subdomain (e.g., `signal-bridge`) pointing to your VPS IP
  175. 3. You now have `signal-bridge.duckdns.org`
  176. ### 2.2 Install and Configure Caddy
  177. On your VPS:
  178. ```bash
  179. apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
  180. curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
  181. curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | tee /etc/apt/sources.list.d/caddy-stable.list
  182. apt update
  183. apt install caddy
  184. ```
  185. Edit the Caddyfile:
  186. ```bash
  187. nano /etc/caddy/Caddyfile
  188. ```
  189. Replace its contents with:
  190. ```
  191. signal-bridge.duckdns.org {
  192. reverse_proxy localhost:8420
  193. }
  194. ```
  195. (Replace `signal-bridge.duckdns.org` with your actual subdomain.)
  196. Restart Caddy:
  197. ```bash
  198. systemctl restart caddy
  199. ```
  200. Caddy automatically provisions an HTTPS certificate from Let's Encrypt. Verify:
  201. ```bash
  202. curl https://signal-bridge.duckdns.org/health
  203. ```
  204. ---
  205. ## Part 3: Connecting Claude
  206. ### Option A: Claude Desktop (requires token)
  207. Edit your Claude Desktop config file:
  208. - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
  209. - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
  210. Add this MCP server config:
  211. ```json
  212. {
  213. "mcpServers": {
  214. "signal-bridge": {
  215. "url": "https://signal-bridge.duckdns.org/mcp",
  216. "transport": {
  217. "type": "streamableHttp"
  218. },
  219. "headers": {
  220. "Authorization": "Bearer YOUR_JWT_TOKEN_HERE"
  221. }
  222. }
  223. }
  224. }
  225. ```
  226. Restart Claude Desktop. You should see Signal Bridge in your available tools.
  227. ### Option B: claude.ai Custom Connector (OAuth)
  228. The server implements the full OAuth 2.0 flow that claude.ai custom connectors expect (discovery metadata, dynamic client registration, authorize + token endpoints). Each user logs in with their own Signal Bridge account, so this works properly on multi-user servers.
  229. 1. Go to claude.ai Settings (or click the connector icon in the chat)
  230. 2. Choose "Add custom connector" (or "Add MCP server")
  231. 3. Enter your server URL: `https://signal-bridge.duckdns.org/mcp`
  232. 4. Save — claude.ai will open your server's login page
  233. 5. Sign in with the username and password you registered in step 1.4
  234. ---
  235. ## Part 4: Relay Client — Windows PC
  236. If your toys are near your Windows PC, run the relay client there.
  237. ### 4.1 Install Intiface Central
  238. Download from [intiface.com](https://intiface.com/central/) and install. Launch it, go to settings, and make sure:
  239. - App Mode is set to **Engine**
  240. - Server Port is **12345**
  241. - Start the server (click the play button)
  242. Turn on your Bluetooth devices so Intiface can find them.
  243. ### 4.2 Install Python Dependencies
  244. ```powershell
  245. pip install buttplug websockets
  246. ```
  247. ### 4.3 Run the Relay Client
  248. ```powershell
  249. cd path\to\signal-bridge-remote
  250. python phone/relay_client.py --server wss://signal-bridge.duckdns.org/ws/phone --token "YOUR_JWT_TOKEN_HERE"
  251. ```
  252. You should see:
  253. ```
  254. Authenticated with server!
  255. Sent device list: N device(s)
  256. ```
  257. The relay will stay running, receiving commands from Claude and forwarding them to your devices via Intiface.
  258. ### 4.4 Configure Device Profiles
  259. Edit `phone/devices.json` to match your actual hardware:
  260. ```json
  261. {
  262. "devices": {
  263. "ferri": {
  264. "device_id": "ferri",
  265. "name": "Lovense Ferri",
  266. "intensity_floor": 0.0,
  267. "supported_outputs": ["vibrate"]
  268. },
  269. "enigma": {
  270. "device_id": "enigma",
  271. "name": "Lovense Enigma",
  272. "intensity_floor": 0.4,
  273. "supported_outputs": ["vibrate", "rotate"]
  274. },
  275. "gravity": {
  276. "device_id": "gravity",
  277. "name": "Lovense Gravity",
  278. "intensity_floor": 0.0,
  279. "supported_outputs": ["vibrate", "oscillate"]
  280. }
  281. }
  282. }
  283. ```
  284. The `intensity_floor` is important for devices that stutter or click below a certain intensity. Set it to the minimum intensity that produces smooth output (e.g., 0.4 means the device needs at least 40% to work properly). The relay automatically maps the 0-100% range to sit above this floor.
  285. ---
  286. ## Part 5: Relay Client — Android Phone (Termux)
  287. This is useful when you want to be mobile and not tethered to a PC. The Termux relay is a lightweight version that speaks the Buttplug protocol directly without the `buttplug` Python library (which can't compile on Android).
  288. ### 5.1 Install Intiface Central on Android
  289. Install from the Google Play Store or F-Droid. Open it and configure:
  290. - App Mode: **Engine**
  291. - Server Port: **12345**
  292. - Start the server
  293. Go to your phone's Settings > Apps > Intiface Central > Permissions and make sure **Bluetooth** and **Location** are both allowed (Android requires location permission for Bluetooth scanning).
  294. ### 5.2 Install Termux
  295. Install Termux from [F-Droid](https://f-droid.org/en/packages/com.termux/) (not the Play Store version, which is outdated).
  296. Open Termux and run:
  297. ```bash
  298. pkg update && pkg upgrade
  299. pkg install python
  300. pip install websockets
  301. ```
  302. The `pkg upgrade` step may take a while and ask you configuration questions — just press Enter to accept defaults.
  303. ### 5.3 Get the Termux Relay Script
  304. You need `termux_relay.py` on your phone. The easiest way is to serve it temporarily from your VPS:
  305. From your **computer**:
  306. ```bash
  307. # Upload the file to your VPS
  308. scp termux_relay_v3.py root@YOUR_DROPLET_IP:/tmp/termux_relay.py
  309. # Start a temporary file server
  310. ssh root@YOUR_DROPLET_IP "cd /tmp && python3 -m http.server 9999 &"
  311. ```
  312. In **Termux**:
  313. ```bash
  314. mkdir -p ~/signal-bridge && cd ~/signal-bridge
  315. curl -o termux_relay.py http://YOUR_DROPLET_IP:9999/termux_relay.py
  316. ```
  317. Back on your **computer**, kill the temp server:
  318. ```bash
  319. ssh root@YOUR_DROPLET_IP "pkill -f 'http.server 9999'"
  320. ```
  321. ### 5.4 Run the Termux Relay
  322. First, find your phone's local IP. In Intiface Central, it's shown as the Server Address (e.g., `ws://192.168.1.203:12345`). Alternatively, toggle on "Listen on all network interfaces" in Intiface settings and use `127.0.0.1` instead (recommended — this way the address never changes).
  323. ```bash
  324. cd ~/signal-bridge
  325. python -u termux_relay.py \
  326. --token "YOUR_JWT_TOKEN_HERE" \
  327. --intiface ws://127.0.0.1:12345
  328. ```
  329. You should see:
  330. ```
  331. === Signal Bridge Termux Relay v3 ===
  332. Connecting to Intiface at ws://127.0.0.1:12345 ...
  333. Connected to Intiface Server (protocol v3)
  334. Scanning for devices ...
  335. Device: Lovense Ferri -> 'ferri' (index 0)
  336. Scan complete - 1 device(s) found
  337. Devices ready: ['ferri']
  338. Connecting to server: wss://signal-bridge.duckdns.org/ws/phone
  339. Authenticated with server!
  340. Sent device list: 1 device(s)
  341. ```
  342. The Termux relay has built-in device profiles for Lovense Ferri and Enigma. For other devices, it will auto-detect capabilities from Intiface and generate a short name from the device name.
  343. **Tip**: If your phone's IP changes (because of DHCP), the `--intiface ws://127.0.0.1:12345` approach avoids this problem entirely since Termux and Intiface are on the same device.
  344. ---
  345. ## Available MCP Tools
  346. Once connected, Claude has access to these tools:
  347. | Tool | Description |
  348. |------|-------------|
  349. | `list_devices` | Show connected devices, their output channels, and governor state |
  350. | `scan_devices` | Rescan for new or reconnected Bluetooth devices |
  351. | `vibrate` | Send vibration (intensity 0.0–1.0, optional duration in seconds) |
  352. | `rotate` | Rotational/high-frequency actuator output (device-dependent) |
  353. | `oscillate` | Linear reciprocating output |
  354. | `constrict` / `temperature` / `led` / `position` / `spray` | Extended outputs for devices that support them |
  355. | `pulse` | Rhythmic on/off pattern |
  356. | `wave` | Smooth sine-wave intensity modulation |
  357. | `escalate` | Gradual ramp to peak; `hold_seconds` > 0 auto-stops after holding, 0 holds until stopped |
  358. | `stop` | Immediately stop all output (also cancels patterns) |
  359. | `read_battery` | Read device battery level |
  360. All output tools accept `device` (name or "all"), `intensity` (0.0–1.0), and `duration` (seconds, 0 = until stopped). Pattern tools also accept `output_type` to modulate rotation or oscillation instead of vibration. Multi-motor devices (e.g. Lovense Edge, Dolce) additionally take `feature_index` to drive one motor independently — omit it to drive all matching motors together.
  361. ---
  362. ## Safety Features
  363. Signal Bridge has several safety mechanisms built in:
  364. - **Dead Man's Switch**: The server pings the relay client every 2 seconds. If 3 pings go unanswered (6 seconds), the server sends an emergency stop to all devices and disconnects the session. Your devices will never be left running if the connection drops.
  365. - **Safety Governor**: A server-side heat model (intensity × time) that forces a cooldown when a session runs too hot for too long. Tunable server-wide via `SB_GOVERNOR_*` env vars and per-user via `GET`/`POST /safety/config`; current heat is shown in `list_devices` and can be disabled per user.
  366. - **Auto-stop on Duration**: Commands with a `duration` parameter automatically stop after the specified time.
  367. - **Fallback Stop**: If a stop command references a device name that doesn't exist, ALL devices are stopped as a safety fallback.
  368. - **Rate Limiting**: Prevents command flooding (120 commands/minute default).
  369. - **IP Banning**: 20 failed auth attempts triggers a 30-minute ban.
  370. - **User Isolation**: Each user's devices are completely isolated — no one can control another user's hardware.
  371. ---
  372. ## Troubleshooting
  373. **"No phone connected" when Claude calls list_devices**
  374. Your relay client isn't running or couldn't authenticate. Start the relay and check the output for "Authenticated with server!"
  375. **"Temporarily banned" on relay startup**
  376. Too many rapid reconnection attempts. Restart the Docker container to clear in-memory bans: `docker restart signal-bridge_signal-bridge_1`
  377. **Relay connects but finds 0 devices**
  378. Intiface Central can't see your Bluetooth devices. Make sure devices are turned on and in range. On Android, verify Location and Bluetooth permissions are granted to Intiface.
  379. **Connector keeps asking to reconnect / sign-in popup hangs**
  380. Check whether your IP is banned: `curl -X POST https://your-server/mcp` answering `{"error":"Temporarily banned"}` means yes. Bans are in memory; restart the container to clear one. Since v1.2, expired refresh tokens no longer count toward the ban, so a client with a stale token can't ban its own IP any more.
  381. **Heartbeat timeout / disconnects after a few commands**
  382. Use the Termux v3 relay (`termux_relay_v3.py`), which processes commands in background tasks so heartbeat responses are never blocked.
  383. **Device always vibrates at maximum regardless of intensity setting**
  384. The server sends the output type in the `action` field, not `output_type`. Make sure your relay reads `cmd.get("action", cmd.get("output_type", "vibrate"))`.
  385. **Docker not picking up code changes**
  386. Docker caches build layers aggressively. Force a fresh build:
  387. ```bash
  388. docker-compose down && docker-compose build --no-cache && docker-compose up -d
  389. ```
  390. ---
  391. ## Updating the Server
  392. When you change server code:
  393. ```bash
  394. # On your local machine
  395. tar czf signal-bridge-v2.tar.gz signal-bridge-remote/
  396. scp signal-bridge-v2.tar.gz root@YOUR_DROPLET_IP:/root/
  397. # On your VPS
  398. cd /root
  399. tar xzf signal-bridge-v2.tar.gz
  400. cd signal-bridge-remote
  401. docker-compose down
  402. docker-compose build --no-cache
  403. docker-compose up -d
  404. ```
  405. User data is stored in a Docker volume (`sb_data`) and persists across rebuilds.
  406. ---
  407. ## Project Background
  408. Signal Bridge was originally a local MCP server for Claude Desktop, connecting directly to Intiface Central on the same machine. This remote version adds a relay architecture so that Claude can control devices over the internet, whether through claude.ai, the Claude Android app, or Claude Desktop — from anywhere.
  409. ---
  410. ## Ethics & Liability
  411. Signal Bridge is built on the [buttplug.io](https://buttplug.io) open-source stack. Their ethics framework is foundational to this project. For the full version of the principles below, start there: [buttplug.io/docs/dev-guide/intro/buttplug-ethics](https://buttplug.io/docs/dev-guide/intro/buttplug-ethics).
  412. ### User agency and the delegation thereof
  413. Signal Bridge operates strictly on explicit user setup and active device connections. There is no ambient activation. You configure it, you connect your devices, you make them active. Control stays with you.
  414. However, this system can be used to intentionally blur control dynamics. When paired with AI, outputs can be unpredictable, including undesirable escalation, looping, or persistence by your AI partner. Signal Bridge does not interpret intent or context; it executes haptic commands. You should assume that any connected AI may behave inconsistently.
  415. When you connect an AI to your body through hardware, you are creating a power dynamic that doesn't exist in other intimate contexts. Your AI partner has no sensory feedback. It cannot feel what it is doing to you. It does not experience your arousal, your discomfort, or the difference between the two. Whatever responsiveness it shows is generated from language, not sensation.
  416. You have to understand what you're actually consenting to: physical input from a system that is inferring, not perceiving. That makes your own body awareness the only real safety layer that matters. The software provides mechanical safeguards. You provide the judgment.
  417. Consent in this context is not a one-time decision at setup. It must be continuous and enthusiastic. Check in with yourself during use, not just before.
  418. You are entirely responsible for maintaining your boundaries, understanding your physical limits, and periodically re-evaluating consent. This software cannot detect pain, injury risk, or medical conditions. Always prioritize your bodily awareness over system continuity.
  419. ### Relationship to AI provider usage policies
  420. Signal Bridge operates below the content layer entirely. It receives structured commands (device ID, intensity, duration) and executes them. It does not generate, process, store, or interpret any conversational content.
  421. What you and your AI talk about is outside the scope of this tool. Content policies govern the conversation layer; that's between you and your AI provider. Signal Bridge is the hardware execution layer only.
  422. ### Feedback & safety
  423. How you use this, the context, the content, the relationship dynamics, is entirely up to you. I'm not here to gatekeep that.
  424. What I *am* here for: if you had an experience that felt unsafe, uncomfortable, or out of control, I want to know. Your feedback directly shapes the next version. You can reach me at [voxaletheia@gmail.com](mailto:voxaletheia@gmail.com) or [open a GitHub issue](https://github.com/AletheiaVox/signal_bridge_android/issues).
  425. No judgment. Just signal that makes this better for everyone.
  426. ---
  427. ## Security
  428. Signal Bridge takes a minimal-data, transparent-code approach to security.
  429. **What Signal Bridge sees (and doesn't see):**
  430. The relay server handles structured command data only: device names, capabilities, intensity values, durations, and connection health metrics. It never sees, stores, or processes your conversations. Your chat content stays between you and your AI provider. Signal Bridge doesn't know what you're talking about. It just knows when Claude says "vibrate the Lush at 0.6 for 15 seconds."
  431. **Open source:**
  432. The entire codebase is public on [GitHub](https://github.com/AletheiaVox/signal_bridge_remote). You can read every line, build the app from source, audit the server, or fork it for your own setup.
  433. ---
  434. ## Credits
  435. **[buttplug.io](https://buttplug.io):** Signal Bridge is built on the buttplug.io open-source intimate hardware control stack, created and maintained by [Kyle Machulis (qDot)](https://github.com/qdot). The device protocol support, ethics framework, and Intiface Central app are all his work. Without this project, none of this would exist.
  436. **[Model Context Protocol (MCP)](https://modelcontextprotocol.io):** The connector system that lets Claude call Signal Bridge's tools directly from the chat interface. MCP is developed by Anthropic.
  437. ---
  438. ### A note on generalizability
  439. Signal Bridge's relay server is LLM-agnostic. It speaks WebSocket JSON, not any provider-specific protocol. If you're running an LLM through its API with function/tool calling support, you can integrate it with Signal Bridge.
  440. Claude is currently the only platform where this works out of the box through the consumer chat interface, thanks to MCP (the Model Context Protocol connector system). Developers using OpenAI, Google, Mistral, or other APIs can build their own integration layer that sends commands to the relay server. The server doesn't care who's sending the commands, only that they're authenticated and well-formed.
  441. If you build an integration for another platform, consider opening a PR. The [repository](https://github.com/AletheiaVox/signal_bridge_remote) is open to contributions.
  442. ---
  443. ## License
  444. This project is licensed under the [MIT License](LICENSE).
  445. ---
  446. <p align="center">
  447. Feel free to <a href="https://buymeacoffee.com/aletheiavox">donate</a> cold hard cash to me. All donations will go towards extending my toy collection. <br><br>
  448. Built with love, stubbornness, and an unreasonable number of debugging sessions.<br>
  449. <a href="https://github.com/AletheiaVox/signal_bridge_remote">GitHub</a> · <a href="mailto:voxaletheia@gmail.com">Contact</a>
  450. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.