# Vaadin Documentation MCP
> Remote MCP server for searching Vaadin documentation and returning framework guidance to AI coding clients. Vaadin also publishes a separate Directory MCP service; that service is not included in this record.
Canonical: https://www.mcpfolio.com/servers/vaadin
Last updated: 2026-10-28
## Catalog record

- Publisher: Vaadin
- Categories: development, search

## Website

https://vaadin.com/

## Transports

Streamable HTTP

## Authentication

Hosted endpoint requires no authentication. Self-hosted endpoint also has no built-in authentication; restrict network access. Self-hosting requires an eligible Vaadin Enterprise Edition license key.

## Tools

- **get_component_java_api**: 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.

- **get_component_react_api**: 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.

- **get_component_styling**: 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.

- **get_component_web_component_api**: 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.
- **get_components_by_version**: 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.

- **get_full_document**: 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.

- **get_java_symbol**: 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.

- **get_new_apis**: 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.

- **get_theme_css_properties**: 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.
- **get_vaadin_dependency**: 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.

- **get_vaadin_versions**: 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.

- **search_vaadin_docs**: 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.

- **get_vaadin_primer**: 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.

## Sources

- [official_setup_and_capabilities](https://vaadin.com/docs/latest/building-apps/agentic-development/mcp)
- [official_hosted_server](https://mcp.vaadin.com/docs)

## Setup

Use the interactive setup panel on [the detail page](https://www.mcpfolio.com/servers/vaadin) to view instructions for each supported client.