Eraser MCP connector for AI agents

Tools your architecture agent reaches for on Eraser, scoped per user.

CALL ANY TOOL

42 tools for Eraser: generate and update diagrams and documents with Eraser's AI, search and export files, and manage folders, teams, presets, rules, and templates.

erasermcp_add_or_remove_template_or_reference

Add or remove template or reference

Attach or detach an EXISTING file as a template (style anchor) or reference (terminology/concept anchor) of a preset. Use this tool when: - the user has an existing workspace they want to promote into a preset (e.g. 'use this file as a template for the System Design preset'), - you need to detach a file from a preset, - or you just created a template via `create_template_or_reference` WITHOUT a `presetId` and need to attach it now. To create a NEW template/reference file and attach it in a single call, use `create_template_or_reference` with `presetId` set, that avoids leaving a detached file in the team. When removing a file leaves it orphaned from all presets, the file is archived automatically. Templates and references are inherently team-scoped (no private/personal templates exist); the preset choice is the only scoping decision.

Parameters

Name

Type

Required

Description

fileId

string

Required

No description.

kind

string

Required

No description. One of: `template`, `reference`.

operation

string

Required

No description. One of: `add`, `remove`.

presetId

string

Required

No description.

teamId

string

Optional

ID of the team to operate in (get IDs from list_teams). Optional when an active team is already set for this session; required otherwise. Overrides the active team for this call only.

erasermcp_create_diagram

Create diagram

PREFERRED for creating a diagram from a natural-language prompt, Eraser's AI picks the diagram type, generates the DSL, and renders it. DO NOT pre-classify the user's request into a diagram type yourself. Pass `text` only (plus destination params) and LEAVE `diagramType` UNSET unless the user EXPLICITLY named a type (e.g. 'make this a sequence diagram', 'use a cloud architecture diagram'). Eraser's render service has type-specific heuristics and will pick a better type from the prompt than your guess will, especially on ambiguous asks like 'show how X works' or 'diagram the architecture'. BEFORE calling this tool, if the user has not already specified the destination, ASK them these questions (skip any the user has already answered): 1. 'Should I create a new file for this diagram, or add it to an existing file?', if existing, ask which fileId (or use one they just referenced). 2. If NEW file: 'Should the file be private (just for you) or shared with your team in a folder?' 3. If shared in a folder: 'Which folder?' (or offer to place it at the team root). Do NOT call list_folders or get_folder to invent a destination yourself, ask the user. Pick destination params based on the answers: - Existing file → pass targetFileId - New private file → omit targetFileId, omit folderId, do NOT set isTeamFile - New shared file at team root → omit targetFileId, omit folderId, set isTeamFile: true - New shared file in a folder → omit targetFileId, pass folderId (this implies shared) Returns the new diagram's id in the `diagrams[].id` field so a follow-up update_diagram/manually_update_diagram call does NOT need a list_diagrams round-trip. Prefer over manually_create_diagram unless you already have hand-written DSL/JSON.

Parameters

Name

Type

Required

Description

text

string

Required

No description.

attachments

array

Optional

No description.

background

boolean

Optional

No description.

colorMode

string

Optional

No description. One of: `pastel`, `bold`, `outline`.

diagramType

string

Optional

OPTIONAL, LEAVE THIS EMPTY by default. Only set it when the user EXPLICITLY names a diagram type (e.g. 'make this a sequence diagram', 'use a cloud architecture diagram', 'turn it into an ERD'). When omitted, Eraser's render service picks the diagram type from the prompt text using diagram-type-specific heuristics and (if applicable) the preset/template in scope, that selection is usually better than guessing from the prompt yourself. Do NOT pre-classify the user's request into a diagram type just because the value is available in your schema; spurious type-locking produces worse diagrams than letting Eraser choose, especially on ambiguous prompts ('show how X works', 'diagram the architecture'). On update_diagram, leave this empty as well, the existing diagram's type is preserved by default. One of: `freeform-diagram`, `sequence-diagram`, `entity-relationship-diagram`, `cloud-architecture-diagram`, `flowchart-diagram`, `bpmn-diagram`.

