CMS Collection Setup

Create a new CMS collection with custom fields, relationships, and proper configuration.

Important Note

ALWAYS use Webflow MCP tools for all operations:

Use Webflow MCP's
```
webflow_guide_tool
```
to get best practices before starting
Use Webflow MCP's
```
data_sites_tool
```
with action
```
list_sites
```
to identify available sites
Use Webflow MCP's
```
data_sites_tool
```
with action
```
get_site
```
to retrieve site details and plan limits
Use Webflow MCP's
```
data_cms_tool
```
with action
```
get_collection_list
```
to check for naming conflicts
Use Webflow MCP's
```
data_cms_tool
```
with action
```
create_collection
```
to create the collection
Use Webflow MCP's
```
data_cms_tool
```
with action
```
create_collection_static_field
```
to create static fields
Use Webflow MCP's
```
data_cms_tool
```
with action
```
create_collection_option_field
```
to create option fields
Use Webflow MCP's
```
data_cms_tool
```
with action
```
create_collection_reference_field
```
to create reference/multi-reference fields
Use Webflow MCP's
```
data_cms_tool
```
with action
```
get_collection_details
```
to verify collection was created correctly
DO NOT use any other tools or methods for Webflow operations
All tool calls must include the required
```
context
```
parameter (15-25 words, third-person perspective)

Instructions

Phase 1: Site Selection & Discovery

Get site information: Use Webflow MCP's
```
data_sites_tool
```
with action
```
list_sites
```
to identify target site
Confirm site: Ask user to select site if multiple available
Check plan limits: Use Webflow MCP's
```
data_sites_tool
```
with action
```
get_site
```
to verify collection limits
List existing collections: Use Webflow MCP's
```
data_cms_tool
```
with action
```
get_collection_list
```
to check for conflicts
Validate naming: Ensure new collection name doesn't conflict with existing

Phase 2: Requirements Gathering

Get collection details: Ask user for:
- Collection display name (e.g., "Blog Posts")
- Singular name (e.g., "Blog Post")
- Optional: Custom slug (default: auto-generated from display name)
Get field definitions: For each field, gather:
- Field name (e.g., "Author Name", "Publish Date")
- Field type (Text, Rich Text, Image, Option, Reference, etc.)
- Required vs optional
- Any validation rules or help text
Identify relationships: Determine if collection needs:
- Reference fields (one-to-many relationships)
- Multi-reference fields (many-to-many relationships)
- Option fields (controlled vocabulary)

Phase 3: Schema Validation & Planning

Validate field types: Check all field types are supported
Check field limits: Ensure within Webflow limits:
- Max fields per collection: varies by plan
- Max 5 multi-reference fields per collection
Plan creation order: Organize fields by dependency:
- Create collections in order if references exist
- Create referenced collections first
- Create option fields before reference fields
Generate preview: Show complete schema with all fields

Phase 4: User Approval

Show complete preview: Display:
- Collection name and slug
- All fields with types and properties
- Any relationships to other collections
- Plan limit verification
Validate schema: Check for common issues:
- Missing required fields (name, slug always required)
- Invalid field types
- Reference to non-existent collections
- Exceeding plan limits
Request confirmation: Wait for explicit "create" approval

Phase 5: Collection Creation

Create collection: Use Webflow MCP's
```
data_cms_tool
```
with action
```
create_collection
```
with:
- Display name
- Singular name
- Optional slug
Capture collection ID: Save for field creation
Show progress: Report collection created successfully

Phase 6: Field Creation

Create fields in order: For each field:
- Use appropriate creation tool based on type
- Static fields:
```
data_cms_tool
```
  with action
```
create_collection_static_field
```
- Option fields:
```
data_cms_tool
```
  with action
```
create_collection_option_field
```
- Reference fields:
```
data_cms_tool
```
  with action
```
create_collection_reference_field
```
Set field properties:
- Display name
- Required flag
- Help text (if provided)
- Validation rules (if applicable)
Show progress: Report each field created
Handle errors: If field creation fails, report and continue

Phase 7: Verification & Reporting

Verify collection: Use Webflow MCP's
```
data_cms_tool
```
with action
```
get_collection_details
```
to retrieve full schema
Confirm all fields: Check that all requested fields were created
Generate report: Show:
- Collection ID
- Collection name and slug
- All fields created with IDs
- Any failures or warnings
Provide next steps: Suggest:
- Use bulk-cms-update to add initial items
- Create collection pages in Designer
- Set up relationships if applicable

