Solutions · Product and catalogue

Maplith for product and catalogue teams

The catalogue is the fact every other system borrows: the shop sells from it, the ads point at it, the helpdesk answers from it. When it is incomplete or duplicated, the cost turns up somewhere else — as a return, a wrong price, a join that misses. Your agent can trace it back — if it knows where each fact lives and how the systems join. Maplith gives it exactly that.

Acme Commerce is a fictional web shop built for our demo: the company, its people, its customers, the device brands, the suppliers and the competing chains are all invented, and nothing in the data comes from any customer. Fjeldrev Outdoor ApS is a fictional web shop built as a test company: the company, its people and its customers are all invented, and nothing in the data comes from any customer.

The workflowsfigures from the worked examples
Returns that do not fit
3 products with no compatibility · 44 does-it-fit conversations name them
Acme Commerce · Fjeldrev Outdoor ApS
Where a product’s facts liveCatalogueShopHelpdeskReportingTwo codes for one product
Between the systems

Where it goes wrong

Recurring problems between the catalogue and the systems that borrow from it.
01

Products nobody can tell the fit of

In the worked example three active products have an empty compatibility field, and the refunds on them lean to “does not fit”: the reason sits in the catalogue, the refunds in the shop and the questions in the helpdesk.
Acme Commerce · in its exported data
02

The same product under two codes

In the worked example seven products were re-listed in the shop under new codes while the catalogue kept the old ones, so a join from sales to the catalogue misses exactly those.
Acme Commerce · in its exported data
03

One item, two prices

In the worked example a re-import duplicated two products, each copy under the same code at a different price, and both copies were selling. A scan of the exports raised it as a finding, with the order lines on each copy.
Fjeldrev Outdoor ApS · raised by a scan of its exports
Workflows

What your agent does about it

The workflow below is told in full on the e-commerce page, where its worked example lives. Everything in it ships today.
Workflow 01

Returns that do not fit

Refunds on a few products lean to “does not fit”, and the reason sits in another system.
Without Maplith
  • Refunds sit in the shop, fit questions in the helpdesk, compatibility in the catalogue.
  • No single system shows that the refunds lean to “does not fit”.
  • Guess how the three join, one system at a time.
With Maplith
  • A rule on refunds per product over the last seven days.
  • A signal that names the product and the count.
  • An answer from ask, citing the joins it rests on.
  • A decision on an operation the shop declared, by the key’s policy.
  1. Your rulesRefunds over the last seven days above a number the shop chooses, per product.
  2. SignalsA rule_fired signal names the product and the count.list_signals
  3. AskWhy returns could be rising, answered with the objects and joins it rests on, and what the map could not establish.ask
  4. The mapWhere compatibility lives and how the catalogue joins the shop, with the rows that do not match counted.get_object
  5. The action gateAn operation the shop declared, such as a task for the catalogue owner, decided by the key’s policy.request_action
  6. Record and valueWhat was done, so the next firing’s context shows it.record_action

Worked example: Acme Commerce · told in full on Maplith for e-commerce

The full workflow, step by step

Without Maplith

Refunds sit in the shop with a reason, fit questions sit in the helpdesk, and which device a product fits sits in the catalogue. In the worked example three active catalogue products have an empty compatibility field; forty-four helpdesk conversations tagged does-it-fit name one of them, and their refunds lean heavily to “does not fit” where the shop’s refunds are otherwise spread evenly across reasons. No single system shows that, and an agent reading them one by one has to guess how they join.

With Maplith

  1. Your rules

    A rule the shop writes: refunds over the last seven days above a number it chooses — per product.

  2. Signals

    When a product crosses it, a rule_fired signal names the product and the count.

  3. Ask

    ask: “why could returns be rising on this product, and what does the map know about it?” The answer cites the objects and joins it rests on with their measured rates, any open finding on the product, and what the map could not establish.

  4. The map

    The map shows where the product’s compatibility lives and how the catalogue joins the shop — and where two systems spell the same product differently, the join says how many rows do not match rather than guessing.

  5. The action gate

    request_action for an operation the shop declared — for example, opening a task for the catalogue owner — decided by the key’s policy.

  6. Record and value

    record_action writes what was done, so the next firing’s context shows it.

The pieces

What your agent calls

Where each thing lives and how the systems join, with the rate Maplith measured for every join it could test.
get_object
Conditions the business writes from the map’s own names, judged for each product, order or other group it chooses.
What needs doing, as typed events to poll instead of re-reading the map.
list_signals

Ask

live
One question in plain language, answered from the map with citations — never from rows.
ask
Allowed, pending a person, or denied — before the agent acts, with a grant good once.
request_action
What was done, so the next judging does not raise it as though nobody had looked — and counted in “What you got”.
record_action

Map your exports. The first map is free.

Your systems stay the source of truth; your agent acts in them with your credentials.

Markdown version · Worked examples · Docs · llms.txt