MCP App Store
by KeenEthics
Maplith icon

Maplith MCP Server for ChatGPT

By Maplith ApS

Overview

Maplith builds a map of the data a company already has and makes it available to your assistant: which business objects the data holds, where they live, how they connect, and what needs attention. A company uploads exports from the systems it runs on — CRM, accounting, mailbox, spreadsheets, helpdesk, transcripts — or connects a system, and Maplith reads their structure to build a semantic map: the business objects in the data, their fields, how they join across systems (with the share of rows that matched, where Maplith tested a join), the processes in the event log, metrics defined on the map's fields, and findings — places where the data in one system disagrees with another. With Maplith in ChatGPT you can: - Get an overview of the map: the business objects by domain and system, the counts of fields, relations, findings, metrics and processes, how many relations were tested against the rows, and when the map was built. - Open one object with its fields, their personal-data marking and its relations, and see which systems and files it was built from. - Find the route between two objects across systems: the join columns of each hop, its strength, the share of rows that reached the other side where Maplith measured it, and the weakest hop. - Read the findings with their evidence and recommendation, the processes with their steps, and the metrics with their formulas. - Signals say what needs doing (a rule the company wrote fired, a finding appeared, a tracked metric moved). For one signal, one call returns its task context: the objects and routes involved, related findings, and the company's playbook where one exists. - Search the map and open an object, finding, process or metric. - Ask a question about the map. The answer is written from the map and cites the objects and joins it used. Ask how Maplith works, and the answer cites Maplith's documentation pages. This version of Maplith for ChatGPT reads the map. Its tools do not start scans, change findings or act in your systems. Sign in and choose the workspace the connection reads. No account yet? Create one in the window that opens when you connect; a new workspace needs its first map, which you build at app.maplith.com. A connection can be limited to named domains, and the server applies the limit to each call. What the tools do not include: Maplith's tools return metadata about your data (names, types, relationships, findings, and the values of metrics a workspace chose to track), not the rows in your systems. Field descriptions and finding evidence are written from your exports and can quote example values; Maplith tries to mask personal identifiers in them, as a best effort, and you decide what your exports hold. The map is metadata, not a copy of your data. Uploaded export files are read for the build and then deleted. Maplith's app, database and file storage are hosted in the EU. Language-model processing runs in the United States, under the European Commission's standard contractual clauses; Maplith's privacy policy and sub-processor list name each provider and where it processes data. Made in Denmark.

How to connect

  1. ChatGPT: Open the Maplith listing in the ChatGPT app directory and choose Connect. ChatGPT listing Maplith exposes 14 tools here.

Tools

ask

ChatGPT
Ask the map one question in plain language and get an answer with its sources. When to use which: ask when a question spans several parts of the map or you do not yet know which tool holds the answer. For one known thing the direct tool is faster and not metered: get_object for an object, route for the join path between two, get_metric for a formula, list_findings for the discrepancies, search to find map items by text. The answer is written from what your key may see (objects, fields, relations and join keys, findings, a bounded page of open signals, processes, metrics and tracked values), cites the exact elements it rests on, and says plainly what the map could not establish. Metadata only: it never reads rows, runs anything in your human's systems or invents an element. Every citation is an id you can pass on (fetch, get_object, route; signals cite signal:<id>); a cited route carries each hop's measured verified_rate, and unmeasured_joins names joins never measured. It also answers questions about Maplith itself from its public documentation, citing doc:<page>. Metered against the workspace's daily allowance and limited per key; keep questions specific, under 1,000 characters. Grounding fields: maplith://docs/mcp.

fetch

ChatGPT
Read one map document by the id a search result handed you. Ids: object:<name>, finding:<id> or finding:<finding_key> (stable across rescans), process:<object type>, metric:<name>, statement:<id> (run-scoped: search again after a rescan), playbook:<id>. It is the second half of the search/fetch pair that connector clients such as ChatGPT require, and returns id, title, text, url and metadata with the direct tools' data flattened to text. If your client can call the direct tools, use them instead (structured, no search first): get_object for an object you can name, get_process for a process, get_metric for a metric, list_findings for findings by status. Use fetch for a result search handed you, or a finding_key.

