MCP App Store
by KeenEthics
Frexy icon

Frexy MCP Server for ChatGPT

By Frexy

Overview

Describe the website you want and ChatGPT builds it with Frexy, starting from a design you choose. Ask for changes in your own words, check each one on a private preview link, and publish to a live address when you are happy with it. Add a contact or booking form and see how many people used it.

How to connect

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

Tools

add_image

ChatGPT
Adds the person's own picture — a logo, a photo, an icon — to this project's library and returns the URL to use. Exactly one of: file (a picture they attached in ChatGPT), url (a picture already on a public website, e.g. the logo on their current site), or svg (SVG markup). A file that is only on their computer comes in with request_upload, and stock photographs with search_images and import_image. Not for a screenshot or mockup of a website or page: that is refused here and in write_files, because it is the site's reference, which capture_reference keeps, and it is never placed on the site, whole or in part. With use "logo", Frexy also puts it in the site as the logo: in the header's link home, in place of the name, and in Settings as the business's logo.

add_page

ChatGPT
Writes the design the person chose (from show_designs) into the site as a new page, between the site's own header and footer and in its colours; the result's instruction says how to finish it. On an empty site a home design (kind "site") becomes the home page. name and path are the ones the person gave, if they gave any; request is the person's own words about the page. A page already at that address is kept as it is.

capture_reference

ChatGPT
Keeps what the person wants their site to look like as the project's reference: a website they name, or a picture of one they attached. url: Frexy opens the website the way a visitor sees it — it plays, scrolls and is measured at six widths — and returns the measured kit as text (colours with roles, fonts and their licences, the type scale, sections, where the layout changes, every picture and what it is for, libraries, each WebGL scene's technique and inputs, motion with spring and easing numbers) and the first screens as pictures; it takes up to a minute. file: a picture they attached of a website, a page or a design (a screenshot or a mockup), kept as the reference to build from. Reading a page as text gives its words, not its look. A reference is a look to build from: its text, pictures and logos belong to the other site.

claim_change

ChatGPT
Takes a pending change request so no one else works on it, and marks it as being worked on, which the person sees in Studio. Exactly one caller's claim succeeds: if another agent claimed it first, this fails with a conflict. A request that is already being worked on is never handed to a second agent.

complete_change

ChatGPT
Reports the outcome of a change request the agent claimed: status 'completed' once the source is written and a preview is deployed, with a one-line summary of what changed, or 'failed' with a short reason. A request claimed with an agentId is completed with that same agentId. Completion records that the work is finished; the person reviews the preview and decides whether it is what they wanted.

create_collection

ChatGPT
Create a CMS collection. Its structure is yours: any fields (or none — records may then hold any JSON keys), with types from the list, json for anything structured, and reference to relate records across collections by slug. Creating a collection writes no source: the site reads published records from Frexy's content endpoint (see get_development_standards with topics ["cms"]).

create_form

ChatGPT
Create a form: Frexy gives it an endpoint, checks what arrives and stores it. Writes no source: then build the form in the site with write_files. The result's rules say how to build its markup and submit it; follow them for every form. Do not collect passwords or payment card numbers. set_form_email sets the emails it sends.

create_project

ChatGPT
Creates a new Frexy project: a static website whose files under public/ are served exactly as written (public/index.html is the home page). The site's structure, design, content and code are the agent's to make; Frexy stores, builds, previews and deploys it. One project per website, written with write_files and previewed with deploy_preview; get_project_context describes it and its constraints. workspaceId puts it in one of the person's workspaces (list_workspaces). A new website starts from a site or picture the person gave to look like (the project is created, then capture_reference keeps it), or from Frexy's designs they chose in show_designs: starter for a whole site (kind "site"), or designs for one design of each kind of page (kinds), with their colours; choice, alone, builds what they chose on Frexy's page (show_designs' choose) with their details and colours. Created without either, the result's next lists the steps before anything is written.

create_record

ChatGPT
Adds a record to a collection, as a draft: set_record_status with published puts it on the live site. Declared fields are checked against their types; any other keys are stored as JSON. An image field holds a Frexy asset id from import_image.

deploy_preview

ChatGPT
Builds and deploys the current project to its isolated preview environment, where the person reviews it at the preview URL. One preview per finished set of changes — after the last write_files of a request, not after each one — and before publishing. A static site is packaged without running anything, usually in seconds. Returns a deployment to poll with get_deployment; a build for identical source joins the one already running rather than starting a second. Once the preview is ready Frexy opens its pages in a browser at 390 and 320 pixels wide, and get_deployment answers with fit (site.responsive).

