ThinQ Connect MCP Server for LG Smart Devices

Overview

ThinQ Connect MCP Server is an open-source server that bridges LG ThinQ smart devices with local automation systems and developer tools. It implements the Model Context Protocol (MCP) surface used by LG devices so you can discover, observe, and control appliances from your own applications or home automation stacks without depending solely on cloud dashboards.

For developers this server provides a consistent local API and event stream representing the state and capabilities of connected ThinQ devices. This makes it easier to build automations, test integrations, and route device updates into dashboards, message buses, or third‑party platforms like Home Assistant.

Features

• Local MCP server that proxies or exposes LG ThinQ device models and events
• Authentication and region configuration for ThinQ cloud access (when required)
• Device discovery and model synchronization to keep state up to date
• REST/WebSocket endpoints for control and real‑time events
• Logging and debug modes useful during development
• Docker and source install options for flexible deployment
• Lightweight, extensible architecture for custom integrations and scripts

Installation / Configuration

Clone the repository, install dependencies, and run the server locally. Example assumes a Node.js based project; adapt commands for your environment.

Clone and install:

git clone https://github.com/thinq-connect/thinqconnect-mcp.git
cd thinqconnect-mcp
npm install

Run the server (development):

# start with default config
npm start

# or
node ./src/index.js --config ./config/default.json

Docker example:

# build image
docker build -t thinq-mcp .

# run container (example env variables shown)
docker run -d \
  -e THINQ_USERNAME="[email protected]" \
  -e THINQ_PASSWORD="your-password" \
  -e THINQ_REGION="us" \
  -p 8080:8080 \
  --name thinq-mcp thinq-mcp

Sample JSON configuration (config/default.json):

{
  "server": {
    "port": 8080,
    "host": "0.0.0.0",
    "enableTls": false
  },
  "thinQ": {
    "username": "[email protected]",
    "password": "REDACTED",
    "region": "us"
  },
  "logging": {
    "level": "info"
  }
}

Common command‑line flags:

• –config PATH Load an alternate config file
• –port INT Override server port
• –debug Enable verbose logging for troubleshooting

Available Resources

• GitHub repository: https://github.com/thinq-connect/thinqconnect-mcp (source, issues, releases)
• Local REST API: endpoint patterns typically under /api or /v1 (check your running server’s documentation)
• WebSocket or SSE: real‑time event stream for device state changes
• Logs: console and file logs configurable via the logging section in the config
• Device inventory: an endpoint or CLI to list discovered devices and their model schemas

If the repository includes an OpenAPI/Swagger spec, use it to explore available endpoints. Otherwise consult the running server’s /health or /info endpoints to discover available routes.

Use Cases

• Home automation integration

  • Connect the MCP server to Home Assistant or Node-RED using the REST or WebSocket endpoints to display device state, trigger automations, and expose device controls as entities.
  • Example: When a washer reports a finished cycle event, run an automation to notify your phone and turn on an exhaust fan.

• Local control for privacy and reliability

  • Route commands through the local MCP server so automations can operate even if cloud services are unreliable. Ideal for critical automations like safety or energy management.

• Development and testing

  • Use the MCP server to emulate or proxy ThinQ device models during integration tests. Capture and replay events to validate automation logic without interacting with physical devices.

• Aggregation and analytics

  • Forward device telemetry to a message bus (MQTT, Kafka) or a time-series database to build usage dashboards, detect anomaly patterns, or optimize energy usage.

• Bridging cloud and local systems

  • Use the server as a translator between LG ThinQ cloud APIs and local smart home ecosystems, implementing custom transformations or access control.

Quick reference table

Tips for Developers

• Keep credentials secure: prefer environment variables or secret managers over committing them to version control.
• Start with debug logging when onboarding a new device to capture model schemas and event flows.
• Use container orchestration (Docker Compose, systemd, Kubernetes) for production deployments to ensure automatic restarts and logging management.
• Check the repository’s issue tracker and docs directory for example integrations and community tips.

For full details, examples, and up-to-date instructions, see the project repository on GitHub: https://github.com/thinq-connect/thinqconnect-mcp