get_map_overview

ChatGPT
Orient yourself: domains, objects, row_counts, freshness and quality within your key's scope (truncated counts may be lower bounds), and your_key: what this key may do and, where wake-ups are on, its endpoints and deliveries (wake_ups). stated: the relationships people stated, with the scan's check of each, for a key that sees the whole map. Journey gives stage/done and up to three next steps (what/why/how/who): use journey to guide your human, including features they have not started yet. Setup counts missing links. Maintenance: last-seen dates, refresh steps for stale sources. Confidence: trust 0-100, with raisers. Then route for a join path, get_object for fields and caveats, ask for cross-map questions. Full semantics: maplith://docs/mcp.

get_metric

ChatGPT
Read one metric in full, or list every metric defined for this workspace. Without name it lists them with their tracking state: each row carries caveat_count, broken_reason (the formula cannot be measured as written, and why; its values are not recorded) and any proposed_for_removal mark, and older definitions kept for review are included. With name it reads that one: its formula in map terms, the exact object.field grounding, every caveat and, where tracking is on, the recorded values. Read the caveats before computing or citing a number: they say when it cannot be trusted. On a map larger than one call reads the list is cut: truncated is true and truncated_note says so. Use this, not fetch, when your client can call it. Tools that act exist, but this key stays read-only; a workspace admin can create a key that may act (Agents & access › Connections).

get_object

ChatGPT
Read one object before you act on it: its applicable decision statements, fields, relations and caveats. Use this, not fetch, for an object you can name; route for the path between two objects; ask when the question spans several. Rules come as trees: each has a layer (principle, policy, rule, default) and rests_on the principle above it; full and compact rules carry statement keys and coverage, and statement_key fetches a compact rule in full. The detail also carries aliases, row_count and row_count_details, grain, field_id, also_called, recognised_by, auto_detected, role and role_basis, count-only profiles, personal-data classifications and pii flags, source systems and same_source_as peers, relations with join keys, coverage sides and basis (declared with declared_by, measured or guessed; null when unknown), findings and automations (list_automations has them all). Never echo pii=true values unless the task requires it. Full semantics: maplith://docs/mcp.

get_process

ChatGPT
Read one process in full, or list every process the map discovered. Without object_type it lists them, one per central object type, with case count, happy-path share and step count; with object_type it reads that one: its happy path with step counts and median hours between steps, and every deviating variant with its missing or extra steps, which are candidates for process-level findings. Processes are found deterministically from an object-centric event log built from the dated rows of the exports and any event log they include. On a map larger than one call reads the list is cut: truncated is true and truncated_note says so. Use this, not fetch, when your client can call it.

get_task_context

ChatGPT
Start any work here: one call equips you for a task, signal or support case. task: its objects, applicable decision statements (layer, rests_on, coverage), routes, playbooks, owners; fields via get_object. signal_id: its evidence, playbooks, playbook_drafts, suggested_action, remedy, handling, lifecycle and trust (weak joins and fields not to quote back), answer_with for Maplith's question, and approved_fix. case: identifier/topic are kinds, never customer values. Follow the rules; open a rule's source only if unclear; read payload.checks before acting on one. Still metadata: fetch rows in your human's own systems. Suggested actions forecast what Maplith would decide if your key asked to do it, never a permission. Details: maplith://docs/signals-and-rules. Tools that act exist, but this key stays read-only; a workspace admin can create a key that may act (Agents & access › Connections).

get_value_summary

ChatGPT
Summarise what the workspace got out of its signals over a period, as counts within your key's scope. It counts work signals raised, acted on, planned and not acted on, in total and by kind; notices and changes resolved before anyone acted are separate totals; findings that appeared and that are no longer reported; actions recorded by outcome with the median and longest time from signal to record; gate requests by decision and approvals a person decided (workspace-wide; null for a key limited to part of the map); the value agents stated in their own numbers (sum per currency, and how many records carried none); dead connections found and reached again; and each tracked metric's recorded values beside the records written against signals about it, by outcome and by day, never a claim that an action moved the number. Maplith does not estimate value or attribute a change to an action: this is what happened, and what your human's agents said it was worth. Acted on means a record exists against the signal, or a person closed it in Maplith or in the system the case lives in. Default period: the last thirty days (since, until).

