Secret

MCP设计创作

提供方 未标注

设计创作 stdio · 本地进程 未标注 社区 / 第三方 ClaudeCursorVS CodeCodex
查看接入方式

基于近期GDWEB参考资料的实证网页设计分析,通过隔离的MCP采样请求生成可直接实施的DESIGN_INDEX规范。

一句话选型结论

按资料字段整理

Secret 属于设计创作类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude、Cursor、VS Code 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类设计创作 传输方式stdio · 本地进程 鉴权未标注 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

设计创作
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

设计

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
npx -y secret-design-mcp

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
出图与素材

生成配图、图标与素材。

设计稿处理

读取设计稿、批量改尺寸或导出。

内容生成

按主题生成文案与视觉草稿。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在设计创作场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Secret当前 未标注 stdio · 本地进程 本地部署 有 未标注
Cursor Talk To Figma MCP Da1c7911 40 未标注 未标注 无 2026-05-17
Blender MCP 17 stdio · 本地进程 本地部署 有 2026-05-18
Nova Canvas MCP Server 2 stdio · 本地进程 本地部署 有 2026-05-17
Figma Context MCP 3aaa8d28 未标注 未标注 支持远程部署 无 2026-05-17
kreuzberg 未标注 stdio · 本地进程 本地部署 有 2026-04-12

服务器档案

设计创作
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类设计创作本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

35.4 KB
来自项目仓库与上游目录的原文,未做删改

English | 한국어

Target Architecture


Secret MCP

An evidence-grounded MCP server for web design analysis, screenshot-to-specification workflows, and frontend reconstruction planning.```bash
npx -y secret-design-mcp


Secret MCP is a local Model Context Protocol (MCP) server that searches GDWEB for recent design references and **creates a separate LLM request and a separate `DESIGN_INDEX` file for every search result**. Each file contains page- and route-specific layouts, navigation, pixel coordinates, colors, components, and responsive specifications traceable to the supplied visual evidence.

The name `Secret MCP` does not mean that the project provides secret features or private data. It was the project name used while experimenting in a private repository with the idea of building an MCP server around design websites. The project's current purpose is to extract reproducible structural evidence from public design references and turn it into one specification per work that an LLM can apply to a new project.

Images and descriptions from multiple works are never combined in a single LLM context or document. The server processes search results sequentially inside the server, creates an independent MCP `sampling/createMessage` request for each work, saves that work's file, and only then advances to the next work. A separate local web application lets you select one work at a time, inspect its source evidence, measured colors and coordinates, LLM contract, generation log, and final document, and manage the exclusion list for subsequent searches.

## Research Note

> **Evidence-Isolated Multimodal Design Analysis through MCP Sampling**
>
> Working paper and implementation report · Secret MCP v0.6.0 · not peer reviewed

### Abstract

Secret MCP implements an auditable pipeline for converting public webpage screenshots into implementation-oriented design specifications. The system prepares desktop and mobile visual evidence, records crop coordinates and representative pixel colors, and invokes client-side MCP sampling once per reference. Unlike workflows that concatenate several design references into one prompt, Secret MCP treats reference identity as both a request boundary and an artifact boundary: one reference produces one sampling request, one request contract, and one `DESIGN_INDEX` document. Each request asks for `includeContext: none` and applies the same 19-section specification contract covering routes, geometry, components, design tokens, responsive behavior, accessibility, implementation tasks, acceptance criteria, and uncertainty. This report evaluates protocol-level isolation and artifact production; it does not claim that one language model, prompt, or reconstruction method outperforms another. A live smoke test verifies the request boundary, while a preserved three-reference run provides descriptive measurements and a qualitative implementation case.

### Research Questions

| Question | Current evidence | Status |
| --- | --- | --- |
| **RQ1.** Can an MCP design-analysis tool maintain one-reference-per-request isolation? | Live sampling smoke test with cross-reference ID inspection and output-file checks | Verified within the test scope |
| **RQ2.** Can screenshot evidence be transformed into auditable spatial, color, and document artifacts? | Preserved three-reference run with evidence manifests, contracts, and generated documents | Descriptively verified |
| **RQ3.** Can the resulting specification guide a distinct frontend implementation? | AEROFLOW qualitative case study | Preliminary; no controlled comparison |

### Formal System Model

For reference `r_i`, the prepared evidence set contains image tiles `I`, crop bounds `B`, representative-color measurements `P`, and source metadata `M`. The fixed specification contract is `C`; the independent request and resulting document are `q_i` and `D_i`.```text
E_i = { I_i,k, B_i,k, P_i,k, M_i }
q_i = sampling/createMessage(C, E_i; includeContext = none)
D_i = G_theta(q_i)

