pac-vector

Local stdio MCP server: an SVG editor and Lottie animator over in-memory virtual documents (one per "window", like Inkscape), with a live browser preview of every edit.

• Content goes in as SVG markup; structure (layers, groups, masks, z-order) has typed tools.
• Animation documents turn finished SVG artwork into Lottie: keyframes or presets per layer, frame renders for the agent, .json export, and a player with a timeline.
• Layers are real Inkscape layers, so exported files open in Inkscape with layers intact.
• Path booleans (union, difference, intersection, exclusion, division) via Skia PathOps.
• Every edit is atomic (a failed call changes nothing), one undo/redo step, and autosaved: windows of a crashed session reopen in the next one.
• render returns a PNG the agent can look at; rendering is resvg (no browser, no Cairo).

Install

Same shape as pac-pincers: a pip package, run as a module by whatever Python it was installed into.

python -m pip install --upgrade pac-vector
claude mcp add pac-vector --scope user -- python -m pac_vector

As a plugin .mcp.json entry (mirrors the datatopia plugin's pac-pincers entry):

"pac-vector": {
  "type": "stdio",
  "command": "${PAC_VECTOR_PYTHON:-python}",
  "args": ["-m", "pac_vector"],
  "env": {}
}

Development:

python -m venv .venv
.\.venv\Scripts\python.exe -m pip install -e ".[dev]"
.\.venv\Scripts\python.exe run_tests.py -q
.\.venv\Scripts\python.exe -m build          # dist/pac_vector-<ver>.tar.gz + .whl

Tools (22)

Animation documents (Lottie)

doc_create(kind="anim", source=<svg doc id | .svg path | markup>, duration="3s", fps=30, split="elements")
animate(doc, layers=["disc"], preset={"name": "pop_in", "start": 0, "duration": "0.8s"})
animate(doc, layers=["ring", "check"], preset={"name": "draw_on", "start": "0.3s"}, stagger="0.4s")
animate(doc, layers=["disc"], property="rotation", keyframes=[{"t": 30, "value": 0}, {"t": "2s", "value": 90, "ease": "back"}])
render(doc, frames=[0, 15, 45, 89])          # look at frames
doc_export(doc, path="intro.json")            # Lottie

• Each element of the artwork becomes a layer (split: elements / layers / single). Shapes are baked to paths in composition pixels with their paint resolved; anchor and position start at the artwork's centre, so scale and rotation pivot there.
• Times are frames (12, "12f") or seconds ("0.4s"). A keyframe's ease shapes the segment that starts at it: linear, ease*, smooth, snap, back, back-in, anticipate, hold or a [x1, y1, x2, y2] cubic-bezier.
• Not carried over (reported on import): text (convert to paths first), images, <use>, clip paths and masks. Gradients become their average colour.
• Track mattes: mask(doc, targets=["bones"], source="screen", kind="clip") — the source layer's artwork, following its own keyframes, decides where the targets show (a moving layer is a moving window). kind="clip" / mode="alpha" = alpha matte, mode="luminance" = luma matte, invert=true hides the targets inside the source instead. One source can matte several layers (exported as one Lottie matte copy per target); hide the source with update(hidden=true) if it should only act as the window. unmask removes a matte.
• render draws frames with resvg from the same model, an approximation of lottie-web (trim paths trim strokes; Lottie also trims fills). The browser preview plays the real exported JSON with lottie-web.

Preview

doc_create / doc_list / inspect print the preview URL (/#<doc> for SVG, /anim#<doc> for animations). The SVG page has a tab per document, outlines the elements each edit touched, and shows (and copies) the id of anything you click. The animation page plays the Lottie with lottie-web (loaded from cdnjs): play/pause, frame step, loop, speed, a range bar to loop a section (handles, drag, I/O keys), and one track per layer with its animated properties and clickable keyframes. The server lives inside the MCP process: it starts on the first doc_create and dies with the session.

Environment

Notes

• stdout is the JSON-RPC pipe: nothing may print to it. tests/test_stdout_safety.py scans the package for print() / sys.stdout, and tests/test_stdio.py runs a real session.
• Native modules are loaded before the stdio loop starts (render.warm): on Windows a first native load from inside the FastMCP loop can hang (see pac-pincers' _excel.py).
• Bounding boxes are measured from pixels (two-pass render), so they include strokes and filters and work for text and curves; content further than two page-widths off-canvas isn't found. align uses them, so it aligns what you see.
• Booleans use fill geometry only (strokes, text and images don't take part); the result is a <path> in the bottom operand's place, styled like it, keeping its id.
• Animations are SMIL: the browser preview plays them; render / PNG export show the static first frame.
• Version lives only in pyproject.toml; a release is a commit named after the version.