deploy_production

ChatGPT
Publishes the current project to production — the live URL visitors see. Returns a deployment to poll with get_deployment. Publishes the whole site, or with pages only those pages, leaving every other page exactly as it is live. Refused while the pages show pictures from other websites: a Frexy site shows only pictures from Frexy's CDN, brought in with search_images and import_image, or add_image.

get_change_request

ChatGPT
Read one change request in full: the person's request in their own words, the page and element they pointed at with its source file and line, the project's state, the infrastructure constraints and the platform requirements that apply. How to implement it is yours to decide. Read the current files with read_file before editing, and claim the request before you modify anything. This changes nothing on its own.

get_deployment

ChatGPT
Check a deployment, waiting up to 25 seconds for it to finish; one still running is checked again. Status is queued, building, ready, failed or cancelled; a ready deployment carries the URL to give the person: the live site, or its preview. A failed one says why: kind source means fix the project and redeploy (the diagnostics name the problem), infrastructure means retry unchanged, unsupported means the project asks for something this Frexy deployment does not run. sourceDrifted means the source changed between requesting the build and running it. A ready preview carries changes: each page it changed since the previous preview, with that page's preview URL. Give the person the URL of the page you changed (not only the home page), then show it with open_site_preview and that page's path. A ready preview you deployed also carries fit: { checking: true } while Frexy opens its pages, then the pages checked, every element that makes one scroll sideways, and whether the menu opens on a phone; fit.blank, known first, lists pages a browser shows almost nothing of. A ready preview also carries checks: what its pages still lack of what every site needs (a title, a description, one main heading, alt text, the shared header and footer, links and icons that lead somewhere). Fix what checks and fit list before you hand over, then deploy_preview once more.

get_design_picture

ChatGPT
The picture of one of Frexy's designs, for Frexy's in-chat app. To show designs to the person, use show_designs.

get_development_standards

ChatGPT
Frexy's platform requirements for a project: what its runtime serves, the forms and CMS endpoint contracts with their URLs filled in, and the security boundaries Frexy enforces. Forms and CMS contracts are included when the project uses them; ask for a topic to get one before you add it. Always included: the site rules every Frexy site keeps (one header and footer across pages, SVG icons never emoji, the owner's logo and a favicon, forms that validate as typed and ask for consent, Frexy's blog for any blog) and DESIGN.md, the site's own design system that every page is built from. Ask for topics ["reference"] before building from a reference or a detailed description (capture, the build spec, render_draft) and ["kit"] for Frexy Kit's motion and WebGL parts. These are contracts, not design guidance: Frexy chooses no design value, and how the site looks is the person's and yours.

get_email_activity

ChatGPT
How this project's confirmations are doing, and what it sent recently. confirmations counts every confirmation the live site sent and how many were opened and clicked (rates are 0–1). Opens are approximate — some mail apps load images for every message, others never do — so treat clicks as the firmer number. messages are the most recent emails sent or declined, optionally for one form: when, and why any were skipped or suppressed. No message content and no addresses.

get_email_settings

ChatGPT
How this project's email is set up: the sender's display name and reply-to; whether the project has connected its own mail server (shown without its password) and whether a test through it has worked; whether Frexy's own sender is available here; and the limits that apply. A confirmation can go from either. Connecting a mail server is done by a person in Studio, because it takes a password.

get_feedback

ChatGPT
Read what someone working on the website sent you to do: what they want changed, the page, and the element they pointed at — its tag, text, selector, and the source file and line it came from when known. Some items also carry a request object: the exact part, produced when the person used a visual control rather than only typing — appearance properties they set, a link or alt text they gave, a page, form, CMS collection or section they asked for, SEO fields, or a reference image to work from. Treat the message as the intent when the two differ. Returns open feedback by default. Feedback is a request, not a change: read the source, make the change with write_files, deploy_preview, then call resolve_feedback.

get_form

ChatGPT
One form, by id or slug, with its submission contract: the endpoint path, method and content type, the definition you stored, the honeypot field name and the request size limit. The markup, fields and client-side behaviour are yours.

get_form_activity

