# Inkscape (inksmcp) (pypi · inksmcp)

Create, edit and export SVG graphics with Inkscape: measured layout, templates, export.

- Trust score: 83/100 (high trust)
- Change this week: +18
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-04

## Components

- pypi · `inksmcp`: 83/100 (this document), [markdown](https://verifymcp.io/servers/bhanutpt-inksmcp/inksmcp.md), [page](https://verifymcp.io/servers/bhanutpt-inksmcp/inksmcp)

## Channel facts

- Registry: `pypi`
- Package: `inksmcp`
- Version: `0.3.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-04.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 1 of 29 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to bhanutpt/inksmcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 29 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 51/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 5104 tokens (~212/item across 24 items; 24 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 70/100
  - Stability observed for 21 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 67/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "delete_elements" implies "delete" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 25 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Inkscape (inksmcp) MCP server?

Inkscape (inksmcp) runs locally as a PyPI package, launched with uvx inksmcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add bhanutpt-inksmcp -- uvx inksmcp
```

### Cursor

```json
{
  "mcpServers": {
    "bhanutpt-inksmcp": {
      "command": "uvx",
      "args": [
        "inksmcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "bhanutpt-inksmcp": {
      "command": "uvx",
      "args": [
        "inksmcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add bhanutpt-inksmcp -- uvx inksmcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "bhanutpt-inksmcp": {
      "type": "local",
      "command": [
        "uvx",
        "inksmcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add bhanutpt-inksmcp --command uvx --arg inksmcp
```

### Hermes

```yaml
mcp_servers:
  bhanutpt-inksmcp:
    command: "uvx"
    args: ["inksmcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "bhanutpt-inksmcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "inksmcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add bhanutpt-inksmcp -t stdio -c uvx -a inksmcp
```

### Other

```json
{
  "mcpServers": {
    "bhanutpt-inksmcp": {
      "command": "uvx",
      "args": [
        "inksmcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 67 to 70. That category is still filling its 30-day observation window: 20 days of observed history at the previous scan, 21 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-02 (score 82, +1)

No change was recorded against any check on this day. Stability & Change Management went from 60 to 63. That category is still filling its 30-day observation window: 18 days of observed history at the previous scan, 19 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-31 (score 81, +1)

No change was recorded against any check on this day. Stability & Change Management went from 53 to 57. That category is still filling its 30-day observation window: 16 days of observed history at the previous scan, 17 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-30 (score 80, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-28 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-26 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 37 to 40. That category is still filling its 30-day observation window: 11 days of observed history at the previous scan, 12 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-25 (score 63, −15)

- [security regression] Malware scan: pass → unverified

### 2026-10-24 (score 78, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (24)

### `inkscape_info` (~23 tokens)

Inkscape version and location, server version, and open documents.

### `document_create` (~79 tokens)

Create a new blank document and make it current. The viewBox matches width/height,
so coordinates are in `unit`. `background` (e.g. '#ffffff') adds a full-page rect with id 'background'.

Input parameters:

- `background`
- `height` (number, required)
- `unit` (string)
- `width` (number, required)

### `document_open` (~94 tokens)

Open an existing SVG (.svg or .svgz) and make it current. Returns its outline, and `notes` when the
file was normalised for editing without changing how it renders: a page whose viewBox doesn't match its
width/height (or uses %), fill/stroke set on the root (new elements would inherit them), ids given to
elements that had none.

Input parameters:

- `path` (string, required)

### `document_save` (~41 tokens)

Save the document as Inkscape SVG (to `path`, or where it was opened/last saved).

Input parameters:

- `doc_id`
- `path`

### `inspect` (~228 tokens)

Outline of the document: layers, groups and elements with ids, fill/stroke as rendered (style,
attributes or inherited), text, `use` targets (href) and real visual bounding boxes [x, y, width, height]
in user units (measured by Inkscape). Layers/groups with more than `max_children` children are summarised
(counts per type, first/last ids, bbox). To list one of them, pass `layer` (layer name or group id) and a
larger max_children.
find: a flat list of matching elements instead of the tree, e.g. {"fill": "#99cc32"} (colours compared
in any notation), {"type": "text", "text": "total"}, {"type": "use", "href": "Parking"},
{"type": "symbol"} (symbols in defs, with titles), {"id_prefix": "card-"}.

Input parameters:

- `bbox` (boolean)
- `doc_id`
- `find`
- `layer`
- `max_children` (integer)

### `add_elements` (~786 tokens)

Add one or more elements in a single call. Returns the new ids.
Element spec keys — common: type, id, label, layer (name; created if missing), parent (group id), transform, style (css string or dict). Style shorthands: fill, stroke, stroke_width, opacity, fill_opacity, stroke_opacity, stroke_dasharray, stroke_linecap, stroke_linejoin, font_size, font_family, font_weight, font_style, text_anchor. Geometry per type: rect: x, y, width, height, rx, ry, fit_to, fit_padding, fit; circle: cx, cy, r; ellipse: cx, cy, rx, ry; line: x1, y1, x2, y2, marker_start, marker_end; polyline: points, marker_start, marker_end; polygon: points; path: d, marker_start, marker_end; text: x, y, text, line_height, vertical_anchor, width, halo, halo_width; group: -; arrow: x1, y1, x2, y2, shaft_width, head_width, head_length; image: x, y, width, height, href, object_fit, embed; use: x, y, width, height, href. points = [[x,y],...]. text supports '\n' for multiple lines; font_size is in user units. Coordinates are in the parent's system: inside a transformed layer or group (e.g. after layout moved it, or a scaled plan group) they are offset/scaled with it. use: href "symbol_id" places a symbol (or any element) of this document; "library.svg#symbol_id" copies that symbol from a file first (list a library's symbols: document_open it, inspect find {"type": "symbol"}); width/height scale a symbol that has a viewBox. clip: an element id (its current shape) or [x, y, w, h] — the element is cut to it and the clip then moves with the element; null removes it. text halo: '#ffffff' outlines the glyphs behind the fill so text reads over lines (halo_width default 0.3 x font size; 'none' removes). place: {"below": id, "gap": 1.5} (or above / left_of / right_of; "align": start|center|end on the other axis) puts the element beside the MEASURED box of another (real glyph extents, any script) and keeps it there when that element changes; inside repeat, ids are template names; null frees it. Responses warn abou…

Input parameters:

- `defaults`
- `doc_id`
- `elements`
- `elements_path`
- `preview` (boolean)

### `repeat` (~594 tokens)

Stamp a block of elements once per data row — timelines, card grids, tables, legends, map
symbols — in one call.
template: element specs as for add_elements, drawn for the FIRST row. "{key}" in any string is
replaced from the row ("{year}"; a value that is exactly "{w}" keeps the row's number), in geometry
and style alike ("fill": "{colour}"); "{n}" is the row number (1-based) and "{i}" the index, so
rows can't use the keys n and i. Ids are local names: "card" becomes card-1, card-2, ... A
"parent" may name another template element (e.g. a group holding a card and its texts); fit_to
and clip may name template elements of the same row.
Each row goes into a group <id_prefix>-<n> moved by n-1 steps: step [dx, dy], or a grid with
\`columns` (step = [column pitch, row pitch]), filled row by row or, with order "column", column
by column. cell ["col", "row"]: each row is placed by its own 1-based column/row values (gaps and
fractions allowed: periodic tables, calendars, timetables, lanes); the template is drawn for cell
(1, 1) and step is the [column, row] pitch. Components (a character, a node, a symbol placed at data positions): a template group
with "transform": "translate({x},{y}) scale({s})" and step [0, 0], parts drawn around a local
origin, pose/shape parts as placeholders ("d": "{arms}").
mirror {"x": 148.5, "rows": "even"|"odd"|"all"} (or "y") mirrors those rows about the axis:
shapes are reflected (pointers flip), texts and groups keep their reading direction and move as
blocks — group a card with its texts so they cross together. Per element "mirror":
"reflect"|"block"|"none" overrides. rows_path: a .json (list of row objects) or .csv file (header
line = keys, numbers parsed) instead of `rows`, so data never passes through the conversation.
Returns the row groups, ids per template name (runs shortened to "card-1..card-12"), wrapped_lines, fitted.

Input parameters:

- `cell`
- `columns`
- `defaults`
- `doc_id`
- `id_prefix` (string)
- `layer`
- `mirror`
- `order` (string)
- `preview` (boolean)
- `rows`
- `rows_path`
- `step` (array, required)
- `template` (array, required)

### `import_file` (~233 tokens)

Place a file into the current document. An SVG (e.g. geometry a script generated) becomes one
group scaled to this document's units, its top-left at `at` (default 0,0); width or height scales it
(both: stretch). Its layers become labelled groups, its defs join ours, clashing ids get "<id>-" in front.
An image (png/jpg/gif/webp/bmp) becomes an image element: natural size at 96 dpi unless width/height
(one keeps the ratio), linked by default (embed: true stores the pixels in the SVG), object_fit
contain|cover|fill for a given box. Relative paths start at the document's folder.
For whole documents use document_open; for data rows see repeat rows_path.

Input parameters:

- `at`
- `doc_id`
- `embed` (boolean)
- `height`
- `id`
- `layer`
- `object_fit`
- `parent`
- `path` (string, required)
- `preview` (boolean)
- `width`

### `split` (~381 tokens)

Divide a region into named cells — comic panels, dashboard tiles, poster columns, table grids —
without computing any positions. region: "page", an element id (its measured box) or [x, y, w, h];
margin insets it (one number, [vertical, horizontal] or [top, right, bottom, left]).
rows: one entry per row, either a number of equal columns or a list of column ratios, e.g.
[[2, 1], [1, 1], [1, 2]]; heights: row ratios (default equal); gutter: space between cells
(number or [horizontal, vertical]).
Creates one rect per cell, <id_prefix>-1, -2, ... row by row, in `layer` — invisible unless `style`
gives e.g. {"fill": "#fff", "stroke": "#000", "stroke_width": 0.6, "rx": 2}. Use the ids as targets:
clip ("clip": "cell-5"), align/layout ("to": "cell-2"), place, fit, connect. An element region is its
measured box (stroke included).
Tables: split the header strip into columns (e.g. rows [[3, 1, 1]]), then `repeat` the data rows with
step [0, row pitch] and texts at the returned column edges (numbers: text_anchor end at the right edge).
Returns the cells [x, y, w, h] and their ids per row.

Input parameters:

- `doc_id`
- `gutter`
- `heights`
- `id_prefix` (string)
- `layer` (string)
- `margin`
- `preview` (boolean)
- `region`
- `rows` (array, required)
- `style`

### `update_elements` (~71 tokens)

Change existing elements. Each update is {"id": ..., <any element-spec keys>}; only the given
keys change. Style shorthands merge into the existing style. Set transform to "" to clear it.

Input parameters:

- `doc_id`
- `preview` (boolean)
- `updates` (array, required)

### `delete_elements` (~78 tokens)

Delete elements (and their children) by id. Connectors attached to them and their labels
are deleted too; all removed ids are returned. Defs only they used (symbols of an imported library,
gradients, clip paths) go too: `defs_removed` counts them.

Input parameters:

- `doc_id`
- `ids` (array, required)

### `connect` (~172 tokens)

Draw arrows/lines between elements that stay attached when things move (align/layout/
update_elements/page_fit). Default: native Inkscape connectors — clipped to the real shape (circles
etc.) and still live in the Inkscape GUI. With from_side/to_side/via you control the route (e.g. a
loop diagram: {"from": "condenser", "to": "valve", "from_side": "left", "to_side": "top",
"routing": "elbow"}); those attach at the middle of the chosen side of the bounding box, as do
connectors with start_gap/end_gap. Returns the connector ids, their layers, label ids and warnings.

Input parameters:

- `connections` (array, required)
- `doc_id`
- `preview` (boolean)

### `layout` (~242 tokens)

Arrange items in a row, column or grid with a gap — no coordinate maths needed.
An item is an id or a list of ids that move together, e.g. ["box1", "box1_label"], or
{"ids": [...], "anchor": "fig1-border"} to arrange by that member's box (plot frames line up even when
their tick labels differ in width); the rest moves along.
\`gap` is a number or [horizontal, vertical]. `align` places items on the cross axis (grid: within cells).
The block stays where the first item is, or its top-left goes to `at` [x, y], or it is aligned to
\`to` ('page' or an element id) using horizontal/vertical/margin. Connectors follow.