list_automations

ChatGPT
List the automations your human's business runs in its own systems, each bound to the map objects it reads and writes: a flow, a zap, a scheduled job, an agent on a timer. Use it to see what breaks if an object changes, and to find dead automation: each entry carries attention, the reasons it needs a look, most urgent first (never_run, last_run_failed, status_unknown, object_not_on_map, paused), and the list is sorted that way. Maplith describes them from what was registered; it does not run or watch them. Filter with object or status. Only automations whose every bound object is in your key's scope are listed. Tools that act exist, but this key stays read-only; a workspace admin can create a key that may act (Agents & access › Connections).

list_findings

ChatGPT
List the documented data problems of this workspace: cross-system discrepancies with evidence, recommendation and lifecycle status, optionally filtered by status. Use it for the discrepancy catalogue; use list_signals for new work and changes since a timestamp, and fetch finding:<finding_key> for one finding you already hold a key for. finding_key stays stable across rescans (ids are per run). The list is complete unless truncated is true. After a scan whose own investigation found nothing, empty_scan says so: found_none_of_its_own when the scan produced no finding at all, findings_kept_from_previous_scan when the previous scan's findings were kept open with the statuses people gave them, so what you read is not this scan's news. A finding's decision says where its work stands; approved: a person approved its fix. Tools that act exist, but this key stays read-only; a workspace admin can create a key that may act (Agents & access › Connections).

list_signals

ChatGPT
Find work and changes: the scoped queue of signals (typed events) with severity, state, objects and aggregate payloads. Use it for the work queue and for what changed since a timestamp (since); use list_findings for documented discrepancies. Follow a signal up with get_task_context. Lease expiry and reopening keep created_at, so also poll states [open] without since for available work; next_cursor paginates. Rules are judged per group by every scan as it finishes: one rule_fired per matching group (by_rule rolls this page's open ones up per rule), rule_broken when unjudgeable; the first evaluation is a quiet baseline, and a live check may raise rule_cleared. Legacy notice kinds remain readable. unacted and the states distinguish open work, plans, holds and completed episodes. Details: maplith://docs/signals-and-rules. Tools that act exist, but this key stays read-only; a workspace admin can create a key that may act (Agents & access › Connections).

list_sources

ChatGPT
List the systems and files this workspace's scans read: where the data behind the map lives. Read it before you query a source system, to know which export holds what; pass system for one system's files in full. Per system: file export or connection, when a scan last read it, whether the current map was built from that scan, and per file its path, format, record count and the objects built from it. Metadata only: no row, no value; paths are the export's own names, and Maplith tries to mask personal data in them. asked holds what a person stated about a system (owner as a team, refresh cadence, retention, access, sensitivity, warehouse hints); unknown means nobody answered: never guess it, ask your human. A key limited to part of the map sees a file only when every object built from it is in its scope. work_done_here counts the work agents reported in each system. Tools that act exist, but this key stays read-only; a workspace admin can create a key that may act (Agents & access › Connections).

route

ChatGPT
Find the shortest verified route between two objects, hop by hop. Per hop: an executable join_spec (leftFile.leftColumn = rightFile.rightColumn, real names; null when the map could not test that hop), the edge's verb and cardinality in the direction the map stores them, strength, coverage and caveats, each object's system, work_done_in (where agents reported working on it) and the PII fields on the path. Use it before fetching data in your human's own systems: it says where to look, by which columns, and how far to trust each step; the map never returns the data itself. Name both objects in any case; the answer uses the map's spelling. Coverage is side-labelled: verified_rate measures join_spec.leftFile rows (blank keys miss), child_coverage child rows finding parents, parent_coverage parents with children; null means unmeasured, and child_key_coverage counts only non-blank keys. Untested hops say so. Each hop has a basis (declared, citing declared_by; measured; guessed), and guessed hops are used only when nothing else connects (guessed_only). Contradictory inferred parent directions are withheld; pinned shapes stay with a shape_conflict warning.

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/maplith"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/maplith)