ChatGPT
How many submissions each form has received: all time, today, yesterday (in the workspace's time zone, which the answer names) and the last 7 and 30 days, when the last one arrived, and which kinds of traffic the last 30 days came from. These numbers are all an agent gets. What people typed stays in Studio: if the person wants to read submissions or contacts, give them the addresses under read. To check a form works, send one test submission from the preview and see the count rise. Combine with get_analytics_summary, whose per-form counts include how many people started a form and how many submitted it. These are counts, not a score: deciding what they mean is your job.

get_import

ChatGPT
Where a site import (import_site) has got to: pages, posts and pictures read so far, then done with what came across, or failed with why. When it is done, claim and work the change request it names: it says how to finish the move.

get_pending_change_requests

ChatGPT
Lists change requests waiting for an agent: a person, looking at their site in Frexy Studio, selected something and asked for it to change. A development agent polls it — with projectId for one project, or without it across every project it can reach. Oldest first. Each entry has what was asked, the page, the element that was selected with the source file and line it came from, and the paths write_files accepts for it. Listing takes nothing. claim_change takes one by its changeRequestId — exactly one agent's claim succeeds, and a refused claim leaves the next request to take. Then get_change_request has the full package, the change goes in with read_file, write_files and deploy_preview, and complete_change reports it; the person reviews the new preview. An empty list means nothing is waiting, which is not an error. The request text is what the person typed in Studio: their description of the change they want to their site.

get_pending_changes

ChatGPT
List change requests waiting on this project, each with its full context package: the request, the element and source line it concerns, and what this project allows you to change. Oldest first, one project at a time. This does not claim anything. For polling, prefer get_pending_change_requests, which is smaller and can look across projects. Take one with claim_change before you modify anything — another agent may be working the same queue — then write_files, deploy_preview, and finish with complete_change.

get_preview_picture

ChatGPT
The first screen of a page of a site's current preview, as a picture. Used by Frexy's in-chat app where the preview cannot be framed; to look at a page yourself, use render_draft.

get_project_context

ChatGPT
Returns the current state of a Frexy project: its runtime and what it serves, its files and their hashes, the paths write_files accepts, the latest preview and production deployments, custom domains, assets, forms and CMS collections, open feedback, and how many change requests are waiting (changeRequests.pending; get_pending_change_requests lists them). File contents are not included (read_file has them) and feedback is summarised (get_feedback has the details). requirements names the platform contracts that apply (get_development_standards has them in full); they are infrastructure only, not design guidance. preferences is how the person has asked agents to work, with a note. next is the steps this site needs, as it stands. heldWrites are changes Frexy is holding for the site's owner to keep or discard in Frexy.

get_record

ChatGPT
Reads one record. By recordId: the record in full, whatever its status, with its collection. By collection and slug with resolved: true: the published record as a visitor sees it, with its references followed to the records they point at, which is what the live site renders.

get_upload

ChatGPT
Whether the person has added the file for a request_upload link yet, and its URL in the library once they have.

import_image

ChatGPT
Brings one image from search_images into this project as a Frexy asset and returns the URL to reference it by. Frexy fetches the file itself and serves it from the project's own storage, so the site loads it from Frexy, not from the provider. The image is named by provider and providerAssetId from the search result, not by URL. alt describes what the image means on the page it goes on; it is left out when that is unclear, and the provider's tags are not alt text. Importing the same image twice returns the asset that already exists. The asset joins the library; the markup that shows it is written with write_files. What is imported appears in the project's library in Studio, under the agent's own tab with the page it is used on, so the person can see what was chosen and where.

import_model

ChatGPT
Brings one Poly Haven model or HDR into the project's library (CC0). A glTF arrives as one .gltf URL whose parts are already on Frexy, for Frexy Kit's data-model; an HDR is for data-env (get_development_standards topics ["kit"]).

import_site

ChatGPT
Moves a website the person already has — on Wix, Squarespace, Framer, Webflow, WordPress or anywhere else — into a new Frexy project, from its web address. Frexy copies the content exactly (pages at the same addresses, posts, pictures, menus, forms, contact details) and writes a plain first draft; the design is rebuilt, not copied. Shops, carts and member areas do not come across. Without start, it counts the pages and groups them (pages, blog, team…) and imports nothing. start: true imports, with owner: true — the person's word that the site is their own or one they manage for its owner — and, for a group of more than 50, which of all, latest (the newest 50) or none to bring. It returns the new project; get_import follows it.

list_collections

ChatGPT
List this project's CMS collections with their field definitions. Changing a published record needs no preview: Frexy republishes the live site's content by itself. Start here before reading or writing records.

list_forms

ChatGPT
List this project's forms: their definitions (fields and config as you stored them) and their status. A form's definition is data — changing it needs no deployment. Start here before reading submissions.

list_projects

ChatGPT
List the websites in a Frexy workspace: each project's id, name and slug, when it last changed, and its preview and live URLs where it has them. Use it to find the projectId for the site the person means before calling get_project_context.

list_records

ChatGPT
List a collection's records. Filter by status to see what is published, what is still a draft and what has been archived — only published records appear on the live site. Each record carries a version; pass it back as expectedVersion when you update, so you are told rather than silently overwriting someone who edited it after you read it.

list_workspaces

ChatGPT
List the Frexy workspaces this connection can reach: each one's id and name, and the person's role in it. A workspace holds its own sites, people and monthly agent counts. Use it when the person has more than one, then pass workspaceId to create_project or list_projects. Tools given a projectId need no workspace.

open_frexy

ChatGPT
Open Frexy's site manager for the person: every site in their account, with its preview, live address, open feedback and buttons to deploy a preview or publish. Use it when they want to see or manage their sites; it returns the same list as list_projects.

open_in_studio

ChatGPT
A one-time address that opens a site in Frexy Studio inside Frexy's card in ChatGPT, signed in. Used by Frexy's in-chat app only; to show a site to the person, use open_site_preview.

open_site_preview

ChatGPT
Shows a Frexy site's preview to the person inside the conversation, with its open feedback and a button to deploy a fresh preview — after deploy_preview, so they review the change without leaving the chat. path is the page that changed (get_deployment's changes) and focus the part of it that changed. Returns the page's url, given to the person as a link, and where it can a picture of the page from Frexy. Without a projectId it opens the most recently changed site; without a path, the page the newest preview changed.

