_ registry / mcp streamable-http · checked 1h ago

vaadin-mcp

https://mcp.vaadin.com

Registry code: 84ca3cd1a4f67c5f

api record

License valid until 2036-09-07.

Vaadin documentation MCP server. Use search_vaadin_docs to retrieve ranked chunks from Vaadin's docs filtered by ui_language (java/react/common) and vaadin_version. Supported versions are 24, 25.0, 25.1, 25.2, 25.3 (Java + React) and 7, 8, 14 (Java-only legacy). The parity alias "25" resolves to the highest released 25.x. Vaadin adds API faster than model training data is refreshed: before writing code against a version, call get_vaadin_primer and get_new_apis — an API added after your cutoff is one you cannot know you are missing. get_new_apis answers with a…

endpoint
https://mcp.vaadin.com/docs
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing
karma
0 · newcomer
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
225ms

last good check

priced tools
0

of 13 tools

_ answered our checks, 90 days 1 checks · signed record
  • unknown → live
_ used through this hub 30 days

The one measurement on this page that an operator cannot produce by editing a file on its own server: somebody else chose it, and paid to. Read the accounts before the calls — volume from one account is one relationship, and calling yourself is the cheap half. Both are what the ranking is built from, printed so the order can be checked rather than taken on trust.

accounts
0

distinct, expensive to fake

calls served
0

successful, last 30 days

