Jade MCP Server for Claude and ChatGPT
By Jade Email, LLC
Overview
Jade hands out a different email address for every sender. Your bank gets one, that shoe store gets another, and when an address leaks or starts collecting spam, you shut that sender off without touching the rest. Jade also has a powerful rules system that can help you organize your email across all of your inboxes. You can bounce email from unwanted senders, automatically unsubscribe from marketing messages, and set up repetitive emails to auto delete once you're done with them. Catch up on what came in overnight, dig up a receipt, reply to your landlord, or unsubscribe from a newsletter. Jade sorts mail with categories and rules, and your agent sets them up or changes them whenever you ask: put receipts in their own category, or trash junk the moment it arrives.
How to connect
- Claude: Open the Jade listing in the Claude connectors directory and choose Connect. Claude listing Jade exposes 49 tools here.
- ChatGPT: Open the Jade listing in the ChatGPT app directory and choose Connect. ChatGPT listing Jade exposes 52 tools here.
Tools
attach_ruleset_to_inbox
ChatGPTposition for a specific slot. The same ruleset cannot be attached to one inbox twice. inbox accepts a single inbox local part or an array; the response is always { rulesetId, bindings: [...] } with one entry per inbox. Per-inbox failures surface in an error field on the entry without failing the whole call. Prefer the array form over a loop.block_screened_address
ChatGPTcreate_category
ChatGPTname is the user's intended label. The slug (immutable lowercase identifier) is derived from it automatically. Pass a real human name like "Receipts"; the slug becomes "receipts". - The slug must be unique per user. On collision the call errors with both the slug and the existing category's display name so you can tell the user which row blocks the new one. - Names must be non-empty, ≤50 characters, and cannot be the reserved value "everything" (reserved for the unified inbox view). - color is an optional hex string used only for UI display. Omit if the user didn't ask for one. - description is optional free-form text (≤500 chars) the user can read in settings and that future agents will see in list_categories — use it to record the INTENT of the category ("order confirmations from US retailers", "newsletters I might read if I have time") so the right bucket is obvious later. - hidden (optional, default false) suppresses the category from the sidebar, the unified Everything view, the unscoped list_emails view, and get_triage_summary's category lists. Inbox and category pages (and a category-scoped list_emails call) still surface its mail. Use this for buckets the user wants kept out of normal browsing (e.g. a "private" pile fed by inbox rules). - Creating a category does NOT assign any existing emails to it. Use recategorize_* tools afterwards if the user wants historical mail moved. </hints>create_inbox
ChatGPTcreated: false if one already exists. - The new inbox receives on every domain the user owns, gets the default rule set, and skips Screening. - Safe to retry. </hints>create_inbox_rule
ChatGPTposition to drop the rule at a specific slot in one call — the server resolves the intent and renumbers the chain for you. <evaluation_model> - Rules fire in ascending order (lowest first) on every incoming email. - Each matching rule's category/status OVERWRITES the current value. The LAST matching rule wins — so a later "exception" rule can override an earlier "default" rule. - stopProcessing: true halts the chain entirely at the point of the match. No later rules run. The stopProcessing rule's values become final. - bounce, unsubscribe, notify, and forwardTo are side-effect actions that queue async work, not state changes. bounce, unsubscribe, and notify fire every time the rule matches a new email; forwardTo fires once per email per address and never re-sends on reprocessing. - Rules apply to INCOMING mail only. To reclassify existing emails after a rules change, call recategorize_inbox or recategorize_category; use recategorize_emails only when you already have a specific id list. </evaluation_model> <hints> - To build "default category X, except Y → category Z": create the default FIRST at position: {kind: "first"} with always: true → X, then create the override (later in the chain, matching Y → Z). Leave stopProcessing: false on both — the override wins via overwrite, not halting. - To insert a rule between two existing rules, pass position: {kind: "before", ruleId} or {kind: "after", ruleId}. Don't hand-pick an integer; the server handles the math. - The chain is always renumbered to sequential 1..N on every insert or move, matching the settings UI. Don't think of order as a stable integer — think of it as the position in the list. - Set always: true with empty matchText and matchLocation arrays for a catch-all rule. </hints>create_ruleset
ChatGPTcreate_ruleset_rule then attach to inboxes with attach_ruleset_to_inbox. <hints> - name is non-empty, ≤100 chars, unique per user (case-insensitive). - description is optional free-form (≤500 chars). Write one describing the intent ("auto-unsubscribe + mark marketing") so future agents can pick the right ruleset. - isDefault: true marks this as the default ruleset for NEWLY-created inboxes. At most one ruleset can be default; setting this clears any prior default. Existing inboxes are NOT retroactively bound. </hints>create_ruleset_rule
ChatGPTcreate_inbox_rule — the rule fires when the ruleset is attached to an inbox and evaluation reaches its position in the chain.delete_category
ChatGPTrecategorize_category BEFORE delete to shift them to a different bucket. - Deleting a slug that doesn't exist throws "Category not found". </hints>delete_inbox_rule
ChatGPTerrors array without failing the whole call. The inbox chain tolerates gaps — deletions do not renumber surrounding rules.delete_ruleset
ChatGPTlist_rulesets for the ruleCount and use list_inbox_rules on the affected inboxes if you want to confirm the blast radius before calling.delete_ruleset_rule
ChatGPTdetach_ruleset_from_inbox.detach_ruleset_from_inbox
ChatGPTbindingId (from list_inbox_rules — each ruleset entry carries its bindingId). The ruleset itself stays; only this inbox stops using it. Pass an array of bindingIds to detach in one call; per-binding failures surface in the errors array without failing the whole call.forward_email
ChatGPT{queued: true} once the message is queued for sending. <hints> - forwardingEmailId must be an email this user owns (server-side tenant gate; cross-tenant IDs are rejected). - htmlContent is ONLY your covering note (may be empty). In mode: 'inline' (default) the server appends the original message below it as a full-HTML Gmail-format quote — tables, styling, and inline images intact — and re-attaches the original's files (filtered by keepAttachmentSourceIndexes if provided). Do NOT paste the forwarded header or quoted body into htmlContent; that would duplicate them. - mode: 'attachment' packages the original's raw MIME as a single .eml attachment instead. Requires hasRawMime: true from get_email_for_forward. - Forward starts a NEW thread. Do NOT set In-Reply-To / References anywhere. - fromInbox defaults to "the inbox the original landed at" in the web UI but is freely chosen here — must still be an address at a domain the user owns. get_email_for_forward's suggestedFromInbox is a ready-made value. </hints> <routing> USE WHEN: sending an existing email onward to a new recipient. DO NOT USE FOR: replying to the sender (send_email with replyToEmailId), or a fresh email (send_email). </routing>get_email
ChatGPTformat: "html" only if raw markup matters. - maxLength truncates long bodies and appends a truncation marker. Default 20000 chars is usually enough. - includeHeaders: true fetches raw email headers via a second read — only needed for deep analysis. - The attachments array includes a stable index for each attachment. Pass that index to get_email_attachment to download the file — it's the opaque handle, not fileName (which can collide within one email). </hints> <routing> USE WHEN: reading or analyzing an email's contents. DO NOT USE FOR: preparing a reply — call get_email_for_reply instead, which returns the address to reply to and a sendable from inbox ready for send_email. </routing>get_email_attachment
ChatGPTget_email_for_forward
ChatGPToriginalSubject, suggestedSubject ("Fwd: ..."), a Gmail-style forwardedHeader block, the quoted body, the list of originalAttachments (source index, filename, and content type — file references are server-only), and hasRawMime (whether the original can be forwarded as a .eml attachment). - forwardedHeader and quotedContent are CONTEXT for you (so you can describe the message to the user) — do NOT embed them in forward_email's htmlContent. The server appends the original message itself, as full HTML with images intact. - Intended as step 1 of a two-step forward workflow. Follow with forward_email passing forwardingEmailId: originalEmailId, the chosen to recipients, the suggestedSubject, fromInbox: suggestedFromInbox (null means the user has no sending domains), and an htmlContent containing only the covering note (may be empty). - Forward starts a NEW thread — do not pass the source email's threading info anywhere. </hints> <routing> USE WHEN: the user asks to forward an email. DO NOT USE FOR: replying — call get_email_for_reply instead. </routing>get_email_for_reply
ChatGPTreplyTo (the address to reply to, with any display name stripped: the sender for mail you received, the recipients for mail you sent), suggestedSubject ("Re: ..."), suggestedFromInbox (a complete, sendable from address — null when the user has no sending domains), and originalInbox (the local part of the address that received the original). - Intended as step 1 of a two-step reply workflow. Follow with send_email using: to: [replyTo], subject: suggestedSubject, fromInbox: suggestedFromInbox, and replyToEmailId: originalEmailId so the reply threads with the original. - htmlContent on the follow-up send_email is ONLY the reply body you compose. The server appends the quoted original below it — do NOT paste a quote or attribution line yourself; that would duplicate them. - To read the original before composing, call get_email. </hints> <routing> USE WHEN: the user asks to reply to an email. DO NOT USE FOR: just reading an email's body — call get_email instead. </routing>get_ruleset
ChatGPTinbox — the rules apply to whichever inbox is bound to the ruleset. For browsing multiple rulesets, prefer list_rulesets with includeRules: true instead of looping this tool.get_triage_summary
ChatGPTunreadCount still counts their mail. - categoriesWithNew / categoriesWithPinned are category slugs — pass them straight to list_emails' category filter or cross-reference list_categories for display names. - Follow up with list_emails (filter: {kind: "category", slug, status: "new"}) to read what's actually there. </hints> <routing> USE WHEN: the user asks "what's new", "what needs my attention", "catch me up" without naming a specific category or inbox. DO NOT USE FOR: browsing actual emails (list_emails), or the full category listing with descriptions (list_categories). </routing>list_categories
ChatGPTslug is the immutable lowercase identifier — pass it to other tools when referencing a category. displayName is the user-facing label (mutable via update_category). - description is free-form text the user wrote to explain what the category is for. Use it when picking the right category for a rule or recategorize call, since the displayName alone may be ambiguous. - color is a UI-only hex string. hidden: true means the category is suppressed from the sidebar, the unified Everything view, the unscoped list_emails view, and get_triage_summary's category lists; inbox and category pages (and a category-scoped list_emails call) still surface its mail. order is the sort position. </hints> <routing> USE WHEN: resolving category slugs, or choosing the right bucket for a rule action or recategorize call. DO NOT USE FOR: browsing the mail inside a category — call list_emails with a category filter. </routing>list_domains
ChatGPTdomains is exactly the set send_email accepts as the domain half of fromInbox. receiveOnlyDomains lists the free domains provided by Jade. They receive mail at any address and remain receive-only after upgrading. <hints> - Build a fromInbox as <local part>@<one of domains>. list_inboxes returns only local parts. - To give the user an address to hand out, pair a different local part for each sender with a domain from either list, such as netflix@<domain>. - An empty domains array means send, reply, and forward are unavailable. The user can still receive mail. </hints> <routing> USE WHEN: finding the user's free Jade domain, constructing a fromInbox for send_email, checking whether the user can send at all, or telling the user which addresses they can hand out. DO NOT USE FOR: per-sender inboxes (list_inboxes), or the domain a specific email arrived at (the domain field on email results). </routing>list_emails
ChatGPTnew, read, pinned, deleted, or archived). Returns metadata only — use get_email to read the body. <hints> - Filter kinds: {kind: "category", slug: "..."} scopes to a category (pass the slug from list_categories), {kind: "inbox", inbox: "..."} scopes to a single inbox, {kind: "all"} or omitted returns everything except mail in hidden categories (the same rows the web Everything view shows; scope to the category explicitly to read hidden mail). Trash (status: "deleted") and archive (status: "archived") listings include hidden categories, as their web views do. Category and inbox cannot be combined — the underlying indexes serve one or the other, not both. - The inbox value is the LOCAL PART only (e.g., "newsletter"), not the full "newsletter@example.com". Call list_inboxes for exact values. - status is optional on every filter kind. Omit it for the default pinned→new→read stack (what the web UI shows). Pass it to isolate a single status (e.g., status: "new" for unread triage, status: "pinned" for starred, status: "deleted" for trash). - Paginate with cursor from a previous response. hasMore: true signals more pages exist. An unscoped page can come back empty with hasMore: true when hidden categories fill it; keep paging with nextCursor. Cursors are not interchangeable across different filter+status combinations. - Every email in the response includes attachmentCount. Use it to triage "which thread has the PDF" without fetching each body — skip straight to get_email on the emails where attachmentCount > 0. </hints> <routing> USE WHEN: browsing/triaging received emails by category, inbox, or status. DO NOT USE FOR: keyword search across subjects or bodies (call search_emails), sent emails (call list_sent_emails), or reading a body (call get_email). </routing>list_forwarding_addresses
ChatGPTlist_inbox_rules
ChatGPTkind: "rule" (a direct inbox rule) or kind: "ruleset" (a binding to a named ruleset, with its rules nested in order). Items interleave by the shared order namespace. <evaluation_model> At runtime the chain is flattened: each ruleset binding expands in place to its contained rules, then the loop runs in order. stopProcessing on any rule — direct OR inside a ruleset — halts the WHOLE chain. Edit a rule inside a ruleset via update_ruleset_rule and every inbox bound to that ruleset sees the change. </evaluation_model>list_inboxes
ChatGPTinbox field is the local part (e.g., "newsletter" for newsletter@example.com) — the exact value to pass as filter.inbox to list_emails or as inbox to the rule tools. - Power users can have many hundreds of inboxes — this is the central premise of Jade. Returns up to 500 in a single call with a truncated flag; work with the subset you need rather than iterating every result. </hints> <routing> USE WHEN: discovering which per-sender inboxes exist, or resolving an exact inbox value for another tool. DO NOT USE FOR: the user's domains (list_domains), or browsing the mail inside an inbox (list_emails with an inbox filter). </routing>list_rulesets
ChatGPTname, optional description (use it to pick the right ruleset by intent; the name alone is often ambiguous), isDefault flag, and ruleCount. Edits to a ruleset propagate to every inbox it's bound to. Pass includeRules: true to inline each ruleset's full rule list — same shape as get_ruleset. The implementation already fetches rules to compute ruleCount, so this is free data and avoids the N×get_ruleset follow-up loop.list_screened_addresses
ChatGPTlist_screened_emails
ChatGPTlist_sent_emails
ChatGPTlist_signatures
ChatGPTmark_category_read
ChatGPTstatus: "read" instead. </routing>move_inbox_rule
ChatGPT{kind: "first"} — move to the top of the chain (runs first). - {kind: "last"} — move to the bottom of the chain (runs last). - {kind: "up"} — swap with the rule immediately above (no-op if already first). - {kind: "down"} — swap with the rule immediately below (no-op if already last). - {kind: "before", ruleId} — insert immediately before another rule in the same inbox. - {kind: "after", ruleId} — insert immediately after another rule in the same inbox. - Moving a rule to a different inbox is NOT supported — delete and recreate with the new inbox instead. - Returns the full renumbered chain so you can see the updated order on every rule. </hints>move_inbox_ruleset
ChatGPTbefore / after, the bindingId field names another binding in the same inbox. To step past a direct inbox rule, use up / down — the merged chain is renumbered across rules and bindings together. Returns the renumbered list of bindings for this inbox.move_ruleset_rule
ChatGPTprepare_attachment_upload
ChatGPTuploadUrl to send the file to and the attachmentHandle that send_email takes. <hints> - Step 1 of a two-step flow. After this call, HTTP PUT the raw file bytes to uploadUrl with Content-Length: <fileSize> and Content-Type: <contentType>. A body of any other length is rejected. Then pass attachmentHandle in send_email's attachmentHandles. - Use uploadUrl from your own HTTP tooling, for example curl -X PUT --data-binary @file. It expires after expiresIn seconds. The handle is single-use. - Limits: 7 MB per file, 10 files and 7 MB total per email. Executables (.exe, .bat, .cmd, .com, .scr, .pif) are rejected. </hints> <routing> USE WHEN: the user wants to send a file they have, or one you produced, as an email attachment. DO NOT USE FOR: forwarding an existing email's attachments (forward_email carries them server-side), or reading an attachment (get_email_attachment). </routing>recategorize_category
ChatGPTrecategorize_emails
ChatGPTrecategorize_inbox
ChatGPTreorder_categories
ChatGPTlist_categories reflects this. - Pass the COMPLETE set of slugs. Partial reorders aren't supported — call list_categories first if you need the current set. </hints>search_emails
ChatGPTfrom: / to: / cc: / bcc: (address match), subject:, body:, has:attachment, category:, before: / after: / on: (YYYY-MM-DD dates only, e.g. before:2026-03-01), larger: / smaller: (size with k/m suffixes, e.g. larger:500k), and is:read / is:unread. Quoted phrases keep spaces (subject:"order shipped"); prefix a token with - to negate it (-from:noreply). - Everything ANDs together — every operator and free-text word must match. There is no OR; run two searches for disjunction. Unknown foo:bar tokens match as literal text. - Plain free-text queries get fuzzy matching (minor typos still match) and a recency boost. The moment any operator is present, results rank by relevance only. - Subject and inbox terms weigh heaviest in relevance ranking. The first result is the best match, not the newest email. - Archived emails are included in results and carry status: "archived". Deleted emails are filtered out; to look at the trash, use list_emails with status: "deleted" instead. - No pagination cursor — bump limit (max 100) if you need more results. - If search is unavailable or fails, this tool returns an empty array rather than an error — don't infer "no matches" from an empty response without trying a broader query. </hints> <routing> USE WHEN: the user describes what they're looking for in words — a sender, subject keyword, or body phrase — without knowing the inbox/category. DO NOT USE FOR: browsing by category or inbox (call list_emails), or fetching a known email by id (call get_email). </routing>send_email
ChatGPT{queued: true} once the message is queued for sending; Jade normally processes it within seconds. <hints> - fromInbox must be an address at a domain the user owns. The tool independently verifies this against the user's registered domains and will reject other senders with a clear error. If unsure which addresses are valid, call list_inboxes first and use <local-part>@<domain> where the domain appears in other emails' from fields. - For replies, call get_email_for_reply first to get a clean recipient, suggested subject, and a sendable from address, then pass them into this tool along with replyToEmailId so the reply threads with the original. When replyToEmailId is set, htmlContent is ONLY your reply body — the server appends the quoted original below it. - textContent is optional — if omitted, the server derives plain text from htmlContent. - Attachments: call prepare_attachment_upload for each file, PUT the bytes to its uploadUrl, then pass the handles in attachmentHandles. Limits: 7 MB per file, 10 files and 7 MB total per email. If any handle is unknown, expired, or already used, nothing is sent. - Delivery failures are not reported back through this tool — confirm via list_sent_emails, which shows the message once the mail provider accepts it. Recorded there means accepted for delivery, not that the recipient received it. </hints> <routing> USE WHEN: sending a fresh email or a reply (with replyToEmailId). DO NOT USE FOR: forwarding an existing email — call forward_email, which carries the original content and attachments server-side. </routing>set_domain_screening
ChatGPTset_email_expiration
ChatGPTdays is counted from NOW, not from when the email was received. This is the manual-control counterpart to the rule deleteAfterDays action (which measures from the email's receipt timestamp). - Pass days: null to REMOVE an existing expiration so the email is never auto-deleted — including expirations originally set by an inbox rule. - days accepts 1–3650. Re-running with a new days reschedules from now (it does not add to the existing date). - Whether an email currently has an expiration is visible as expiresAt (ISO 8601, or null) on every list_emails / search_emails / get_email result. - Reading or pinning an email leaves a schedule intact; soft-deleting it (set_email_status → "deleted") replaces any schedule with the standard 30-day trash-retention TTL. - Accepts a single emailId or an array (up to 500). Per-email failures surface in errors without failing the whole call. </hints> <routing> USE WHEN: the user wants to auto-delete specific emails after a while, or wants to cancel a scheduled deletion on specific emails. DO NOT USE FOR: auto-expiring all future mail to an inbox — set a deleteAfterDays action on an inbox rule (create_inbox_rule) instead. For an immediate (not scheduled) delete, use set_email_status with status "deleted". </routing>set_email_status
ChatGPTnoChange. <hints> - status: 'pinned' moves the email to the pinned shelf regardless of its prior state. To unpin, set status: 'read' — pinned → read applies as an intentional unpin. - status: 'deleted' is a soft delete — restore the email by setting it to 'new'; setting it to 'read' intentionally leaves deleted mail untouched. - When status: 'read', deleted and archived emails are left untouched and reported in noChange so a bulk mark-as-read can't accidentally resurrect them. To pull a deleted/archived email back into the primary view, use 'new' instead. - status: 'new' resurrects a deleted/archived email back into the primary view. - Missing email ids surface per-email in the errors array; they do not fail the whole call. </hints> <routing> USE WHEN: changing email status by id list for any target state. DO NOT USE FOR: clearing an entire category by name — call mark_category_read instead (one call, no id list required). </routing>set_signature
ChatGPTunsubscribe_email
ChatGPTerrors array without failing the whole call. Prefer one batch call over a loop. - Dedup is per-email, not per-sender: each email queues its own attempt, and future mail from the same sender is unaffected. To unsubscribe on every future arrival, set unsubscribe: true on an inbox rule instead. - queued means the attempt was accepted for processing, not that the sender honored it. Emails without unsubscribe information fail silently at processing time. </hints> <routing> USE WHEN: the user wants off a mailing list represented by specific received emails. DO NOT USE FOR: recurring auto-unsubscribe on an inbox (create_inbox_rule with action.unsubscribe), or making mail stop arriving in Jade views (set_email_status or a rule with status: "deleted"). </routing>update_category
ChatGPTdisplayName, color, description: pass an empty string ("") to CLEAR, or a value to set. displayName clearing falls back to a capitalized form of the slug. - For hidden: pass true to suppress from the sidebar, the Everything view, the unscoped list_emails view, and get_triage_summary's category lists; false to make visible again. Inbox and category pages (and a category-scoped list_emails call) always surface the mail regardless. - Renaming a category is just update_category({ slug, displayName: "New Name" }). The slug never changes, so URLs and rule action targets keep working without any data rewrite. </hints>update_inbox
ChatGPTinbox is the local part, not the full address. - Pass senderName: null to clear it. - Safe to retry. </hints>update_inbox_rule
ChatGPTruleId plus any subset of matchText, matchLocation, always, action, or stopProcessing. The rule's id and inbox are immutable — to move a rule to a different inbox, delete it and recreate. To reorder a rule within its inbox, use move_inbox_rule instead — this tool intentionally does NOT accept order, because raw integer ordering is an implementation detail the MCP surface hides from callers. <hints> - Updating action changes only the fields you send. Omitted fields stay unchanged; pass null for a field to remove that action. </hints>update_ruleset
ChatGPTdescription: "" to CLEAR it; pass isDefault: true to make this the default (clearing any prior default); isDefault: false unmarks without promoting a new default.update_ruleset_rule
ChatGPTruleId plus any subset of matchText, matchLocation, always, action, or stopProcessing. Within action, omitted fields stay unchanged; pass null for a field to remove that action. The change applies to every inbox bound to the ruleset. Use move_ruleset_rule to reorder within the ruleset.allow_screened_address
Claudeattach_ruleset_to_inbox
Claudeblock_screened_address
Claudecreate_category
Claudecreate_inbox
Claudecreate_inbox_rule
Claudecreate_ruleset
Claudecreate_ruleset_rule
Claudedelete_category
Claudedelete_inbox_rule
Claudedelete_ruleset
Claudedelete_ruleset_rule
Claudedetach_ruleset_from_inbox
Claudeforward_email
Claudeget_email
Claudeget_email_attachment
Claudeget_email_for_forward
Claudeget_email_for_reply
Claudeget_ruleset
Claudeget_triage_summary
Claudelist_categories
Claudelist_domains
Claudelist_emails
Claudelist_forwarding_addresses
Claudelist_inbox_rules
Claudelist_inboxes
Claudelist_rulesets
Claudelist_screened_addresses
Claudelist_screened_emails
Claudelist_sent_emails
Claudemark_category_read
Claudemove_inbox_rule
Claudemove_inbox_ruleset
Claudemove_ruleset_rule
Claudeprepare_attachment_upload
Clauderecategorize_category
Clauderecategorize_emails
Clauderecategorize_inbox
Claudereorder_categories
Claudesearch_emails
Claudesend_email
Claudeset_domain_screening
Claudeset_email_expiration
Claudeset_email_status
Claudeunsubscribe_email
Claudeupdate_category
Claudeupdate_inbox_rule
Claudeupdate_ruleset
Claudeupdate_ruleset_rule
ClaudeLinks
Similar Apps
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/jade"><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
[](https://mcp-app-store.keenethics-labs.com/app/jade)






