19 posts tagged with "Update"

Welcome to the monthly update for EventCatalog, here you can find what's next, how to get started, and what's coming next.

• EventCatalog Linter
• New Entity Resource and Entity Map
• Fetching Schemas at Runtime
• Better Search Capabilities (Search v2)
• Customize Your Documentation Pages (Detail Panel)
• Updated Ubiquitous Language Explorer
• AsyncAPI and OpenAPI Generator Enhancements
• Other project improvements

EventCatalog Linter​

We're excited to introduce the EventCatalog Linter — a powerful tool to help you maintain consistency and quality across your architecture documentation. The linter helps catch common issues, enforces best practices, and ensures your EventCatalog stays well-organized as it grows.

The linter can be integrated into your CI/CD pipelines to catch issues early and maintain documentation standards across your team.

$ npx @eventcatalog/linter

services/user-service/index.mdx
  ✖ error version: Invalid semantic version format [version] (schema/valid-semver)
  ⚠ warning Summary is required for better documentation [summary] (best-practices/summary-required)

✖ 2 problems

domains/sales/index.mdx
  ✖ error Referenced service "order-service" does not exist [services] (refs/resource-exists)

✖ 1 problem

✖ 3 problems (2 errors, 1 warning)
  2 files checked

To get started with the EventCatalog Linter, you can read our quick guide in our documentation here.

New Entity Resource and Entity Map​

We've introduced Entity Resources and the new EntityMap component to help you document and visualize your domain entities and their relationships. This new feature allows you to:

• Document your domain entities with rich metadata
• Visualize entity relationships across your architecture
• Track how entities flow through your systems
• Better understand your domain model

See Demo

The Entity Map provides a visual representation of your domain entities and their relationships, making it easier to understand your domain model at a glance.

Using the EntityMap component you can embed the entity map into your documentation pages and pick and choose which entities to display.

Fetching Schemas at Runtime​

EventCatalog now supports fetching schemas at runtime with the new Remote Schemas component, allowing you to dynamically load and display schema information without needing to rebuild your catalog. This feature is particularly useful for:

• Large organizations with frequently changing schemas
• Dynamic schema registries
• Keeping documentation in sync with live systems

This capability ensures your documentation stays up-to-date with the latest schema changes without manual intervention.

You can read more about the RemoteSchema component here.

Better Search Capabilities (Search v2)​

We've completely rebuilt our search experience with Search v2. The new search provides:

• Faster, more accurate results
• Better filtering options
• Improved relevance scoring
• Enhanced autocomplete
• Search across all resource types including entities

Try the new search

The improved search makes it much easier to find the information you need across your entire EventCatalog.

To get started, just update your EventCatalog with the command:

$ npm install @eventcatalog/core@latest

Customize Your Documentation Pages​

EventCatalog now gives you more control over how your documentation pages are displayed. You can now customize the detail panel to your needs.

To start configuring the detail panel, you can read our documentation here.

Updated Ubiquitous Language Explorer​

The Ubiquitous Language Explorer has been significantly improved with:

• Bigger, more prominent display making it easier to browse your domain language
• Subdomain language integration — terms from subdomains now appear in their parent domains
• Better organization of domain-specific terminology
• Enhanced navigation through your ubiquitous language

Explore the demo

This makes it much easier for teams to discover and understand the shared language across domains and subdomains.

AsyncAPI and OpenAPI Generator Enhancements​

Our AsyncAPI and OpenAPI generators have received significant updates:

Draft Support for life cycle management​

You can now mark resources as draft during generation, allowing you to:

• Tell your team that a message or endpoint is still in development
• Iterate on designs without affecting live documentation
• Maintain work-in-progress resources separately

You can read more about the draft support here.

Markdown Templates​

The generators now support custom markdown templates, giving you:

• Full control over generated documentation format
• Ability to match your organization's documentation standards
• Flexible content generation based on your needs

These enhancements make the generators much more flexible and suitable for enterprise workflows.

Other project improvements​

• Improved performance for large catalogs
• Updated Astro Versions
• New EventCatalog SDK version to support Entities

What's coming in August?​

In August, we are focused on EventCatalog Studio. We are working on a visual interface for managing your EventCatalog, making it even easier for non-technical team members to contribute to your documentation. You can sign up for the early access release here.

We are also working on notifications. These will be webhook notifications you can setup and listen to when things in your catalog change. Examples of these are schema changes, breaks, new versions, etc. Usecase's include:

• Teams getting notified when a new version of a schema is published
• Trigger contract tests or infustructure when schemas change
• Provision new infrastructure when a new version of a service is published
• Trigger a build when a new version of a service is published

If you have any questions or want to join our community of over 1200 people exploring EventCatalog and event-driven architecture feel free to join us!

Welcome to the monthly update for EventCatalog, here you can find what’s next, how to get started, and what’s coming next.

• Authentication and Role Based Access Control
• Domain Integration Map
• EventCatalog GitHub Action
• EventCatalog MCP 1.0 release
• EventCatalog Snippets
• PlantUML Support
• AWS Glue Schema Registry integration
• Other project improvements

Authentication and Role Based Access Control​

We have introduced Authentication and Role Based Access Control to EventCatalog. This allows you to secure your EventCatalog instance and control access to your resources.

EventCatalog now provides secure authentication to control access to your documentation. Whether you're a small team getting started or a large enterprise with complex identity requirements, EventCatalog's flexible authentication system grows with your needs.

Get started with EventCatalog Authentication

To get started with authentication, you can read our quick guide in our documentation here.

Domain Integration Map​

We are excited to introduce the Domain Integration Map — a powerful new visualizer designed to give you a clear view of how messages flow across domain boundaries in your event-driven architecture.

This feature highlights all messages that are produced or consumed between domains, helping you instantly spot integration events and understand cross-domain communication at a glance.

View the demo

If you're building systems using domain-driven design (DDD) and event-driven architecture (EDA), this should make it much easier to track message usage and reduce the time spent mapping interactions.

The new page can be seen in EventCatalog at /visualiser/domain-integrations (see demo here).

EventCatalog GitHub Action​

The EventCatalog GitHub action is a powerful tool that helps you catch issues early in your pull requests, ensuring your event-driven architecture stays healthy, aligned and governed.

The EventCatalog Action has the context of your EventCatalog, and can help you identify issues with producers, consumers, messages and much more.

The action brings AI-powered insight into your Git workflows. It uses large language models (LLMs) to automatically review changes to your EventCatalog, helping you catch issues early—before they reach production (you can pick your model and provider).

Think of it as a smart assistant for your pull requests. It doesn't just lint code—it understands the implications of your changes.

You can learn more and how to get started in our release blog post here.

EventCatalog MCP 1.0 release​

You can now connect any MCP Client (e.g Cursor, Claude) to your EventCatalog instance. Version 1.0 introduces new MCP tools and features, including:

• Get resources (domains, services, messages, etc)
• Find producers and consumers for a given message
• Create flows based on your business requirements
• Review schema changes
• And much more.

When it comes to AI LLMs or Agents, context is key.

EventCatalog let's you document domains, models, messages, producers and consumers and much more. Using the MCP client, this context is given to your LLM's providing your models with the context they need to understand your architecture and domains.

Get started

With the EventCatalog MCP server you can give models the context they need to understand your architecture and domains.

The best way to try it out is to install the MCP server and connect it to your EventCatalog instance. You can get get started with the MCP in our documentation here.

Introducing EventCatalog Snippets​

Keeping your documentation DRY just got easier.

With EventCatalog Snippets, you can now reuse markdown and variables across your EventCatalog documentation — whether it's domains, services, or events.

Instead of duplicating content, simply define it once and import it wherever you need it.

This is perfect for maintaining consistent, centralized information across your docs. And with variable support, you can easily customize shared content without repetition.

To get started with snippets, you can read our quick guide in our documentation here.

PlantUML Support​

We have added support for PlantUML to EventCatalog. This allows you to create diagrams and visualizations of your architecture using PlantUML.

The new plantuml code block allows you to define PlantUML diagrams in your documentation.

```plantuml
@startuml
!define Table(name,desc) class name as "desc" << (T,#E5E7EB) >>
!define PK(x) <u>x</u>
!define FK(x) <i>x</i>

' ===== Core Tables =====

Table(Customers, "Customers") {
  PK(customerId): UUID
  firstName: VARCHAR
  lastName: VARCHAR
  email: VARCHAR
  phone: VARCHAR
  dateRegistered: TIMESTAMP
}

Table(Orders, "Orders") {
  PK(orderId): UUID
  FK(customerId): UUID
  orderDate: TIMESTAMP
  status: VARCHAR
  totalAmount: DECIMAL
}

Table(Products, "Products") {
  PK(productId): UUID
  name: VARCHAR
  description: TEXT
  price: DECIMAL
  stockQuantity: INT
}

Table(OrderItems, "Order Items") {
  PK(id): UUID
  FK(orderId): UUID
  FK(productId): UUID
  quantity: INT
  unitPrice: DECIMAL
}

Table(Payments, "Payments") {
  PK(paymentId): UUID
  FK(orderId): UUID
  amount: DECIMAL
  method: VARCHAR
  status: VARCHAR
  paidAt: TIMESTAMP
}

Table(InventoryEvents, "Inventory Events") {
  PK(eventId): UUID
  FK(productId): UUID
  eventType: VARCHAR
  quantityChange: INT
  eventTime: TIMESTAMP
}

Table(Subscription, "Subscriptions") {
  PK(subscriptionId): UUID
  FK(customerId): UUID
  plan: VARCHAR
  status: VARCHAR
  startDate: TIMESTAMP
  endDate: TIMESTAMP
}

' ===== Relationships =====

Customers ||--o{ Orders : places
Orders ||--o{ OrderItems : contains
Products ||--o{ OrderItems : includes
Orders ||--o{ Payments : paid_by
Products ||--o{ InventoryEvents : logs
Customers ||--o{ Subscription : subscribes

@enduml
```_

This will render the following diagram:

View the demo

