picked 0.0.101-next.2 → 0.0.101

package/docs/how-to/authenticate-with-oauth.md

@@ -0,0 +1,49 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to authenticate with OAuth
+
+This guide shows you how to sign a user in through Google.
+
+## 1. Get the authorization URL
+
+```graphql
+mutation {
+  oauthAuthorize(input: {
+    provider: GOOGLE
+    redirectUrl: "https://app.example.com/auth/callback"
+    scopes: ["openid", "email", "profile"]
+  }) {
+    url
+  }
+}
+```
+
+## 2. Send the user to that URL
+
+Google authenticates the user and sends them back with a `code` parameter.
+
+## 3. Exchange the code
+
+```graphql
+mutation {
+  oauthCallback(input: { provider: GOOGLE, code: "auth-code-from-google" }) {
+    session { accessToken refreshToken expiresAt }
+  }
+}
+```
+
+## API and MCP
+
+You can also do this task with the [Management API](/reference/management-api/schema), the [MCP server](/reference/tools/mcp), or code that you send to [`picked_run`](/reference/tools/mcp-run).
+
+| Task | GraphQL | MCP tool | Run |
+| --- | --- | --- | --- |
+| Get the authorization URL | [`oauthAuthorize`](/reference/management-api/schema/auth#oauthauthorize) | None | None |
+| Exchange the code | [`oauthCallback`](/reference/management-api/schema/auth#oauthcallback) | None | None |
+
+## Related
+
+- [Authentication](/reference/management-api/authentication) — every mutation.

package/docs/how-to/build-a-flow.md

@@ -0,0 +1,106 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to build a flow
+
+This guide shows you how to put a flow together on the canvas. You need an experience
+first. See [How to create an experience](/how-to/create-an-experience).
+
+## Add nodes
+
+Drag a step, an action, or a condition from the library onto the canvas. A new
+node appears where you drop it.
+
+You can also drop a block directly onto an arrow that is there already. The flow
+builder puts the node into the line. The first arrow splits into two arrows, with the
+new node between them. A **+** indicator appears when you hold the pointer over a
+valid arrow.
+
+## Connect nodes
+
+Click the output handle of a node, on the right side. Drag to the input handle of
+another node, on the left side. An arrow then joins the two nodes.
+
+The flow follows the arrows from left to right, and it starts at the origin. Every
+node after the origin is part of the experience flow.
+
+## Branch with conditions
+
+Connect the origin, or any other node, to a condition node. The condition evaluates
+its rule and sends the flow down one of two paths.
+
+Connect the green handle, for a true result, to the nodes that must run when the
+condition holds. Connect the red handle, for a false result, to the other path. Each
+path can lead to more steps, more actions, and more conditions.
+
+## Assign fields to steps
+
+Drag a field from the library onto a step node and drop it. That step then
+holds the field.
+
+You can assign more than one field to one step. The step node gives the number of
+assigned fields. To see which fields it holds, choose the step. Then read the **Fields**
+section in the inspector.
+
+## Choose nodes
+
+Click a node to choose it. Its inspector opens in the right panel.
+
+Drag on empty canvas to choose every node inside a rectangle. Press `Cmd/Ctrl+A` to
+choose every node.
+
+When you choose more than one node, the inspector gives a count and a list in groups.
+Click an item in that list to open its inspector.
+
+## Move nodes
+
+Drag a node to move it. Each node snaps to the grid.
+
+Use the arrow keys to move a node a small distance. Hold `Shift` to move it further.
+
+## Delete nodes
+
+Choose one or more nodes. Press `Delete` or `Backspace`. The flow builder removes
+those nodes and every arrow that joins them.
+
+## Duplicate nodes
+
+Choose one or more nodes. Press `Cmd/Ctrl+D`. A copy of each node appears next to the
+first one.
+
+## Undo and redo
+
+Press `Cmd/Ctrl+Z` to undo. Press `Cmd/Ctrl+Shift+Z` to redo. You can also use the two
+buttons at the bottom left of the canvas.
+
+The flow builder records each change that you make to the flow. This includes each node
+that you add or delete, each connection, each move, and each change in the inspector.
+Text that you type into one field with no stop of more than one second is one change.
+
+When the cursor is in a text field, `Cmd/Ctrl+Z` undoes the text in that field. When you
+save the flow or discard your changes, the flow builder starts a new record.
+
+You cannot undo the delete of a step, an action, a condition, or a field from the
+workspace. The flow builder removes it from each change in the record.
+
+## API and MCP
+
+You can also do this task with the [Management API](/reference/management-api/schema), the [MCP server](/reference/tools/mcp), or code that you send to [`picked_run`](/reference/tools/mcp-run).
+
+| Task | GraphQL | MCP tool | Run |
+| --- | --- | --- | --- |
+| Add a node | [`experienceFlowUpdate`](/reference/management-api/schema/experience#experienceflowupdate) | [`update_experience_flow`](/reference/tools/mcp#update_experience_flow) | `tools.update_experience_flow({ experience_id, workspace_id, create_nodes })` |
+| Connect two nodes | [`experienceFlowUpdate`](/reference/management-api/schema/experience#experienceflowupdate) | [`update_experience_flow`](/reference/tools/mcp#update_experience_flow) | `tools.update_experience_flow({ experience_id, workspace_id, create_edges })` |
+| Connect the true path and the false path of a condition | [`experienceFlowUpdate`](/reference/management-api/schema/experience#experienceflowupdate) | [`update_experience_flow`](/reference/tools/mcp#update_experience_flow) | `tools.update_experience_flow({ experience_id, workspace_id, create_edges })` |
+| Assign fields to a step | [`stepUpdate`](/reference/management-api/schema/step#stepupdate), [`experienceFlowUpdate`](/reference/management-api/schema/experience#experienceflowupdate) | [`update_experience_flow`](/reference/tools/mcp#update_experience_flow) | `tools.update_experience_flow({ experience_id, workspace_id, update_steps })` |
+| Move a node | [`experienceFlowUpdate`](/reference/management-api/schema/experience#experienceflowupdate) | [`update_experience_flow`](/reference/tools/mcp#update_experience_flow) | `tools.update_experience_flow({ experience_id, workspace_id, update_nodes })` |
+| Delete a node | [`experienceFlowUpdate`](/reference/management-api/schema/experience#experienceflowupdate) | [`update_experience_flow`](/reference/tools/mcp#update_experience_flow) | `tools.update_experience_flow({ experience_id, workspace_id, delete_node_ids })` |
+
+## Related
+
+- [Canvas](/reference/dashboard/flow-builder/canvas) — the panels and the view controls.
+- [Nodes](/reference/dashboard/flow-builder/nodes) — every node type.
+- [Keyboard shortcuts](/reference/dashboard/flow-builder/keyboard-shortcuts)
+- [About how Picked works](/explanation/how-picked-works) — why a flow is a graph.

package/docs/how-to/call-an-external-api-from-a-workflow.md

@@ -0,0 +1,116 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to call an external API from a workflow
+
+This guide shows you how to make a workflow send a request to a system outside Picked.
+It also shows you how to read the answer in a later node.
+
+A workflow can only call an origin that you register first. An origin is the scheme, the
+host and the optional port of an address, such as `https://api.vendor.test`. When you
+register one, every path on it becomes available to the workflow.
+
+## 1. Register the external API
+
+1. Open **Integrations**.
+2. Choose **Configure external APIs**.
+3. Choose **New external API**.
+4. Enter a **Display name**. This name is for you. Picked does not send it with the
+   request.
+5. Enter the **Origin**, such as `https://api.vendor.test`. Do not enter a path, a query
+   or a fragment.
+6. If the API needs an authorization header, set **Credential** to **Authorization
+   header**.
+7. Enter the header name and its value.
+8. Choose **Register external API**.
+
+For an API whose access tokens expire, refer to
+[How to register an API that uses OAuth2](/how-to/register-an-api-that-uses-oauth2).
+
+The header value is write-only. After you save it, Picked shows only the header name and
+a mask. To replace the value, choose **Rotate authorization header**.
+
+## 2. Add an External API node
+
+1. Open the workflow.
+2. Choose **Add node**.
+3. Choose **Add tool**.
+4. Choose **External API**.
+5. Set `method` to the request method, such as `GET` or `POST`.
+6. Set `url` to the full address, such as `https://api.vendor.test/v1/orders`. Picked
+   lists the origins you registered below the field.
+7. For a `POST` or a `PUT`, set `body` to the JSON to send.
+
+:::warning
+Do not enter a credential in `headers`. Picked refuses the workflow when you save it.
+Picked sends the authorization header from the registration for you.
+:::
+
+## 3. Read the answer
+
+A later node reads what the call recorded:
+
+- `{{ nodes.<node-id>.status }}` — the HTTP status.
+- `{{ nodes.<node-id>.ok }}` — true for a status from 200 to 299.
+- `{{ nodes.<node-id>.body }}` — the parsed JSON answer.
+
+## 4. Continue after an error status
+
+By default, a status outside 200 to 299 fails the node and stops the run. The run page
+shows the node that failed. Refer to the [workflow runs reference](/reference/dashboard/workflow-runs). To test
+the status in the workflow instead:
+
+1. Set `failOnErrorStatus` to off.
+2. Add a condition node after the External API node.
+3. Test `{{ nodes.<node-id>.status }}` in the condition.
+
+## 5. Continue after a failed call
+
+A timeout or a connection failure also fails the node. To continue the run after a
+failed call:
+
+1. Connect the node's error exit to a condition node.
+2. Test `{{ nodes.<node-id>.error.retryable }}` in the condition.
+3. Connect the condition's `false` exit to the nodes that record the failure.
+
+To send the request again, refer to
+[How to retry a failed call with a loop](/how-to/retry-a-failed-call-with-a-loop).
+
+The run follows the error exit only when the call fails. These failures stop the run at
+the node:
+
+- A required argument has no value.
+- An argument has a value that the tool does not accept. For example, the value has the
+  wrong type, `method` is not one of the six methods, or `timeoutMs` is not from
+  1000 to 30000.
+- A template cannot be rendered.
+- The workflow does not have a scope that the tool needs.
+- An error occurs in Picked.
+
+Refer to the [External APIs reference](/reference/dashboard/external-apis#errors) for each
+reason.
+
+## API and MCP
+
+You can also do this task with the [Management API](/reference/management-api/schema), the [MCP server](/reference/tools/mcp), or code that you send to [`picked_run`](/reference/tools/mcp-run).
+
+| Task | GraphQL | MCP tool | Run |
+| --- | --- | --- | --- |
+| Register the external API | [`externalApiCreate`](/reference/management-api/schema/external-api#externalapicreate) | None | None |
+| Replace the header value | [`externalApiAuthHeaderSet`](/reference/management-api/schema/external-api#externalapiauthheaderset) | None | None |
+| Add an External API node | [`workflowGraphUpdate`](/reference/management-api/schema/workflow#workflowgraphupdate) | [`update_workflow_graph`](/reference/tools/mcp#update_workflow_graph) | `tools.update_workflow_graph({ workflow_id, create_nodes, create_edges })` |
+| Find the node that failed | [`workflowRun`](/reference/management-api/schema/workflow-run#workflowrun) | [`get_workflow_run`](/reference/tools/mcp#get_workflow_run), [`list_workflow_run_tasks`](/reference/tools/mcp#list_workflow_run_tasks) | `tools.get_workflow_run({ run_id })`, `tools.list_workflow_run_tasks({ run_id })` |
+| Add a condition node | [`workflowGraphUpdate`](/reference/management-api/schema/workflow#workflowgraphupdate) | [`update_workflow_graph`](/reference/tools/mcp#update_workflow_graph) | `tools.update_workflow_graph({ workflow_id, create_nodes, create_edges })` |
+
+The external API mutations refuse an API key. Use the access token of a user.
+
+## Related
+
+- [How to retry a failed call with a loop](/how-to/retry-a-failed-call-with-a-loop) — send
+  the request again after a wait.
+- [External APIs](/reference/dashboard/external-apis) — every argument, every limit and
+  every error message.
+- [Workflow templates](/reference/dashboard/workflow-templates) — the data that a node can
+  read, and templates in a condition.

package/docs/how-to/connect-the-mcp-server.md

@@ -0,0 +1,46 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to connect the MCP server
+
+This guide shows you how to control your Picked workspace from an AI tool that writes
+code. The server URL is `https://api.picked.app/mcp`.
+
+## Claude Desktop
+
+1. Open **Settings > Connectors > Add custom connector**.
+2. Set **Name** to `Picked`.
+3. Set **URL** to `https://api.picked.app/mcp`.
+4. Click **Connect**.
+5. Answer the authorization prompt.
+
+## Claude Code, Cursor, Windsurf, and others
+
+Add `.mcp.json` to the root of your repository:
+
+```json
+{
+  "mcpServers": {
+    "picked": {
+      "type": "http",
+      "url": "https://api.picked.app/mcp"
+    }
+  }
+}
+```
+
+Cursor reads the same content from `.cursor/mcp.json`.
+
+## Two-factor authentication
+
+The authorization prompt signs you in to Picked. If your account must use MFA, the prompt
+asks for the code from your authenticator app before it connects the tool. Picked staff,
+and members of an organization that requires MFA, must use it. When an organization
+turns the requirement on, the tools its members connected before that point do not
+work. Connect them again to continue.
+
+## Related
+
+- [MCP server](/reference/tools/mcp) — every tool that the server gives you.

package/docs/how-to/create-a-content-entry.md

@@ -0,0 +1,58 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to create a content entry
+
+This guide shows you how to make one instance of a Model and fill it with data. You need
+a Model first. See [How to define a page layout](/how-to/define-a-page-layout).
+
+A Page makes its own entry when you create the page. Use this guide for the content that
+no Page and no Step owns, such as an author or a product.
+
+## 1. Open the entries list
+
+1. Open your workspace.
+2. Click **CMS** in the sidebar.
+3. Click **Content entries**.
+
+## 2. Create the entry
+
+1. Click **New content**.
+2. Choose the **Model** for the entry.
+3. Fill in each field. The form comes from the schema of the Model.
+4. Click **Create entry**.
+
+The Model is fixed when you create the entry. To move content to another Model, make a
+new entry and copy the values across.
+
+## 3. Correct every error
+
+An invalid field shows an error next to it while you edit. The error carries the path to
+the exact field. Correct each one before you publish, because Picked serves valid content
+only.
+
+## Find an entry again
+
+The entries list shows a title for each entry. The title is the first single-line text
+field of the entry. It shows the entry id when no such field holds a value.
+
+Use the **Model** filter to narrow the list to one Model.
+
+## API and MCP
+
+You can also do this task with the [Management API](/reference/management-api/schema), the [MCP server](/reference/tools/mcp), or code that you send to [`picked_run`](/reference/tools/mcp-run).
+
+| Task | GraphQL | MCP tool | Run |
+| --- | --- | --- | --- |
+| Create the content entry | [`contentEntryCreate`](/reference/management-api/schema/cms-models#contententrycreate) | [`create_content_entry`](/reference/tools/mcp#create_content_entry) | `tools.create_content_entry({ content_model_id, data })` |
+| Find and correct the errors | [`workspaceContentEntryValidation`](/reference/management-api/schema/cms-models#workspacecontententryvalidation), [`contentEntryUpdate`](/reference/management-api/schema/cms-models#contententryupdate) | [`validate_workspace_content_entries`](/reference/tools/mcp#validate_workspace_content_entries), [`update_content_entry`](/reference/tools/mcp#update_content_entry) | `tools.validate_workspace_content_entries({ workspace_id })`, `tools.update_content_entry({ content_entry_id, data })` |
+| Find an entry again | [`contentEntries`](/reference/management-api/schema/cms-models#contententries) | [`list_content_entries`](/reference/tools/mcp#list_content_entries) | `tools.list_content_entries({ workspace_id, content_model_id })` |
+
+## Related
+
+- [Content entries](/reference/dashboard/content/content-entries) — the editor reference.
+- [Models](/reference/dashboard/content/models) — every field type.
+- [How to point one entry at another](/how-to/point-one-entry-at-another)
+- [How to publish a workspace](/how-to/publish-a-workspace)

package/docs/how-to/create-a-project.md

@@ -0,0 +1,40 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to create a project
+
+This guide shows you how to add a project. A project is one site or one application, and
+it holds its own experiences, content, and options.
+
+## Steps
+
+1. Open your organization.
+2. Click **New project**.
+3. Enter a name.
+4. Click **Create project**.
+
+The project home page opens. It shows your SDK snippet and the setup tasks that are still
+open.
+
+## Next
+
+Copy the snippet and add it to your site. See
+[How to install the SDK](/how-to/install-the-sdk).
+
+## API and MCP
+
+You can also do this task with the [Management API](/reference/management-api/schema), the [MCP server](/reference/tools/mcp), or code that you send to [`picked_run`](/reference/tools/mcp-run).
+
+| Task | GraphQL | MCP tool | Run |
+| --- | --- | --- | --- |
+| Create the project | [`projectCreate`](/reference/management-api/schema/project#projectcreate) | [`guide_create_project`](/reference/tools/mcp#guide_create_project) | `tools.guide_create_project({ organization_slug })` |
+
+The MCP server does not create a project. `guide_create_project` gives the link to
+create it in the dashboard.
+
+## Related
+
+- [Projects](/reference/dashboard/projects) — the project surface.
+- [Add Picked to your application](/tutorials/first-experience) — the whole path.

package/docs/how-to/create-an-experience.md

@@ -0,0 +1,51 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to create an experience
+
+An experience is a Flow or a Page. This guide adds a **Flow**: the interactive kind, of
+more than one step, which the browser renders. A **Page** is the standalone kind that your
+server renders for a search engine, and
+[How to fill and publish a page](/how-to/fill-and-publish-a-page) covers it.
+
+[About pages and flows](/explanation/pages-and-flows) sets out the difference, and which
+kind a piece of work needs.
+
+## Steps
+
+1. Open your project.
+2. Click **Flows** in the sidebar. The experiences list opens.
+3. Click **New experience**.
+4. Enter a name.
+5. Leave **Type** on the **Flow** option.
+6. Open **Advanced**.
+7. Enter a component name. It must match a component that you register in your
+   application.
+8. Click **Create flow**.
+
+The flow editor opens with an empty canvas.
+
+## Set the options
+
+Click the canvas background to open the experience inspector.
+
+- **Condition** — the experience starts only for a visitor who matches it. Keep it blank
+  to start for every visitor.
+- **Initialize Open** — the experience opens by itself when the page loads.
+
+## API and MCP
+
+You can also do this task with the [Management API](/reference/management-api/schema), the [MCP server](/reference/tools/mcp), or code that you send to [`picked_run`](/reference/tools/mcp-run).
+
+| Task | GraphQL | MCP tool | Run |
+| --- | --- | --- | --- |
+| Create the experience | [`experienceCreate`](/reference/management-api/schema/experience#experiencecreate) | [`create_experience`](/reference/tools/mcp#create_experience) | `tools.create_experience({ workspace_id, name, key })` |
+| Set the options of the experience | [`experienceUpdate`](/reference/management-api/schema/experience#experienceupdate) | [`update_experience_flow`](/reference/tools/mcp#update_experience_flow) | `tools.update_experience_flow({ experience_id, workspace_id, status, condition, targets })` |
+
+## Related
+
+- [How to build a flow](/how-to/build-a-flow) — add your first node.
+- [About pages and flows](/explanation/pages-and-flows) — Page or Flow.
+- [Experiences](/reference/dashboard/experiences) — every option.

package/docs/how-to/create-and-revoke-an-api-key.md

@@ -0,0 +1,54 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to create and revoke an API key
+
+This guide shows you how to give your code access to the Picked API. Use a key where your
+own code calls the API, such as a server-side integration.
+
+An API key does not sign the [CLI](/reference/tools/cli) in. The CLI reads a session, which
+`picked login` writes. See
+[How to authenticate the CLI](/how-to/authenticate-the-cli) for the commands that CI can
+run without one.
+
+## Create a key
+
+1. Open your organization.
+2. Click **API Keys**.
+3. Click **Create API Key**.
+4. Enter a **Name**, such as `Production key`.
+5. Set **Project** to one project. The default, **All projects**, gives the key every
+   project.
+6. Choose the **Permissions** that your integration needs.
+7. Click **Create API Key**.
+
+:::warning
+Copy the key immediately. The dashboard does not show it again.
+:::
+
+## Revoke a key
+
+1. Open the API keys list.
+2. Click **Revoke** next to the key.
+3. Click **Revoke Key** to confirm.
+
+Picked invalidates the key immediately. No later request can use it.
+
+## API and MCP
+
+You can also do this task with the [Management API](/reference/management-api/schema), the [MCP server](/reference/tools/mcp), or code that you send to [`picked_run`](/reference/tools/mcp-run).
+
+| Task | GraphQL | MCP tool | Run |
+| --- | --- | --- | --- |
+| Create the key | [`apiKeyCreate`](/reference/management-api/schema/api-key#apikeycreate) | None | None |
+| Find the key in the list | [`apiKeys`](/reference/management-api/schema/api-key#apikeys) | None | None |
+| Revoke the key | [`apiKeyRevoke`](/reference/management-api/schema/api-key#apikeyrevoke) | None | None |
+
+`apiKeyCreate` needs a user session. An API key cannot create a different key.
+
+## Related
+
+- [API keys](/reference/dashboard/api-keys) — the scopes.
+- [Authentication](/reference/management-api/authentication) — how to send the key.

package/docs/how-to/debug-with-the-chrome-extension.md

@@ -0,0 +1,57 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to debug with the Chrome extension
+
+This guide shows you how to add a Picked panel to Chrome DevTools and check your
+integration on any page that runs the SDK.
+
+## 1. Install the extension
+
+Install it from the
+[Chrome Web Store](https://chromewebstore.google.com/detail/picked-developer-tools/nimmdamgnhlhdpngnalkpmnleebngidh).
+
+## 2. Add the devtools plugin
+
+```typescript
+import { createClient } from 'picked'
+import { svelteDevtoolsPlugin } from '@picked/svelte/plugins/devtools'
+
+const picked = createClient({
+  projectId: 'your-project-id',
+  plugins: [svelteDevtoolsPlugin()],
+})
+```
+
+The extension then connects to the SDK.
+
+## 3. Add a tool of your own
+
+A custom tool is a framework-adapted component, and it receives the live Picked client
+exactly as an experience component does.
+
+```typescript
+import { adaptReactComponent } from '@picked/react'
+import { svelteDevtoolsPlugin } from '@picked/svelte/plugins/devtools'
+import MyTool from './MyTool'
+
+const picked = createClient({
+  projectId: 'your-project-id',
+  plugins: [
+    svelteDevtoolsPlugin({
+      customTools: [
+        { id: 'my-tool', label: 'My Tool', component: adaptReactComponent(MyTool) },
+      ],
+    }),
+  ],
+})
+```
+
+Your tools appear under a **Custom Tools** tab. In React use `usePicked()`, and in Svelte
+use `getPicked()`.
+
+## Related
+
+- [Chrome extension](/reference/tools/chrome-extension) — the panel reference.

package/docs/how-to/define-a-page-layout.md

@@ -0,0 +1,54 @@
+---
+type: how-to
+layout: docs
+---
+
+# How to define a page layout
+
+This guide shows you how to define the shape of a page. A page layout sets which fields a
+page can hold, and it holds no data itself.
+
+## Steps
+
+1. Open your workspace.
+2. Click **Pages** in the sidebar, then **Page Layouts**.
+3. Click **New model**.
+4. Set **Category** to **Page layout**.
+5. Enter a **Name** and a **Key**. The key is stable, and your SDK code and your API
+   calls both use it.
+6. Add your fields. Choose a type for each one.
+7. Click **Create model**.
+
+The category is fixed when you create the Model. You cannot change it later.
+
+## Make a field repeatable
+
+Turn on **repeatable** on any field. It then renders as a sortable list of values. Use it
+for a gallery, or for a list of features.
+
+## Group related fields
+
+Add a **Group** field to hold a set of fields under one key. Make the group repeatable to
+describe a list of objects, such as a list of feature cards.
+
+## Define content with no layout role
+
+A Model needs no category. Leave **Category** as **None (general content)** for content
+that no Page and no Step renders, such as an author or a product. Reach such a Model
+under **CMS** in the sidebar, and point at its entries with a **Reference** field.
+
+## API and MCP
+
+You can also do this task with the [Management API](/reference/management-api/schema), the [MCP server](/reference/tools/mcp), or code that you send to [`picked_run`](/reference/tools/mcp-run).
+
+| Task | GraphQL | MCP tool | Run |
+| --- | --- | --- | --- |
+| Create the page layout | [`contentModelCreate`](/reference/management-api/schema/cms-models#contentmodelcreate) | [`create_content_model`](/reference/tools/mcp#create_content_model) | `tools.create_content_model({ workspace_id, name, key, schema, category: 'page-layout' })` |
+
+## Related
+
+- [About the content model](/explanation/the-content-model) — why the schema and the data
+  are separate.
+- [Models](/reference/dashboard/content/models) — every field type.
+- [How to reuse a section](/how-to/reuse-a-section)
+- [How to point one entry at another](/how-to/point-one-entry-at-another)