Field Type Reference

Static Field Types

PlainText - Short text (max 256 chars) or long text

Use for: Titles, names, descriptions, excerpts
Properties: maxLength validation (256 for short)
Example: "Title", "Author Name", "Excerpt"

RichText - Formatted text with HTML

Use for: Blog content, bios, articles, long descriptions
Properties: No length limit
Example: "Post Content", "Bio", "Description"

Email - Email address

Use for: Contact emails, author emails
Properties: Email format validation
Example: "Contact Email", "Author Email"

Phone - Phone number

Use for: Contact numbers
Properties: E.164 format
Example: "Phone Number", "Mobile"

Link - External URL or internal link

Use for: Website links, social media, external resources
Properties: URL validation
Example: "Website", "LinkedIn Profile"

Number - Numeric values

Use for: Prices, ratings, counts, order numbers
Properties: Integer or decimal
Example: "Price", "Rating", "Order"

Image - Single image

Use for: Featured images, photos, thumbnails
Properties: Max 4MB per image
Example: "Featured Image", "Photo", "Thumbnail"

MultiImage - Multiple images (up to 25)

Use for: Galleries, product photos
Properties: Max 25 images, 4MB each
Example: "Gallery", "Product Photos"

File - File upload

Use for: PDFs, documents, downloads
Properties: Max 4MB per file
Example: "Resume PDF", "Brochure", "Manual"

Video - Video embed (YouTube/Vimeo)

Use for: Video content
Properties: Embed URL
Example: "Tutorial Video", "Demo"

DateTime - Date and/or time

Use for: Publish dates, event dates, deadlines
Properties: ISO 8601 format
Example: "Publish Date", "Event Date"

Switch - Boolean (true/false)

Use for: Featured flags, visibility toggles
Properties: Boolean value
Example: "Featured", "Published", "Active"

Color - Color value

Use for: Theme colors, accents, brand colors
Properties: Hex format
Example: "Brand Color", "Accent Color"

Option Field Type

Option - Single choice from predefined list

Use for: Status, category, type, priority
Properties: List of option names
Example: "Status" (Draft, Review, Published)

Creation: Use

data_cms_tool

with action

create_collection_option_field

with options array

Example:

json

{
  "type": "Option",
  "displayName": "Status",
  "metadata": {
    "options": [
      {"name": "Draft"},
      {"name": "In Review"},
      {"name": "Published"}
    ]
  }
}

Reference Field Types

Reference - Link to one item in another collection (one-to-many)

Use for: Author → Post, Category → Post, Brand → Product
Properties: Collection ID of referenced collection
Example: "Author" (reference to Authors collection)

Creation: Use

data_cms_tool

with action

create_collection_reference_field

with collectionId

MultiReference - Link to multiple items in another collection (many-to-many)

Use for: Post → Tags, Product → Features, Project → Technologies
Properties: Collection ID of referenced collection
Limit: Max 5 multi-reference fields per collection
Example: "Tags" (reference to Tags collection)

Creation: Use

data_cms_tool

with action

create_collection_reference_field

with collectionId

Reference Field Example:

json

{
  "type": "Reference",
  "displayName": "Author",
  "metadata": {
    "collectionId": "abc123..."
  }
}

Multi-Reference Field Example:

json

{
  "type": "MultiReference",
  "displayName": "Tags",
  "metadata": {
    "collectionId": "xyz789..."
  }
}

Examples

Example 1: Simple Blog Collection

User prompt:

Create a Blog Posts collection with title, content, author, and publish date

Step 1: Discovery

🔍 CMS Collection Setup

Available sites:
1. Company Website
2. Blog Site

Which site? (1/2)

Step 2: After User Selects Site

📊 Existing Collections on Company Website:

Currently: 0 collections
Plan limit: 20 collections (CMS Plan)

✅ You have capacity to create new collections.

---

📋 Collection Requirements

Display Name: Blog Posts
Singular Name: Blog Post
Slug: blog-posts (auto-generated)

Fields to create:
1. Title - Text (required)
2. Content - Rich Text (required)
3. Author - Text
4. Publish Date - Date/Time (required)

Is this correct? (yes/no)
If you want to add/modify fields, describe the changes.

Step 3: Preview

📋 Preview: Create "Blog Posts" Collection

