Documentation

FolioMuse docs

Everything you need to know about building a portfolio that is genuinely your own — informed by real examples, sharpened by AI feedback, assembled with an agent.

What is FolioMuse?

FolioMuse is a portfolio-building product that helps individual creators and professionals build a portfolio that is genuinely their own. It is not a template marketplace, a cloning service, or a general-purpose website builder.

The core promise: See what works, understand why it works, and get help making your version — not a copy.

The three pillars

Human Gallery

A curated collection of real, attributed portfolio examples. Every entry is reviewed, scored (L0-L4), and carries immutable attribution metadata. Browse by role, style, stack, or quality level.

Section Intelligence

AI-powered analysis scoped to individual portfolio sections — hero, projects, case studies, about, contact. Feedback is grounded in patterns across 3+ examples, never a single source.

MCP Agent

An AI assistant that helps you build, edit, and refine your portfolio through natural-language conversation. It only writes content you authored or synthesized guidance.

Who is FolioMuse for?

P1 — The Builder

Professionals actively building or refreshing their portfolio. Has real work to showcase but unsure about structure/presentation.

P2 — The Explorer

Career-changers or early-career professionals browsing for inspiration before having much content of their own.

P3 — The Agent Operator

Users who prefer conversational tooling. Describe intent and have the agent apply changes using your own content.

What makes FolioMuse different?

01

Generic AI tools produce generic output. FolioMuse produces feedback grounded in real, attributed examples.

02

Portfolio templates produce identical-looking sites. FolioMuse helps you understand why a layout works, then build your own.

03

Other tools let you copy. FolioMuse enforces originality through 8 binding rules (R1-R8) and a compliance gate.

04

Section-level intelligence gives feedback on specific parts of your portfolio, not vague whole-site advice.

The four-step process

FolioMuse follows a clear path from discovery to a finished portfolio. Each step builds on the previous one.

01

Discover

Browse the curated gallery of real portfolios. Filter by role (designer, developer, photographer, etc.), style tags (minimal, editorial, dark), stack tags (React, Figma, etc.), or quality level. Use the search bar for keyword matching across titles, creators, and tags. Hit Random to discover something unexpected.

  • The gallery contains portfolios that have passed a quality review (L2 or above) and compliance check.
  • Every portfolio carries attribution: creator name, source URL, license type, and consent date.
  • Facet counts are computed server-side — you see how many portfolios match each filter before applying it.
02

Study & analyze

Open any portfolio to see its full detail view: sections, strengths, stack evidence, and quality score. Understand what makes it work — the structure, the narrative, the visual hierarchy.

  • Section patterns are extracted from the portfolio: hero, projects, case studies, about, contact, and more.
  • Strengths are identified by the curation system: clear problem statements, strong visual hierarchy, specific outcomes.
  • Stack evidence shows what technologies were used and how they're demonstrated in the portfolio.
03

Draft your portfolio

Start your own portfolio draft. The MCP agent helps you structure sections and sharpen your narrative based on patterns across 3+ examples. You write; the agent refines.

  • The agent never writes content from scratch — it improves your existing draft.
  • Suggestions are synthesized from aggregated patterns, never copied from a single portfolio.
  • Every agent edit is marked in your edit history so you can see what changed and why.
04

Assemble & ship

Go from draft to polished portfolio in minutes. The agent assembles sections, you refine the details, and ship. Every change is tracked, every suggestion is rejectable.

  • Before publishing, an originality check compares your portfolio against gallery items.
  • You can always see why a suggestion was made and reject it without side effects.
  • Published portfolios are monitored for similarity (R8) to maintain gallery integrity.

MCP Agent overview

The FolioMuse MCP agent is an AI assistant that helps you build, edit, and refine your portfolio through natural-language conversation. It connects via the Model Context Protocol (MCP).

The agent is nota chatbot that generates generic content. It’s a specialized tool that understands portfolio structure, analyzes patterns across real examples, and helps you improve your own work.

How the agent works

  1. Pattern analysis: the agent analyzes patterns across multiple gallery examples (minimum 3) to understand what works in your field.
  2. Feedback generation: based on those patterns, it gives you structural and content feedback scoped to specific sections.
  3. Content refinement: it helps you refine your own draft — reordering, tightening, sharpening — never writing from scratch.
  4. Edit tracking: every change the agent makes is marked in your edit history, distinguishable from your own edits.

Example conversation

You
“I’m a front-end developer. I have my own case study draft, but the intro feels flat. Can you help me sharpen it and suggest what sections to lead with?”
FolioMuse agent

Across the 3+ developer portfolios we reviewed, the strongest intros open with the problem being solved and one concrete constraint — not the stack. Your draft already names the tech; try leading with the constraint instead.

