MCP App Store
by KeenEthics
Knavigator icon

Knavigator MCP Server for ChatGPT

By Avvera Technologies Inc

Overview

Let your AI agent understand and search your Knack app's structure: fields, objects, pages, views, rules, tasks and emails. Knavigator answers questions about how a Knack app is built. Ask where a field is used, which forms can change it, how objects connect, what a page contains, which user roles can reach which login pages, or what a record rule, scheduled task or email does. Answers name the exact objects, fields, views and pages, with their keys, so you can find them in the Knack Builder. Knavigator reads app structure only. It never reads or changes your records, and it never changes the app. To use it, create a Knavigator account at knav.avvera.ca and register your Knack app there.

How to connect

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

Tools

knav_app

ChatGPT
App-level metadata: id, slugs, region, counts, home scene, live URL, API header hint, integration flags, design/layout settings (theme, full width vs max width, sticky header, menu format), and the platform user-security settings (password expiry/reuse, account lockout incl. the configured-vs-ENFORCED distinction, inactivity timeout, IP allow-list, support access, Data Access Control presence/enforcement + any override that bypasses it). NOT knav_apps, which lists the apps registered on the account and supplies the app_id values.

knav_apps

ChatGPT
List the Knack apps registered on this Knavigator MCP account (app id, name, status, verification freshness), the account's credit balance, and where to register more apps. Supplies the app_id every other tool takes; one call per session is enough. NOT knav_app, which describes ONE app's metadata and security settings.

knav_census

ChatGPT
Value census of ONE key path across the app: every distinct value the key takes, with a count and example owners per value; for example, scenes[].views[].action with type form gives create / insert / update counts. Path segments: name, name[] (every array element), name[key=value] (only elements whose key equals value), * (every property). Target tables is a TABLE CENSUS in one call: every table view with its page, rows per page, whether users can change it (allow_limit), and its KTL _dr / _sth values (raw and parsed). Walks one path, so it is never capped by unrelated matches the way knav_grep is. To find WHERE a known value occurs use knav_grep.

knav_code

ChatGPT
The app's live custom JavaScript and CSS: whether each is stored and switched on, its size and SHA-256. Set lines ("5640-5790") or module (by banner comment) to read that code (CSS with css), numbered, exactly as written, nothing masked: 400 lines / 40 KB a call. Set calls to list every view-based Knack API call (view-based PUT, POST, GET, DELETE) with the facts needed to judge it against Knack's view-based API rules, such as the 7 Oct 2026 (week 41) change: line, method, how the call is made, the scene and view and whether the view is on that scene, the view's type and editing / adding settings, each field sent and whether it is editable on that view (with the reason), and whether it is a records or a connection-picker request; plus the app's "Restrict POST for View-based API" setting. A view chosen at run time is stated, with candidates only when traced. Commented-out calls are listed apart. It shows whether custom code is present and switched on; comparing hashes detects a change. For "check my apps for Knack's API changes", "will my custom code break on 7 Oct" or a Knack forum post about the change, calls lists the facts, once per app (knav_apps lists the apps), to compare with Knack's rules. knav_grep finds text only.

knav_conditional_rules

ChatGPT
A field's own conditional (auto-set) rules: each rule's set-to value + trigger criteria, in builder order. Given an OBJECT, lists every rule-bearing field on it with rule counts, for "what gets auto-set on every save of X?". NOT knav_display_rules (which show/hide OTHER things based on it). For every setter of the field beyond its own rules (form inputs, inline edits, record rules, tasks) use knav_writes.

knav_display_rules

ChatGPT
Display rules referencing a field: form/view display rules plus column conditional-format rules, with conditions. Rules that SHOW / HIDE / restyle OTHER things based on this field's value. NOT knav_conditional_rules (which auto-SETS this field's own value). Page-level rules are not included; knav_scene with rules:true returns them.

knav_editable

ChatGPT
Views where a field is editable: the [Editable] form inputs and [Inline Edit] table columns. User-driven edits only. For every reference (not just editable ones) use knav_uses; for every mechanism that sets the field, including record rules and tasks, use knav_writes.

knav_emails

ChatGPT
Per-object email count (== the Knavigator Emails tab), split by source. Set views to enumerate the senders (views and tasks, with subject, recipients and trigger); set app-wide to sweep EVERY object for an app-wide inventory. For the emails referencing a specific FIELD use knav_emails_using.