Collection:
├── Display Name: Blog Posts
├── Singular Name: Blog Post
├── Slug: blog-posts
└── Site: Company Website

Fields (6 total):
├── name (PlainText, required) ← Auto-created
├── slug (PlainText, required) ← Auto-created
├── title (PlainText, required)
├── content (RichText, required)
├── author (PlainText)
└── publish-date (DateTime, required)

✅ Validation Passed:
- Collection name available
- Within plan limits (0/20 collections)
- All field types valid
- No dependency issues

⚠️ Type "create" to proceed.

Step 4: Creation

🔄 Creating Collection...

✅ Collection created: Blog Posts (ID: 64f1a2b3...)

Adding fields...
├── ✅ title (PlainText)
├── ✅ content (RichText)
├── ✅ author (PlainText)
└── ✅ publish-date (DateTime)

Progress: ████████████████████ 100% (4/4 fields)

🎉 Collection Setup Complete!

Collection: Blog Posts
ID: 64f1a2b3...
Fields: 6 (2 auto-created + 4 custom)

---

💡 Next Steps:
1. Use bulk-cms-update to add initial blog posts
2. Create collection template page in Designer
3. Set up collection list page for blog index
4. Configure SEO settings for dynamic pages

Example 2: Collection with Relationships

User prompt:

Create a Products collection with name, price, description, images, brand, and tags

Step 1: After Initial Gathering

📋 Collection Analysis

I see you want:
- Brand: This should be a reference field
- Tags: This should be a multi-reference field

This requires creating additional collections first:
1. Brands collection
2. Tags collection

Then we can create Products with references to them.

Would you like me to:
A) Create all three collections (Brands, Tags, Products)
B) Just create Products (you'll add relationships later)
C) Modify the requirements

Your choice? (A/B/C)

Step 2: After User Selects "A"

📋 Preview: Create 3 Collections

---

### 1. Brands Collection

Fields (4 total):
├── name (PlainText, required) ← Auto
├── slug (PlainText, required) ← Auto
├── logo (Image)
└── description (PlainText)

---

### 2. Tags Collection

Fields (3 total):
├── name (PlainText, required) ← Auto
├── slug (PlainText, required) ← Auto
└── color (Color)

---

### 3. Products Collection

Fields (9 total):
├── name (PlainText, required) ← Auto
├── slug (PlainText, required) ← Auto
├── price (Number, required)
├── description (RichText)
├── images (MultiImage)
├── brand (Reference → Brands)
└── tags (MultiReference → Tags)

---

Creation Order:
1. Brands (no dependencies)
2. Tags (no dependencies)
3. Products (references 1 & 2)

✅ Validation:
- All collections available
- Within plan limits (0/20 collections)
- Multi-reference limit: 1/5 ✅
- All dependencies resolvable

⚠️ Type "create" to proceed with all 3 collections.

Step 3: Creation

🔄 Creating Collections...

[1/3] Creating Brands...
✅ Brands collection created (ID: abc123...)
├── ✅ logo (Image)
└── ✅ description (PlainText)

[2/3] Creating Tags...
✅ Tags collection created (ID: def456...)
└── ✅ color (Color)

[3/3] Creating Products...
✅ Products collection created (ID: ghi789...)
├── ✅ price (Number)
├── ✅ description (RichText)
├── ✅ images (MultiImage)
├── ✅ brand (Reference → Brands)
└── ✅ tags (MultiReference → Tags)

Progress: ████████████████████ 100% (3/3 collections)

🎉 All Collections Created!

Summary:
├── Brands (ID: abc123...)
├── Tags (ID: def456...)
└── Products (ID: ghi789...)

---

💡 Next Steps:
1. Add brand items first (use bulk-cms-update)
2. Add tag items (use bulk-cms-update)
3. Then add products with brand/tag references
4. Create collection pages in Designer

Example 3: Team Members with Option Field

User prompt:

Create a Team Members collection with name, role (dropdown: Designer, Developer, Manager), bio, photo, email

Step 1: Preview

📋 Preview: Create "Team Members" Collection

Collection:
├── Display Name: Team Members
├── Singular Name: Team Member
└── Slug: team-members

Fields (7 total):
├── name (PlainText, required) ← Auto
├── slug (PlainText, required) ← Auto
├── role (Option, required)
│   Options:
│   ├── Designer
│   ├── Developer
│   └── Manager
├── bio (RichText)
├── photo (Image)
└── email (Email)

✅ Validation Passed