Input parameters:

- `align` (string)
- `at`
- `columns`
- `direction` (string)
- `doc_id`
- `gap`
- `horizontal`
- `items` (array, required)
- `margin` (number)
- `preview` (boolean)
- `to`
- `vertical`

### `path_operation` (~118 tokens)

Geometry operations performed by Inkscape on the given ids. For difference, the top-most
(later in document order) object is subtracted from the bottom one. to_path converts shapes
and text into paths. union/intersection/exclusion/difference keep the BOTTOM object's id, style
and layer; combine keeps the TOP object's (E22). `result` lists the ids that hold the outcome.

Input parameters:

- `doc_id`
- `ids` (array, required)
- `operation` (string, required)
- `preview` (boolean)

### `run_actions` (~100 tokens)

Escape hatch: run raw Inkscape actions (e.g. "object-align:left last", "transform-rotate:30")
after selecting `select` ids. File, export, window and quit actions are blocked. Extensions
(org.inkscape.*) always act on the whole document, so they can't be combined with select.

Input parameters:

- `actions` (array, required)
- `doc_id`
- `preview` (boolean)
- `select`

### `page_fit` (~98 tokens)

Resize the page to fit the drawing (or only `ids`) plus `margin` (one number, [vertical, horizontal]
or [top, right, bottom, left], user units). All content moves together so the page keeps its 0,0
top-left; full-page background rects are resized, connectors follow.