Using plantuml you can now bring more diagrams and context to your documentation. You can read more about it in our documentation here

AWS Glue Schema Registry integration​

We have added support for AWS Glue Schema Registry to EventCatalog. This allows you to pull and sync your schemas from AWS Glue Schema Registry into EventCatalog.

Schema registries are great, but they lack meaning, context, business context, history and much more. This new integration let's you document your schemas in ways that aren't possible with a schema registry. Providing you and your teams with more information, visualizations, AI capabilities and much more.

You can import all your schemas, or just the ones you want to sync and use filtering to map them to your producers and consumers.

To get started with the AWS Glue Schema Registry integration, you can read our quick guide in our documentation here.

Other project improvements​

• EventCatalog now supports SSR mode
• Configure EventCatalog with your environments
• Faster build times (20%-50% reduced output size)
• Ability to walk through EventCatalog Flows(see demo)
• SchemaViewer now has search and expand features(see demo)
• All headings are now clickable and linkable
• Sidebar now has better search, and collapsible buttons

What’s coming in July?​

In June, we’re releasing more integrations for EventCatalog, including support for Azure messaging services, Azure Schema Registry, and Apicurio Schema Registry. These integrations will allow you to add semantic meaning to your schemas and keep them in sync with your documentation—making it easier for teams to find the information they need and maintain a shared understanding of your architecture.

Many teams use EventCatalog as a design > implement > document workflow. We’re exploring ways to make drafting messages, services, and resources directly in EventCatalog easier—and we expect to release the first version of this feature in July.

Lastly, we know many of you are eagerly waiting for EventCatalog Studio. We’re still hard at work on it and aim to release an initial version soon. Stay tuned!

If you have any questions or want to join our community of over 1150 people exploring EventCatalog and event-driven architecture feel free to join us!

Today we are excited to announce the release of the EventCatalog GitHub Action. This action is a powerful tool that helps you catch issues early in your pull requests, ensuring your event-driven architecture stays healthy, aligned and governed.

What is the EventCatalog GitHub Action?​

The EventCatalog GitHub Action is a GitHub Action that helps you catch issues early in your pull requests. You can pick which tasks you want to use from the Action from your pull requests.

The EventCatalog Action has the context of your EventCatalog, and can help you identify issues with producers, consumers, messages and much more.

Get started with the EventCatalog GitHub Action

The EventCatalog GitHub Action brings AI-powered insight into your Git workflows. It uses large language models (LLMs) to automatically review changes to your EventCatalog, helping you catch issues early—before they reach production.

Think of it as a smart assistant for your pull requests. It doesn't just lint code—it understands the implications of your changes.

What it does:

• Detect breaking changes in schemas during pull requests
• Score how likely a change is to cause issues
• List affected consumers so you know who’s impacted
• Recommend actions to resolve problems before merging

By automating the review process, this GitHub Action saves your team hours of manual effort, reduces human error, and brings consistency to your EventCatalog maintenance.

You’re always in control—the final merge decision is still up to you. But now, you’ll have the insights to make it with confidence.

What are tasks?​

Tasks are the core of the EventCatalog GitHub Action. They are a range of tools you can use.

With this initial version we are launching the Schema Review task.

We will be adding more tasks in the future.

How does the schema review task work?​

The schema review task is used to review schemas for breaking changes. This task let's you catch breaking changes in your schemas before they are deployed.

The schema review supports any schema format, including (JSON, Avro, Protobuf, Thrift, etc.).

Why use the schema review task?

• Capture breaking changes in your schemas before they are deployed
• Get a score of how likely the changes are to be breaking
• See a list of consumers that will be affected by the changes
• Take action to fix breaking changes before they are deployed

Workflow example:

1. Your team member makes a change to a schema in EventCatalog (inside your events, queries or commands folders)
2. The action will review the schema for breaking changes using your configured LLM (OpenAI, Anthropic, Google)
3. The action will return a summary of changes, and give you a score of how likely the changes are to be breaking
4. The action will list affected consumers so you know who’s impacted
5. Your team member is still in control of the merge decision, but now has the information to make a more informed decision

How to get started?​

To get started you can read our quick guide in our documentation here.

The EventCatalog GitHub Action uses LLMs to review your schemas, and find breaking changes. You can pick your provider and model from the following list:

• OpenAI
• Anthropic
• Google

Summary​

The EventCatalog GitHub Action is a powerful tool that helps you catch issues early in your pull requests, ensuring your event-driven architecture stays healthy, aligned and governed.

Finding breaking schemas early can save you time and de-risk your production environment.

To get started you can read our quick guide in our documentation here.

FAQ​

• What is the EventCatalog GitHub Action?

  • The EventCatalog GitHub Action is a GitHub Action that helps you catch issues early in your pull requests. You can pick which tasks you want to use from the Action from your pull requests.

• Will the LLM hallucinate?

  • Like all LLMs, the EventCatalog GitHub Action can hallucinate, although we provide the right context to the LLM to help it understand the context of the changes and the effected consumers.
  • You have configuration to pick which provider and models you want to use. If you are seeing hallucinations, you can try a different provider or model.
  • Think of EventCatalog GitHub Action as another member of your team. It is not a replacement for your team, but a tool to help you catch issues early, saving you time.

• Can I bring my own rules?

  • We are working on it!
  • We want you to to have the ability to bring your own rules to the action. This will let you define your own rules for your organization and health checks for the LLM.
  • This will let you define specific rules for your organization and governance checks for the LLM to check for your reviews.

Welcome to the monthly update for EventCatalog, here you can find what’s next, how to get started, and what’s coming next.

• Subdomain support to EventCatalog
• Introducing EventCatalog Reports
• New GitHub Plugin for EventCatalog
• New Confluent Schema Registry
• Bring your own models to EventCatalog Chat
• Entities are now supported in EventCatalog
• Add multiple specifications to your services
• EventCatalog Visualizer updates
• What’s coming in June?

Subdomain support to EventCatalog​

Many users of EventCatalog come from a Domain-Driven Design (DDD) background and rely on domains to organize their resources. To better support this approach, we’re excited to introduce subdomains.

Subdomains provide an additional layer of flexibility, allowing you to group resources within domains. When you create a subdomain in EventCatalog, it will be displayed as part of the parent domain, enabling a clearer structure and easier navigation between domains and their subdomains.

View the demo

If you’re following Domain-Driven Design (DDD) practices, subdomains can help you better organize your resources. You can find more details on how to get started in our documentation.

Introducing EventCatalog Reports​

We believe that establishing strong governance foundations is essential when building an event-driven architecture. This includes setting clear naming conventions, defining schema versioning strategies, establishing ownership, documenting producer/consumer relationships, and much more.

Unfortunately, many teams skip over governance early on—only to face the consequences later. Without governance, architectures often suffer from poor discoverability, a lack of shared understanding, and missed opportunities for delivering value.

EventCatalog already helps teams achieve better discoverability through documentation, schemas, visualization, and ownership. With the introduction of EventCatalog Reports, you can now track and monitor governance across your organization, ensuring your event-driven architecture stays healthy and aligned.

See generated reports for demo catalog

EventCatalog Reports generates a PDF that highlights areas where your governance practices could be improved across your documentation and architecture (see demo). These insights include:

• Schema completeness across your services and messages
• Identification of parts of your architecture that lack clear ownership
• Detection of services using outdated versions or deprecated messages
• And much more.

Learn more about EventCatalog Reports in our announcement blog post here.

New GitHub Plugin for EventCatalog​

Many teams use GitHub as their schema registry, and now EventCatalog makes it easy to integrate with your GitHub repositories. Our new plugin allows you to pull and sync schemas directly from GitHub into EventCatalog, ensuring your documentation stays up to date with your source of truth.

Watch the video to see it in action, or read the documentation to get started.

New Confluent Schema Registry​

We’re excited to announce that you can now pull and sync schemas from Confluent Schema Registry directly into EventCatalog.

This integration allows you to keep your documentation and architecture in sync with your source of truth. With support for custom filters, you can easily select which schemas to pull—giving you full control over which messages get updated and how they are assigned within EventCatalog.

Watch the video above for a quick demo, or read the documentation to get started.

Bring your own models to EventCatalog Chat​

EventCatalog Chat now supports OpenAI, Gemini, and Anthropic models.

This integration allows you to connect your own AI models with EventCatalog and gain insights into your architecture through natural language—helping you ask questions, understand relationships, and explore your event-driven system more intuitively.

With EventCatalog, you can ask questions, define custom prompts, and much more—giving you a powerful way to explore and interact with your event-driven architecture.

To get started you can read the documentation.

Entities are now supported in EventCatalog​

In Domain-Driven Design (DDD), entities are the core building blocks of a domain. They represent key concepts or objects—like Order, Customer, or Invoice—that have a unique identity and persist over time. Each entity lives within a bounded context, ensuring it adheres to the specific business rules and logic of that part of the system.

With this release, EventCatalog introduces Entities as a new resource type. You can assign entities to domains and services, helping your teams better understand the concepts they work with. This makes it easier to build a shared understanding of your architecture and the real-world ideas it models.

View the demo

If you want to get started with entities you can read the documentation.

Add multiple specifications to your services​

EventCatalog now supports adding multiple specifications to a single service. This is especially useful for teams managing services that expose several interfaces—such as APIs, events, and schemas—under the same service.

By assigning multiple specifications to a service, EventCatalog will display them for your users in a clear and organized way—helping your team better understand the capabilities and responsibilities of each service.

View the demo

If you want to get started with multiple specifications you can read the documentation.

EventCatalog Visualizer updates​

Swap between multiple versions in Visualizer​

We’ve added the ability to switch between different versions of your architecture directly in the EventCatalog Visualizer. Using a simple dropdown, you can navigate across as many versions as you need—making it easy to compare changes, track evolution, and spot differences over time.

View the demo

Embed multiple Visualizers into your documentation​

You can now embed multiple Visualizers within your documentation. This allows you to embed any domain, service, or message—giving your team rich, visual context directly alongside your written documentation.