References(q_i) = { r_i }
For every i != j: referenceId(r_j) is absent from q_i

Coordinates measured inside a prepared tile map back to the original screenshot as follows.```text
x_source = (cropLeft + x_tile) / scaleX
y_source = (cropTop + y_tile) / scaleY


This is an operational isolation invariant, not a claim of statistical independence. The server and smoke test can inspect request contents and artifacts; they cannot prove what an arbitrary external model provider may retain outside the MCP message.

## Empirical Results

### Protocol Isolation```mermaid
flowchart LR
    R1["gdweb-26522"] --> Q1["Request 1<br/>5 evidence images<br/>includeContext: none"] --> D1["DESIGN_INDEX_gdweb-26522.md"]
    R2["gdweb-24516"] --> Q2["Request 2<br/>4 evidence images<br/>includeContext: none"] --> D2["DESIGN_INDEX_gdweb-24516.md"]
Sampling request gdweb-26522 present gdweb-24516 present Output documents
Request 1 1 0 1
Request 2 0 1 1

Figure 1. Live smoke test recorded on 2026-08-22 using the query 금융 (n = 2 sampled references after excluding gdweb-26905). Each request contained its own reference ID and visual evidence, no other sampled reference ID, and includeContext: none; the run produced two distinct Markdown files. The test verifies observable request composition and file separation, not model-memory behavior outside the protocol.

Recorded Run Measurements```mermaid

xychart-beta
title "Prepared evidence images per reference"
x-axis ["gdweb-27294", "gdweb-25378", "gdweb-24234"]
y-axis "Evidence images" 0 --> 5
bar [3, 4, 5]


| Reference | Desktop source height | Prepared images | Image payload | Color measurements | Document tokens | Document size | Required headings |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| `gdweb-27294` | 2,675px | 3 | 126.6KB | 24 | 7,921 | 54.0KB | 19/19 |
| `gdweb-25378` | 7,043px | 4 | 302.5KB | 32 | 9,953 | 69.8KB | 19/19 |
| `gdweb-24234` | 7,832px | 5 | 387.8KB | 40 | 9,517 | 63.2KB | 19/19 |

*Figure 2.* Descriptive measurements from preserved run `2026-07-29T15-54-10-483Z-5c70317e` (`n = 3` references). The run prepared 12 evidence images totaling 816.9 decimal KB and recorded 96 representative-color measurements. It produced three `DESIGN_INDEX` documents totaling 27,391 whitespace-delimited tokens and 187.0 decimal KB. All three contain headings 1–19; heading presence does not establish semantic correctness.

### Qualitative Case Study

*Figure 3.* A preserved qualitative trace from the GDWEB evidence viewer to the generated Korean Air `DESIGN_INDEX` and then to AEROFLOW. AEROFLOW intentionally introduces new branding, content, imagery, and functionality; this example illustrates specification use and is not a controlled visual-fidelity comparison.

### Interpretation and Limitations

- The live isolation result has `n = 2`; the recorded artifact analysis has `n = 3`. Neither supports broad claims about design quality or model performance.
- The current evaluation has no control group, human rating, repeated trials, confidence intervals, or comparison against screenshot-to-code baselines.
- Representative colors are measured after resizing, JPEG normalization, and channel quantization. They are screenshot evidence, not proof of the source website's CSS tokens.
- The 19/19 result measures required heading presence. A future benchmark must separately evaluate factual grounding, coordinate error, color difference, responsive behavior, and implementation fidelity.
- The qualitative implementation is an existence example, not evidence that Secret MCP improves reconstruction quality.

## Usage

### 1. Install and Build

Node.js 20.19 or later is required.

The published MCP server can be launched with:```bash
npx -y secret-design-mcp

