the first one is 470 euro 5k 60 hz , the second one is 540 euro 5k 120 hz , which should I buy? I'm not a professional photographer or a passionate gamer , I'm looking for something good for my Mac Pro 16 , for reading and coding , and maybe sometimes to associate with my ps5
I’m working on a system that converts industrial communication manuals into a structured catalog that can later support deterministic lookup and RAG/chat.
The manuals may describe Modbus, Siemens-style DB/DW/bit addressing, OPC UA, proprietary protocols, or memory ranges. Although they often contain similar information, table layouts, column names and addressing conventions vary significantly between manufacturers.
For example, an unseen manual might contain:
| Absolute Address | Parameter | Number of Items | Format |
|---|---|---|---|
| 30101 | Phase Current | 2 | Float |
The desired canonical result would be something like:
{
"name": "Phase Current",
"data_type": "Float",
"protocol": "modbus",
"register_type": "input_register",
"address": 30101,
"register_count": 2
}
My current experimental pipeline is:
PDF
→ document/table extraction
→ protocol and table-type detection
→ schema matching
→ canonical catalog
→ validation
→ deterministic address/name lookup
→ optional LLM-generated natural-language answer
For known manual families, deterministic extractors work well. The main difficulty is generalizing to unseen layouts: identifying which tables contain actual variables, mapping unfamiliar headers to canonical fields, interpreting address conventions, and avoiding protocol examples or configuration tables being mistaken for register maps.
I experimented with a local LLM as a constrained schema planner. Instead of generating register values, it only proposes mappings such as:
Absolute Address → address
Parameter → variable_name
Number of Items → register_count
Format → data_type
The source values are then read and validated deterministically. This prevents many hallucinations, but results have been mixed: it helped significantly on one unseen manual, added nothing where deterministic extraction already worked, and sometimes proposed incorrect column roles. Sending many tables to the model also adds several minutes of latency.
I’m therefore still open to the overall architecture and to a different role for the LLM. Possible options include:
How would you design this system to generalize across unseen industrial manuals while keeping every extracted value traceable to the source? Where would an LLM provide genuine value, and which parts should remain deterministic? I’m especially interested in approaches that improve recall without silently inventing addresses, data types, scaling factors, or protocol bindings.
Hi to everybody ,
I need a monitor for my Mac , what do you suggest me to buy ? I was in doubt between a ASUS PROART DISPLAY PA27JCV 5k 60 hz for 470 euro and Dell 27 Plus Monitor - S2725QS 120 hz 4k for 250 euro .. I will use it for everyday activities such us coding , reading , watching films , nothing professional in terms of editing or intensive gaming , does plus than 200 euro justify the upgrade from 4k to 5k with Mac ?
Hi to everybody ,
I need a monitor for my Mac , what do you suggest me to buy ? I was in doubt between a ASUS PROART DISPLAY PA27JCV 5k 60 hz for 470 euro and Dell 27 Plus Monitor - S2725QS 120 hz 4k for 250 euro .. I will use it for everyday activities such us coding , reading , watching films , nothing professional in terms of editing or intensive gaming , does plus than 200 euro justify the upgrade from 4k to 5k with Mac ?
I’m working on a system that converts industrial communication manuals into a structured catalog that can later support deterministic lookup and RAG/chat.
The manuals may describe Modbus, Siemens-style DB/DW/bit addressing, OPC UA, proprietary protocols, or memory ranges. Although they often contain similar information, table layouts, column names and addressing conventions vary significantly between manufacturers.
For example, an unseen manual might contain:
| Absolute Address | Parameter | Number of Items | Format |
|---|---|---|---|
| 30101 | Phase Current | 2 | Float |
The desired canonical result would be something like:
{
"name": "Phase Current",
"data_type": "Float",
"protocol": "modbus",
"register_type": "input_register",
"address": 30101,
"register_count": 2
}
My current experimental pipeline is:
PDF
→ document/table extraction
→ protocol and table-type detection
→ schema matching
→ canonical catalog
→ validation
→ deterministic address/name lookup
→ optional LLM-generated natural-language answer
For known manual families, deterministic extractors work well. The main difficulty is generalizing to unseen layouts: identifying which tables contain actual variables, mapping unfamiliar headers to canonical fields, interpreting address conventions, and avoiding protocol examples or configuration tables being mistaken for register maps.
I experimented with a local LLM as a constrained schema planner. Instead of generating register values, it only proposes mappings such as:
Absolute Address → address
Parameter → variable_name
Number of Items → register_count
Format → data_type
The source values are then read and validated deterministically. This prevents many hallucinations, but results have been mixed: it helped significantly on one unseen manual, added nothing where deterministic extraction already worked, and sometimes proposed incorrect column roles. Sending many tables to the model also adds several minutes of latency.
I’m therefore still open to the overall architecture and to a different role for the LLM. Possible options include:
How would you design this system to generalize across unseen industrial manuals while keeping every extracted value traceable to the source? Where would an LLM provide genuine value, and which parts should remain deterministic? I’m especially interested in approaches that improve recall without silently inventing addresses, data types, scaling factors, or protocol bindings.
I’m working on a system that converts industrial communication manuals into a structured catalog that can later support deterministic lookup and RAG/chat.
The manuals may describe Modbus, Siemens-style DB/DW/bit addressing, OPC UA, proprietary protocols, or memory ranges. Although they often contain similar information, table layouts, column names and addressing conventions vary significantly between manufacturers.
For example, an unseen manual might contain:
| Absolute Address | Parameter | Number of Items | Format |
|---|---|---|---|
| 30101 | Phase Current | 2 | Float |
The desired canonical result would be something like:
{
"name": "Phase Current",
"data_type": "Float",
"protocol": "modbus",
"register_type": "input_register",
"address": 30101,
"register_count": 2
}
My current experimental pipeline is:
PDF
→ document/table extraction
→ protocol and table-type detection
→ schema matching
→ canonical catalog
→ validation
→ deterministic address/name lookup
→ optional LLM-generated natural-language answer
For known manual families, deterministic extractors work well. The main difficulty is generalizing to unseen layouts: identifying which tables contain actual variables, mapping unfamiliar headers to canonical fields, interpreting address conventions, and avoiding protocol examples or configuration tables being mistaken for register maps.
I experimented with a local LLM as a constrained schema planner. Instead of generating register values, it only proposes mappings such as:
Absolute Address → address
Parameter → variable_name
Number of Items → register_count
Format → data_type
The source values are then read and validated deterministically. This prevents many hallucinations, but results have been mixed: it helped significantly on one unseen manual, added nothing where deterministic extraction already worked, and sometimes proposed incorrect column roles. Sending many tables to the model also adds several minutes of latency.
I’m therefore still open to the overall architecture and to a different role for the LLM. Possible options include:
How would you design this system to generalize across unseen industrial manuals while keeping every extracted value traceable to the source? Where would an LLM provide genuine value, and which parts should remain deterministic? I’m especially interested in approaches that improve recall without silently inventing addresses, data types, scaling factors, or protocol bindings.
I'm building a system that parses industrial communication manuals, mostly protocols like Modbus, Siemens/SAM-style DB/DW/bit maps, and potentially OPC-UA/BACnet later.
The goal is to convert each manual into a structured “machine variable catalog”, something like:
{
"name": "Internal Temperature",
"description": "Internal Temperature",
"semantic_tags": ["temperature", "measurement"],
"unit": "°C",
"data_type": "SF32",
"access": "read",
"protocol_bindings": [
{
"protocol": "modbus",
"register_type": "input_register",
"address": 4894,
"register_count": 2,
"original_address": "4854"
}
],
"source": {
"page": 17,
"table_id": "..."
}
}
So far I have:
PDF → parsed document JSON with tables
extractor registry
specialized extractors for known manuals:
- ABB Modbus register map
- Daikin MicroTech Modbus register map
- SAM DB/DW/bit tables
generic fallback table extractor
health report showing selected extractor, confidence, fallback, field completeness, etc.
keyword retrieval over name / aliases / semantic_tags / description / notes
This works well for the known manuals.
The problem is new manuals.
Example: I tested two new Modbus PDFs.
One was more of a generic Modbus protocol explanation: function codes, request/response frames, coils/register concepts. The fallback extracted rows, but they are not really machine variables.
The other was a real energy meter register map, but its table format was very different:
Columns like:
- Parametro
- Cod. di funzione (Hex)
- INTERO / Registro (Hex)
- INTERO / Word
- INTERO / U. M.
- IEEE / Registro (Hex)
- IEEE / Word
- IEEE / U. M.
Example row:
V1 • Tensione L-N fase 1 | 03/04 | 0000 | 2 | mV | 1000 | 2 | V
The generic fallback extracted many rows, but with no Modbus binding, no protocol, no address semantics, no unit mapping, etc.
My question:
What is the best architecture for handling new unseen industrial manuals?
Option A:
Keep adding specialized extractors for each manual/vendor format.
Option B:
Build a more generic “Modbus register-map extractor” that detects common address/name/unit/function-code columns across many formats.
Option C:
Use an LLM offline at parse/index time to classify table types and map columns into a fixed schema, but only with constrained JSON output and validation.
Option D:
Hybrid:
- deterministic extractor when table structure is recognized
- generic Modbus column mapper for common cases
- LLM only as fallback/assistant for ambiguous tables
- validation + health report + human review queue
I'm leaning toward D.
I’m especially unsure about:
How to reliably distinguish a real register map from generic protocol documentation.
How much should be rule-based vs LLM-based.
Whether an LLM can safely map columns into a fixed schema without hallucinating.
How to evaluate this across new manuals without manually creating full ground truth for every document.
Whether the “catalog enrichment” step should happen inside each protocol extractor or as a separate post-processing layer.
Has anyone built something similar for messy technical manuals / register maps / industrial protocol docs?
What architecture would you recommend?
Hi everyone,
I’m working on a system that parses industrial communication manuals and turns them into a structured machine-variable catalog.
The manuals are things like:
- Modbus register maps for solar inverters
- Modbus protocol sheets for chillers/controllers
- SEND/RECEIVE / S5-style process-image manuals for compressors or industrial managers
The current pipeline is roughly:
PDF manual
-> parsed document/tables
-> raw variable catalog
-> retrieval/chat over the catalog
For example, a raw extracted variable might look like:
{
"name": "Inverter Temperature",
"unit": "°C",
"access": "read",
"protocol": "modbus",
"address": 1122
}
I would like to enrich it into something like:
{
"category": "measurement",
"quantity_type": "temperature",
"system_area": "inverter",
"semantic_tags": ["temperature", "thermal", "measurement"],
"symptom_tags": ["overheating", "heat"]
}
The reason is that retrieval works much better if the catalog has consistent semantic metadata. For example, user questions like “the inverter is overheating, what should I check?” should match temperature-related variables even if the manual uses different wording.
My question is:
Does it make sense to use an LLM during ingestion to assign these metadata fields from a predefined taxonomy?
For example, the LLM would only be allowed to choose from fixed categories like:
category:
- measurement
- command
- status
- alarm
- configuration
- identity_metadata
- communication
- diagnostic
- unknown
quantity_type:
- temperature
- humidity
- pressure
- current
- voltage
- power
- energy
- frequency
- state
- unknown
My concern is reliability. I’m afraid the LLM may inconsistently classify similar records, or hallucinate associations. For example, it might classify “humidity of inverter” as temperature-related just because it appears near thermal terms, or assign inconsistent categories across different manuals/vendors.
The alternative is to hardcode enrichment rules manually, but that may not scale because new manuals can come from different vendors, devices, and industrial protocols.
Would you recommend:
I’m especially interested in how people handle consistency across many technical documents and whether LLM-based enrichment is reliable enough if the output schema and allowed categories are tightly constrained.
I’m building a RAG pipeline over industrial manuals. The documents are parsed into a normalized machine-variable catalog rather than raw PDF chunks. Each register/variable becomes a structured record like:
address: 1122
name: Inverter Temperature
description: Inverter Temperature
semantic_tags: temperature, measurement
unit: °C
data_type: SF32
access: read
notes: DC/AC Converter Temperature
source: ABB TRIO manual, page 22
Then I run hybrid retrieval over these catalog records:
keyword score + dense embedding cosine similarity
In this specific benchmark, the catalog is quite small: fewer than 100 register/variable records. So this is not a massive vector database problem. Still, I’m seeing noisy top-k retrieval for troubleshooting-style queries.
Example query:
"the inverter seems to be overheating, which registers should I check?"
Expected relevant records would be things like:
1122 - Inverter Temperature
1120 - Internal Temperature
Actual top results look more like:
1122 - Inverter Temperature ✅
1015 - Inverter Manufacture date ❌
1019 - Inverter Type ❌
1003 - Inverter Part number ❌
1000 - Inverter ID ❌
The top-1 is correct, and the final LLM answer is usually fine because it can inspect the retrieved context and ignore irrelevant candidates. But the top-k retrieval itself is noisy.
The score pattern suggests that both keyword and embedding retrieval are over-weighting generic terms like inverter:
1122 Inverter Temperature:
keyword_raw: 7.5
embedding_cosine: 0.659
1015 Inverter Manufacture date:
keyword_raw: 7.5
embedding_cosine: 0.596
1019 Inverter Type:
keyword_raw: 7.5
embedding_cosine: 0.589
So the correct record is ranked higher, but not by a huge margin. The embedding model seems to understand the query somewhat, but the semantic jump:
overheating → temperature / thermal
is not strong enough to clearly separate temperature-related registers from generic inverter metadata.
I’m not embedding long chunks of text; I’m embedding compact catalog records. So I expected semantic retrieval to separate these concepts more cleanly.
My current options are:
1. Add domain-specific stopwords:
inverter, register, value, parameter, product, device
2. Change field weighting:
lower weight for generic name matches
higher weight for semantic_tags, unit, notes
3. Change the embedding text representation:
maybe avoid repeating generic words like "inverter"
maybe emphasize tags/units/notes more
4. Add query rewriting:
"overheating" → "temperature thermal heat"
5. Add a reranker or LLM verifier:
retrieve top-k, then ask whether each candidate is actually relevant
6. Add thresholds or score-gap checks:
only trust candidates if cosine/hybrid score is clearly above noise
My question:
For RAG over small structured industrial register catalogs, what is the recommended way to improve semantic retrieval for troubleshooting-style queries?