Based on that pattern, here’s a tightening of your own opening line (your words, re-ordered):

“The map had to load in under a second — on hotel Wi-Fi, with 40k points. That constraint drove every choice in this case study.”

I only reworked your text — I didn’t pull copy from any gallery portfolio.

Safety rules

R2

Synthesis, not sourcing

Suggestions derive from patterns aggregated across N ≥ 3 items, never a single source verbatim.

R3

Attribution travels

Attribution is always retrievable and displayed alongside any referenced content.

R5

User content only

The agent only writes content you authored or synthesized guidance — never gallery copy.

R6

AI disclosure

AI-authored content is marked in your edit history, distinguishable from manually-typed content.

R7

Inspect & reject

You can see why a suggestion was made and reject it without side effects.

Available tools

The MCP agent exposes these tools (all respect safe projection rules — no full-content fetch):

list_gallery_items

Browse accepted gallery items with filtering and pagination.

get_item_summary

Get metadata and attribution for a specific gallery item.

get_section_patterns

Get aggregated section patterns across multiple items.

analyze_portfolio_section

Analyze a user's portfolio section against patterns.

suggest_improvements

Get improvement suggestions for a specific section.

Originality rules (R1-R8)

These rules are binding on any feature touching the gallery, section intelligence, or MCP agent. A feature that violates any rule must be rejected or amended before merge.

R1

No verbatim structural cloning

No feature may allow a user to duplicate another gallery item's full structure + copy + assets as a single action that produces a near-identical portfolio.

This is enforced at the compliance gate through cross-creator clone detection. The quality scoring rules also incentivize against cloning: L3+ requires original, specific content.

R2

Synthesis, not sourcing

Section-intelligence suggestions must be generated from patterns aggregated across multiple gallery examples (minimum N ≥ 3), never from a single item's exact content.

If only one relevant example exists, the system falls back to general structural principles rather than paraphrasing that one item.

R3

Attribution travels with content

Any time gallery content is displayed, referenced in feedback, or used to ground an AI suggestion, its attribution/provenance metadata must be retrievable and displayed.

Attribution is stored as a non-nullable foreign key in the schema and enforced at the persistence layer.

R4

Consent-gated ingestion

No third-party portfolio content enters the gallery without an explicit consent/licensing record. Scraping without consent is prohibited.

The consent model records who consented, when, and under what terms. Consent can be revoked at any time.

R5

Agent writes only user-owned content

The MCP agent may only write content that is either authored/dictated by the user or synthesized guidance derived per R2. It must never copy gallery item content directly.

This is the core anti-cloning rule for the agent. All agent output must be traceable to the user's own inputs plus synthesized guidance.

R6

Disclosure of AI authorship

Any content inserted or modified by the MCP agent must be marked as such in the portfolio's edit/version history, distinguishable from manually-typed user content.

This ensures transparency and allows users to see exactly what the agent changed.

R7

Right to inspect and reject

Users must always be able to see why a suggestion was made and reject it without side effects. Suggestions must never auto-apply without explicit user action.

Unless the user has explicitly configured an auto-accept policy, every suggestion requires manual acceptance.

R8

Similarity monitoring

Before or at publish time, a published portfolio should be checked against the originality-score guardrail. The signal is computed and logged.

The exact algorithm and threshold are defined in an ADR. The data model is ready for enforcement (warn vs. block) in a future version.

Personas

P1

The Builder (primary)

An individual professional (designer, developer, writer, photographer, PM) who has real work to showcase but is unsure how to structure or present it. Actively job-hunting, freelancing, or refreshing an existing portfolio.

Goals:

  • Present actual work clearly and credibly.
  • Understand what “good” looks like without studying dozens of sites.
  • Get concrete, section-specific feedback.
P2

The Explorer

Someone earlier in their career (student, career-changer, junior professional) who doesn’t yet have a strong portfolio. Browsing for inspiration and structural understanding before producing much work of their own.

Goals:

  • Understand what sections/structure a portfolio in their field needs.
  • Build confidence about what “enough” looks like.
  • Avoid copying someone else’s site.
P3

The Agent Operator

A user who prefers conversational or programmatic tooling. Wants to describe intent (“tighten my hero section”) and have the agent apply it, using their own content.

Goals:

  • Make edits through natural-language instructions.
  • Trust that agent advice is grounded in real patterns.
  • Keep full ownership/authorship of content.

For AI agents & automation

If you’re an AI agent or automation tool accessing FolioMuse, this section covers the key endpoints and patterns you need.

GET/api/gallery/summaries

Paginated gallery items with filtering. Returns { items, total, page, pageSize }.