knav_emails_using

ChatGPT
Emails that reference a field, with the roles the field plays (subject/body/recipient/criteria). One field in, its emails out: each email named with where it is sent from and the role the field plays in it. For an object's email count or its full sender list use knav_emails; for the field's non-email references use knav_uses.

knav_field

ChatGPT
What a field is: type, object, connection, equation, settings, usage count. One field's definition and its usage total. For the itemized list of WHERE it is used call knav_uses; to compare usage across many fields call knav_rank; for what recalculates downstream of it call knav_ripple.

knav_formulas

ChatGPT
Every CALCULATED field on an object in one call: equations with their formula text, and count/sum/average/min/max aggregates (what they aggregate, over which connection, under which filters), plus the source fields each one reads. Answers "what recalculates on X, and from what?". Per-object catalogue. For the downstream chain from ONE field across objects use knav_ripple; for a field's own definition use knav_field.

knav_graph

ChatGPT
Connection adjacency (no args), one object's graph + reachable set (from), or shortest path (from + to). No args = every object's outbound edges; from = one object's neighbours + everything reachable downstream; from + to = the shortest connection path. For a SINGLE object's own inbound/outbound list use knav_object with connections:true.

knav_grep

ChatGPT
Full-text search of the RAW snapshot (recipients, criteria values, URLs…) with owning entity + JSON path per hit, plus the live custom JavaScript/CSS searched line by line (decoded). Case-sensitive unless i is set; capped at 50 locations unless all is set. Matches VALUES (recipients, criteria, URLs, choice text, messages); for resolving a NAME to an entity key use knav_search; for a URL census grouped by host use knav_hosts; for the distinct values ONE key takes across the app, with counts (e.g. every form action), use knav_census; to list custom-code API calls with their editability facts, use knav_code with calls.

knav_hosts

ChatGPT
App-wide external-host inventory: every http(s) URL in the raw snapshot grouped by host, with occurrence counts and the entities referencing it. Set urls to list each distinct URL instead. Capped at 50 rows unless all is set. For one known URL or host string with its exact locations use knav_grep.

knav_ktl

ChatGPT
KTL keyword index. KTL (Knack Toolkit Library) keywords are underscore-prefixed directives such as "_hv" written into field and view descriptions to switch on custom behaviour. Lists all keywords in use (no target), the keywords on or targeting one entity, or every use of one keyword. Each hit names the keyword and the entity carrying it. An empty index means the app carries no KTL keywords.

knav_names

ChatGPT
Bulk id → name resolution: one tab-separated "key<TAB>name<TAB>context" line per id; unknown ids report per-line. Ids only, never names; to go from a name to a key use knav_search.

knav_object

ChatGPT
Object summary (or every field / connection graph / views sourced on it, via flags). Summary by default; set fields, connections or views to get the full field list, this object's own inbound+outbound connections, or the views sourced on it (the same list knav_views returns for an object target). For the app-wide object-to-object graph or a path between two objects use knav_graph; for the app-wide object list use knav_objects.

knav_objects

ChatGPT
App-wide object inventory: one row per object (key, name, role flag, field & task counts) plus app totals. Set roles to list only the role (profile) objects. For one object in depth use knav_object. This inventory only flags WHICH objects are roles; for whether each role can actually log in use knav_roles.

knav_orphans

ChatGPT
App-wide ORPHAN census of what exists in the schema but nothing reaches: views listed on a page yet not placed in its layout (never render, still answer the view API), pages nothing links to (unreachable · detached), objects no view sources, fields whose connection or formula names something deleted, ids the live custom JavaScript/CSS names that the app does not have. Scope with views/scenes/objects/fields/code; set unused to add the slow every-unused-field sweep (the rank least census). For ONE view or page use knav_view / knav_scene, which report the same orphan facts. Each listed section is capped at 1000 rows here (counts stay exact; the cut is stated). unused is time-budgeted: on a large app it can be refused, and the refusal names the per-object alternative (knav_rank with least and object).

knav_rank

ChatGPT
Fields ranked by total usage: view/rule usage PLUS schema roles (object identifier, connection display field). Most-used by default; least flips the order, object scopes to one object, limit caps the rows. By far the slowest tool: cost grows with the app's field count and results are NOT cached, so every call pays the full sweep. On a large app (~2,500+ fields) the whole-app sweep does not fit in one request and is refused; object ranks one object's fields instead. limit does NOT reduce the work (it only trims the output). For one field's own count use knav_field.