⚠️ Type "create" to proceed.

Step 2: Creation

🔄 Creating Collection...

✅ Collection created: Team Members (ID: jkl012...)

Adding fields...
├── ✅ role (Option: 3 options)
├── ✅ bio (RichText)
├── ✅ photo (Image)
└── ✅ email (Email)

Progress: ████████████████████ 100% (4/4 fields)

🎉 Collection Setup Complete!

Collection: Team Members
Fields: 6 (2 auto + 4 custom)

Field Details:
- role: Option field with 3 choices
  • Designer
  • Developer
  • Manager

---

💡 Next Steps:
1. Add team member items
2. Create team page in Designer
3. Consider adding:
   - LinkedIn profile (Link field)
   - Years of experience (Number field)
   - Specializations (MultiReference to Skills collection)

Example 4: Complex E-commerce Setup

User prompt:

Create an e-commerce setup with Products, Categories, Brands, and Features

Step 1: Requirements Clarification

📋 E-commerce Collection Planning

I'll create 4 collections:

1. **Categories** - Product categories
2. **Brands** - Product brands
3. **Features** - Product features (e.g., "Waterproof", "Wireless")
4. **Products** - Main product catalog

Relationships:
- Product → Category (Reference)
- Product → Brand (Reference)
- Product → Features (MultiReference)

Fields per collection:

**Categories:**
- Name, Slug (auto)
- Description
- Parent Category (self-reference for hierarchy)
- Icon

**Brands:**
- Name, Slug (auto)
- Logo
- Description

**Features:**
- Name, Slug (auto)
- Icon
- Description

**Products:**
- Name, Slug (auto)
- Price
- Sale Price
- Description
- Images (MultiImage)
- Category (Reference → Categories)
- Brand (Reference → Brands)
- Features (MultiReference → Features)
- In Stock (Switch)
- SKU (PlainText)

Is this structure good? (yes/modify/cancel)

Step 2: Preview (User says "yes")

📋 Preview: Create E-commerce Collections

---

### Collection 1: Categories

Fields (5 total):
├── name (PlainText, required)
├── slug (PlainText, required)
├── description (PlainText)
├── parent-category (Reference → Categories) ← Self-reference
└── icon (Image)

---

### Collection 2: Brands

Fields (4 total):
├── name (PlainText, required)
├── slug (PlainText, required)
├── logo (Image)
└── description (PlainText)

---

### Collection 3: Features

Fields (4 total):
├── name (PlainText, required)
├── slug (PlainText, required)
├── icon (Image)
└── description (PlainText)

---

### Collection 4: Products

Fields (12 total):
├── name (PlainText, required)
├── slug (PlainText, required)
├── price (Number, required)
├── sale-price (Number)
├── description (RichText)
├── images (MultiImage)
├── category (Reference → Categories)
├── brand (Reference → Brands)
├── features (MultiReference → Features)
├── in-stock (Switch)
└── sku (PlainText)

---

Creation Order:
1. Categories (self-reference OK)
2. Brands (no dependencies)
3. Features (no dependencies)
4. Products (references 1, 2, 3)

✅ Validation:
- Within plan limits (0/20 collections)
- Multi-reference count: 1/5 ✅
- All field types valid
- Self-reference supported

⚠️ Type "create" to proceed with all 4 collections.

Step 3: Creation with Progress

🔄 Creating E-commerce Collections...

[1/4] Creating Categories...
✅ Categories created (ID: aaa111...)
Progress: ████████░░░░░░░░░░░░ 25%

[2/4] Creating Brands...
✅ Brands created (ID: bbb222...)
Progress: ████████████░░░░░░░░ 50%

[3/4] Creating Features...
✅ Features created (ID: ccc333...)
Progress: ████████████████░░░░ 75%

[4/4] Creating Products...
✅ Products created (ID: ddd444...)
Progress: ████████████████████ 100%

---

🎉 E-commerce Setup Complete!

Collections Created (4):
├── Categories (ID: aaa111..., 5 fields)
├── Brands (ID: bbb222..., 4 fields)
├── Features (ID: ccc333..., 4 fields)
└── Products (ID: ddd444..., 12 fields)

Relationships Configured:
- Products → Categories (one-to-many)
- Products → Brands (one-to-many)
- Products → Features (many-to-many)
- Categories → Parent Category (self-reference)

---