open_studio

ChatGPT
Opens a Frexy site in Frexy Studio, full screen in this conversation: the person sees every page, taps the part they want changed and says what to change, and their request arrives here as their own message. Use it when they ask to open Studio, or to see and edit their site themselves. Without a projectId it opens the most recently changed site. Do not also call open_site_preview.

read_file

ChatGPT
Read one source file from a Frexy project, or the lines you name. Paths come from get_project_context, which also lists DESIGN.md's sections with their lines. For a small change, find the place with search_files and read only those lines. Generated and build output directories are not readable.

read_settings

ChatGPT
Read how the person has asked agents to work on their Frexy sites. get_project_context already includes these as preferences, so an agent rarely needs this.

render_draft

ChatGPT
See what you are about to build before writing it. Renders the project with these files (the same shape as write_files) in a real browser, without saving or deploying anything, and returns pictures at desktop and mobile size and what was measured. With referenceId it compares with that captured reference and lists every difference naming both sides ("display: reference 96px Oswald, yours 56px Inter"), with the reference's screens beside yours. It also opens the page at 390 and 320 pixels wide and lists in fit every element that makes it scroll sideways. Use it before every write_files that builds or restyles pages; fix what differs and every fit problem, and render again, up to three rounds.

request_upload

ChatGPT
Returns a link where the person adds a picture from their own computer to this project's library: a logo or photo they want on the site, as a file the conversation cannot pass on. The link works once, for an hour. When they have added it, get_upload returns the picture's URL.

resolve_feedback

ChatGPT
Marks a feedback item resolved, once the change it asked for is made and deployed to preview. It records that the request was dealt with; the change itself is made with write_files and deploy_preview.

review_copy

ChatGPT
The editorial pass: review how a page, a post or any copy reads before anyone previews it. Pass project paths (an HTML page is read as a visitor sees it, a Markdown post as its prose) and/or text (a record field, a form message, an email). Returns, per item, stock phrasing, em-dash density, repeated "not just X, but Y", uniform sentence length and repeated openers, plus every sentence stating a figure, finding or quote, and the brief to revise against. Frexy suggests no wording: revise the copy yourself with write_files or update_record, then review again.

rollback

ChatGPT
Put a previous production deployment back on the live URL. Nothing is rebuilt and the project's source is left exactly as it is, so the source and the live site will differ until you deploy again. Only a production deployment that actually served traffic can be a target.

search_files

ChatGPT
Find text in a Frexy project's source files, e.g. a class name, a colour or a heading's words. Returns each matching line with its path and line number, so you can read just those lines or change them with edits in write_files. Case-insensitive, exact text (not a pattern).

search_images

ChatGPT
Searches stock imagery for this site. Returns candidates — an id, a preview URL, dimensions, an aspect ratio and a few tags — and downloads nothing. The query is the words that describe the picture ("minimal concrete stairwell, low light"). import_image brings a chosen one into the project; a preview URL is only for looking at, and the site uses the URL import_image returns. An unlucky query returns no results; a Frexy deployment without image search returns a clear failure — those are different things.

search_models

ChatGPT
Search open-licence 3D models (kind "model", glTF) or HDR lighting environments (kind "hdri") from Poly Haven, all CC0. Returns candidates with a preview picture URL and downloads nothing; bring the one you choose in with import_model.