direction

string

Optional

No description. One of: `up`, `down`, `left`, `right`.

folderId

string

Optional

OPTIONAL, leave this empty by default. Only set it when the user EXPLICITLY names a folder to place the new file in (e.g. "put it in the Engineering folder"). Do NOT call list_folders or get_folder to "pick a sensible folder", when omitted, the file is created at the team root and the user can move it themselves. Spurious folder discovery wastes tokens and produces unexpected file placement.

format

string

Optional

No description. One of: `png`, `jpeg`.

gitContexts

array

Optional

No description.

imageQuality

string

Optional

No description.

includeImage

boolean

Optional

Set true only when you need a PNG URL. By default no image is rendered or stored and the response carries no imageUrl. When true, imageUrl is by default a private link that expires after 1 hour; use urlSettings to request a longer ttl or access: "public" for a permanent link. Public URLs are not secure: anyone with the link can view the image, so use them only when the user explicitly wants a permanent, shareable image. The persisted diagram is exported afterwards, so an image failure never fails the diagram write. Not needed for in-app viewing, prefer the returned fileUrl/diagramUrl.

isTeamFile

boolean

Optional

Only honored by create_diagram when a NEW file is being created (i.e. targetFileId is omitted). When true, the new file is shared with the team (non-private); when false, the new file is private to the caller. Required on plans that don't support private files. Ignored by update_diagram, and ignored on create_diagram when targetFileId is set (because no new file is created).

presetId

string

Optional

OPTIONAL, the AI preset (rules, references, templates) to apply. Omit it to use the team default preset, when the team has one; pass null to use no preset. To resolve a preset the user names, call list_presets with nameContains.

priorRequestId

string

Optional

No description.

styleId

string

Optional

No description.

styleMode

string

Optional

No description. One of: `plain`, `shadow`, `watercolor`.

targetFileId

string

Optional

No description.

teamId

string

Optional

ID of the team to operate in (get IDs from list_teams). Optional when an active team is already set for this session; required otherwise. Overrides the active team for this call only.

templateId

string

Optional

OPTIONAL, usually leave this empty. Whenever a preset applies, Eraser picks the preset template the request names or clearly matches, so to use a template just name it in `text` (e.g. 'using the Incident Report template'). Set templateId only to force one specific template: pass its fileId from get_preset's `templates` list. It must belong to the preset in scope, so also pass that preset's presetId unless it is the team default; otherwise the call fails.

theme

string

Optional

No description. One of: `light`, `dark`.

title

string

Optional

No description.

typeface

string

Optional

No description. One of: `rough`, `clean`, `mono`.

urlSettings

object

Optional

Access policy for an opt-in image URL. Omit to use the team/org default (one-hour token links unless default.type is public). ttl applies only to token URLs and accepts seconds or durations such as "6h", "5d", or "2w" (maximum 365d). Omitted ttl inherits team/org default.ttl, then 1h. Teams allow permanent or expiring download links, expiring download links only, or none; a disallowed link request returns an error.

erasermcp_create_document

Create document

erasermcp_create_file

Create file

erasermcp_create_preset

Create preset

erasermcp_create_template_or_reference

Create template or reference

erasermcp_delete_diagram

Delete diagram

erasermcp_delete_document

Delete document

erasermcp_delete_file

Delete file

erasermcp_delete_folder

Delete folder

erasermcp_export_diagram

Export diagram

erasermcp_export_document

Export document

erasermcp_export_file

Export file

erasermcp_get_diagram

Get diagram

erasermcp_get_document

Get document

erasermcp_get_file

Get file

erasermcp_get_me

Get me

erasermcp_get_preset

Get preset

erasermcp_list_diagrams

List diagrams

erasermcp_list_files

List files