Clone the repository when you also need the local viewer or want to work on the source:```bash
git clone https://github.com/yyeongjin/secret_mcp.git
cd secret_mcp
npm install
npm run build


### 2. Start the Web Application

Set `DESIGN_INDEX_OUTPUT_DIR` to the same value for the MCP server and the web application so that both processes read the same output directory.```bash
DESIGN_INDEX_OUTPUT_DIR=/absolute/path/to/design-index npm run web

Open the following address in a browser.```text
http://127.0.0.1:4317


The web application displays the generation-run list, per-work progress, GDWEB evidence images, measured coordinates and palettes, the specification contract sent to the LLM, the final Markdown, and generation timestamps. Documents and evidence are read-only; only `Exclude from search` and `Remove exclusion` change the filter used by subsequent searches.

### 3. Register the MCP Server```json
{
  "mcpServers": {
    "secret-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "secret-design-mcp"
      ],
      "env": {
        "DESIGN_INDEX_OUTPUT_DIR": "/absolute/path/to/design-index",
        "SECRET_MCP_WEB_ORIGIN": "http://127.0.0.1:4317"
      }
    }
  }
}

For a source checkout, replace command and args with "command": "node" and "args": ["/absolute/path/to/secret_mcp/dist/index.js"].

The MCP client must support sampling/createMessage. When a client does not support sampling, the server returns an explicit error instead of running a fallback that places multiple works in the same context.

The MCP stdio server itself does not open an HTTP port. The client launches node dist/index.js as a child process and exchanges JSON-RPC messages over stdio. Only the separate web viewer process uses port 4317 by default.

Direct Sampling Client for Hosts Without Sampling

The server does not need to be modified when the outer MCP host cannot answer sampling/createMessage. A separate MCP protocol client can connect directly to dist/index.js, advertise sampling: {}, and handle every sampling request by launching a fresh Codex LLM process in a fresh temporary workspace.```ts
const client = new Client(
{ name: 'secret-mcp-sampling-client', version: '1.0.0' },
{ capabilities: { sampling: {} } }
);

client.setRequestHandler(CreateMessageRequestSchema, async request => {
const workspace = await mkdtemp('secret-mcp-sampling-');
const response = await launchFreshCodex({
workspace,
messages: request.params.messages,
systemPrompt: request.params.systemPrompt,
});

return {
model: response.model,
role: 'assistant',
content: { type: 'text', text: response.markdown },
};
});


The sampling handler must copy only the current request's text blocks and evidence images into that workspace. It must not reuse a Codex conversation, process, working directory, response file, or message history from another work. The workspace launches one new Codex process, waits for its complete Markdown response, returns that response to the pending MCP sampling call, and can then be removed after the server has saved the work's contract, evidence, and document.

The server still controls the sequential queue: work 2 is not prepared until work 1 has returned and been saved. This makes the fresh process and workspace an execution-level equivalent of the protocol-level `includeContext: none` boundary without adding a combined fallback to the server. The direct client becomes the sampling-capable MCP host; it should use a tool-call timeout long enough for the per-work output budget and must never answer multiple sampling requests through one persistent LLM conversation.

### 4. Ask the LLM

A separate `/web-design` slash command is not required.```text
Find three recent design references on GDWEB that are suitable for a Godot project website.
Analyze every search result through a completely independent LLM request,
and create one reproducible DESIGN_INDEX document for each result.
Inside each document, separate every visible page into its own page specification,
and specify everything from navigation and section coordinates to exact color formats and responsive values.

