SVGLoop
Allows SVGLoop to use a locally running Ollama server as its OpenAI-compatible model endpoint for generating, reviewing, and revising SVG logo and icon designs.
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.
SVGLoop
An MCP server that draws logos and icons as clean, editable SVG with your own local models.
SVGLoop doesn't need an image-generation model. It uses the same loop a human designer uses: plan a few directions, draw each one as SVG code, render it, have a vision model look at the render, fix what's wrong, and keep the best. Everything runs on your machine against any OpenAI-compatible server (llama.cpp, Ollama, LM Studio, …).

Real vector output: small, hand-editable SVG that stays sharp at any size, not a raster image to trace.
Self-checking: every draft is rendered and reviewed by a vision model at app-icon and favicon size.
Safe by construction: model-written SVG is sanitized before it is rendered or saved.
Fits any MCP client: Claude Desktop, Claude Code, VS Code, OpenCode, or your own app. There's also a command line and a TypeScript library.
Ready-to-use exports: SVG, PNGs from 16 to 512 px, a dark-mode variant and a Windows
.ico.
How it works

Plan: the model proposes N clearly different directions for your brief (JSON).
Draft: each direction is drawn as SVG under strict rules: one canvas, your palette, a shape limit, a margin, no text (letters as paths).
Clean and check: code, not a model, strips anything unsafe and checks the rules. It also renders the drawing to find blank, tiny or clipped artwork.
Review: a vision model sees the mark at 256 px and at 32 px (enlarged with hard pixels, so it judges real small-size legibility). It says what it actually sees, then lists strengths, problems and fixes, and scores 0–10 against your brief.
Revise: weak drafts go back to the drawing model with the problems, the strengths to keep, and what a viewer currently sees. Each direction keeps its best version, so a bad revision never replaces a good one.
Rank and export: the best directions come back as finalists.
Here is one direction improving over two revision rounds, with the reviewer's own words:

Model calls are batched: all drafts, then all reviews, then all revisions. On a single GPU, a server that swaps between a drawing model and a vision model swaps as rarely as possible. Using one multimodal model for both jobs avoids swaps entirely.
Related MCP server: logoloom
Requirements
A model server with an OpenAI-compatible
/v1/chat/completionsendpoint and a model that accepts images (for the review step). One multimodal model can do both drawing and reviewing.One of:
Node.js 20.3+ to run it with
npx(no install step), ora standalone binary from Releases (no runtime needed).
Start a local model (llama.cpp example)
llama-server -m your-model.gguf --mmproj your-model-mmproj.gguf --port 8080 -c 16384 --jinja--mmproj loads the vision part; without it the review step can't see the drawings. scripts/start-llama.ps1 and scripts/start-llama.sh wrap this with sensible defaults, including a VRAM headroom option.
Other servers work the same way: point SVGLOOP_BASE_URL at them, for example http://127.0.0.1:11434/v1 for Ollama or http://127.0.0.1:1234/v1 for LM Studio.
Add it to your MCP client
Set at least SVGLOOP_BASE_URL and SVGLOOP_MODEL. The model name must be one your server knows.
Claude Desktop (claude_desktop_config.json), Cursor and other clients that use mcpServers:
{
"mcpServers": {
"svgloop": {
"command": "npx",
"args": ["-y", "svgloop", "mcp"],
"env": {
"SVGLOOP_BASE_URL": "http://127.0.0.1:8080/v1",
"SVGLOOP_MODEL": "your-model-name"
}
}
}
}On Windows, some clients need "command": "cmd" with "args": ["/c", "npx", "-y", "svgloop", "mcp"].
Claude Code:
claude mcp add svgloop -e SVGLOOP_BASE_URL=http://127.0.0.1:8080/v1 -e SVGLOOP_MODEL=your-model-name -- npx -y svgloop mcpVS Code (.vscode/mcp.json):
{
"servers": {
"svgloop": {
"type": "stdio",
"command": "npx",
"args": ["-y", "svgloop", "mcp"],
"env": { "SVGLOOP_BASE_URL": "http://127.0.0.1:8080/v1", "SVGLOOP_MODEL": "your-model-name" }
}
}
}OpenCode (opencode.json):
{
"mcp": {
"svgloop": {
"type": "local",
"command": ["npx", "-y", "svgloop", "mcp"],
"environment": { "SVGLOOP_BASE_URL": "http://127.0.0.1:8080/v1", "SVGLOOP_MODEL": "your-model-name" },
"enabled": true,
"timeout": 90000
}
}
}Standalone binary: use the binary's path as command and ["mcp"] as args. It also reads an svgloop.config.json placed next to it.
Then ask your assistant something like:
Make a logo for Tidewell, a small app that tracks water intake. Calm and friendly; it has to work as an app icon.
Tools
Tool | What it does | Main parameters |
| Starts a run and returns a |
|
| Waits up to |
|
| Stops a run after the current model call. |
|
| Cleans, checks and renders any SVG and returns the images, so a client's own model can draw and look at its work. |
|
| Writes final files: SVG, PNGs, dark variant, |
|
Jobs run one at a time, so a single GPU never serves two runs at once.