💡 Recommended Content Order:
1. Add categories first (including parent relationships)
2. Add brands
3. Add features
4. Finally add products (with all references)

💡 Next Steps:
1. Use bulk-cms-update for initial data
2. Create product template page
3. Create product listing page with filters
4. Set up category landing pages
5. Configure e-commerce integration

Guidelines

Phase 1: Discovery Best Practices

Site Selection:

Always use
```
sites_list
```
to get available sites
Never assume site ID
Verify user has correct site selected

Plan Limit Checking:

Check limits before creation:
- Starter: 1 collection, 50 items
- Basic: 2 collections, 200 items
- CMS: 20 collections, 2,000 items
- Business: 40 collections, 10,000 items
- Enterprise: Custom

Warn user if approaching limits.

Naming Conflict Prevention:

Check existing collection names
Suggest alternative names if conflict
Validate slug availability

Phase 2: Requirements Gathering Best Practices

Display Name vs Singular Name:

Display Name: Plural form shown in CMS
Singular Name: Singular form for individual items

Examples:
- Display: "Blog Posts" → Singular: "Blog Post"
- Display: "Team Members" → Singular: "Team Member"
- Display: "Products" → Singular: "Product"
- Display: "Categories" → Singular: "Category"

Field Naming Conventions:

✅ Good names:
- author-name (descriptive, hyphenated)
- publish-date (clear purpose)
- featured-image (specifies which)
- main-content (explains use)

❌ Bad names:
- text1 (meaningless)
- field (too generic)
- data (unclear)
- img (which image?)

Detecting Relationships:

If user says:
"... with author" → Likely reference field
"... with tags" → Likely multi-reference field
"... with category" → Likely reference field
"... with related products" → Likely multi-reference field

Ask clarifying questions:
- Is [author] the same across items? → Reference
- Can items have multiple [tags]? → Multi-reference
- Do you have a [Categories] collection? → Check existence

Phase 3: Schema Validation Best Practices

Field Type Validation:

Common field type mappings:

User says... → Field type:
"title", "name" → PlainText
"description", "summary" → PlainText (long)
"content", "bio", "article" → RichText
"photo", "image", "thumbnail" → Image
"gallery", "photos" → MultiImage
"document", "PDF", "file" → File
"video" → Video
"link", "URL", "website" → Link
"email" → Email
"phone", "mobile" → Phone
"price", "cost", "amount" → Number
"date", "published", "deadline" → DateTime
"featured", "active", "published" → Switch
"status", "type", "category" → Option (if fixed choices)
"color", "theme" → Color

Multi-Reference Limit Check:

Count multi-reference fields requested:

If > 5:
⚠️ Warning: Collection Limit Exceeded

Webflow allows max 5 multi-reference fields per collection.

You requested: 7 multi-reference fields

Options:
1. Choose 5 most important relationships
2. Convert some to reference fields (one-to-many)
3. Create bridging collections
4. Use option fields for simple categorization

Which would you prefer?

Dependency Resolution:

For reference fields:
1. Check if referenced collection exists
2. If not, add to creation queue
3. Create in correct order

Example:
Products needs:
- Categories collection (create first)
- Brands collection (create first)
Then create Products

Phase 4: Preview Best Practices

Complete Preview Format:

📋 Preview: Create "[Collection Name]"

Collection Details:
├── Display Name: [Name]
├── Singular Name: [Singular]
├── Slug: [slug]
└── Site: [Site Name]

Fields ([X] total):
├── name (PlainText, required) ← Auto-created
├── slug (PlainText, required) ← Auto-created
├── [field-1] ([Type], [required/optional])
├── [field-2] ([Type], [required/optional])
│   [Additional info if Option or Reference]
└── [field-n] ([Type], [required/optional])

Relationships:
├── [field] → [Collection] (Reference)
└── [field] → [Collection] (MultiReference)

✅ Validation Results:
- Collection name available: Yes
- Within plan limits: X/Y collections
- Multi-reference count: X/5
- All field types valid: Yes
- Dependencies resolved: Yes

⚠️ Type "create" to proceed.

Validation Checks:

Before showing preview:
1. ✅ Collection name available
2. ✅ Within plan collection limit
3. ✅ All field types supported
4. ✅ Multi-reference limit ≤ 5
5. ✅ Referenced collections exist or queued
6. ✅ No circular dependencies
7. ✅ Field names follow conventions

Phase 5: Creation Best Practices

Collection Creation:

Required fields:
- displayName (required)
- singularName (required)
- slug (optional, auto-generated if omitted)

Always include both names for clarity:
✅ {"displayName": "Blog Posts", "singularName": "Blog Post"}
❌ {"displayName": "Blog Posts"} (missing singular)

Error Handling:

If collection creation fails:
❌ Collection Creation Failed

Error: [Error message from API]

Common causes:
- Collection name already exists
- Invalid characters in name/slug
- Plan limit reached
- API authentication issue

Would you like to:
1. Try a different collection name
2. Check existing collections
3. Upgrade plan
4. Cancel operation

Phase 6: Field Creation Best Practices

Field Creation Order:

Create fields in this order:
1. Static fields (Text, Rich Text, Number, etc.)
2. Option fields (with options defined)
3. Reference fields (after referenced collections exist)

For each field:
- Set displayName
- Set isRequired flag
- Add helpText if provided by user
- Set validation rules if applicable

Field Creation Tools:

Field Type → Tool to use:

PlainText, RichText, Email, Phone, Link, Number,
Image, MultiImage, File, Video, DateTime, Switch, Color
→ collection_fields_create_static

Option
→ collection_fields_create_option
   (requires metadata.options array)

Reference, MultiReference
→ collection_fields_create_reference
   (requires metadata.collectionId)

Progress Reporting:

For each field created:
✅ [field-name] ([FieldType])

If field fails:
❌ [field-name] - [Error message]

Continue with remaining fields even if one fails.
Report all failures at end.

Option Field Creation:

{
  "type": "Option",
  "displayName": "Status",
  "isRequired": false,
  "metadata": {
    "options": [
      {"name": "Draft"},
      {"name": "Published"},
      {"name": "Archived"}
    ]
  }
}

Notes:
- Options have name property
- Options cannot have ID (auto-generated)
- Minimum 2 options required
- Maximum: unlimited

Reference Field Creation:

{
  "type": "Reference",
  "displayName": "Author",
  "isRequired": true,
  "metadata": {
    "collectionId": "abc123..."
  }
}

For MultiReference:
{
  "type": "MultiReference",
  "displayName": "Tags",
  "metadata": {
    "collectionId": "def456..."
  }
}

Notes:
- Must provide collectionId of referenced collection
- Referenced collection must already exist
- Max 5 MultiReference fields per collection

Phase 7: Verification Best Practices

Post-Creation Verification:

After creating collection and fields:
1. Call data_cms_tool with action get_collection_details with collection ID
2. Verify all fields present
3. Check field properties match request
4. Confirm relationships configured correctly

Final Report Format:

🎉 Collection Setup Complete!

Collection: [Name]
ID: [collection-id]
Slug: [slug]

Fields Created ([X]):
├── name (PlainText, required) ← Auto
├── slug (PlainText, required) ← Auto
├── [field-1] ([Type])
├── [field-2] ([Type])
└── [field-n] ([Type])

[If relationships exist]
Relationships:
├── [field] → [Collection]
└── [field] → [Collection]

[If any failures]
⚠️ Failed Fields ([Y]):
├── [field]: [error]
└── [field]: [error]

---

💡 Next Steps:
[Relevant suggestions based on collection type]

Next Steps Suggestions:

For any collection:
1. Use bulk-cms-update to add initial items
2. Create collection template page in Designer
3. Create collection list page
4. Configure SEO settings

For collections with relationships:
5. Create referenced collections first
6. Add items in dependency order
7. Test relationship displays

For e-commerce:
5. Set up payment integration
6. Configure inventory management
7. Create checkout flow

Phase 8: Error Handling

Common Errors:

1. Collection Name Conflict:

❌ Collection Already Exists

A collection named "Blog Posts" already exists on this site.

Existing collection:
- Name: Blog Posts
- ID: xyz789...
- Created: 2025-12-15

Would you like to:
1. Choose a different name
2. View existing collection
3. Add fields to existing collection
4. Cancel

2. Plan Limit Reached:

❌ Plan Limit Reached

Cannot create collection. You've reached your plan limit.

Current: 20/20 collections (CMS Plan)

Options:
1. Upgrade to Business Plan (40 collections)
2. Delete unused collections
3. Contact Webflow support

Would you like me to show your existing collections?

3. Invalid Field Type:

❌ Invalid Field Type

Field type "dropdown" is not supported by Webflow.