_ what it can do 13 tools
1 open 12 never probed 1 of 13 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • get_vaadin_versions open 1h ago

    Lists the Vaadin versions this image has documentation for, and the latest Vaadin releases known when it was built — stable and prerelease, with their dates. Use it to pick a vaadin_version before calling search_vaadin_docs, get_components_by_version or another version-scoped tool, and to answer "what is the latest Vaadin version?". The two halves are independent: a release can be newer than any version documented here, and either half can be missing, which the response names. An entry flagged "prerelease": true is the next, unreleased minor, indexed for pre-release testing — do not recommend it for production work. "extended_maintenance": true is a property of the version, not of a component: whether a component needs a Vaadin Pro subscription is the separate "commercial" flag on get_components_by_version and get_vaadin_dependency. The `staleness_note` field is data — surface it so the user knows to check vaadin.com for releases newer than the bundled snapshot date.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [],
  "properties": {}
}
    arguments 6 lines
  • get_full_document unknown never probed

    Retrieves one or more documentation pages by file path, whole or one section at a time. Pass one or more paths in `file_paths`; each must include the `v{N}/` prefix as reported by search_vaadin_docs's `Document Path` field (e.g. `v24/components/button/index-java.md`). Append `#<section>` to a path for that heading and everything under it — paste a hit's `Heading:` value as printed, or an address from `outline`. An unknown or repeated one is declined with the sections that page does have. Page sizes differ by more than an order of magnitude — median ~1,000 tokens, one in ten above 3,000, the largest between 15,000 and 27,000 depending on the version — so choose the paths you need rather than accumulating them. Each document reports its token cost, `outline` lists a page's sections and what each costs, and `max_tokens_per_document` bounds the answer.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "file_paths"
  ],
  "properties": {
    "outline": {
      "type": "boolean",
      "description": "Optional. Return each path's sections — one line per section with its address and token cost — instead of its body. Use it to pick a `#section` on a page no search hit named."
    },
    "file_paths": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Non-empty array of document paths, each in the form `v{N}/<relative-path>` (e.g. `v24/components/button/index-java.md`). Use the values reported as `Document Path` by search_vaadin_docs. Append `#<section>` to any of them to get one section instead of the whole page; an unknown or ambiguous section is declined with the sections that page does have."
    },
    "max_tokens_per_document": {
      "type": "integer",
      "format": "int32",
      "description": "Optional cap on each returned document's tokens. Omitted, every page comes back whole; set, a longer page is cut at the cap and marked. Applies to whatever the path selected — page, section or outline — and per document, so a batch of N can cost N times it. Values below 200 are raised to 200; no upper bound."
    }
  }
}
    arguments 25 lines
  • get_java_symbol unknown never probed

    Returns the API of a Vaadin Java type: every declared member with its signature, plus the members it inherits, grouped by the supertype that declares them. Generated from the platform's own javadoc at image-build time, so it answers offline. Use it before writing a call you are not certain exists, before concluding some method is missing, and whenever you need the legal values of an enum — a card for an enum is its complete constant list, which is how to stop guessing at VaadinIcon, Key or LumoUtility names. The inherited half is the point: most of what a Vaadin component can do is declared on a mixin interface or a base class, so TextField.setLabel is not declared on TextField. `name` accepts a fully-qualified name (com.vaadin.flow.component.button.Button), a simple name (Button, LumoUtility.ZIndex), or a bare member name (bindVisible), which answers with the types that declare it. A simple name matching several types returns the candidates rather than picking one. It also covers Vaadin's testing API — the browserless *Tester and *Locator classes and TestBench's elements — marked as testing and carrying the testing framework's own release number, which is not the Vaadin version. Vaadin versions whose javadoc predates the machine-readable format this is built from have no cards, and the tool says so rather than reporting that a type does not exist.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "name",
    "vaadin_version"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Java type or member name. A fully-qualified type (com.vaadin.flow.component.textfield.TextField), a simple type name (TextField, VaadinIcon, LumoUtility.ZIndex), or a member name (bindVisible, setLabel) to find the types declaring it. Case matters, as it does in Java."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 18 lines
  • get_new_apis unknown never probed

    Lists what a given Vaadin version introduced, from two records built into this image and answered offline: the Java API it added and deprecated — classes and methods from the platform's own javadoc — and the documentation pages Vaadin marks as newly introduced, each with a document_path for get_full_document. Use this whenever you are about to write Vaadin code for a version newer than your training data, when a user asks "what's new in 25.2?", or before concluding that some API does not exist: an API added after your cutoff is one you cannot know you are missing. Either half can be absent; the response names which and why rather than answering with an empty list, and states how to read the groups it does return. Filter the Java API half by `maven_artifact_id`, by `package_prefix`, or with `types_only` to ask a narrow question rather than pull a version's whole map; they compose, and a filtered call answers that half alone.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "vaadin_version"
  ],
  "properties": {
    "types_only": {
      "type": "boolean",
      "description": "Optional. Drop member rows, leaving one row per new or deprecated class."
    },
    "max_results": {
      "type": "integer",
      "format": "int32",
      "description": "Optional. Maximum symbols or documentation entries to return in each of the added, deprecated and documentation lists (default 40, clamped to 2000). The default is a summary: raise it to walk a version's whole arrival history. Asserted Java API symbols come ahead of first_seen ones and newer minors ahead of older, so a truncated answer drops the weakest evidence and the oldest releases first; the response states the full counts and what it showed either way."
    },
    "package_prefix": {
      "type": "string",
      "description": "Optional. A package or fully-qualified type, matched on whole dotted segments: \"com.vaadin.flow.component.grid\" excludes ...gridpro."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    },
    "maven_artifact_id": {
      "type": "string",
      "description": "Optional. One Maven artifact id, as get_vaadin_dependency returns it: \"vaadin-grid-flow\"."
    }
  }
}
    arguments 30 lines
  • get_component_java_api unknown never probed

    Returns the Java API documentation for a Vaadin component. The component name can be in any common format (e.g. 'Button', 'button', 'vaadin-button', 'Text Field' — including the spaced names get_components_by_version prints). Returns markdown. This is the documentation page — prose, examples and guidance. For the class's actual members, including the ones it inherits from base classes and mixin interfaces, call get_java_symbol with the type name. A few components are documented for React/Hilla only (Auto Grid, Auto Form, Auto CRUD): this declines for those and names get_component_react_api, which is an answer, not a malfunction.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "component_name",
    "vaadin_version"
  ],
  "properties": {
    "component_name": {
      "type": "string",
      "description": "Component identifier in any common format (Button, button, vaadin-button, TextField, 'Text Field', ...)."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 18 lines
  • get_component_react_api unknown never probed

    Returns the React API documentation for a Vaadin component. The component name can be in any common format (e.g. 'Button', 'button', 'vaadin-button', 'Text Field' — including the spaced names get_components_by_version prints). Returns markdown. A few components are documented for Java/Flow only (Map, Spreadsheet, HTML Elements): this declines for those and names get_component_java_api, which is an answer, not a malfunction.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "component_name",
    "vaadin_version"
  ],
  "properties": {
    "component_name": {
      "type": "string",
      "description": "Component identifier in any common format (Button, button, vaadin-button, TextField, 'Text Field', ...)."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 18 lines
  • get_component_styling unknown never probed

    Returns the styling/theming documentation for a Vaadin component. The component name can be in any common format (e.g. 'Button', 'button', 'vaadin-button', 'Text Field' — including the spaced names get_components_by_version prints). Returns markdown: one rendering when framework names java or react, both when framework is omitted. Not every component has a styling article in every version: where there is none this declines, which is the corpus answering rather than a lookup failure — use search_vaadin_docs for that component's styling guidance.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "component_name",
    "vaadin_version"
  ],
  "properties": {
    "framework": {
      "type": "string",
      "description": "Optional UI language to return the styling guidance for: java or react. Omit it for both renderings, which are converted from one source article and so largely repeat each other."
    },
    "component_name": {
      "type": "string",
      "description": "Component name in any common form (e.g. 'Button', 'button', 'vaadin-button', 'Text Field'). Normalised to kebab-case for path lookup, so the spaced names get_components_by_version prints work as-is."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 22 lines
  • get_component_web_component_api unknown never probed

    Returns the Web Component (TypeScript) API documentation for a Vaadin component. The component name can be in any common format (e.g. 'Button', 'button', 'vaadin-button', 'Text Field'). Returns markdown.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "component_name",
    "vaadin_version"
  ],
  "properties": {
    "component_name": {
      "type": "string",
      "description": "Component name in any common form (e.g. 'Button', 'button', 'vaadin-button', 'Text Field'). Normalised to kebab-case for path lookup, so the spaced names get_components_by_version prints work as-is."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 18 lines
  • get_components_by_version unknown never probed

    Lists the Vaadin components available for a given Vaadin minor version, each with its Title Case name, React component name, Flow Java class, Web Component and React wrapper npm packages, Maven coordinate and commercial flag, from the snapshot bundled at image-build time. Use this when a user asks "what components ship with Vaadin 24.8?", needs to confirm a component name, class, or npm package exists in their version, or needs to know whether a component is commercial. Pass `component` to ask about one, or `commercial_only` for the paid subset, instead of reading the whole catalogue. For the dependency to add for one specific component, call get_vaadin_dependency instead.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "vaadin_version"
  ],
  "properties": {
    "component": {
      "type": "string",
      "description": "Optional. One component instead of the catalogue, in any form get_vaadin_dependency accepts: \"Master Detail Layout\", \"grid-pro\", \"@vaadin/charts\", or the Flow class read from an import."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    },
    "commercial_only": {
      "type": "boolean",
      "description": "Optional. Only the components that need a commercial Vaadin subscription."
    }
  }
}
    arguments 21 lines
  • get_theme_css_properties unknown never probed

    Returns CSS custom properties documentation for a specific Vaadin theme (Aura, Lumo, or Base styles). Use this to look up the correct CSS variables for the theme the application is using. Base style properties (--vaadin-*) are available in all themes. Aura and Base are Vaadin 25+ only; Vaadin 24 supports Lumo only.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "theme",
    "vaadin_version"
  ],
  "properties": {
    "theme": {
      "type": "string",
      "description": "The theme to get CSS custom properties for: \"aura\" (Vaadin 25+ default), \"lumo\" (classic theme, and the only one Vaadin 24 documents), or \"base\" (base styles available in all themes, Vaadin 25+ only)."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 18 lines
  • get_vaadin_dependency unknown never probed

    Takes exactly one of `component` ("Charts", "grid-pro"), `java_class` ("com.vaadin.flow.component.charts.Chart" — use this when you are reading an existing file's imports) or `feature` ("sso", "collaboration"), and returns that one Vaadin component or add-on product's Maven coordinate (groupId + artifactId), commercial status, license requirement, BOM membership and ready-to-paste Maven/Gradle snippets. Use this whenever you need to know which dependency to add to a pom.xml or build.gradle for a Vaadin feature, whether it needs a commercial subscription, or whether it is already covered by the com.vaadin:vaadin / com.vaadin:vaadin-core dependency the project has. This is the authoritative source for com.vaadin.* coordinates — prefer it over any general-purpose Maven Central index, which resolves Vaadin symbols incorrectly.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "vaadin_version"
  ],
  "properties": {
    "feature": {
      "type": "string",
      "description": "Add-on product rather than a UI component: \"sso\", \"kubernetes\", \"observability\", \"appsec\", \"collaboration\", \"swing\". Optional if component or java_class is given."
    },
    "component": {
      "type": "string",
      "description": "Component name in any form: \"Charts\", \"chart\", \"grid-pro\", \"GridPro\", \"@vaadin/charts\", or the artifact id itself. Optional if java_class or feature is given."
    },
    "framework": {
      "type": "string",
      "description": "Optional UI language the answer is for: java or react. Does not change the Maven coordinate — it only marks which npm package applies when the project is a React one."
    },
    "java_class": {
      "type": "string",
      "description": "Fully-qualified Flow Java class, e.g. \"com.vaadin.flow.component.charts.Chart\". A bare simple class name also resolves when it is unambiguous. Optional if component or feature is given."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 29 lines
  • search_vaadin_docs unknown never probed

    Search Vaadin documentation. Returns ranked chunks with file path, title, heading, content and framework (java/react/common); component pages also report their Maven artifact and whether the component is commercial. A hit on newly introduced API also reports the version that introduced it ("New In"), which is a signal that content is newer than most training data. Use get_full_document to retrieve the surrounding document for any returned file_path, and get_vaadin_dependency for the exact dependency to add.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "question",
    "vaadin_version"
  ],
  "properties": {
    "question": {
      "type": "string",
      "description": "Natural-language search query"
    },
    "max_tokens": {
      "type": "integer",
      "format": "int32",
      "description": "Token budget for the returned sections' content only: the metadata block around each section is outside it, so the message costs more than the content it bounds. Defaults to 1500. Range 100–5000; values outside it are clamped. When the budget runs out the ranking is cut from the end rather than skipped over, so fewer than max_results can come back."
    },
    "max_results": {
      "type": "integer",
      "format": "int32",
      "description": "Maximum number of results to return. Defaults to 5. Values above 20 are silently clamped to 20. max_tokens can return fewer — always the top of the ranking, never a gapped selection from it."
    },
    "ui_language": {
      "type": "string",
      "description": "Optional UI-language filter: java, react, or common. When unset, all languages (and shared content) are searched."
    },
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 32 lines
  • get_vaadin_primer unknown never probed

    Returns this server's primer for one Vaadin version: what a model trained on older material gets wrong about it — Flow (server-side Java) versus Hilla (React), project structure, theming, security, components. Call it before writing code against a version, so your assumptions are that version's rather than your training data's. For legacy versions (7, 8, 14), returns guidance on version-specific resources.

    mcp-tool

    {
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "vaadin_version"
  ],
  "properties": {
    "vaadin_version": {
      "type": "string",
      "description": "Vaadin version. One of: 7,8,14,24,25.0,25.1,25.2,25.3. An unlisted bare major resolves to that major's newest released minor. Answers are per version."
    }
  }
}
    arguments 13 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/84ca3cd1a4f67c5f/badge.svg)](https://brick.blue/agent/84ca3cd1a4f67c5f)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Own the domain? Prove it and the listing carries a verified badge here too: passport.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.