erasermcp_list_folders

List folders

erasermcp_list_presets

List presets

erasermcp_manually_create_diagram

Manually create diagram

erasermcp_manually_update_diagram

Manually update diagram

erasermcp_manually_update_file

Manually update file

erasermcp_publish_template_or_reference

Publish template or reference

erasermcp_search

erasermcp_update_document

Update document

erasermcp_update_folder

Update folder

erasermcp_update_rules

Update rules

For more tools, view docs.

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Eraser MCP tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["erasermcp"], toolNames: [
    "erasermcp_search",
    "erasermcp_create_diagram",
    "erasermcp_update_diagram"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Create a sequence diagram of our login flow in the Auth Service file" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["erasermcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Create a sequence diagram of our login flow in the Auth Service file" }],
  tools,
});

// Execute the tool call with the user's vaulted Eraser token
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["erasermcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Create a sequence diagram of our login flow in the Auth Service file" }],
  tools,
});

// Tool call runs with the user's vaulted Eraser token
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["erasermcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "architecture_agent",
  model: "gemini-2.5-pro",
  instruction: "Eraser MCP tools scoped to this user",
  tools,
});

await agent.run("Create a sequence diagram of our login flow in the Auth Service file");

Try these prompts

Copy any prompt into your agent. Each maps directly to a Eraser MCP tool. Click to copy, paste into your agent, done.

Diagrams

Copy the prompt

Copied

Create a sequence diagram of our login flow in the Auth Service file.

Copy the prompt

Copied

Add a Kafka broker between the API and the workers in the Data Pipeline diagram.

Copy the prompt

Copied

Export the System Overview diagram as a PNG.

Documents and files

Copy the prompt

Copied

Write a design doc for the new payment service in this empty file.

Copy the prompt

Copied

Search my workspace for files about the billing migration.

Copy the prompt

Copied

List the diagrams in the Platform Architecture file.

Presets and folders

Copy the prompt

Copied

Create a preset with a rule that all auth flows are sequence diagrams.

Copy the prompt

Copied

List the files in the Engineering folder.

Copy the prompt

Copied

Rename the Drafts folder to Archive.

SEE HOW AUTH WORKS

Each user signs in to Eraser once; Scalekit stores and refreshes their tokens. Credentials stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

Eraser MCP

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

Eraser MCP

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

Eraser MCP

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

Eraser MCP

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other design and developer tool connectors.

Engineering Teams

Engineering standup agent

Pulls commits from GitHub and GitLab, tracks issue movement in Jira, and posts a per-engineer standup brief to Slack. Each engineer's activity is read on their own delegated OAuth.

Engineering Teams

Auto release notes agent

Reads merged GitHub PRs, groups them into structured release notes, publishes the page to Notion, and announces the release in Slack. Every call runs on the engineer's own delegated OAuth.

Engineering Teams

DevOps assistant agent

Polls GitHub for failing checks and stale PRs, opens Linear issues for the ones that need work, and posts a daily digest to Slack. It acts as the engineer, not a shared service account.

Support and Ops Teams

Meeting prep

Pulls agenda, participant context, and open action items before every meeting.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared Eraser token looks fine in a demo. In production every diagram and document edit looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Eraser today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Eraser as the user or through a shared service account?

As the user. Each user signs in to Eraser once, and Scalekit stores and refreshes their tokens. Audit logs attribute every action to that user, not a shared service account.

Where is the Eraser OAuth token stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. Refresh is automatic. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in Eraser?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example the 16 read-only tools without create, update, or delete. Scalekit also enforces scope checks before every API call.

What happens when a user revokes Eraser access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Does Eraser's AI generate the diagrams?

Yes. erasermcp_create_diagram and erasermcp_create_document take a natural-language prompt and Eraser's AI generates the result. erasermcp_update_diagram and erasermcp_update_document apply edits described in plain language. The manual create and update tools write caller-supplied DSL or markdown verbatim, with no AI.