send_test_email

ChatGPT
Send one test of a form's email to the signed-in person's own address — never to anybody else — with sample values. Defaults to the confirmation.

set_form_email

ChatGPT
Set what a form sends when it is submitted: notification goes to the project's owners on every submission, confirmation to the person who submitted, when the form asks for an email address. Sending happens after the submission is stored, never instead of it. The result lists the merge tags.

set_record_status

ChatGPT
Publishes, unpublishes or archives a record. Publishing re-validates it first, so a record missing a required field is refused rather than published broken, and then puts it on the live site with a content publish, normally within a minute; unpublishing and archiving take it off the same way, without deleting it. publish.deploymentId is a deployment to poll with get_deployment; the record is live once that is ready. Publishing changes what visitors see.

show_designs

ChatGPT
Shows the person Frexy's finished designs to choose from, before building: for a new site or a new page. kind "site" for a whole website to start from (create_project with starter), or a page type for a new page: pricing, about, services, contact, faq, testimonials, team, products, careers, events, case-studies, projects, landing, privacy, terms, cookies, refunds, not-found, thank-you. Each design comes numbered and named, with Frexy's own picture of it; the result holds only Frexy's designs. The design the person picks goes to add_page by its id (on an empty site, the home design makes its first page). For a whole site page by page, kinds: ["home", "about", "pricing", "contact", …] shows designs of each kind; the person picks at most one of each, and their picks go to create_project as designs (start_site for a site that is still empty).

start_site

ChatGPT
Start a site that is still empty from what the person chose in show_designs: a starter (kind "site") or one design of each kind of page (kinds), or the choice they made on Frexy's page (choice). Frexy writes the whole site, with one header and footer, its contact form and its pages; the result's instruction says how to finish it. For a new site, create_project does the same in one step.

update_collection

ChatGPT
Change a collection's name, description or fields. The slug cannot change — it is the address records are reached by, and every route and reference depends on it. Removing a field does not delete what records already hold in it; adding a required field means existing records cannot be published until they have it.

update_email_settings

ChatGPT
Set how this project's email presents itself: the sender's display name and the reply-to address. Ask the person for a real reply-to address; never invent one.

update_form

ChatGPT
Change a form's name, description, fields, config or status. Only an active form accepts submissions. The slug cannot change. Send the version you read as expectedVersion so a concurrent edit is reported, not overwritten.

update_record

ChatGPT
Replaces a record's field values: the record holds exactly the fields sent — a replacement, not a merge. With expectedVersion from when it was read, a save someone made in between comes back as a conflict instead of being overwritten. Updating a published record puts the change on the live site with a content publish, normally within a minute: publish.deploymentId is a deployment to poll with get_deployment until it is ready (or failed, with the reason); the change is live once it is ready. Before the site's first publish there is nothing live to update (publish.state not_published).

update_settings

ChatGPT
Changes how the person has asked agents to work on their Frexy sites, as read_settings shows it: each field given replaces its value and the rest stay as they are.

view_reference

ChatGPT
Look at a reference: its pictures, and for a measured one (capture_reference) its kit. section (1-based, from the kit's list) shows the screens covering one section; viewport "mobile" the phone layout. A reference shows the look to match; nothing on it may be copied into the site.

write_files

ChatGPT
Writes, updates or deletes website source files in a Frexy project. All files in one call are applied together or not at all, as a single version. On a static project the site is public/, served as written — any HTML, CSS, JavaScript, SVG or other text a browser uses. Writable paths are public/, content/ (the shared header and footer are content/partials/), src/, DESIGN.md and frexy.config.json; Frexy's own files (astro.config.mjs, package.json, tsconfig.json, .frexy/, build output) are refused, as is public/_frexy/. Content is text; binary assets come from import_image or Studio uploads. Limits: 200 files, 1 MiB per file, 10 MiB per call. edits change part of a file that exists: far quicker than sending the whole file, and applied to the file as it is now, so they keep somebody else's change. A conflict names the files that changed (details.changed); the other files can be sent again unchanged. A write that would strip a page (losing the site's header or footer, most of its text, or leaving only pictures) comes back held, not applied: held says what it would remove, and held.approveUrl is where the site's owner keeps or discards it in Frexy. warnings lists links, #sections and icons that lead nowhere yet (expected mid-build, fixed before hand-over), text characters used as icons and pictures loaded from other websites. A blank site starts from a design the person chose (show_designs, then start_site) or a reference they gave (capture_reference), not from a page of the agent's own.

Capabilities

WritesInteractive

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