The host LLM calls the generate-gdweb-design-indexes tool once. The MCP server performs the search and separates the per-work LLM requests internally.

The manual tool-call format is shown below.```json
{
"name": "generate-gdweb-design-indexes",
"arguments": {
"query": "game portfolio",
"limit": 3,
"awardOnly": true,
"includePreviousYear": true,
"language": "English",
"outputDirectory": "/absolute/path/to/design-index",
"maxTokens": 131072
}
}


If `outputDirectory` is omitted, the tool uses the `DESIGN_INDEX_OUTPUT_DIR` environment variable. If that variable is also absent, it uses the `design-index` directory under the server's working directory.

`maxTokens` is a per-work output budget, not a budget shared by the run and not a budget divided equally between pages. A single work may contain multiple visible pages or routes, and every page must repeat the complete page-specific parts of the 19-section contract. The default and minimum are therefore `131072` tokens. Clients may request up to `262144` tokens for exceptionally large multi-page evidence sets.

With `limit: 3`, the default run can request up to three independent `131072`-token outputs; the works do not share one `131072`-token pool. The connected sampling client and selected model must support the requested output size. If the model returns `stopReason: maxTokens`, the server treats that work as failed instead of saving a truncated `DESIGN_INDEX` as complete.

When the tool completes, it returns the run ID, run-manifest path, per-work document paths, and web-viewer URL.

## End-to-End Example: From GDWEB Specifications to a Godot Aviation Website

For the actual example, Secret MCP found three aviation award winners registered on GDWEB in 2026 and 2025, created a `DESIGN_INDEX` for each work through an independent LLM request, and then applied the structure of the Korean Air reference to a Godot aviation project website.

The finished `AEROFLOW` website is not a clone of the Korean Air website. It uses the information hierarchy, navigation, action panel, section arrangement, and responsive principles from the specification while introducing a new brand, copy, aviation imagery, and content. This example demonstrates that **even when the resulting design differs from the reference, measurable structural evidence can still produce a polished website with a distinctive identity**.

### Run the Example```bash
# 1. Build
npm install
npm run build

# 2. Per-work document web viewer
DESIGN_INDEX_OUTPUT_DIR="$PWD/tmp/design-index/aviation-godot-20260730" npm run web

# 3. Specification-driven result website
python3 -m http.server 4320 \
  --bind 127.0.0.1 \
  --directory tmp/showcase/aviation-godot/generated-site

After starting the processes, open the following screens.

  • Per-work specification web viewer:
  • AEROFLOW result website:

1. Per-Work Specification Results

Select works one at a time from the run list on the left. The right side displays only the final DESIGN_INDEX for the selected work, without mixing in content from other works.

2. Evidence Images and Measurements

The Evidence tab shows the desktop and mobile images sent to the independent LLM request, tile coordinates, reduction ratios, and representative colors.

3. Independent LLM Request Contract

The Request Contract records page separation, navigation, section bounds, HEX/RGB/HSL colors, components, the responsive matrix, and acceptance criteria. This contract prevents the result from ending as a superficial mood summary and makes it an implementation specification another LLM can use.

4. Generation Process

The Generation Log shows the sequence from search and evidence preparation through the independent per-work LLM request, document save, and full-run completion. This run processed all three works with separate includeContext: none requests.

5. Specification-Driven AEROFLOW First View

The bright aviation portal and action-panel structure observed in the Korean Air reference were adapted to a Godot project. The brand, aircraft imagery, copy, and functionality were created specifically for this result.

6. Project Highlights

The reservation and promotion card structure was repurposed for core project content: flight regions, a glass cockpit, and real-time weather.

7. Development Log and Shortcuts

The source reference's notices and service shortcuts were restructured into build history, development progress, flight models, avionics, media, controls, and roadmap navigation.

8. Media and Footer

The final area contains project media, development, support, and license links, followed by an independent-project footer.

