IDM Heat Pump MCP Server
Integrates with GitHub Copilot to enable reading and writing of IDM heat pump registers.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@IDM Heat Pump MCP ServerWhat is the current outside temperature?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
IDM Heat Pump MCP Server
Ein unabhängiger Model Context Protocol (MCP)-Server, der KI-Assistenten kontrollierten Zugriff auf eine IDM-Wärmepumpe über Modbus TCP ermöglicht. Damit können kompatible MCP-Clients konfigurierte Anlagenwerte abfragen, verständlich anzeigen und – nur nach ausdrücklicher Freigabe – ausgewählte Sollwerte schreiben.
Dieses Community-Projekt steht inkeiner Verbindung, Partnerschaft oder Beauftragung mit der iDM Energiesysteme GmbH und wird von ihr nicht unterstützt oder zertifiziert. „IDM“/„iDM“ und Produktnamen sind Kennzeichen ihrer jeweiligen Inhaber. Dieses Projekt ist keine offizielle Bedienoberfläche und ersetzt weder Herstellerdokumentation noch Fachbetrieb. Siehe DISCLAIMER.md.
Wofür ist das Projekt gedacht?
Eine Wärmepumpe spricht normalerweise kein MCP. KI-Clients wie Claude Desktop, Claude Code, Codex oder unterstützte IDEs können deshalb nicht direkt mit ihr kommunizieren. Dieser Server bildet die Brücke zwischen beiden Welten:
MCP-Client / KI-Assistent
│ lokales MCP über stdio
▼
IDM Heat Pump MCP Server
│ Modbus TCP im lokalen Netz
▼
IDM-WärmepumpeDer Server übersetzt sprechende Namen wie heating.outside_temperature in die für das jeweilige
Gerät konfigurierte Modbus-Adresse, liest den Rohwert und rechnet ihn mit Datentyp, Skalierung,
Offset und Einheit in einen verständlichen Wert um. Dadurch muss der KI-Assistent weder
Registeradressen kennen noch selbst Binärwerte interpretieren.
Typische Anwendungsfälle sind:
aktuelle, konfigurierte Betriebswerte in natürlicher Sprache abfragen,
Temperaturen oder andere einzelne Messwerte auslesen,
einem KI-Assistenten die verfügbaren Werte samt Einheit und Beschreibung zeigen,
Diagnosegespräche mit aktuellen Anlagendaten unterstützen und
nach bewusster Freigabe einzelne, geprüfte Sollwerte innerhalb definierter Grenzen ändern.
Der Server ist kein dauerhaftes Monitoring-System: Er speichert keine Messhistorie, erstellt
keine Diagramme und ersetzt weder Home Assistant noch idm-heatpump-api. Er stellt ausschließlich
die in der lokalen Registerdatei definierten Werte als MCP-Tools und MCP-Resources bereit.
Related MCP server: WinCC OA MCP Server
Was kann der Server?
Entities auflisten: Namen, Adressen, Einheiten, Beschreibungen und Schreibregeln anzeigen.
Live-Werte lesen: Ein konfiguriertes Holding- oder Input-Register direkt von der Wärmepumpe lesen.
Werte dekodieren: Vorzeichenbehaftete
int16- und vorzeichenloseuint16-Register inklusive Skalierung und Offset in verständliche Werte umrechnen.Kontrolliert schreiben: Ein freigegebenes Holding-Register skalieren, auf Minimal- und Maximalwert prüfen und schreiben.
Gerätespezifisch arbeiten: Die Register werden als JSON konfiguriert und können damit an Modell, Firmware und Anlagenkonfiguration angepasst werden.
Mehrere MCP-Oberflächen bedienen: Funktionen werden sowohl als MCP-Tools als auch als MCP-Resources angeboten.
Lokal bleiben: Die Verbindung zur Wärmepumpe erfolgt aus dem eigenen Netzwerk; der Server benötigt keinen Cloud-Zugang.
Verfügbare MCP-Tools
Tool | Zweck | Beispiel |
| Alle konfigurierten Entities und Metadaten anzeigen | „Welche Wärmepumpenwerte kannst du lesen?“ |
| Aktuellen Wert eines Entity lesen | „Lies |
| Einen ausdrücklich erlaubten Wert setzen | „Setze den freigegebenen Sollwert auf 21 °C.“ |
Verfügbare MCP-Resources
Resource | Inhalt |
| Liste aller konfigurierten Entities |
| Aktueller Wert eines bestimmten Entity |
Welche konkreten Temperaturen, Betriebszustände oder Sollwerte verfügbar sind, entscheidet allein
die lokale registers.json. Ohne konfigurierte Entities liefert list_entities eine leere Liste.
Sicherheitskonzept
Der Server startet grundsätzlich read-only. Ein Schreibzugriff wird nur ausgeführt, wenn alle drei Bedingungen gleichzeitig erfüllt sind:
IDM_ALLOW_WRITES=trueaktiviert Schreiben global,das betreffende Entity besitzt
"writable": true, undseine Adresse steht zusätzlich in
IDM_WRITABLE_ADDRESSES.
Optionale minimum- und maximum-Werte begrenzen den erlaubten Sollwert zusätzlich. So führt weder
eine ungenaue Formulierung noch ein einzelner fehlerhafter Konfigurationseintrag automatisch zu
einem Schreibzugriff. Trotzdem müssen alle Adressen und Grenzen fachlich geprüft werden. Weitere
Hinweise stehen unter Sicherer Betrieb.
Voraussetzungen
IDM-Wärmepumpe mit aktiviertem und im LAN erreichbarem Modbus TCP
für das konkrete Gerät und die Firmware verifizierte Registeradressen
Python 3.11 oder neuer oder alternativ Docker
ein lokaler MCP-Client mit
stdio-Unterstützung
Schnellstart
python -m venv .venv
source .venv/bin/activate
pip install .
cp .env.example .env
cp config/registers.example.json config/registers.json
# .env und registers.json an das eigene Gerät anpassen
idm-mcpDie Beispieladressen sind keine echten bzw. universellen IDM-Adressen. Register können je nach Modell, Firmware und Anlagenkonfiguration abweichen. Nur verifizierte Adressen verwenden.
Danach wird die gewünschte KI-Anwendung gemäß der clientbezogenen Anleitung eingerichtet. Ein sinnvoller erster Test im Client ist:
Liste alle konfigurierten IDM-Entities auf. Schreibe keine Werte.
Anschließend kann ein tatsächlich konfiguriertes Entity gelesen werden:
Lies
heating.outside_temperatureund erkläre Wert und Einheit. Verändere nichts.
MCP-Client
Eine ausführliche, clientbezogene Anleitung ist unter Claude, ChatGPT, GitHub Copilot, Codex und Z.ai einrichten verfügbar.
Wichtig: Dieser Server verwendet aktuell den lokalen MCP-Transport stdio. Claude Desktop,
Claude Code, Codex CLI und unterstützte IDEs können ihn direkt als lokalen Prozess starten.
Webdienste wie ChatGPT im Browser oder GitHub.com können dagegen keinen Prozess auf dem eigenen
Rechner starten. Dafür wäre ein separat abgesicherter HTTPS-MCP-Gateway erforderlich; der
Modbus-Port der Wärmepumpe darf dafür keinesfalls ins Internet gestellt werden.
Dokumentation / Wiki-Vorlage
Die Seiten unter docs/ können in ein GitHub-Wiki übernommen werden. GitHub-Wikis liegen technisch
in einem separaten Repository und werden nicht automatisch mit diesem Repository veröffentlicht.
Aktuelle Grenzen
nur einzelne 16-Bit-Register (
uint16undint16), noch keine 32-Bit-, Float-, String- oder Bitfeld-Entities,keine automatische Erkennung von Modell, Firmware oder Registertabelle,
keine mitgelieferte universelle IDM-Registerliste,
keine Zeitreihen, Statistiken, Diagramme oder lokale Datenbank,
aktuell nur lokaler MCP-Transport über
stdio, kein öffentlicher HTTPS-Endpunkt,keine Authentifizierung innerhalb von Modbus TCP.
Diese Einschränkungen sind bewusst sichtbar dokumentiert, damit der Server nicht mit Fähigkeiten eingesetzt wird, die er derzeit nicht besitzt.
Lizenz
Der Quellcode steht unter der MIT-Lizenz. Sie erlaubt Nutzung, Änderung und Weitergabe unter Beibehaltung des Lizenz- und Copyright-Hinweises und enthält einen Gewährleistungs- und Haftungsausschluss. Der ergänzende Disclaimer erklärt Projektstatus und Betriebsrisiken in verständlicher Form; er ersetzt keine Rechtsberatung.
Available Tools
3 toolslist_entitiesA
List all configured heat-pump entities.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the behavioral burden. It clearly states a read-only listing action, but does not disclose details such as whether the result is ordered, filtered, or if any side effects occur. For a simple list operation this is acceptable but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that conveys the essential purpose without any filler. It is front-loaded and has no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the tool has no parameters and an output schema exists, the description is largely complete for a simple listing operation. However, it could benefit from a brief note about the returned structure or any prerequisites, but the output schema likely covers that. The main gap is the lack of explicit comparison with sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description does not need to elaborate on parameter semantics. The schema has no properties, and the description correctly omits any parameter details, meeting the baseline for a zero-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'List' and a clear resource 'heat-pump entities', and the qualifier 'all configured' distinguishes it from siblings that operate on individual entities (read_entity, write_entity). An agent can immediately understand its scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use it (when you need all entities) but does not explicitly state when not to use it or mention alternatives like read_entity for a single entity. No explicit routing guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
read_entityB
Read a configured entity by name.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. 'Read' implies a safe, non-mutating operation, which is useful. However, the description does not disclose what happens if the named entity does not exist (error vs. empty result), whether this is a read-only operation, or any access/authentication requirements. The read semantics are implied but not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no wasted words. The core action and target are front-loaded, and there is no redundancy or filler. For a simple one-parameter tool, this length is appropriate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has one required parameter, no annotations, and no nested objects. The output schema exists, so return-value documentation is not required from the description. For a simple single-entity read tool with one parameter, the description covers the essential information an agent needs to invoke it correctly; the gaps (error behavior) are minor given the tool's low complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the single parameter, 'name'. The description does mention that the tool reads 'by name', which gives some meaning to the parameter. However, it does not specify what format the name must take (e.g., exact string, case sensitivity, ID vs. display name) or whether it refers to a fully-qualified path. Minimal value is added beyond the schema field title.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Read a configured entity by name' states a clear verb (read) and resource (configured entity) with a specific scope (by name). It does not explicitly differentiate from siblings, but 'read' is naturally contrasted with list_entities and write_entity, so an agent can infer this is the single-entity retrieval counterpart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus list_entities or write_entity. The description does not state that this is for retrieving a single specific entity while list_entities enumerates all entities, nor does it mention any prerequisites such as the entity needing to already exist. Usage context must be inferred entirely from sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
write_entityC
Write an explicitly allowed entity; writes are disabled by default.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| value | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It discloses the important fact that writes are disabled by default, but it does not clarify whether writes overwrite existing entities, whether values are persisted, what authorization is required, or how failures are handled.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that front-loads the action and includes the most critical caveat ('writes are disabled by default') with no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although an output schema exists and return values need not be described, the tool still lacks essential context: what 'explicitly allowed' means, how to enable writes, parameter semantics, and behavioral side effects. For a write operation, this is too thin for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain what 'name' or 'value' mean beyond the schema's generic titles. The word 'entity' hints at the context, but the description fails to clarify naming conventions, value constraints, or how the parameters relate to the write operation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb-plus-resource ('Write an explicitly allowed entity') and contrasts with read/list siblings by indicating this tool performs writes. The phrase 'explicitly allowed' is somewhat ambiguous, but the core purpose is intelligible.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a context clue ('writes are disabled by default') but does not state when to use this tool versus list_entities or read_entity, nor does it explain conditions under which writing becomes allowed. Usage guidance is only implied, not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.1.0- First observed
list_entities - First observed
read_entity - First observed
write_entity
TDQS
Scored across 3 tools
Each tool has a distinct purpose: list all entities, read one entity by name, and write an entity. There is no overlap or ambiguity between them.
All tool names follow a consistent verb_noun snake_case pattern: list_entities, read_entity, write_entity. The singular/plural usage is natural and predictable.
Three tools is well-scoped for a focused heat-pump entity server. Each tool serves a clear, necessary function without redundancy.
The set covers listing, reading, and writing configured entities, which is the core workflow. Missing create/delete is acceptable since entities are 'configured' externally, though there is no explicit way to discover which entities are writable.
Maintenance
Related MCP Connectors
- mcpOAuthcom.keboola
Connect your AI assistants to Keboola and expose your data, transformations, SQL queries, ...
- mytesla.ioOAuthio.mytesla
Control your Tesla from your AI assistant - climate, charging, access, and security.
Connect any AI assistant to Odoo 16–19 via OAuth 2.0 + PKCE. 400 free calls, no local install.
Connect any AI agent to 1,000+ apps and 27,000+ actions through one remote MCP server (OAuth).
Related MCP Servers
- AlicenseAqualityAmaintenanceConnect AI assistants to Victron Energy systems to read real-time solar, battery, grid, and inverter data from your local network via Modbus TCP or MQTT.3218 npm4MIT
- AlicenseNot gradedqualityDmaintenanceA Model Context Protocol server that bridges AI assistants with WinCC OA projects, enabling natural language queries for datapoint search, manager management, and CTL script execution.2MIT
- AlicenseAqualityDmaintenanceAn unofficial MCP (Model Context Protocol) server that exposes a Vaillant heat pump's data to AI assistants like Claude. Query outdoor and room temperatures, hot water status, energy consumption, COP estimates, schedules, and diagnostics through natural conversation.4MIT
- FlicenseAqualityDmaintenanceEnables monitoring and control of IDM Navigator 2.0 heat pumps via Modbus TCP.13-