This feature is perfect for helping teams explore and understand your architecture more easily, all within the same place.

View the demo

You can see an example of the customised homepage for EventCatalog.

Copy markdown from any page in EventCatalog for your LLMs​

A new pattern emerging in documentation is the ability to copy a page’s markdown for use in LLMs. We’ve made this easy in EventCatalog by adding a dropdown on every page—letting you quickly copy markdown to your clipboard for use in AI models or other tools.

In addition, you can view any page as markdown and copy schemas to your clipboard just as easily.

View the demo

Other project improvements​

• EventCatalog SDK has been updated to match all the new features.
• Channels now have two render modes in your EventCatalog.
• You can turn off changelogs in EventCatalog

What’s coming in June?​

In June, we’re releasing more integrations for EventCatalog, including support for Azure messaging services, Azure Schema Registry, and Apicurio Schema Registry. These integrations will allow you to add semantic meaning to your schemas and keep them in sync with your documentation—making it easier for teams to find the information they need and maintain a shared understanding of your architecture.

We’re also exploring improvements to the EventCatalog MCP server and working to bring EventCatalog closer to the tools your teams already use, like Slack and Azure Chat.

We are exploring CI/CD GitHub actions to help find governance problems before they reach your environments.

Many teams use EventCatalog as a design > implement > document workflow. We’re exploring ways to make drafting messages, services, and resources directly in EventCatalog easier—and we expect to release the first version of this feature in June.

Lastly, we know many of you are eagerly waiting for EventCatalog Studio. We’re still hard at work on it and aim to release an initial version soon. Stay tuned!

If you have any questions or want to join our community of over 1150 people exploring EventCatalog and event-driven architecture feel free to join us!

Event-driven architecture (EDA) practitioners often rely on schema registries to manage their event schemas. Popular solutions include the Confluent Schema Registry, Apicurio Registry, and cloud-based options like AWS Glue Registry, Azure Schema Registry, and Amazon EventBridge Schema Registry. These tools offer ready-to-use solutions for versioning, managing, and retrieving schemas at runtime.

However, through conversations with EventCatalog users, we discovered that many teams are also leveraging GitHub as a schema registry. GitHub’s built-in version control, collaborative feedback features, and ability to serve as a single source of truth make it a practical choice for managing schemas.

Despite their utility, traditional schema registries often fall short in one key area: context. While they store the schema data (like JSON, Avro, or Protobuf), they lack insights into how schemas are used, who produces or consumes them, and which teams are responsible for maintaining them.

EventCatalog aims to bridge this gap by enhancing the discoverability of event-driven architecture. We believe that by running EventCatalog alongside your existing schema registries, you can unlock greater value from your schemas and your organization.

If you're using GitHub as your schema registry, this blog post will guide you through syncing your schemas with your documentation, associating them with producers and consumers, and extracting more meaningful insights from your JSON, Avro, or Protobuf schemas.

Using GitHub as a schema registry​

There is no standardized approach for using GitHub as a schema registry—no universal folder structure or patterns. Typically, teams maintain a repository that houses their schemas. In this blog post, we will use an example schema registry called the FlowMart Schema Registry (see on GitHub).

View the example repository

As shown, the repository organizes schemas into folders, each representing a specific context. Within these folders are the schemas themselves, which naturally benefit from version control through Git. Teams often update schemas by creating a new version file while deprecating older ones as needed.

However, despite being versioned, these schemas lack contextual information. While it’s possible to add README files to explain their usage, this manual approach doesn’t offer a clear, visual representation of how schemas are applied or who is responsible for them.

That’s where EventCatalog comes in. With the EventCatalog GitHub integration, you can seamlessly sync your schemas with your documentation. This integration not only keeps your schemas up to date from external sources but also enables you to add context, visualize your architecture, and better understand how your schemas are used across your applications.

By leveraging EventCatalog, your teams can gain a clearer, more structured understanding of how schemas support your business processes.

EventCatalog generated from schemas in GitHub repository

Integrating GitHub with EventCatalog​

EventCatalog supports integration with any broker or schema registry, providing flexibility to users regardless of their existing setup. We already offer integrations with popular tools such as Confluent Schema Registry, Backstage, OpenAPI, and AsyncAPI. Now, we’ve introduced a new integration with GitHub.

If you want to explore examples right away, check out our GitHub repository: EventCatalog GitHub Generators.

Step 1: Create a New Catalog

If you don’t already have a catalog, create one using the following command:

npx @eventcatalog/create-eventcatalog@latest my-catalog

Step 2: Install the GitHub Plugin

Once your catalog is set up, you need to integrate it with your GitHub repository. For this example, we’ll use the FlowMart Schema Registry (see on GitHub). First, install the GitHub generator plugin:

npm i @eventcatalog/generator-github 

This command installs the necessary components to pull schemas from the remote repository.

Step 3: Configure the Plugin

To link your catalog with GitHub, update the eventcatalog.config.js file with the following configuration:

// rest of conf file
generators: [
  '@eventcatalog/generator-github',
      {
        // The URL of your GitHub repository
        repository: 'https://github.com/event-catalog/eventcatalog',
        // The branch to pull schemas from (default: main)
        branch: 'main',
        // The root path to your schemas
        path: 'some-folder/schemas',
        
        // The producers and consumers (services) to assign schemas to (optional)
        services: [
          {
            id: 'Orders Service',
            version: '1.0.0',
            // the messages this service sends
            sends: [{
              id: 'place-order',
              version: '2.1',
              // The path to the schema file (relative to the root path, some-folder/schemas/place-order.avro)
              schemaPath: 'place-order.avro',
              // The type of message, can be 'command', 'event' or 'query'
              type: 'command',
            }],
            // the messages this service receives
            receives: [{
              id: 'order-shipped',
              version: '1.0',
              // The path to the schema file (relative to the root path, some-folder/schemas/order-shipped.avro)
              schemaPath: 'order-shipped.avro',
              // The type of message, can be 'command', 'event' or 'query'
              type: 'event',
            }],
          },
          {
            id: 'Inventory Service',
            version: '1.0.0',
            // the messages this service sends
            sends: [{
              id: 'inventory-updated',
              version: '1.0',
              // The path to the schema file (relative to the root path, some-folder/schemas/inventory-updated.avro)
              schemaPath: 'inventory-updated.avro',
              // The type of message, can be 'command', 'event' or 'query'
              type: 'event',
            }],
            // the messages this service receives
            receives: [{
              id: 'order-placed',
              version: '1.0',
              // The path to the schema file (relative to the root path, some-folder/schemas/order-placed.avro)
              schemaPath: 'order-placed.avro',
              // The type of message, can be 'command', 'event' or 'query'
              type: 'event',
            }],
          },
        ],
        // We assign the services to a domain "Retail Domain" (optional)
        domain: {
          id: 'retail-domain',
          name: 'Retail Domain',
          version: '1.0.0',
        }
      },
    ]

This configuration creates two services, Orders Service and Inventory Service, which both send and receive messages (commands and events). The services are grouped under the Retail Domain.

Step 4: Generate the Catalog

After configuring the plugin, generate the catalog using:

npm run generate

This command pulls your schemas from GitHub, assigns them to the relevant services, and organizes your architecture. If a service or message doesn’t exist in EventCatalog, it will be created, and on future imports, only the schema will be updated, preserving your existing documentation.

Step 5: Run the Catalog Locally

To view your catalog locally, start the development server:

npm run dev

Visit localhost:3000 to see your generated catalog, complete with integrated schemas and documentation.

By combining GitHub with EventCatalog, you can keep your schemas synchronized while also documenting producers, consumers, and service relationships—all within a unified, visual interface.

To get started you can read the GitHub integration documentation.

Unlocking the Full Potential of Your Schemas with EventCatalog​

Once you have imported and synced your schemas, EventCatalog offers a range of features designed to enhance their usability and discoverability. Here are some of the key features that can add value to your schema management process:

1. EventCatalog Visualizer​

The EventCatalog Visualizer allows you to see the relationships between your producers and consumers, making it easy to understand how messages flow through your architecture. You can simulate message exchanges between services and access detailed documentation and schema information by right-clicking on any node. This visual insight helps you map interactions in your event-driven system effectively.

View the demo

2. Embed Schemas Directly in Documentation​

Since it’s your documentation, you have the flexibility to include any content you want. EventCatalog makes it even better by providing Schema and SchemaViewer components, allowing you to embed schemas directly into your documentation. This integration ensures that your documentation remains accurate, comprehensive, and context-rich, while also being visually informative.

View the demo

3. Quick Schema Downloads​

Users can easily download schemas directly from the EventCatalog UI. This feature is especially useful for teams needing quick access to schema details without navigating through complex repositories. It saves time and ensures that your teams always have the latest schema versions on hand.

View the demo

4. Conversational Insights with EventCatalog Chat​

EventCatalog Chat leverages LLMs (Large Language Models) to let you interact with your architecture. You can query your producers, consumers, and schemas conversationally, helping you find insights faster than manually sifting through GitHub repositories. This feature is ideal for quickly understanding how different parts of your architecture are interconnected. You can also use EventCatalog MCP server to query your schemas directly in your code editors.

Read the documentation

5. Assign Ownership for Better Accountability​

Assigning ownership to producers, consumers, and schemas within EventCatalog makes it easy to track who is responsible for specific parts of your architecture. This feature helps you quickly identify the right team or person when you need to update a schema or troubleshoot an issue. By clearly defining ownership, you reduce the risk of orphaned schemas and ensure accountability.

View the demo

By leveraging these features, EventCatalog transforms your schema management from a static, isolated process into an interactive and insightful experience. Whether you need visualization, quick downloads, conversational insights, or clear ownership mapping, EventCatalog enhances how you manage and understand your event-driven architecture.

Summary​

Event-driven architectures often rely on schema registries like Confluent, Apicurio, AWS Glue, and Azure Schema Registry to manage event schemas. However, these registries typically lack context, making it difficult to understand how schemas are used, who owns them, and how they fit into the broader architecture. Many teams also use GitHub as a schema registry due to its version control and collaboration features, but this approach also lacks visualization and contextual insights.