Input parameters:

- `doc_id`
- `ids`
- `margin`
- `preview` (boolean)

### `page_resize` (~98 tokens)

Set the page size in user units (e.g. 210 x 297 for A4 in a mm document). anchor='center' keeps the
drawing centred on the new page; 'top-left'/'none' leave content where it is. Backgrounds are resized.

Input parameters:

- `anchor` (string)
- `doc_id`
- `height` (number, required)
- `preview` (boolean)
- `width` (number, required)

### `grid` (~509 tokens)

Draw a grid / graph paper inside rect [x, y, w, h] — linear or logarithmic per axis — without
computing any line positions. Axis specs:
  linear: {"scale": "linear", "major": 10, "medium": 5, "minor": 1, "label_start": 0, "label_step": 1}
          (spacings in user units, each a whole multiple of the finest; labels on major lines)
  log:    {"scale": "log", "cycles": 3, "subdivisions": "standard" | "fine" | "integers", "start": 10}
          (decades major, 2..9 medium, subdivisions minor; "start" = value at the origin (default 1);
          "labels": "decades" (start, start*10, ...; default when start is given) | "paper" (1..9 per cycle))
  "reverse": true flips an axis (default x left→right, y bottom→top); "lines": false keeps the axis
  (labels, `plot` mapping) but draws none of its gridlines, e.g. vertical-only lines for a bar chart.
