Which integrations are available for this server?

Supports optional thumbnail generation through any OpenAI-compatible image API configured via environment variables. Provides tools for Roblox development, including generating complete Luau UI modules, design token systems, interface audits, Roblox-specific Luau review, and Rojo/Rokit/Wally/StyLua/Selene project scaffolding.

How do I use GEORGE GUI @Search?

This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.

GEORGE GUI @Search

by renniyy

Overview Schema Source Related Servers Discussions Admin

TypeScript

Hybrid

GEORGE GUI @Search is a Model Context Protocol server that turns natural language into production-grade Roblox interfaces: complete, self-contained Luau UI modules with theme tokens, animations, responsive layout and a controller API — every one audited for contrast, touch targets and text sizes before it is returned.

It is not an image-generation wrapper. Every artifact that comes out of George is real, editable, standards-checked code:

"a neon shop with tabs and item cards"
        │
        ▼  george_generate_gui
┌─────────────────────────────────────────────┐
│  ShopUI.module.lua                          │
│  ├─ --!strict (typechecks under luau-lsp)   │
│  ├─ Theme tokens (WCAG-validated palette)   │
│  ├─ Full instance hierarchy                 │
│  ├─ Tween animations + gamepad focus        │
│  ├─ Controller API (mount/open/on/setItems) │
│  └─ Self-critique audit: 100/100 ✓          │
└─────────────────────────────────────────────┘

Why George

	GEORGE GUI @Search
Audited by default	WCAG contrast math, 36 px touch targets, minimum text sizes, responsive checks — every generation is scored, and every palette/kind combination ships at 100/100 (verified by 144 test cases).
Really runs	Generated modules are valid `--!strict` Luau, parse under the real StyLua 2 formatter, and pass George's own Roblox-specialised static analysis with zero errors.
Design systems, not vibes	Six curated palettes with light/dark variants, 4 px spacing grid, type scale, radius and motion scales — emitted as a Luau `Theme` table and JSON.
Security-first patterns	The Luau templates (secure rate-limited remotes, retrying DataStore profiles, signals) are the kinds of code production games need, and the review engine flags unprotected DataStore calls, unvalidated remotes, frozen loops and more.
Offline-first	Zero network calls required. The research knowledge base, pixel thumbnail renderer and all generators run locally. Optional adapters (ComfyUI, any OpenAI-compatible image API, changedetection.io…) activate via environment variables.

Related MCP server: Roblox Studio MCP Server (Posuceius Fork)

Install

Requirements: Node.js ≥ 20 and any MCP client (Claude Desktop, VS Code, Cursor, Zed…).

npx george-gui-search

Or add it to your MCP client configuration (see docs/INSTALLATION.md for every client):

{
  "mcpServers": {
    "george-gui-search": {
      "command": "npx",
      "args": ["-y", "george-gui-search"]
    }
  }
}

The tool suite

Tool	Engine	What it does
`george_search`	George Research	Source-linked Roblox/MCP knowledge search (43 verified entries, all with official URLs).
`george_design_system`	George Designer	Emit a full design token system (Luau Theme module + JSON), or list palettes.
`george_generate_gui`	George Builder	Natural language → complete Roblox interface module (12 interface kinds).
`george_audit_gui`	George Inspector	Re-run the self-critique audit on any generated GuiSpec.
`george_generate_luau`	George Engineer	Production script templates: secure remotes, DataStore profiles, signals.
`george_review_luau`	George Engineer	Roblox-specialised static analysis of your Luau.
`george_project_scaffold`	George Architect	Rojo + Rokit + Wally + StyLua + Selene project scaffold.
`george_generate_thumbnail`	George Designer	Offline pixel-art thumbnail PNG + SVG banner; optional external image providers.
`george_integrations`	George Marketplace	Honest, live-probed status of the integration ecosystem.
`george_version`	—	Version and capability report.

Full schemas and examples: docs/MCP_TOOLS.md.

Interface kinds

main-menu · shop · inventory · settings · hud · loading-screen · leaderboard · notifications · dialogue · quest-tracker · profile-card · custom — auto-detected from your description, or forced explicitly.

Every generated module shares the same controller pattern:

local ShopUI = require(game.ReplicatedStorage.Shared.ShopUI)

local ui = ShopUI.mount()
ui:open()
ui:on("buy", function(item)
  print("Player wants to buy", item.name, "for", item.price)
end)
ui:setItems({
  { name = "Plasma Blade", subtitle = "Weapon", price = "750", badge = "NEW" },
})

Example session

You: Use george_generate_gui to build "a royal arcade profile card for the winner, light mode".
George: returns ProfileCardUI — a single ModuleScript with the Royal Arcade light design system, avatar slot, stat grid, badge row, VIEW PROFILE action, hover/press/gamepad feedback, entrance animation — and its audit report: 12 contrast checks passed, all touch targets ≥ 36 px, score 100/100.

Try it yourself in 60 seconds with the quickstart or the MCP Inspector:

npx @modelcontextprotocol/inspector npx george-gui-search

Configuration

George is zero-config. Optional environment variables activate adapters (see docs/CONFIGURATION.md):

Variable	Activates
`GEORGE_IMAGE_API_URL` + `GEORGE_IMAGE_API_KEY` (+ `GEORGE_IMAGE_MODEL`)	Any OpenAI-compatible image API for thumbnails
`GEORGE_COMFY_URL` (+ `GEORGE_COMFY_CHECKPOINT`)	A local ComfyUI instance for thumbnails
`GEORGE_SCRAPLING_URL`	A Scrapling extraction sidecar (see `examples/integrations/scrapling_sidecar.py`)
`GEORGE_AGENT_REACH_URL`	An Agent-Reach service for extended research reach
`GEORGE_BROWSER_USE_URL`	A browser-use server for authorised browser workflows
`GEORGE_CHANGEDETECTION_URL` (+ `GEORGE_CHANGEDETECTION_API_KEY`)	changedetection.io doc/dependency watch management