What This Result Demonstrates

  • A new project can use a validated information hierarchy and layout relationships without copying the reference's logo, trademarks, copy, or images.
  • Converting static screenshots into navigation, pixel bounds, color tokens, components, and a responsive matrix gives another LLM enough detail to create a concrete implementation plan.
  • Even with the same structural evidence, newly designed content, branding, and visual assets can create a distinctive identity that differs from the source.
  • Secret MCP is intended to extract structural evidence from good design and use it to build a polished website suited to a new project, not to reproduce the source pixel for pixel.

Specification and Request Contract

  • Korean Air DESIGN_INDEX specification
  • Independent LLM request contract
  • Run manifest
  • Generated website source

These links point directly to the actual files included in the repository. The same artifacts are also grouped under tmp/showcase/aviation-godot through relative symbolic links for local execution and browsing.

Core Execution Architecture```mermaid

flowchart TD
User["User request"] --> Host["Host LLM"]
Host --> Tool["One generate-gdweb-design-indexes call"]
Tool --> Exclusions["Load the exclusion list managed in the web viewer"]
Exclusions --> Search["Search GDWEB internally and filter work IDs"]
Search --> Queue["Keep results inside the server"]
Queue --> R1["Work 1 images + specification contract"]
R1 --> S1["Independent sampling/createMessage request 1"]
S1 --> F1["Save DESIGN_INDEX_gdweb-1.md"]
F1 --> R2["Work 2 images + specification contract"]
R2 --> S2["Independent sampling/createMessage request 2"]
S2 --> F2["Save DESIGN_INDEX_gdweb-2.md"]
F2 --> More["Repeat sequentially for every work"]
More --> Manifest["Record per-work evidence and status in run.json"]
Manifest --> Web["Inspect one work at a time in the local web viewer"]
Manifest --> Status["Return only file paths and statuses to the host"]


The following boundaries are essential.

- Images or specification bodies from multiple works are never returned to the outer host LLM as one batch.
- With `limit: 3`, the server performs exactly up to three mutually independent LLM sampling requests.
- Every sampling request uses `includeContext: none`.
- A sampling request contains only one work's metadata and image tiles.
- The previous work's ID, images, and analysis document are never passed into the next work's request.
- Works excluded in the web viewer are removed from search results before any sampling request is created.
- The server starts the next work only after saving the current sampling response to a file.
- At the end, only generated file paths, the model used, and success or failure status are returned to the host.

In other words, this is not the earlier architecture in which the host LLM reads every result at once and produces a combined summary.

## Web Viewer

The web viewer reads `DESIGN_INDEX_OUTPUT_DIR/.secret-mcp-runs` every 2.5 seconds. There is no separate database or debugging connection between the MCP generation process and the web server.

The interface contains the following areas.

- Generation runs: query, requested count, allowed years, and overall status
- Work list: progress and evidence-image count for each `gdweb-`
- Work details: specification, evidence images and measurements, request contract, and generation log for one selected work
- Search exclusions: exclude the selected work from future searches, include it again, and manage the full exclusion list

When a run contains three works, it also produces three documents as shown below.```text
.secret-mcp-runs/<run-id>/
├── run.json
├── contracts/
│   ├── gdweb-26905.md
│   ├── gdweb-26522.md
│   └── gdweb-xxxxx.md
├── evidence/
│   ├── gdweb-26905_desktop_01-of-05.jpg
│   ├── gdweb-26522_desktop_01-of-04.jpg
│   └── ...
└── documents/
    ├── DESIGN_INDEX_gdweb-26905.md
    ├── DESIGN_INDEX_gdweb-26522.md
    └── DESIGN_INDEX_gdweb-xxxxx.md

run.json is not a file that combines document bodies from multiple works. It is a viewer manifest containing only per-work file paths, status, timestamps, model, and evidence lists.

Search Exclusion List