EventCatalog addresses these challenges by integrating with both traditional registries and GitHub, enhancing schema discoverability and usability. With the GitHub integration, you can automatically sync schemas, visualize producer-consumer relationships, embed schemas in documentation, assign ownership, and use conversational insights with EventCatalog Chat. This holistic approach not only centralizes schema management but also makes it intuitive and insightful for development teams.

If you want to learn more about how to use EventCatalog with GitHub you can read the GitHub integration documentation.

We are coming to Current London 2025!​

We are coming to https://current.confluent.io/london in May! If you are coming to the conference, we would love to hang out, just reach out!

If you have any questions or want to join our community of over 1100 people exploring EventCatalog and event-driven architecture feel free to join us!

Welcome to the monthly update for EventCatalog, here you find what's new in EventCatalog, what's coming next, and how to get started.

• EventCatalog Growth update 🚀
• Subdomains are now supported in EventCatalog
• Bring your own documentation to EventCatalog
• Bring your own AI keys (OpenAI) to EventCatalog Chat
• Embed diagrams into EventCatalog
• Resources can now be marked as deprecated
• Flow improvements
• Other project improvements

What’s coming in May?

• What’s coming in May?
• We are coming to Current London

EventCatalog Project update​

EventCatalog community continues to grow ❤️, now we have 1,127 Discord members (^3%), 2.1k Stars on GitHub (^5%), 879 new catalogs have been created in April (^7.20%) and 14.8k catalogs built into production (^32.59%). EventCatalog continues to grow every month, and super excited to see where the project can go!

EventCatalog sponsors OSO and Gravitee continue their sponsorship for the project (thank you!) 🙏. This sponsorship helps my goal towards open source sustainability. EventCatalog is free to use and open source, if you want to support the project checkout the tiers on GitHub or contact me directly at dave@eventcatalog.dev , I really appreciate any support ❤️

In April we introduced Subdomain support, Bring your own documentation to EventCatalog with custom documentation, with EventCatalog Chat you can now bring your own AI keys starting with OpenAI support, embed diagrams (Miro, Lucid, FigJam and DrawIO) into your pages with realtime editing, mark messages as deprecated and much more.

In this blog post we will dive deeper into features and improvements that were released in April, and how you can get started.

Subdomains are now supported in EventCatalog​

Many users of EventCatalog are following domain driven design practices. One thing missing from EventCatalog was the ability to create subdomains.

Subdomains look and behave the same as domains in EventCatalog, but they introduce a new way to group domains together.

An example of a domain and subdomain relationship is:

• Domain: Ecommerce
  • Subdomain: Orders
    • Service: Payment
    • Service: Shipping
  • Subdomain: Customers
    • Service: Profile
    • Service: Address
  • Subdomain: Inventory
    • Service: Products
    • Service: Warehouse

In this example, the Ecommerce domain contains the Orders, Customers and Inventory subdomains. Each subdomain contains services that are related to that subdomain.

When you add a subdomain to a domain, your users will be able to see the relationship between the domain and subdomain, navigate between them and see subdomains within the visualizer.

What do subdomains look like in EventCatalog?

You can now quickly see domains/subdomain relationships in EventCatalog. The page below shows a parent domain, with subdomains. Users can quickly navigate to subdomains using the sidebar or navigation panel.

View the demo

Subdomains are also visualized in EventCatalog. Using the filter you can highlight resources that belong to a certain domain. This let’s your teams get a visual of the whole domain (including the services, and messages) and dive deeper if they need into their subdomains.

View the demo

To start adding subdomains to your documentation you read the documentation.

Bring your own documentation to EventCatalog​

In April we released a new feature called Custom Documentation. This gives you the ability to add any documentation you want to EventCatalog. This can be a great way to extend your catalog beyond what is provided, and bring your own documentation to EventCatalog, rather than having documentation spread across multiple tools.

Custom documentation also supports all components in EventCatalog, this let’s you embed the EventCatalog Visualizer into your documentation, your diagrams from Miro, Lucid or Draw.io and much more.

Custom documentation is flexible and let’s you document anything you want. For example you could document Architecture Decision Records, Infrastructure & Operations, CI/CD configurations, team processed, onboarding information and much more….

View the demo

To start adding custom documentation you can read our getting started guide.

Bring your own AI keys to EventCatalog Chat​

EventCatalog is technology agnostic, and can integrate with any broker and specification in the world. This let’s you document your architecture, topics, messages, services, and domains into EventCatalog, once captured, this context can be used within LLMs.

EventCatalog Chat gives you the talk to your architecture, and can help your team find insights in seconds rather than hours or days.

EventCatalog Chat support browser based models, and now supports OpenAI models.

You can now bring your own OpenAI keys into EventCatalog, deploy EventCatalog on a server and let your teams start to get insights about your architecture. You can choose your model and embedding models for your catalog information.

EventCatalog also provides a prompt store. This gives you the ability to provide a library of prompts for your teams to get started with, and also create dynamic prompts for your teams.

To get started you can watch the video below, or read our OpenAI getting started guide, and you can learn more about our prompt store reading the prompt store guide.

Embed diagrams into EventCatalog​

You can now embed diagrams with EventCatalog, including Miro, Lucid, DrawIO and FigJam

View the demo

No longer have diagrams that sit and get stale, embed them into your documentation for your teams to quickly find, edit and collaborate.

To learn more you can read our component documentation.

Resources can now be marked as deprecated​

Sometimes your messages or services may get deprecated. You can now use the new deprecated property in EventCatalog to mark your resources as deprecated.

When you mark a resource as deprecated you can specify the date and message to show to your teams. This lets you deprecate things in the future, and help your teams understand what they should do to migrate away from a message, version or service.

---
id: OrderService
... # other service frontmatter

