Search and discovery

A catalog is only useful if you can find things in it. Componecat indexes everything and gives you several ways in.

One page for browsing and searching

Catalog is where you both explore and search. Open it with an empty search box and you get the whole catalog; type into that box and the same page narrows to what matches. There is no separate search screen to switch to, and no filter that works in one place but not the other.

Tree or list

A toggle above the results picks how they are drawn:

• Tree follows the hierarchy — systems containing components containing sub-components — with expand and collapse for navigating deep structures.
• List ranks results by relevance and shows the matching text, including the documentation snippet that matched.

Browsing starts in the tree; typing a query moves you to the ranked list, because that is when relevance has something to say. Toggle whenever you like — the choice is remembered, and it travels in the link you share.

Narrowing the catalog does not flatten the tree. Matches stay where they belong in the hierarchy, and any parent that did not itself match is still drawn above them, dimmed, so you can see where a result lives. Those context rows are not counted in the result total, but they are still real entities you can open.

Full-text search

Search runs across an entity’s display name, name, description, tags, and key field values — and across documentation sections, so a phrase buried in a runbook still surfaces the entity. Partial and case-insensitive matches are handled, so you don’t have to remember exact spelling.

Faceted filters

Narrow the catalog by kind, lifecycle, owner, namespace, source repository, tags, and any searchable field. Filters opens the panel; each chip carries the number of entities it would leave you with. Filters combine, so “production components owned by team-payments” is a couple of clicks. Filter state lives in the URL, so a filtered view is a shareable, bookmarkable link.

The query language

Facets answer “narrow this down”. When you need to ask a real question of the catalog — anything with an or, a not, or a comparison — type it into the same search box:

lifecycle:production AND (language:go OR language:rust) AND NOT tag:deprecated

A query is a mix of bare words, which search names, descriptions, tags, and documentation exactly as they always have, and field clauses, which filter on a specific field. Typing plain words still does plain search — the language only engages once you use a clause or an operator.

Fields

Built-in fields: name, displayName, namespace, description, kind, lifecycle, owner, tag, language, repository, branch, hasDescriptor, interface, interfaceVisibility, protocol, hasDocs, createdAt, updatedAt. Several have shorter aliases — ns, desc, team, lang, repo, updated.

interface, interfaceVisibility, and protocol ask about the interfaces an entity exposes, and match when any one of them fits: interface:mcp finds every entity publishing an MCP server, interface:* every entity publishing anything at all, and interface:null the ones publishing nothing. hasDocs:true finds entities carrying documentation, whether a linked page or a section held in the catalog.

Your organization’s field definitions are addressable by their key: tier:1, costCenter:CC-100. If a field key happens to match a built-in name, reach it as field.owner and the built-in as owner.

Start typing a field name in the search box and it will suggest the ones that exist, including your own.

Operators

Expression	Matches
lifecycle:production	Field equals the value
name:~gateway	Field contains the value
name:*gateway*	Wildcards — * for any run of characters, ? for one
replicas:>=3	Compare — >, >=, <, <= on number and date fields
updatedAt:[2026-01-01 TO 2026-03-01]	Inclusive range; * for an open end
namespace:null	Field is absent
repository:*	Field is present
owner:!platform-team	Field does not equal the value

Combine clauses with AND, OR, NOT, and parentheses. A space between clauses means AND, so kind:service lifecycle:production needs no operator. Negation also has the short forms -tag:deprecated and !tag:deprecated. Quote anything containing a space: owner:"Platform Team".

owner: takes a team name or a team id, and kind: takes a kind key.

Text matching ignores case everywhere, on your organization’s fields as much as on the built-in ones, so tier:GOLD and tier:gold find the same entities. Number, boolean, and date fields compare by value rather than by text, so replicas:>=9 matches 10 and a wildcard in one of them is an error rather than a literal character to look for.

If a query doesn’t parse, the search box says why and points at the character that confused it — nothing is silently ignored. Plain words are never rejected, though: text that happens to contain a colon — auth: token, a pasted link — is searched for as written rather than treated as a broken expression.

Filters and queries together

Facet selections and the query box are combined, so you can filter down with chips and then refine with an expression. To query rewrites the active facets as the equivalent expression and hands it to the search box, which is where you go when a click-built filter needs an or it can’t express. The reverse doesn’t hold: an arbitrary expression has no chip form, so once a query is doing the work, it is the single source of truth.

The same language everywhere

The expression you type in the UI is the same one the API takes. Pass it as q to GET /api/rest/v1/catalog/search, as query to the GraphQL searchCatalog field, or as query to the MCP search_catalog tool — see the API reference.

Keeping a query: dynamic collections

A collection is a named, shareable set of catalog entities. A static one holds the entities you picked by hand, in the order you put them in. A dynamic one holds a query instead, and its members are whatever that query matches right now — an entity that starts matching joins on its own, and one that stops matching leaves.

The query is written in the language above, in a box with the same field suggestions and the same syntax help, alongside a live preview of what the collection would contain. Anything you can search for, you can keep:

kind:service AND lifecycle:production AND NOT tag:deprecated
interface:mcp AND hasDocs:true
owner:"Platform Team" AND updatedAt:>2026-01-01

A collection’s page shows its query, and Open in catalog hands the query back to the catalog search box so you can widen it, narrow it, and save the result as another collection.

Where the search box treats a query it can’t make sense of as ordinary words to search for, a saved query is refused until it parses — a collection that quietly matched nothing would be worse than one that won’t save.

The command palette

Press Cmd/Ctrl + K anywhere for a global command palette: type to jump straight to any entity. Your recently viewed entities are one keystroke away, so hopping between the things you’re working on is fast.

Results are grouped by what they are. Alongside Catalog entries and app pages, a Documentation group matches this documentation itself, so a question about how Componecat works — “descriptor”, “team sync”, “impact analysis” — finds the page that answers it without leaving what you were doing. Catalog matches always rank first, so searching for a term that names one of your entities still puts the entity at the top. Selecting a documentation result opens the page here on the documentation site in a new tab, at the exact section that matched.

The palette shows the best few matches, not all of them. See all results at the bottom of the Catalog group opens the catalog page with the same text, where the filters and the query language are waiting.

Related

• Entities and kinds
• Documentation and activity — docs participate in search.