Command line
The same program works from a terminal:
npx svgloop make --brief "Logo mark for Tidewell, a water tracker app"
npx svgloop make --brief "..." --start out/run-.../final-1.svg --feedback "rounder, less orange"
npx svgloop validate logo.svg # rule and safety check, canvas problems
npx svgloop render logo.svg --sizes 32,256
npx svgloop export logo.svg --name tidewell
npx svgloop ping # do the model endpoints answer?Add --json for machine-readable output, so any program in any language can call it. Each make run writes a folder containing every draft (c<n>-r<round>.svg/.png), the plan (concepts.json), the finalists (final-<n>.svg/.png) and result.json with every score and reviewer note.
Configuration
Settings come from environment variables, a config file, or both (environment variables win).
Environment variables
Variable | Meaning |
| OpenAI-compatible base URL, e.g. |
| Model name, used for drawing and reviewing |
| Optional bearer key |
| Use a different model (or server) for the review step |
| JSON merged into every request. For thinking models on llama.cpp: |
| Where results go. Default: |
| Path to a config file |
Config file
The config file is found via --config, then $SVGLOOP_CONFIG, then ./svgloop.config.json, then svgloop.config.json next to the program. Start from svgloop.config.example.json. Any string can use {env:NAME} to read an environment variable, which is handy when a host app starts the model server on a random port with a fresh key.
Key | Default | Meaning |
| — | Endpoints: |
| 4 colours |
|
|
| Off-palette colours are errors instead of warnings |
| 3 / 2 / 2 | Directions per run / revision passes / finalists returned |
| 8 | Review score at which a direction stops being revised |
| 24 | Shape limit |
| 256 | viewBox size |
| [32, 256] / 16…512 | Sizes shown to the reviewer / written on export |
| shipped | Your style references (below) |
| see above | Results folder |
Teach it your taste
examples/: SVGs you like. The two most relevant ones (matched by file name and an optional<!-- tags: a, b -->comment) are shown to the model as style references. This is the biggest quality lever: replace the starters with marks you love.style.md: short house rules included in every prompt.
Point examplesDir and styleFile at your own copies in the config file.
Models: what to expect
SVGLoop's quality depends on your model. These are the results from development testing on a single 16 GB consumer GPU:
Model | Result |
Qwen3.6-35B-A3B (MoE, one model for both jobs) | Best tested. About 50 tokens/s with part of the model in system RAM. A 2-direction run took about 2 minutes end to end; 3 directions × 2 rounds about 2.5 minutes. Revisions raised scores (e.g. 4→7, 6→8). |
Gemma 4 12B | Fast, with sharp reviews, but its revisions rarely improved a draft. |
Dense ~27B, partly offloaded | Too slow (about 4 tokens/s): a run would take around half an hour. Prefer MoE models when VRAM is tight. |
Tips:
Turn thinking off for drawing calls (
SVGLOOP_EXTRA_BODYorextraBodyabove). It costs tokens and doesn't help the SVG.Reviews vary by about ±2 points between runs of the same drawing. Several candidates per run absorb that.
llama.cpp is the tested server. Ollama and LM Studio speak the same API but haven't been tested yet; reports welcome.
Safety
Every SVG a model writes passes through cleanSvg before it is rendered or written to disk. It removes:
scripts and event handlers (
on*)foreignObjectand<image>outside
hrefandurl()referencesDOCTYPEandENTITYdeclarationsany element or attribute not on an allow-list
Rendering uses resvg, which runs no scripts and fetches nothing. MCP exports are written only inside the configured output folder. See SECURITY.md to report a problem.
Limitations
Results are as good as your local model. Expect clean, geometric marks, not detailed illustration.
Drawings that use
<text>depend on installed fonts. The prompts ask for letters drawn as paths.One job runs at a time per server process.
Use as a library
import { loadConfig, makeGraphic, exportGraphic } from "svgloop";
const cfg = loadConfig(); // env vars and/or svgloop.config.json
const run = await makeGraphic(cfg, { brief: "Logo mark for Tidewell" }, (e) => console.log(e.message));
exportGraphic(cfg, run.finalists[0].svg, "tidewell");Development
bun install
bun test # offline: a stand-in model server, MCP round trip included
bun run build:node # dist/cli.js for npm/npx
bun run build:exe # standalone binary for this platformContributing
Contributions are welcome. Please read CONTRIBUTING.md. Contributors sign a short Contributor License Agreement, and a bot asks for it on your first pull request.
License
Apache-2.0. Third-party components are listed in THIRD_PARTY_NOTICES.md.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Generate images from Claude, ChatGPT, Cursor and Codex with 12 top AI image models and 10 tools: up to 4 images per call, SVG vectorization, editing and more. Remote MCP with OAuth, no API keys. Pay per image, no subscription.
Generate images from Claude, ChatGPT, Cursor and Codex with 12 top AI image models. Up to 4 images per call, SVG vectorization, background removal, upscaling and image-to-video. Remote MCP with OAuth, no API keys.
Lets AI assistants draw: logos, posters, illustrations and scenes, as editable SVG and PNG.
Create professional SVG artwork, icons and vector logos from a prompt, or vectorize any image.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAI-powered SVG icon generation MCP server. Generate production-ready SVG icons from text descriptions with customizable styles, sizes, and themes.108 npm8MIT
- AlicenseNot gradedqualityDmaintenanceAI logo design MCP server — generates SVG logos with text-to-path conversion, SVG optimization, and full brand kit export (favicon, social media sizes, color palette). 4 tools: text_to_path, optimize_svg, export_brand_kit, image_to_svg.181 npm59MIT
- AlicenseAqualityDmaintenanceRoutes one brief to the right image model across 60+ (gpt-image-1.5, Ideogram 3, Recraft V4, Flux), validates the output, and fans out to iOS/Android/PWA/favicon/visionOS/Flutter bundles. Works without an API key via Pollinations, HF Inference, Stable Horde, or host-LLM inline SVG.2425MIT
- AlicenseAqualityBmaintenanceEnables local creation, inspection, revision, and rendering of editable Apple Icon Composer .icon documents from static SVG or PNG artwork, with native appearance previews on macOS.61MIT