knav_ripple

ChatGPT
What recalculates, at ANY depth, when a field changes: the transitive recalc chain over equation/concatenation tokens and aggregate membership (aggregated field AND filter field), with cross-object hops labelled. knav_uses answers depth 1 (direct references); this walks every hop. knav_formulas is the per-object catalogue of calculated fields; this is the chain from ONE field, across objects.

knav_roles

ChatGPT
Per-role access rollup: every user role, how many login pages name it (admittedByName, and which), how many open login pages there are (openLogins: limit off, they admit every signed-in role), reachable (= a named login or any open login), how often its profile key is referenced elsewhere (references), and where its NAME is used (nameReferences / byName: KTL [ktlRoles, ...] keyword options, quoted names in the custom JavaScript, roles the KTL config switches on such as bulkOps and userFilters). Set unreachable to list only the roles with no named login and no open login. Reachable = at least one login view admits the role. NOT knav_objects with roles:true, which is the plain list of role objects with no access analysis.

knav_scene

ChatGPT
A page's path, live URL, builder link, login requirement, views, child pages, and page rules. Scope it with rules/views/children/entered-from when you only want one section; set diff to a second page to compare the two page subtrees view by view. For the whole page tree use knav_scenes; for one VIEW on the page use knav_view; for a data OBJECT use knav_object; for the app-wide census of orphaned views and unreachable or detached pages use knav_orphans.

knav_scenes

ChatGPT
App-wide page (scene) tree: root pages with recursive subtree page counts (portal sizing), page-level role restrictions annotated, + orphaned-parent-slug warnings. Set tree to expand the nested descendants under each root; set root to show one page's subtree and depth to limit how many levels are shown. For ONE page's details (views, rules, entry points) use knav_scene.

knav_task

ChatGPT
A scheduled task's full config: schedule, when-conditions, field updates, email settings, field references. For the LIST of tasks on an object, or every task in the app, use knav_tasks.

knav_tasks

ChatGPT
Tasks on an object (== the builder's Tasks tab): name, action, run status, cadence. With no target: every task in the app, grouped by object, with run-status counts. For one task's full config use knav_task.

knav_uses

ChatGPT
Where a field is used (Used In / Depended On By / Depends On), grouped as the Knavigator screen groups it, entities named. Direct (depth-1) references only; for the transitive recalc chain use knav_ripple. Narrower neighbours: knav_editable = only where a user can CHANGE it; knav_display_rules = rules that show/hide things based on it; knav_conditional_rules = rules that auto-set its value; knav_emails_using = emails that reference it; knav_writes = every mechanism that SETS it.

knav_view

ChatGPT
A view's source object, rule blocks (record/inline-edit/display/submit/action-link/column-styling), field references, emails it sends, each connection input's source filters and option limits in words (or none), and every place the custom code names the view (Code References, with each CSS rule block - full selector list, declarations, enclosing @media/@supports - and each JS line with 2 lines of context; facts only; it does not say whether the view is hidden). Form Fields show each connection input's source filters and option limits in words; "none" means every record is offered. Set rules-summary for rule counts only; pass diff=<view> for a clone-drift audit against a second view. For the OBJECT behind it use knav_object; for the PAGE it sits on use knav_scene; for the app-wide view census use knav_views; for every orphaned view or unreachable page app-wide use knav_orphans.

knav_views

ChatGPT
App-wide view inventory by TYPE: per-type counts (incl. explicit 0 for absent native types like report) + total; set type to list every view of one type (each row carries how many custom-code lines name the view). Given an OBJECT target, lists the views SOURCED on that object (type, page, connected-or-not), for the "which views expose object_N, and which can I read via the view-based API?" question. Set editable for the write-capability census of table views. For ONE view use knav_view.

knav_writes

ChatGPT
What writes records INTO an object (form submits, record rules, action links, inline editing, DELETE links, tasks), or, given a FIELD, every mechanism that SETS that field (form inputs, inline-edit columns, record rules, tasks, its own conditional rules, custom-code API calls). Answers "where do records of X come from?" / "what writes this field?". Field mode is a superset of knav_editable (user inputs only): it also counts record rules, tasks and conditional rules. For READ references use knav_uses.

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/knavigator"><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/knavigator)