# deprecatd as an object (Recommended)
deprecated:
  # Date the service will be or was deprecated (YYYY-MM-DD)
  date: 2025-01-01
  # Reason the service is deprecated, supports markdown (optional)
  message: | 
    This service has been deprecated and replaced by the new service **InventoryServiceV2**.
    Please contact the [team for more information](mailto:inventory-team@example.com) or visit our [website](https://eventcatalog.dev).

# deprecated as a boolean 
deprecated: true
---

To get started, you can read our guide on how to deprecate a service, or deprecate a message.

Flow improvements​

EventCatalog Flows allow you to document interactions between services and messages. Flows give you the ability to document event-driven architecture choreography.

Flows can now reference other flows, helping you manage large scale flows in your diagram. This let’s you break out business processes in subflows and visualize them in your architecture

steps:
  - id: "step-1"
    title: "Example Step of a Event"
    # here we define the id and version of the flow we want to use in the flow diagram
    flow:
      id: "order-flow"
      version: 0.0.1

You can also now create your own custom nodes in your flow diagrams. This gives you the flexibility to create any type of visualization for your documentation.

View the demo

To learn more, you can read our getting started with flows guide, and explore the custom nodes in our documentation.

Other project improvements​

• EventCatalog SDK has been updated to match all the new features.
• We added ResourceLink and Link components to help you create links in your catalog
• Badges now support icons in EventCatalog
• GRPC and ZMQ protocols have been added to channel documentation
• Visualizer can now be embedded into custom docs

What’s coming in May?​

In May we are releasing even more integrations with EventCatalog, including Confluent Schema Registry, Azure messaging services and Azure schema registry, Apicurio schema registry and GitHub integrations (for those that keep schemas in GitHub). These new integrations will let you add semantic meaning to your schemas, and keep your schemas in sync with your documentation, giving your teams the ability to quickly find the information they need in your architecture.

We are also adding Anthropic and Gemini support for EventCatalog Chat. This will let you bring even mode models to your documentation, allowing you to query and gain insights using the models you use in your organization.

We also want to release the first version of our Schema API. This will let you call EventCatalog as an API to get your schemas, which could be useful for contract testing, validation and much more. We are looking to follow the xRegistry specification for this.

Many users of EventCatalog, are using EventCatalog as a design > implement > documentation tool. We are exploring ways to draft messages, services and resources in EventCatalog. We expect to release the first version of this in May.

We know a lot of people are waiting for EventCatalog Studio. We are still working on this, and aim to get an initial version out soon.

We are coming to Current London​

We are coming to https://current.confluent.io/london in May! If you are coming to the conference, we would love to hang out, just reach out!

If you have any questions or want to join our community of over 1100 people exploring EventCatalog and event-driven architecture feel free to join us!

I’m excited to share that EventCatalog 2.33.0 is now available. This release introduces the new EventCatalog Custom Documentation feature. This feature allows you to bring your own documentation to EventCatalog.

What does "Custom Documentation" mean?​

In the past EventCatalog has been focused on documenting your domains, services and messages. This has been great for EventCatalog users, but many people wanted the ability to extend the documentation capabilities of EventCatalog.

This is why we are introducing the new EventCatalog Custom Documentation feature. This feature allows you to bring your own documentation to EventCatalog.

View the demo

You can now document anything you want in EventCatalog, assign owners to the documentation and use EventCatalog components inside your documentation.

The use cases are endless, but here are some examples:

• Architecture Decision Records (ADRs)
• Product documentation
• Infrastructure documentation
• Guides and Tutorials
• Company policies
• Meeting notes
• And much more...

What does custom documentation look like in EventCatalog?​

A new sidebar icon has been added to EventCatalog. Clicking this icon will render your custom documentation.

In your EventCatalog you can customize the sidebar of your documentation and the content that is displayed.

View the demo

All your custom documentation is stored in the /docs folder, and can be organized in anyway you want. You then configure the sidebar in your eventcatalog.config.js file to configure your sidebar.

You can read the documentation here to get started and start building your own documentation.

Getting started​

You can start adding your custom documentation to your EventCatalog in minutes. You can read the documentation here to get started and start building your own documentation.

Roamap for custom documentation​

This is the first version of custom documentation, in April we are aiming to get the following features out:

• Import EventCatalog resources into your documentation
  • Import any EventCatalog resource into your documentation, using components
• Embed EventCatalog visualizations into your documentation
  • Add visualizations to your documentation using new components
• SDK support for custom documentation
  • Programmatically add documentation to your EventCatalog
• Adding custom documentation to EventCatalog Chat
  • Ability to ask questions about your documentation, privacy first, unlimited tokens

Summary​

I'm super excited about this release, it's the first step in our journey to make EventCatalog the best tool for documenting your architectures.

If you have any feedback or suggestions please create an issue or join the community on Discord.

I look forward to seeing what you build with this new feature!

Welcome to the monthly update for EventCatalog, here you can find what’s next, how to get started, and what’s coming next.

EventCatalog community continues to grow ❤️, now we have 1,097 Discord members, 2.1k Stars on GitHub, 820 new catalogs have been created in March and 11.2k catalogs built into production. EventCatalog continues to grow every month, and we are on track with open source sustainability.

EventCatalog sponsors OSO and Gravitee continue their sponsorship for the project (thank you!) 🙏. This sponsorship helps my goal towards open source sustainability. EventCatalog is free to use and open source, if you want to support the project checkout the tiers on GitHub or contact me directly at dave@eventcatalog.dev , I really appreciate any support ❤️

In March we introduced tiered pricing, EventCatalog MCP Server, Custom nodes to Flows, New Navigation Bar, More customization options, new components and many features were introduced.

• Introducing EventCatalog Tiered Pricing
• Introducing Architecture Overviews
• Introducing EventCatalog MCP Server
• Introducing custom nodes to flows
• Introducing MessageTable - Ability to see all messages a given domain
• Resource Groups with EventCatalog
• Improved Search results in EventCatalog
• New navigation bar for your documentation
• Customize your application sidebar
• Project improvements
• New talk - Managing Complexity with Event-Driven Architecture
• What’s coming in April?

In this blog post we will dive deeper into features and improvements that were released in March, and how you can get started.

Introducing EventCatalog Tiered Pricing​

In March we introduced tiered pricing to EventCatalog, these plans include, Community Edition, Starter Plan, Scale Plan and Enterprise Plan, our aim is to help companies when they need it, and scale governance and documentation with them along their journey.

After years of working with event-driven architecture, I’ve come to see it as a journey that many companies undertake. It often begins with simple broker-based pub/sub patterns, which are easy to understand and manage early on. At this stage, governance isn't a major concern. But as the architecture scales across the organization, complexity grows—and with it, the need for stronger governance and structure becomes increasingly clear.

When you go from 10 events to 1000s of events, maintenance becomes hard and people fall into the same common mistakes around versioning strategy, lack of documentation, and wasted time trying to figure all this out. (I have a talk about all this!)

The new EventCatalog plans are designed to support you at every stage of your event-driven journey, scaling governance and documentation as your needs grow.

Begin with the Community edition to get up and running quickly. As your requirements expand, the Start plan offers additional capabilities like custom documentation and conversational architecture insights. When it's time to scale your architecture, the Scale plan introduces automation and advanced features to streamline your workflow. And for organizations operating at mass scale, our Enterprise plan provides the tools and flexibility needed to manage complexity with confidence.

You can find the plans here and features that are included in each tier, if you have any questions feel free to reach out, happy to help.

Introducing new Architecture Overviews​

Architecture pages were released into EventCatalog. This is another way to quickly visualize and understand what messages are doing to and from your services and domains.

The architecture diagrams let you drill down into various different levels of information. Starting at domains, you can click into your services to see detailed information about what messages are sent/received from that service, and finally clicking on the message will take you to the documentation and schema for that message.

View the demo

Using the filters you can quickly filter by message type, or search for domains, services and messages you are interested in. If you are interested to learn more you can watch the video here or view the demo.

Introducing EventCatalog MCP Server​

You can now use EventCatalog inside your IDE or any MCP client. This brings a huge amount of value to EventCatalog for your teams and developers. Your team can now talk to your catalog of information in the client of their choice (e.g IDE), and use that context to create code , get schemas or understand their architecture.

Teams waste a huge amount of time trying to find the information they need. In event-driven architectures this problem scales fast. Being able to quickly find producers/consumers, schemas, messages, and context can save a huge amount of time, and now using the MCP server I believe developers can save even more time.

As developers are writing and exploring ideas, they can talk directly to your EventCatalog to get the information they need, and write code based on the context of your architecture.

This is the first release of this feature, and we look to add more value in April.

If you are interested and want to try the feature you can read more in the release blog post.

Introducing custom nodes to flows​

EventCatalog gives you the ability to document business workflows (EventCatalog Flows). You can use your resource inventory (services and messages) and create business workflows. These workflows can help your organization understand and know what is happening in your architecture.

View the demo

Flows can be used to help you get more value from EventCatalog. Think of a feature you have, from A to Z, and you want to document what happens and the events, messages, services, external systems that it interacts with. This is what flows help you document.

In March we released the ability to add any custom node to your flow. To give you examples, you can now document schedules, decisions, timers, processors… anything you want!

Using custom nodes you can now document any business flow you want in EventCatalog and embed these flows directly into your documentation using the Flow component.

You can get started reading the documentation or view the demo.

Introducing MessageTable - Ability to see all messages a given domain​

Some users want to see all the messages that belong to a domain, so we introduced a new component called MessageTable.

View the demo

The new message table component will list all messages in a domain or service on your documentation page and give your users the ability to quickly search for messages they are interested in and filter them by queries, commands or events.

To get started you can read the documentation or view the demo.

Resource Groups with EventCatalog​

We introduced the idea of Resource Groups, this gives you the ability to document and group resources in EventCatalog in ways that EventCatalog wasn’t to before.

With resource groups you can also define your own documentation sections in your sidebars.

View the demo

This feature just gives you more flexibility if you need it. You can read the documentation to get started.

Improved Search results in EventCatalog​

Thanks to our community we now have better search results in EventCatalog. Using the search bar in EventCatalog will now return better results for your users, giving them the ability to quickly find what they need.

AsyncAPI and OpenAPI documents are also added to the search results.

View the demo

New navigation bar for your documentation​

In March we released a new navigation bar option to help organize your documentation. With this new navigation bar you can quickly find the information you need, use custom badges to highlight resources and also view OpenAPI and AsyncAPI specifications.

View the demo

To get started you can read the documentation, to learn how to opt into this navigation bar.

Customize your application sidebar​

You can now pick and choose which features are shown in your application side bar, giving you more flexibility for your catalog and documentation.

To get started you can read the documentation

Project improvements​

• We moved over to MDX files for EventCatalog, for faster interactions with EventCatalog
• Custom landing pages now support components
• We added ResourceLink and Link components to help you create links in your catalog
• Tile component, now supports colors and icons
• Flows now have a sidebar to help you quickly see flow owners, versions and changelogs.
• EventCatalog Studio still on target for initial release in Q2 2025.
• OpenAPI Generator 5.0.2 is now out. Adding httpMethodsToMessages property to the OpenAPI Generator plugin. Map HTTP methods to message types easier in EventCatalog.

Upgrade your EventCatalog​

To get the most of all the new features, we recommend upgrading to the latest version of EventCatalog.

npm install @eventcatalog/core@latest

New Talk - Managing Complexity with Event-Driven Architecture​

Ealier in the year I gave a new talk about complexity with event-driven architecture, and how domain-driven design can help you manage complexity.

If you are interested in learning more about event-driven architecture, and how to manage complexity, you can watch the talk below.

What’s coming in April?​

In April we are releasing the ability to add custom documentation to EventCatalog, this gives you the ability to bring your own docs to your catalog (e.g Runbooks, Product pages etc), this gives you flexibility on what you want to document, whilst using EventCatalog components to enhance it. We will also be adding custom docs to EventCatalog Chat and MCP server.

We also want to release the first version of our Schema API. This will let you call EventCatalog as an API to get your schemas, which could be useful for contract testing, validation and much more. We are looking to follow the xRegistry specification for this.

Introducing the ability to add drafts to EventCatalog and letting teams use EventCatalog in early phases of your journey. Documenting your thoughts and getting feedback from your teams.

We are aiming to get the Confluent schema registry plugin released, giving you the ability to pull in schemas from Confluent into EventCatalog.

We are exploring runtime components, giving you the ability to write your own runtime components/blocks on your page to extend the catalog into more personal use cases (e.g self service for producers/consumers, datadog integrations).

We want to spend more time on Event EventCatalog Studio. Giving you the ability to do all of this with a custom UI, and design your EventCatalog.

As normal, things can change but this is the direction we are heading.

If you have any questions or want to join our community of over 1100 people exploring EventCatalog and event-driven architecture feel free to join us!

The vision for EventCatalog is simple; to help companies bring discoverability to their architecture and reduce the time it takes to maintain, understand, and build new features.

We want to build a platform that enables developers to quickly find and understand the information they need, whilst giving architects and business stakeholders the ability to govern their architecture and control the standards of their systems.

Overtime distributed systems become more complex, the need for a governance and a single source of truth for your architecture becomes more important.

We believe EventCatalog is a step in the right direction to help teams achieve this, and today we are happy to share that EventCatalog now supports the Model Context Protocol (MCP), which we believe can help teams save time by finding the information they need directly in their code editor or LLM.

Using the EventCatalog MCP Server you can provide your EventCatalog data to any LLM or AI application that supports the MCP protocol.

Some examples of what you can do with the EventCatalog MCP Server include:

• Improved Discoverability - Ask questions about your architecture directly in your code editor or LLM.
• Schema Access - Get access to schemas directly in your code editor or LLM and use them to build new features.
• Producers and Consumers - Quickly understand who consumes the events you are about to change
• Context - Use EventCatalog context to help you build new features, and explore what you already have.
• Saving time - Reduce the time it takes to understand, find information you need to maintain or build new features.

In this blog post we will cover what is the MCP protocol and how you can get started with the EventCatalog MCP Server.

What is the MCP protocol?​

MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools. (MCP Introduction)

You can read more about the MCP protocol here.

Why use the EventCatalog MCP Server?​

The EventCatalog MCP server can be installed on your machine and give you access to your EventCatalog data in your code editor or LLM (MCP Client, e.g Cursor, Windsurf, Claude Desktop).

This can reduce the time it takes to understand and build new features, as you can ask questions about your architecture directly in your code editor or LLM.

Rather than having to search through your code base, trying to find producers and consumers of the event you are about to change, you can ask the EventCatalog MCP server for this information, or maybe you want to know what other events are related to the one you are about to change, or you want to quickly find events based on the feature you want to build.... the possibilities are endless.

We want to reduce the time it takes for developers to understand their architecture and we believe that the EventCatalog MCP server can help you achieve this.

How to get started?​

The EventCatalog MCP server is available on GitHub and can be installed by following the instructions here.

• Setup Cursor MCP Client
  • Download the Cursor IDE here
  • Configure the EventCatalog MCP Server in the Cursor IDE
• Setup Windsurf MCP Client
  • Download the Windsurf IDE here
  • Configure the EventCatalog MCP Server in the Windsurf IDE
• Setup Claude Desktop MCP Client
  • Download the Claude Desktop IDE here
  • Configure the EventCatalog MCP Server in the Claude Desktop IDE

Demo​

If you prefer a video tutorial, you can watch the demo below. This demo shows how to use the EventCatalog MCP Server in the Cursor IDE.

Summary​

We are excited to announce that EventCatalog now supports the MCP protocol. This is a big step forward for EventCatalog and we are looking forward to seeing what you can build with it.

If you have any questions, please reach out to us on Discord or GitHub.

Happy building!

Welcome to the monthly update for EventCatalog, here you can find what’s next, how to get started, and what’s coming next.

EventCatalog community continues to grow ❤️, now we have 1,030 Discord members, 2k Stars on GitHub, 759 new catalogs have been created in February and 8.5k catalogs built into production. EventCatalog continues with 15-20% growth every month. We are currently on track for open source sustainability in 2025.

EventCatalog sponsors OSO and Gravitee continue their sponsorship for the project (thank you!) 🙏. This sponsorship helps my goal towards open source sustainability. EventCatalog is free to use and open source, if you want to support the project checkout the tiers on GitHub or contact me directly at dave@eventcatalog.dev , I really appreciate any support ❤️

In February EventCatalog Cloud, EventCatalog Chat, EventCatalog Directory, new Amazon API Gateway integration, RSS Catalog feeds, progress on EventCatalog Studio, new consulting services, a brand new look for the website, and many features were introduced.

In this blog post we will dive deeper into features and improvements that were released in February, and how you can get started.

• Introducing EventCatalog Cloud
• Introducing EventCatalog Chat
• Introducing LLMS.txt for developer tools
• New integration with Amazon API Gateway
• Introducing a new user/team directory
• New sidebar for EventCatalog Documentation
• EventCatalog Examples Repository
• New consulting/workshop services

Introducing EventCatalog Cloud​

EventCatalog Cloud was introduced giving people the ability to create accounts and get trial licenses for EventCatalog integrations, including OpenAPI, AsyncAPI, Amazon EventBridge, and many more.

View the EventCatalog Cloud

EventCatalog documentation can be automated from any system or broker in the world (using the SDK) or EventCatalog integrations, this cloud platform was designed to give users the ability to trial integrations before deciding to purchase integration licenses.

In the future EventCatalog Cloud will offer hosting, organizations/users, ability to design event-driven architectures (with EventCatalog Studio) and much more.

Introducing EventCatalog Chat​

You can now use natural language to talk to your EventCatalog. This new feature let’s your teams get access to information they need in seconds rather than hours or days.

EventCatalog Chat is a local first, and privacy first AI feature, that runs locally in your browser. No data is shared, which allows you to keep your data private to your organization.

Use cases include:

• Ask your catalog what messages you have related to a new feature you want to build
• Ask your catalog what messages a service publishes/consumes
• Find gaps in your messages or naming conventions in your architecture
• Highlight messages that are not following certain conventions
• And much more…

EventCatalog Chat is still in beta, and you can access it by enabling it on your catalog and following these instructions. If you want to try it yourself, you can view the demo here (Chrome and Edge browser support only).

Introducing LLMS.txt for developer tools​

LLMS.txt is a proposed standard that helps AI-powered development tools better understand and interact with your documentation. Similar to how robots.txt guides web crawlers, LLMS.txt provides structured information that makes it easier for AI assistants like Claude, ChatGPT, and GitHub Copilot to process your EventCatalog documentation.

EventCatalog now supports LLMS.txt standard, you can read more here to get started.

New integration with Amazon API Gateway​

You can now integrate your APIs built with Amazon API Gateway into EventCatalog.

This allows you to sync your API Gateway configuration with EventCatalog, and hydrate your routes/apis with semantic meansing.

Automate EventCatalog with Amazon API Gateway →

EventCatalog will connect to your AWS account, download the OpenAPI formats for your API Gateways and hydrate them with custom EventCatalog features.

Using this integration you can document your APIs in seconds, and keep your documentation up to date with your API in the cloud.

To get started you can read the documentation.

Introducing a new user/team directory​

A new user directory feature has been added to EventCatalog. This new feature let’s you quickly find resources that belong to users or teams.

If you want to know who owns a particular message, or which team owns a particular service you can now quickly find this information.

View the EventCatalog Directory demo

You can use filters to filter by owned events, commands and queries, or services and teams. You can view the demo here.

New sidebar for EventCatalog Documentation​

Thanks to Carlos Rodrigues we now have a new way to navigate documentation in EventCatalog.

View the new sidebar demo

Using the new TREE_VIEW setting the sidebar will now render your catalog resources in a nested structure (which mirrors your directory structure). This can be particularly useful for large catalogs

To get started you can configure the tree view setting in your configuration file.

EventCatalog Examples Repository​

Want to learn how EventCatalog can help you? A new examples repository has been created, with over 10 examples of how to use EventCatalog with OpenAPI, AsyncAPI, Amazon API Gateway, Amazon EventBridge, and EventCatalog Federation.

Hopefully these new examples can help you understand how EventCatalog works with our integrations, and how you can get value from automating your documentation, or scaling your documentation in your organization using EventCatalog federation.

New consulting/workshop services​

We continue to work with companies around the world helping them lay the foundations for their event-driven architecture governance. This includes best practices, patterns and diving deep into their problems.

If this is something you would be interested in, please get in touch. Happy to explore how we can help.

Other improvements and fixes​

• RSS feeds are available for all resource types in EventCatalog
• AsyncAPI and OpenAPI plugins now group resources using directory structures making it easier to mange them.
• EventCatalog Studio still on target for initial release in Q1 2025.

What’s coming in March?​

EventCatalog has huge potential to help people govern their event-driven architecture. Surrounding this includes a wide range of tools and value it can unlock for you and your teams. Our vision in 2025 is make this happen, and here is a diagram of where we are heading.

In March we hope to improve the visualizer, add the ability to add events to domains, and visualize integration events between domains. We aim to get EventCatalog Studio in front of the first batch of early beta users to help them design and edit their catalogs.

If you have any questions or want to join our community of over 1000 people exploring EventCatalog and event-driven architecture feel free to join us!

I’m excited to share that EventCatalog 2.24.3 is now available. This release introduces the new EventCatalog Chat feature (in beta). This feature allows you to understand your architecture through natural conversation.

How can EventCatalog Chat help?​

Here are some examples of how EventCatalog Chat can help you understand your architecture:

• Building a new feature? Want to know what messages you already have?
  • Don’t know what messages your company has already? Ask the catalog, get insights in seconds, not days.
  • EventCatalog will point in you in the right location, with links directly to your messages, services and domains.
• Want to know the impact of breaking changes?
  • EventCatalog knows who produces/consumes messages (powered by AsyncAPI, OpenAPI, or any broker in the world). That chat interface can tell you in seconds the impact of your changes.
• Want to find gaps in your event architecture?
  • Ask your catalog what events are missing, it can help suggest some naming conventions for you and get you started.
• Talk to enterprise architecture?
  • Save time across your organization. Use EventCatalog Federation to build a single source of truth for your event-driven architecture
  • Use EventCatalog Chat to talk to large architectures across your organization.
• Talk to any broker in the world
  • EventCatalog is tech agnostic, integrate with any system you want either using our integrations or by using the EventCatalog SDK.
  • Integrate OpenAPI, AsyncAPI, or brokers with EventCatalog.
  • Use EventCatalog Chat to ask questions about your spec files, schemas, messages, services and domains.
  • Ask your catalog who owns what. Quickly get contact details.
• The possibilities are endless...

Governance first mindsets can unlock huge amounts of value for your developers, architects and organizations.

EventCatalog Chat can help you understand your architecture, get insights in seconds, not days.

How does EventCatalog Chat work?​

EventCatalog Chat is privacy first.

All models are downloaded to your browser (you can configure which model) and run locally. This helps keep your data safe, local and private.

EventCatalog Chat is using WebLLM to power this integration. You can configure which model you prefer to use, and fine tune your own models.

EventCatalog Chat is only supported in Chrome and Edge (nightly builds of FireFox), so for now you will have to use these browsers to get access to this feature.

If you want to learn more how it works, you can read the documentation or use the demo here.

Getting started​

To get started you need to install the latest version of EventCatalog and install the new @eventcatalog/generator-ai generator.

The steps include:

1. Install and run the @eventcatalog/generator-ai generator (see documentation)
2. Configure your model (recommend the default one)
3. Build and run your catalog.

For further instructions and configuration you can read the documentation.

Summary​

If you are interested in bringing your own models (API Keys) (OpenAI, Anthropic, etc) let us know as this is on our roadmap, if more folks vote we can prioritize the feature.

We are also building EventCatalog Studio a visual editor for event-driven architectures. You can sign up to the beta here.

If you have any feedback or suggestions please create an issue or join the community on Discord.

EventCatalog 2.20.2 is now available. This release introduces the EventCatalog Directory, a new way to find users and teams using EventCatalog.

View the EventCatalog Directory demo

When event-driven architectures get to a certain size it becomes difficult to know who owns a service, event, query or command. This is why we are introducing the EventCatalog Directory.

Using the EventCatalog Directory you can quickly find users or teams by services, events, queries and commands that they own. If you need to quickly find out who owns a service, event, query or command you can use the directory to find them.

What has changed?​

Previously the users and teams were listed in the documentation sidebar. We have now moved them to their own directory page keeping the documentation sidebar focused on your domains, services and messages in your catalog. To upgrade to the new version you can run the following command:

npm install @eventcatalog/eventcatalog@latest

How does it work?​

A new page has been added to EventCatalog. Clicking on the new directory page will show a list of users and teams.

To add users and teams to your EventCatalog you can read our guides:

• Add users to your EventCatalog
• Add teams to your EventCatalog

When you add a user or team as owners of your domains, services, events, queries and commands they will appear in the directory and on your documentation pages.

View the service ownership demo

Each user and team has their own page in EventCatalog. This page helps you understand more information about the owner and quickly see what services, events, queries and commands they own.

View the user page demo

Summary​

As your event-driven architecture grows, the EventCatalog Directory will become more useful. The EventCatalog Directory can be used to help your developers, architects and stakeholders understand the ownership of your event-driven architecture.

Each team or user in EventCatalog has their own page, this page helps you understand more information about the owner and quickly see what services, events, queries and commands they own.

EventCatalog Directory works well with the EventCatalog Federation plugin. Federation allows you to pull in users and teams from other catalogs into your main catalog, this means you can have a single source of truth for your event-driven architecture.

There is much more we want to do here, and we are just getting started.

If you have any feedback or suggestions please create an issue or join the community on Discord.

EventCatalog has been another great month for EventCatalog with almost 2k stars on GitHub, and 1000 Discord members. Our project continues to grow about 10/15% every month in usage.

We are happy to share our first initial release of EventCatalog Cloud.

Our vision here is to offer you a new way to experience EventCatalog, which will include:

• Hosting - Manage hosting for your EventCatalog instance
• Licensing - Manage your plugin licenses and updates
• Ask your Catalog questions - Using AI to answer questions about your Catalog, quickly get answers to your questions
• Collaborate - Design with EventCatalog Studio, and collaborate with your team

Integration licenses on EventCatalog Cloud​

To help keep the project sustainable and open source we have now introduced license keys for our plugins. All our plugins were dual licensed, but did not require any license key to run or use them. This small change allows us to offer a better experience for our users and a sustainable project.

All plugins will now have a 14 day trial period (you can extend contacting us), after which you will need to purchase a license key to continue using the plugin.

To obtain a license key for a plugin or a trial you can login to EventCatalog Cloud and navigate to the integrations page.

What's next?​

We will be adding more features to EventCatalog Cloud in the coming months, including:

• Plugin improvements - We will be adding more plugins (e.g GitHub, GitLab) and improving the existing ones
• Improvements to EventCatalog - New features and customization options for EventCatalog.
• EventCatalog Studio - A new way to design and collaborate on your EventCatalog (Beta launch)
• AI - Ask your Catalog questions, and get answers quickly

Summary​

January was slightly a slow month in terms of maintenance and features as I was focused on EventCatalog Cloud, and talks for NDC and FOSDEM. These events were great and I met a lot of new people, and got to catch up with old friends.

I am looking forward to February, we have a lot of great features and quality of life improvements planned.

If you want to join us on this journey feel free to join our Discord community, and if you want to sponsor the project you can do so here.

Speak soon!

David Boyne

Welcome to the monthly update for EventCatalog, here you can find what’s next, how to get started, and what’s coming next.

EventCatalog community continues to grow ❤️, now we have 937 Discord members, 1.9k Stars on GitHub, we hit over 1000 pull requests into the project, 423 new Catalogs have been created in December and over 5,000 catalogs built into production this month. EventCatalog got a great shoutout at re:Invent 2024, and the project continues with 15-20% growth every month.

EventCatalog sponsors OSO and Gravitee continue their sponsorship for the project (thank you!) 🙏.

Sponsorships help our goal towards open source sustainability. EventCatalog is free to use and open source, if you want to support the project checkout the tiers on GitHub or contact me directly at dave@eventcatalog.dev , I really appreciate any support ❤️

Our integration platform continues to grow, including OpenAPI, AsyncAPI and Amazon EventBridge, Backstage, GitHub and GitLab. Automate your documentation with any of these integrations or contact us to build a custom integration.

In December we introduced the ability to filter resources by custom badges, ability to document Ubiquitous Language, over 200,000 icons support with Mermaid v11, new tab components, 80% increased build times and we launched EventCatalog Federation.

In this blog post we will dive deeper into features that were released in December, why they were built and how they can help you govern your architectures. At the end of the blog post I will share a personal update and what’s planned for January 2025.

Introducing EventCatalog Federation​

In December we launched our first version of EventCatalog Federation. EventCatalog federation let’s you unify your documentation across your organization into one view.

EventCatalog Federation takes many catalogs and merges them into one view for your organization.

This let’s your teams keep their own documentation, schemas and spec files close to their code, and merge this information into one view for the organization.

Federation benefits to organizations include:

• Give your architects and company the ability to get a holistic view of the whole architecture
• See ownership of domains, services and messages and contact them
• Let your teams quickly find events, schemas and specs they want to start consuming
• Let’s your team own their own documentation, focusing on their domain and service

Our vision with EventCatalog is to bring discoverability to architectures for teams saving them time from discovering a message to the implementation phase. We believe EventCatalog Federation can help scale EventCatalog within your teams and business.

To get started you can read the documentation here, or if you would prefer to walk through your problems and how EventCatalog can help you can email hello@eventcatalog.dev for a walkthrough/demo.

Introducing the ubiquitous language dictionary​

Event-driven architecture and domain-driven design work very well together (see visual here). Many teams are embracing domain-driven design practices whilst building their event-driven architecture. Part of this process includes understanding and defining a ubiquitous language.

Ubiquitous language is the language (terms) you use within a particular domain. For example a Policy in a Underwriter Domain might be completely different to a Policy in a User Domain.

This language often get’s translated into code/models within your architecture, but the meaning of these terms/words can often get lost or confused.

The EventCatalog ubiquitous language dictionary gives you the ability to document your domains language with a simple markdown file. These definitions will get rendered into EventCatalog and can help your teams understand terms used within your architectures domain, helping with any confusion that may occur.

The ubiquitous language dictionary is powered by markdown files, this let’s you document short or large descriptions of your language and users can quickly filter and search for terms in your domain.

To get started you need to create a ubiquitous-language.mdx in your domain folder, and then EventCatalog will render this for your users. To understand more and get started you can read the documentation here.

Introducing custom filters in EventCatalog​

EventCatalog has a discover feature (see demo) that allows you to quickly search and filter domains, services and messages.

We have now added the ability to search and filter by badges. Badges are custom tags you can add to your resources in EventCatalog, this let’s you add any metadata you like to your domains, services, flows and messages.

If you want to enable quick filtering/search based on custom information you can use badge filters to do this.

To get started, you need to add badges to your resources and EventCatalog will render the filters for you.

Mermaid v11 and 200,000 icons have beed added​

EventCatalog let’s you use mermaid code blocks in all resources, this is handy if you want to provide extra visualisations or information about your domains, services or messages.

In December we updated Mermaid to V11. This gives you the ability to render Architecture Diagrams and now supports over 200,000 icons for your diagrams.

You can also render Block Diagrams, C4 Diagrams, Mind maps and much more (see examples).

Mermaid can be a great way to provide additional information for your developers and teams in EventCatalog. To get started you can read our documentation on how to use mermaid in EventCatalog.

Other improvements made in December​

• EventCatalog builds are now 80% faster!
• EventCatalog now renders Avro Schemas in the UI (with AsyncAPI files)
• EventCatalog got updated to Astro v5
• You can now use Tab components in EventCatalog
• You can now add Microsoft teams (contact information) to your users and teams in EventCatalog

EventCatalog Studio​

In November we started working on EventCatalog Studio. This visual editor for EventCatalog, letting you quickly explore, experiment and design your architecture with a drag and drop interface. The vision is to go from design to implementation faster than ever.

We continue to work on this in Q1 2025, if you would like to sign up to the beta you can sign up here. Or if you want to understand how it can help your teams feel free to reach out to us at hello@eventcatalog.dev .

Whats next in 2025​

Our vision is to help companies bring discoverability to their event-driven architecture through open source community and software. The project usage is growing 15-20% a month and we aim to at least double this in 2025.

Community​

Our aim is to work backwards from the community and EventCatalog users to define a public roadmap and continue to grow our community. The community and open source is the core of the project and we want to do everything we can to help maintain this and grow.

We will focus on making a welcoming community, have community meetings and create a place where people can learn, explore and help each other.

Working with companies​

We have started to work with companies to help them govern their event-driven architectures and make best use of EventCatalog. If you want to work with us reach out at hello@eventcatalog.dev , we would love to help you understand how EventCatalog can help your organization, provide value and solve problems you may be facing.

Sponsors​

We will continue to explore project sponsors. This helps keep the core of the project free and open source. If you or your company would like to sponsor our project we would love to connect. You can reach out at hello@eventcatalog.dev and we can share details with you on what you can get from sponsoring the project. We currently have 2 sponsors, our 2025 goal is to double this.

Integration platform​

We will continue to grow our integration platform. This includes working with cloud providers, broker providers and companies to integrate EventCatalog into their eco-system. If you would to see an integration or get help building a custom integration we can help.

EventCatalog ecosystem​

We will continue to explore the EventCatalog eco system. Looking at tools like EventCatalog Studio and other tools that users may find useful. We believe that EventCatalog can had a huge amounts of value to businesses and teams, and we are just starting.

With the EventCatalog ecosystem we believe we can save teams time and money and get them building and documenting event-driven architectures faster than ever.

Summary​

We are excited for what 2025 has in store for EventCatalog, we have a lot of ideas and plans to help grow the project and community. We are looking forward to working with you and your teams to help you document and govern your event-driven architectures.

If you have any questions or feedback please reach out to us at hello@eventcatalog.dev and we can help you get started.

Happy New Year!

David Boyne

We are happy to share the first initial release of EventCatalog Federation.

EventCatalog Federation is a new plugin that allows you to merge multiple EventCatalog instances into one for a single source of truth.

In this blog post we will cover why federation might be useful for you and your teams, how it works, and how you can get started.

Why EventCatalog Federation?​

In 2024 we have seen a lot of companies and teams adopting EventCatalog. We have seen teams use EventCatalog to document their event-driven architectures and microservices.

Many teams are using EventCatalog as a single source of truth for their domains, services and messages . This gives organizations a single source of truth for their documentation.

EventCatalog is helping developers, architects and business stakeholders understand their architectures and quickly find the information they need.

Whilst speaking to our community we have learned that many teams want the ability to keep their documentation close to their code and still continue to have the single source of truth for their organization.

EventCatalog Federation allows your teams to have their own EventCatalog, stub out dependencies and provide an ability to merge multiple catalogs into one main catalog.

This allows your teams to keep their documentation close to their code, store their documentation in git whilst continuing to provide value to the organization.

How does EventCatalog Federation work?​

Teams owning their own documentation​

Your teams create their own EventCatalog instance, they can use the eventcatalog CLI to create a new catalog.

Your teams own their own documentation, domains, services and messages (all optional). This allows your teams to focus, document what they are doing and what they are consuming.

If your team consumes a dependency from another team, you can use the new EventCatalog stubs to mock them out in your own catalog.

Once teams commit their documentation to their repository, they can run the federation generator to merge their documentation into a main catalog. This main catalog provides the organization with a single source of truth for the entire architecture.

To dive deeper and get started with EventCatalog Federation, read our EventCatalog Federation Setup Team Catalog guide.

Organization EventCatalog​

You will create a main EventCatalog instance that uses the federation generator to merge all the EventCatalog instances from your teams.

Using the federation generator you can specify the source repository to pull from, the branch to pull from, the files to copy from the source repository to your main catalog and if you want to override any conflicts (last-write-wins).

Merging many catalogs into one provides your developers, architects and business stakeholders with a single source of truth for your organization.

The single source of truth lets you see the entire architecture of your organization, and provides a way to understand the dependencies between your teams.

Developers can quickly understand and search for the information they need, and business stakeholders can understand the entire architecture of the organization and start to define business processes (flows) for EventCatalog.

Getting started​

To get started you can read the following guides:

• EventCatalog Federation Setup Team Catalog
• EventCatalog Federation Configuration
• EventCatalog Federation Introduction

Summary​

EventCatalog Federation is a new plugin that allows you to merge multiple EventCatalog instances into one for a single source of truth.

This allows your teams to keep their documentation close to their code, store their documentation in git whilst continuing to provide value to the organization.

We are excited to see what you build with EventCatalog Federation and we are looking forward to seeing the EventCatalog community grow in 2025.

If you have any questions or feedback, please let us know in the EventCatalog Discord.

In this blog post we will dive deeper into features that were released in November, why they were built and how they can help you govern your architectures. At the end of the blog post I will share a personal update and what’s planned for December.

Community, sponsors, and project growth​

EventCatalog community continues to grow ❤️, now we have 890 Discord members, 409 new Catalogs have been created in November and over 4,000 catalogs built into production this month.

EventCatalog is on track to hit 1.9k stars in November, and a shout out to Carlos Rodrigues and Omid Eidivandi for their support with the project and helping with issues, and community feedback ❤️.

EventCatalog got a new gold sponsor from OSO and Gravitee continue their sponsorship (thank you!) 🙏. This sponsorship helps my goal towards open source sustainability.

EventCatalog is free to use and open source, if you want to support the project checkout the tiers on GitHub or contact me directly at dave@eventcatalog.dev , we appreciate any support to help project sustainability ❤️

Introducing EventCatalog Studio​

EventCatalog is proving to be a great tool to help companies govern and document their event-driven architecture. It’s great to see the project, usage and the community grow. Although this is great for folks that have event-driven architectures to document, we still feel there is a pain point when designing your event-driven architecture.

We feel there is a gap between design to implementation with event-driven architectures.

Many teams use whiteboards to design and explore their event-driven architecture (in person or virtual). During this process many discussions and ideas are captured but lost. Also there is an increasing effort to go from initial design to implementation. We believe there must be better way.

This is why we are building EventCatalog Studio.

EventCatalog Studio is a visual designer for event-driven architectures. EventCatalog Studio can sync with your local EventCatalog, and provide you with an editing experience, ability to collaborate with your teams, experiment ,and create draft designs to get feedback.

With EventCatalog Studio you can design new architectures, draft new ideas, design and explore your schemas, ask questions about your architecture, and much more. Everything is mapped to your EventCatalog.

EventCatalog Studio let’s you walk away from your white board sessions with something tangible, schemas to get your started and code models to help.

We are aiming to get our MVP out in December 2024, and if this is something you could find useful you can sign up to beta access here.

EventCatalog now supports channels​

EventCatalog let’s you document your domains, services and messages (commands, queries and events). One core part missing was the ability to document a channel.

In EventCatalog a channel represents the organization and transmission of messages.

Channels in EventCatalog describe how a messages transport between producers and consumers.

Documenting channels in EventCatalog gives your team deeper understand of how your messages are transmitted between producers and consumers, what broker they use and any other information you may find useful.

As EventCatalog is technology agnostic this means you can document any channel and protocol you like including http, amqp, eventbridge, googlepubsub, kafka, mercure, nats, pulsar, redis, sns, solace, sqs and ws (websockets).

Adding channels to EventCatalog​

Channels are resources in EventCatalog that you can define in your /channels directory.

Any message (event, command or query) can be associated to one or many channels.

When you assign a channel to a message, EventCatalog will render these channels between your messages and services (see demo)

Our plugins for AsyncAPI and Amazon EventBridge have been updated, allowing you to document your channels from your specification files.

If you want to learn more, and get started you can read our getting started with channels guide.

Simulating message flow in the visualizer​

You can now simulate messages in the EventCatalog visualizer. This new feature let’s you quickly see what type of events are flowing between your services.

To turn on the feature, use the Visualizer Settings and click Simulate Messages.

This is the first version of message simulation, ideas we have is the ability to define frequency flow in your documentation to help your teams understand how busy messages are, and even connecting this to live systems. If you have any ideas or requests please join Discord and let us know.

Services can now send/receive the same message​

Sometimes your service will send and receive the same message, previously in EventCatalog this was not possible, but we are happy to share that EventCatalog now supports this.

In EventCatalog you can document what messages your service sends and receives.

When the service sends and receives the same message, EventCatalog visualiser will now represent this.

---
id: OrderService
... # other service frontmatter
receives:
    # id of the message this service receives
    - id: PaymentProcessed
sends:
    # id of the message this service sends
    - id: PaymentProcessed
---

<!-- Markdown contents... -->

To learn how do document your services and messages with EventCatalog, you can read our service guide.

OpenAPI Generator 3.0 is now out​

You can automate EventCatalog using your OpenAPI files. This plugin let’s you document services and messages (commands, queries and events) through your OpenAPI files. EventCatalog will keep track of changes, versions and let you add documentation to these messages.

The 3.0 plugin now includes:

• Ability to document events, queries and commands (using the x-eventcatalog-message-type extension)
• Ability to define custom names and ids for your messages (using x-eventcatalog-message-id and x-eventcatalog-message-name)
• By default all messages are now documented as queries (previously commands)

If you and your teams have OpenAPI files, you can use EventCatalog to get discoverability for them. To get started you can read the OpenAPI integration guide.

New support levels added​

In November we have been working with companies to help them understand the importance of governance with event-driven architecture and getting them started.

We offer a range of support including internal talks, internal workshops, and hands on catalog builds.

If you are interested in working with us you can reach out on LinkedIn or email at hello@eventcatalog.dev

Want to learn more about event-driven architectures?

We have created free resources for you to dive deeper into event-driven architectures called EDA Visuals. EDA visuals are designs I have made with extra resources. You can view them and download the book for free!

What’s next in December​

In December we will be continuing the work for EventCatalog Studio and getting an initial beta version out. If you want to keep up to date and get access you can sign up here.

We will continue to review feature requests and work backwards from the community. If you have any feature requests, ideas or bugs please let us know on Discord.

Towards the end of the month we will be taking time off to recharge and focus on what’s next for 2025. I feel EventCatalog has a huge roadmap and vision ahead and we are only just getting started ❤️.

October has been a busy month for EventCatalog. The community has grown from 800 Discord members to 856, with 360 new Catalogs created and over 120 organizations actively using EventCatalog.

EventCatalog got a new gold sponsor Gravitee and Hookdeck continues their sponsorship 🙏, this is a great step towards open source sustainability. If you would like to sponsor the project you can check out the tiers on GitHub or contact me directly at dave@eventcatalog.dev.

September 2024 has been a great month for EventCatalog. In this blog post I want to highlight some growth and new features you can start using with EventCatalog.

📈 Growth​

• 1,258 new catalogs were created, bringing the total to 16,974.
• Our Discord community now has over 800 members.
• 1,703 total GitHub stars

⭐️ Features and improvements​

• OpenAPI and AsyncAPI integrations
• New landing page for all catalogs
• UX improvements to visualizer
• New components to use in your Catalog (Tiles and Steps)
• Build your own generators with the new plugin generator

It’s been a couple of months since I left my full time job at AWS to pursue my passion for event-driven architecture (EventCatalog) and cloud computing (Wing). I wanted to share an update on the exciting changes we rolled out for EventCatalog in August, it's been a busy month.