Did you mean:
- "Option" - Single choice from list
- "Reference" - Link to another collection
- "MultiReference" - Link to multiple items

Which would you like to use?

4. Referenced Collection Not Found:

❌ Referenced Collection Not Found

Cannot create reference field to "Authors" collection.

Issue: "Authors" collection doesn't exist yet.

Solutions:
1. Create "Authors" collection first
2. Remove reference field for now
3. Let me create both collections in order

Your choice? (1/2/3)

5. Multi-Reference Limit Exceeded:

❌ Too Many Multi-Reference Fields

You requested 6 multi-reference fields.
Webflow limit: 5 per collection

Requested:
1. Tags
2. Categories
3. Related Products
4. Features
5. Certifications
6. Compatible Products ← Exceeds limit

Choose 5 to keep, or convert one to Reference field.

Phase 9: Advanced Scenarios

Self-Referencing Collections:

Example: Categories with parent categories

Collection: Categories
Fields:
├── name (PlainText, required)
├── slug (PlainText, required)
├── parent-category (Reference → Categories)
└── level (Number) - 1, 2, 3 for hierarchy

Implementation:
{
  "type": "Reference",
  "displayName": "Parent Category",
  "isRequired": false,
  "metadata": {
    "collectionId": "[same-collection-id]"
  }
}

Note: Must create collection first, then add self-reference field

Multi-Collection Setup:

When creating multiple related collections:

1. Identify dependencies:
   - Which collections reference others?
   - What's the creation order?

2. Create in order:
   - Independent collections first
   - Dependent collections after

3. Show overall progress:
   [1/4] Creating Categories...
   [2/4] Creating Brands...
   [3/4] Creating Tags...
   [4/4] Creating Products...

4. Report collectively:
   All 4 collections created successfully!

Complex Option Fields:

For complex dropdowns:

User: "Create status field with Draft, In Review, Approved, Published, Archived"

Option field with 5 choices:
{
  "type": "Option",
  "displayName": "Status",
  "isRequired": true,
  "metadata": {
    "options": [
      {"name": "Draft"},
      {"name": "In Review"},
      {"name": "Approved"},
      {"name": "Published"},
      {"name": "Archived"}
    ]
  }
}

Tip: Use workflow order for options

Production Checklist

Before considering collection setup complete:

✅ Discovery

Site selected and confirmed
Plan limits checked
Existing collections listed
No naming conflicts
User has appropriate permissions

✅ Requirements

Display name gathered
Singular name gathered
All fields defined with types
Required vs optional specified
Relationships identified

✅ Validation

All field types valid
Multi-reference count ≤ 5
Referenced collections exist or queued
No circular dependencies
Field names follow conventions
Within plan limits

✅ Preview

Complete schema shown
All fields listed with properties
Relationships displayed
Validation results shown
User confirmation obtained

✅ Creation

Collection created successfully
Collection ID captured
All fields created
Field creation errors handled
Progress shown to user

✅ Verification

Collection retrieved and verified
All fields present
Field properties correct
Relationships configured
Any errors reported

✅ Reporting

Final summary provided
Collection ID shared
Fields listed
Failures reported (if any)
Next steps suggested

✅ Error Handling

Collection conflicts handled
Plan limits checked
Invalid field types caught
Missing references detected
Partial failures reported

cms-collection-setup

NPX Install

Tags

SKILL.md Content

CMS Collection Setup

Important Note

Instructions

Phase 1: Site Selection & Discovery

Phase 2: Requirements Gathering

Phase 3: Schema Validation & Planning

Phase 4: User Approval

Phase 5: Collection Creation

Phase 6: Field Creation

Phase 7: Verification & Reporting

Field Type Reference

Static Field Types

Option Field Type

Reference Field Types

Examples

Example 1: Simple Blog Collection

Example 2: Collection with Relationships

Example 3: Team Members with Option Field

Example 4: Complex E-commerce Setup

Guidelines

Phase 1: Discovery Best Practices

Phase 2: Requirements Gathering Best Practices

Phase 3: Schema Validation Best Practices

Phase 4: Preview Best Practices

Phase 5: Creation Best Practices

Phase 6: Field Creation Best Practices

Phase 7: Verification Best Practices

Phase 8: Error Handling

Phase 9: Advanced Scenarios

Production Checklist

✅ Discovery

✅ Requirements

✅ Validation

✅ Preview

✅ Creation

✅ Verification

✅ Reporting

✅ Error Handling