Selecting Exclude from search in the web viewer saves the work number to the following file.```text
DESIGN_INDEX_OUTPUT_DIR/.secret-mcp/exclusions.json


- Historical runs and generated documents are never deleted.
- New `generate-gdweb-design-indexes` and `search-gdweb-designs` runs filter work numbers before selection.
- To avoid returning too few results because of exclusions, the search reads additional GDWEB candidates and selects the requested `limit` from the non-excluded works.
- Selecting `Remove exclusion` makes the work eligible again starting with the next search.
- The MCP server and web viewer must use the same `DESIGN_INDEX_OUTPUT_DIR` to share the same exclusion list.

## Image Processing

GDWEB's full desktop captures can be extremely tall and several megabytes in size. Sending the original base64 data directly in a sampling request can exceed MCP transport limits or cause a vision model to miss fine structural details.

Before creating the request for each work, `gdweb-sampling-images.ts` performs the following operations.

- Load the GDWEB desktop registration image with `sgbn=1`
- Load the GDWEB mobile registration image with `sgbn=3`
- Resize the desktop image to a maximum width of 1200px
- Split a long page into overlapping vertical tiles 1600px high
- Preserve the mobile image as separate evidence
- Compress the evidence as JPEG to reduce the MCP sampling-request size
- Record the original and prepared canvas dimensions, scale factor, prepared `x/y/width/height` coordinates, source-space coordinates, and source URL for every tile
- Measure eight representative colors from every tile and record HEX, RGB, HSL, and pixel coverage

Multiple tiles from one work are included in the same work-specific sampling request. Tiles from different works are never included in the same request.

Representative colors are measurements sampled from normalized screenshot pixels. They are precise evidence for visual comparison, but they must not be presented as the source site's CSS variables because JPEG error and image content affect the values. The generation contract distinguishes `MEASURED` colors from `INFERRED` implementation tokens.

The server does not open the work's live production website or crawl its DOM. Visual evidence is limited to the images and metadata registered on GDWEB.

## GDWEB Search

Design search does not use browser automation, Bing, Brave, or DuckDuckGo.```text
Query
  -> POST https://www.gdweb.co.kr/sub/search.asp
  -> form field: Txt_word=<query>
  -> parse the GDWEB result HTML
  -> collect work number, category, and registration year
  -> retain only the current and previous year
  -> load GDWEB detail metadata and registered images

Freshness Policy

  • If year is omitted, the current runtime year is used.
  • includePreviousYear defaults to true.
  • When run in 2026, only works registered in 2026 and 2025 are allowed by default.
  • With includePreviousYear: false, only the target year is allowed.
  • awardOnly defaults to true, so works without an award name are excluded.
  • limit can be set from 1 through 10.

Work Metadata

Field Description
strNo GDWEB work number, also used in the document filename
txtFgbn GDWEB work-category value
title Work title
gdwebUrl GDWEB work detail page
registeredDate / registeredYear Registration date and the year used for filtering
award Award name
concept Design concept
primaryColor Primary color
productionCompany Production company
desktopImageUrl GDWEB desktop capture (sgbn=1)
mobileImageUrl GDWEB mobile capture (sgbn=3)

DESIGN_INDEX Specification

Every independent sampling request includes the secret-mcp/design-index/v2 contract. The resulting filename is DESIGN_INDEX_gdweb-.md.

There is one file per work, but each file begins with a page and route inventory and repeats a complete subsection for every verified page. The contract does not mistake sections in a long scrolling capture for separate pages; it splits pages only when the evidence collage visibly contains separate screens.

Every document must contain all 19 numbered sections below.