weights: {"major", "medium", "minor"} stroke widths (defaults 0.45/0.22/0.08 mm); border: stroke width
of the frame (default 0.6 mm, 0 = none). labels: {"sides": ["left", "bottom"], "font_size", "gap",
"color", "font_family", "bold_major", "x_title", "y_title", "title_font_size"} — placed outside the
grid, centred on their lines (measured); major labels are bold unless "bold_major": false; titles go
below / left (rotated) of the tick labels.
Result: one path per weight class in layers '<layer_prefix> minor/medium/major', labels in
'<layer_prefix> labels'. Use `plot` with grid=<id_prefix> to draw data on it.

Input parameters:

- `border`
- `color` (string)
- `doc_id`
- `id_prefix` (string)
- `labels`
- `layer_prefix` (string)
- `preview` (boolean)
- `rect` (array, required)
- `weights`
- `x`
- `y`

### `plot` (~391 tokens)

Plot data on a grid made with the `grid` tool, in DATA values — no coordinate maths.
grid: that grid's id_prefix. Each series: {"points": [[x, y], ...], "line": true, "stroke": "#1f77b4",
"stroke_width", "stroke_dasharray", "marker": "circle"|"square"|"diamond"|"none", "marker_size",
"marker_fill" (default white), "point_labels": ["", "COP 3.2", ...] (one per point, null/"" to skip),
"label_offset": [dx, dy], "label_anchor": "start"|"middle"|"end", "label_halo": "#ffffff"|"none",
"label_font_size", "label_color", "font_family", "id", "layer"}.
Labels: label_offset is from the point to the label's anchor, and the label is vertically CENTRED on
point + dy (dy = 0 → centred on the point). Anchor defaults to start for dx >= 0, else end. Without
label_offset the label goes right of the point, on the side the line is not heading to. Labels carry a
halo stroke (default white) so the line can cross them — set label_halo "none" (or the background
colour) for labels on dark fills; recolouring a label later does not remove its halo (use stroke: "none").
Ids follow the series id: <id>-line, <id>-marker-<k>, <id>-label-<k> (k = 1-based point index).
Returns per series those ids and the points in user units (for annotations); warns about points
outside the grid.

Input parameters:

- `doc_id`
- `grid` (string)
- `preview` (boolean)
- `series` (array, required)

### `z_order` (~121 tokens)

Change stacking order (what is drawn on top). front/back: top/bottom within the element's own
layer or group. forward/backward: one step past the next object it overlaps (visible change).
above/below: directly above/below `target`, moving into target's layer/group if needed while keeping
the visual position. Several ids keep their relative order. Returns each id's position.

Input parameters:

- `doc_id`
- `ids` (array, required)
- `operation` (string, required)
- `preview` (boolean)
- `target`

### `move_to_layer` (~85 tokens)

Move elements into a layer (by name; created on top if missing) or into a group/layer by id,
at its top or bottom. They keep their relative order and stay visually where they were.

Input parameters:

- `doc_id`
- `ids` (array, required)
- `layer` (string, required)
- `position` (string)
- `preview` (boolean)

### `align` (~104 tokens)

Align elements to the page, to each other, or inside another element — e.g. centre a label in a box:
{"ids": ["label"], "to": "box", "horizontal": "center", "vertical": "middle"}. Operations run in order,
each seeing the previous moves. Returns the moves [dx, dy] and new bboxes in user units.

Input parameters:

- `doc_id`
- `operations` (array, required)
- `preview` (boolean)

### `export` (~177 tokens)

Export via Inkscape. Format defaults to the file extension. What is exported:
\`region` [x, y, w, h] (user units, everything visible); or `ids` — only those objects cropped to
them (only_ids=true, default) or the area around them with everything visible (only_ids=false);
otherwise area 'page' or 'drawing'. For PNG set dpi or width/height (px); background e.g. '#ffffff'
(default transparent).

Input parameters:

- `area` (string)
- `background`
- `doc_id`
- `dpi`
- `format`
- `height`
- `ids`
- `only_ids` (boolean)
- `path` (string, required)
- `region`
- `text_to_path` (boolean)
- `width`

### `render_preview` (~110 tokens)

Render to a PNG image you can look at (white background, longest side = max_size px).
Zoom in with `region` [x, y, w, h] in user units, or with `ids` (the area around them, everything
still visible). only_ids=true draws just those objects.

Input parameters:

- `area` (string)
- `doc_id`
- `ids`
- `max_size` (integer)
- `only_ids` (boolean)
- `region`

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/bhanutpt-inksmcp/inksmcp#diagnostics

## Score history

- 2026-11-04: 83
- 2026-11-03: 82
- 2026-11-02: 82
- 2026-11-01: 81
- 2026-10-31: 81
- 2026-10-30: 80
- 2026-10-29: 65
- 2026-10-28: 65
- 2026-10-27: 64
- 2026-10-26: 64
- 2026-10-25: 63
- 2026-10-24: 78
- 2026-10-23: 77
- 2026-10-22: 77
- 2026-10-21: 58
- 2026-10-20: 58
- 2026-10-19: 58
- 2026-10-18: 58
- 2026-10-17: 73
- 2026-10-16: 58
- 2026-10-15: 58
- 2026-10-14: 58
- 2026-10-13: 35
- 2026-10-12: 35

## Common questions

### What is the Inkscape (inksmcp) MCP server?

Inkscape (inksmcp) is an MCP server listed in the public MCP registry as io.github.bhanutpt/inksmcp. Create, edit and export SVG graphics with Inkscape: measured layout, templates, export. This page covers its PyPI package (inksmcp).

### Is the Inkscape (inksmcp) MCP server safe to use?

Inkscape (inksmcp) scores 83 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 4 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Inkscape (inksmcp) MCP server expose?

Inkscape (inksmcp) exposes 24 tools: inkscape_info, document_create, document_open, document_save, inspect, and 19 more. Their descriptions and schemas cost roughly 4,933 tokens of context every time the server is loaded.

### Is the Inkscape (inksmcp) MCP server still maintained?

Inkscape (inksmcp) is still listed as active in the MCP registry. We last reached this channel on 4 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Inkscape (inksmcp) MCP server under?

Inkscape (inksmcp) declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/inksmcp/
- Socket report: https://socket.dev/pypi/package/inksmcp
- Repository: https://github.com/bhanutpt/inksmcp
- Changelog RSS feed: https://verifymcp.io/servers/bhanutpt-inksmcp/inksmcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/bhanutpt-inksmcp/inksmcp.json
- HTML version of this page: https://verifymcp.io/servers/bhanutpt-inksmcp/inksmcp