Params: q, role, style, stack, quality, consent, sort, page, pageSize

GET/api/gallery/facets

Facet counts for filter UIs. Returns { facets: { roles, styles, stacks, qualities, consents, total } }.

Params: None

GET/api/gallery/random

Returns a random accepted portfolio ID. Returns { id }.

Params: None

GET/api/gallery/items/[id]

Full portfolio detail including sections, strengths, stack evidence.

Params: id (path)

GET/api/sections

Section pattern library. Browse reusable portfolio section patterns.

Params: sectionType (optional)

Code examples

Fetch a random portfolio

const res = await fetch("/api/gallery/random");
const { id } = await res.json();
window.location.href = `/gallery/${id}`;

Search portfolios by role

const res = await fetch(
  "/api/gallery/summaries?role=Front-end%20Developer&pageSize=10"
);
const { items, total } = await res.json();
console.log(`Found ${total} portfolios`);
items.forEach(item => {
  console.log(item.title, item.attribution.creatorName);
});

Get facet counts for filters

const res = await fetch("/api/gallery/facets");
const { facets } = await res.json();

// facets.roles: [{ value: "Designer", count: 15 }, ...]
// facets.styles: [{ value: "minimal", count: 8 }, ...]
facets.roles.forEach(r => console.log(`${r.value}: ${r.count}`));

Safe projection rules

  • No full-content fetch (ADR-0001): the API never returns raw content blobs.
  • Aggregated patterns only (R2): only patterns across N ≥ 3 items.
  • User content only (R5): only user-authored or pattern-synthesized content.
  • Attribution always included (R3): every response includes attribution metadata.

API Reference

All API endpoints return JSON and use Cache-Control: no-store. Errors return { error, message }.

GET /api/gallery/summaries

Paginated gallery items with server-side filtering and sorting. This is the primary endpoint for browsing the gallery.

GET /api/gallery/summaries?q=react&role=Developer&sort=quality&pageSize=10

Response: {
  "items": [GalleryItemSummary, ...],
  "total": 42,
  "page": 1,
  "pageSize": 10
}

GET /api/gallery/facets

Facet counts for building filter UIs. Returns counts for roles, styles, stacks, qualities, consents, and total portfolio count.

GET /api/gallery/facets

Response: {
  "facets": {
    "total": 42,
    "roles": [{ "value": "Designer", "count": 15 }, ...],
    "styles": [{ "value": "minimal", "count": 8 }, ...],
    "stacks": [{ "value": "React", "count": 12 }, ...],
    "qualities": [{ "value": "L3", "count": 10 }, ...],
    "consents": [{ "value": "FULL", "count": 30 }, ...]
  }
}

GET /api/gallery/random

Returns a random accepted portfolio ID. Use this for discovery features or “surprise me” buttons.

GET /api/gallery/random

Response: { "id": "clx..." }

// 404 if no accepted portfolios exist
// 500 if gallery is unavailable

GET /api/gallery/items/[id]

Full portfolio detail for a specific item. Includes sections, strengths, stack evidence, and all metadata.

GET /api/gallery/items/clx...

Response: {
  "id": "clx...",
  "title": "Portfolio Title",
  "creatorRole": "Front-end Developer",
  "sections": [...],
  "strengths": [...],
  "stackEvidence": [...],
  ...
}

Query parameters

ParamTypeDescription
qstringSearch query (title, role, tags)
rolestring[]Filter by creator role (repeatable)
stylestring[]Filter by style tags (repeatable)
stackstring[]Filter by stack tags (repeatable)
qualitystring[]Filter by quality level L0-L4 (repeatable)
consentstring[]Filter by consent tier (repeatable)
sortstringSort: newest | title-asc | title-desc | quality
pagenumberPage number (default: 1)
pageSizenumberItems per page (1-100, default: 24)

Response shape

// GalleryItemSummary (returned in /summaries responses)
{
  "id": "clx...",
  "title": "Portfolio Title",
  "creatorRole": "Front-end Developer",
  "styleTags": ["minimal", "editorial"],
  "qualityLevel": "L3",
  "complianceStatus": "PASS",
  "status": "ACCEPTED",
  "attribution": {
    "creatorName": "Jane Doe",
    "sourceUrl": "https://janedoe.com",
    "licenseType": "DISPLAY",
    "consentDate": "2025-01-15T00:00:00.000Z"
  },
  "consentTier": "FULL",
  "reviewedAt": "2025-01-20T00:00:00.000Z",
  "mediaUrl": "https://...",
  "githubUrl": "https://github.com/...",
  "stackTags": ["React", "TypeScript", "Tailwind"]
}