Area Required Specification
Reconstruction goal Reference ID, target fidelity, routes, target viewports, and non-goals
Evidence and coordinate system Image IDs, original/prepared dimensions, scale, tile coordinates, source-space coordinates, and overlap-removal method
Site map Verified pages and routes, purpose, evidence images, shared shell, active menu, and confidence
Shared app shell Global background, container, gutters, overlays, page chrome, and stacking context
Navigation Desktop and mobile heights, logo/menu coordinates, gaps, touch areas, and active/hover/focus/open states
Per-page specification and coordinate table Canvas model, section order, x/y/width/height, layout, states, data, and evidence level for every page
Layout deep dive DOM, grid/flex, tracks, min/max, ratios, gaps, overflow, sticky, absolute, and z-index
Component abstraction Page-linked component tree, props, variants, slots, state, events, and data contracts
Tokens and exact colors HEX/RGB/HSL/alpha, usage, measurement coordinates, confidence, tolerance, and CSS variables
Typography Font family by role, px/rem, weight, line height, letter spacing, alignment, truncation, and responsive values
Assets and icons Page and section, display size, aspect ratio, crop, focal point, object-fit, loading, and fallback strategy
Responsive matrix Containers, columns, order, visibility, navigation, and spacing at 1440/1280/1024/768/390/360px
Interaction and motion Color, opacity, transform, duration, easing, keyboard, and reduced-motion behavior for every state
Accessibility Per-page landmarks, headings, focus, menu semantics, labels, alt text, contrast, and touch targets
Data and content Page entities, fields, counts, ordering, formats, localization, and loading/empty/error fixtures
Frontend architecture Routes, directories, page/shared modules, tokens, assets, state, and server/client boundaries
Implementation task graph Measurement, shell, navigation, per-page task IDs, dependencies, deliverables, and completion criteria
Per-page acceptance criteria Coordinate, color, and typography tolerances; viewport comparison; overflow; assets; keyboard; and performance
Uncertainties and decisions Per-page and per-section UNKNOWNs, adopted values, alternatives, confidence, and additional evidence required

Every major judgment is marked with one of the following evidence levels.

  • OBSERVED: directly visible in a GDWEB image or metadata
  • MEASURED: numerically verified from supplied pixel coordinates or the measured palette
  • INFERRED: reasonably inferred to reproduce the same result
  • UNKNOWN: cannot be verified from static evidence and must not be asserted as fact

Another LLM must be able to derive the component tree, tokens, responsive rules, assets, implementation order, and validation items from the completed document alone.

Exposed Tools

The server currently exposes five MCP tools.

Tool Purpose
generate-gdweb-design-indexes Search GDWEB, make an isolated LLM request per result, and save documents
search-gdweb-designs Return a GDWEB reference list without generating specifications
full-web-search Search the general web and extract full page content
get-web-search-summaries Return titles, URLs, and descriptions from a general search
get-single-web-page-content Extract the full content of a known general webpage

Use generate-gdweb-design-indexes for design planning, layout analysis, implementation specifications, and DESIGN_INDEX requests. Use search-gdweb-designs only for lightweight list requests.

Source Structure```text

secret_mcp/
├── src/
│ ├── index.ts MCP tool registration and sampling requests
│ ├── dashboard-server.ts Local web server and document/exclusion APIs
│ ├── design-index-run-store.ts Run manifest and per-work artifact records
│ ├── design-exclusion-store.ts Add/remove persistent search exclusions
│ ├── design-index-paths.ts Shared MCP/viewer output-path resolution
│ ├── gdweb-design-search.ts GDWEB search, year filtering, and registered-image loading
│ ├── gdweb-design-index-generator.ts Sequential per-work generation and Markdown saving
│ ├── gdweb-sampling-images.ts Long-capture resizing, tiling, and compression
│ ├── design-spec-contract.ts Required DESIGN_INDEX specification contract

…(正文过长,页面只展示前面部分,完整内容见仓库)
```

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Secret 怎么安装?

在客户端按下面的安装命令接入:npx -y secret-design-mcp。装完在客户端配置里引用同一个包或端点。

Secret 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Secret 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Secret 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

Secret 支持哪些客户端?

资料标注支持 Claude、Cursor、VS Code、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Secret 能提供哪些能力?

资料显示能力标签包括 设计。具体工具清单以官方文档为准。

Secret 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Secret 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。