Getting started

Componecat is a software component catalog: a hierarchical, richly-typed registry of every system, service, library, and resource your organization operates. It combines structured metadata, Git integration, hosted documentation, and explicit endpoint definitions, and exposes the whole catalog to AI coding agents over a Model Context Protocol (MCP) server.

This page takes you from signing in to a populated catalog your team and your agents can use.

Sign in and choose an organization

Open your Componecat instance — the hosted app lives at app.componecat.ai — and sign in. Everything in Componecat is scoped to an organization: the catalog you see, the teams that own entities, and the access tokens you issue all belong to the organization you’re currently working in. If you belong to more than one, use the organization switcher to pick the right one before you start.

If you’re the first person from your company, create an organization during sign-up. Invite the rest of your team from the organization settings once you’re in.

Create your first entity

Every catalog entry is an entity. Entities have a kind that determines what they can hold — a System groups things, a Component links to a source repository, a Resource represents a datastore or piece of infrastructure, and so on. See Entities and kinds for the full model.

To add one by hand:

1. Go to the catalog and choose New entity.
2. Pick a kind (start with Component if you’re cataloguing a service or library).
3. Fill in the built-in fields: a display name, a URL-friendly name, the owning team, a lifecycle stage (Experimental, Development, Production, Deprecated, or Retired), and a one-line description.
4. Optionally link a repository and add tags.
5. Save. Your entity now appears in the catalog, is full-text searchable, and is reachable by its reference URI (component://namespace/name).

From the entity’s page you can add relationships to other entities, declare interfaces it exposes, and write documentation.

Populate the catalog from Git

Adding entities by hand is fine for a few, but the catalog stays accurate when it lives next to the code. Drop a componecat.yaml file in a repository and Componecat ingests it — on every push (via webhook) and on a scheduled scan.

apiVersion: componecat/v1
kind: component
metadata:
  name: payment-gateway
  namespace: payments
  description: Processes card transactions
  owner: team-payments
  tags: [payments, pci, critical]
spec:
  lifecycle: production
  fields:
    languages: [go, protobuf]
  interfaces:
    - kind: api
      name: Payment API
      protocol: grpc
      url: grpc://payments.internal:443
  relationships:
    - kind: depends-on
      target: resource://datastores/payments-db

This “catalog-as-code” model keeps the catalog in step with reality and lets each team own its own entries. See Catalog as code for the discovery mechanisms, monorepo support, and how conflicts between descriptor and manual edits are resolved, and the descriptor file reference for every field.

Connect your other systems

Descriptor ingestion runs off an integration — one authenticated connection to GitHub, GitLab, or Bitbucket, created by an admin in organization settings. The same connection can do more than scan: it can import your teams so entities have real owners, and pull Markdown from your repositories into entity documentation. Atlassian and Microsoft 365 connect for team sync as well.

Start with Integrations, then set up the capabilities you need — repository scanning, team sync, and documentation sync.

Connect your AI agents

Componecat’s reason for existing is to give AI coding agents real organizational context. It exposes the catalog over an MCP server at /api/mcp, so an agent can search the catalog, read an entity’s documentation, traverse its dependencies, and inspect its interfaces before it writes a line of code.

Point your agent at your instance’s MCP endpoint (for the hosted app, https://app.componecat.ai/api/mcp) and authorize it with the OAuth device flow. See Connect AI agents for the full walkthrough and the list of tools an agent gets.

Where to go next

• Entities and kinds — how the catalog models your software, and how to customize kinds and fields.
• Relationships — hierarchy, dependencies, and impact analysis.
• Interfaces — declaring the APIs, packages, and other connection points an entity exposes.
• Documentation — attaching Markdown docs, external links, and Git-sourced docs to entities.
• Integrations — connecting GitHub, GitLab, Bitbucket, Atlassian, and Microsoft 365, and what each connection can do.
• Search and discovery — finding your way around a large catalog.
• APIs — the REST and MCP surfaces for automation.