Unset variables never break anything — features degrade gracefully and george_integrations reports exactly what is active.

Architecture

┌─────────────────────────── MCP client (Claude / VS Code / Cursor / …) ─────────────────────────┐
│                                                                                                 │
│                          stdio · Model Context Protocol · @modelcontextprotocol/sdk             │
└───────────────────────────────────────────────┬────────────────────────────────────────────────┘
                                                │
┌─────────────────────────────── src/server.ts (10 validated tools) ─────────────────────────────┐
│                                                                                                │
│   core/gui-generator   intent → GuiSpec IR → Luau emission (kinds-a/kinds-b + shell)           │
│   core/tokens          6 palettes × light/dark, WCAG-solved by scripts/adjust-palettes.mjs     │
│   core/audit           self-critique: contrast math, touch targets, text sizes, responsive     │
│   core/luau-review     Roblox static analysis (deprecated APIs, unprotected DataStore, …)      │
│   core/luau-templates  secure-remotes · profile-store · signal                                 │
│   core/luau-text       canonicalizer (tab indent, one prop per line — StyLua-clean output)     │
│   core/knowledge       verified, source-linked research index                                  │
│   core/image           offline pixel renderer + SVG composer + provider adapters               │
│   core/png             dependency-free PNG encoder (Node zlib)                                 │
│   core/scaffold        Rojo/Rokit/Wally/StyLua/Selene project scaffolds                        │
│   integrations/        honest registry + health probes (11 mandated + ecosystem)               │
└────────────────────────────────────────────────────────────────────────────────────────────────┘

Details: docs/ARCHITECTURE.md · Tool schemas: docs/MCP_TOOLS.md · API: docs/API_REFERENCE.md

Quality gates (all enforced by CI)

71 automated tests, including a real MCP client→server protocol test over stdio
144 audit cases: every interface kind × palette × mode must score 100/100
Generated Luau passes the real StyLua 2.0.2 formatter with the shipped config (verified in CI-style checks) and typechecks under --!strict
The review engine flags its own historical bug classes: deprecated globals, unprotected DataStore calls, unvalidated remotes, frozen loops, chat-ignoring input handlers

Documentation

Doc	Purpose
Getting started	60-second first generation
Installation	Every supported MCP client
Configuration	Environment variables and providers
User guide	Recipes per interface kind
Developer guide	Working on George itself
Architecture	How the pipeline works
MCP tools	Every tool, schema and example
API reference	Programmatic embedding
Integrations	The integration acceptance report
Security	Threat model and guarantees
Troubleshooting	Fixes for common issues
FAQ	Answers
Roadmap	What's next
Changelog	Release history

Branding

The full identity — logo system, palettes, typography, mascot usage — lives in brand/BRAND_GUIDELINES.md. All assets are original works shipped as editable SVG plus optimized PNG.

Contributing

Issues and pull requests are welcome — see CONTRIBUTING.md. Security reports follow SECURITY.md. By participating you agree to the Code of Conduct.

License

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

This server cannot be deployed

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

Maintenance

ActivityMaintained

ResponsivenessNo recent community issues

Resources

Related MCP Connectors

marmo-uiA
io.github.mahmoudilyan
Live React design-system APIs, patterns, and code validation so AI agents build real UI, not slop.
Design Tools Developer Tools
2
https://mcp.marmoui.com/mcp
Visily UI Design
io.github.visily-app
UI design from prompts, screenshots, and URLs for AI coding agents and theme tokens.
Design Tools AI & Machine Learning Developer Tools
26
https://app.visily.ai/api/mcp
design-system
app.zaklad
Build and manage your design system with AI: tokens, themes, components, icons, Figma and code.
Design Tools Developer Tools
2
https://platform.zaklad.app/api/mcp
21st.devA
dev.21st
Find UI components and themes, retrieve code, and generate with hosted 21st AI when enabled.
Design Tools Developer Tools AI & Machine Learning
2
https://21st.dev/api/mcp

Related MCP Servers

Roblox Studio MCP
Developer Tools App Automation Games & Gamification
paralov
A
license
A
quality
C
maintenance
Enables AI coding tools to control Roblox Studio for workspace exploration, instance manipulation, and script management. It provides tools for playtesting, scene rendering, and integration with the Roblox Creator Store.
Updated a month ago (2026-09-30 11:33 UTC)
6
9
MIT
Roblox Studio MCP Server
Developer Tools Games & Gamification
Posuceius
A
license
Not graded
quality
D
maintenance
Connects AI assistants like Claude and Gemini to Roblox Studio, enabling game structure exploration, script editing, UI generation, style extraction, and bulk changes locally and safely.
Updated 7 months ago (2026-04-07 08:53 UTC)
6 npm
MIT
ui-architect-mcp
Design Tools Developer Tools App Automation
foduucom
A
license
A
quality
D
maintenance
Enables AI assistants to generate production-ready, professional UI design systems and components from simple descriptions, with real images, animated components, and automated quality checks.
Updated 7 months ago (2026-03-30 13:48 UTC)
16
MIT
roblox-studio-mcp
Developer Tools Code Execution
iknouee
F
license
Not graded
quality
C
maintenance
Enables AI assistants to directly manage Roblox Studio projects by creating, reading, updating, and deleting scripts, listing instances, executing Luau code, and inspecting properties. It works through natural language, making Studio operations accessible to AI.
Updated 3 months ago (2026-08-25 04:18 UTC)
-