AI-Assisted Modeling: How to Import Your Event-Driven Assets with Event Portal MCP Server

If you’re building or maintaining event-driven systems at scale, you’ve likely felt the pain of trying to map out what already exists. Applications, services, schemas and and events  running in production, but turning that into a clear, documented representation of your event-driven architecture (EDA) feels like a massive undertaking.What if you could point an AI coding assistant at your codebase and let it handle  most of that work for you?

In this walkthrough , I’ll show you how to set up the Solace Event Portal  Model Context Protocol (MCP) server with a tool like Claude Code to automatically analyze your code, identify event-driven patterns, and import your existing applications, events and schemas directly into Solace Event Portal.

Companion Videos for the Event Portal MCP Server
Setting Up with Claude
Import Existing Application Architectures

What We’re Building

By combining the Event Portal MCP Server with an AI coding assistant, you can build a workflow that:

• Analyzes your existing codebase to understand your system
• Automatically creates application domains, schemas, events, and applications in Event Portal
• Maps relationships between producers and consumers
• Generates a visual representation of your architecture
• Catalogs your applications, events and schemas to promote visibility, sharing and reuse

The process involves three main steps:

1. Setting up the Event Portal MCP Server with your MCP Client of choice
2. Using an LLM to analyze your code to find events, schemas, topics and application names
3. Giving your LLM tools a way to interact with Event Portal to create applications, events, schemas and application domains

Why Document Your Architecture in Solace Event Portal?

Event Portal gives developers tools to understand, govern and evolve event-driven systems:

• Design Tools: Visual design capabilities that help you plan and architect new features before writing code.
• Governance: Ensure your organization’s standards, naming conventions, and best practices are followed across all teams.
• Robust Cataloging: Create a single source of truth for all your events, schemas, and applications that developers can reference.
• Deployment Management: Coordinate deployments across your event mesh and manage the lifecycle of your event-driven components.
• Discoverability: Enable developers across your organization to discover and reuse existing events rather than recreating functionality.
• Visualizing & Sharing: Provide clear, visual representations of your EDA that make it easy to communicate system structure to management, enterprise architects, and new team members.
• Cross-Team Visibility: Give platform and integration teams insight into how applications are using the infrastructure they provide.

The biggest challenge? Getting your existing architecture into Event Portal. If you’ve been using Solace without Event Portal, or you’re migrating from legacy messaging technology, manually documenting everything through the GUI can take significant engineering time. The Event Portal MCP Server solves that.

Why Use the MCP Server Approach?

Traditionally,  importing architecture into Event Portal typically involves either:

1. Manual GUI Entry: Dispatch developers to manually go through the application stack and build out all components via the Event Portal interface. This is time-consuming, error-prone, and pulls developers away from feature work.
2. Custom Scripts: Build one-off import scripts that parse your codebase and documentation and add it to Event Portal via the REST APIs. This requires development effort, ongoing maintenance, and doesn’t adapt well to different codebases.
3. Event Portal Runtime Discovery + Manual Enhancement: Event Portal can perform runtime discovery on existing Solace brokers, gathering information about queues, topic subscriptions and broker configuration. This information is imported into the Event Portal where users must enhance it with publishing topics and schemas.

The Event Portal MCP Server offers a better way. By  letting your  AI coding assistant interact directly with Event Portal’s API, you can:

• Offload cognitive work to the LLM: Let AI understand your code structure, naming patterns, and event flows.
• Iterate interactively: Provide guidance and corrections as the import progresses.
• Maintain control: Review and approve changes before they’re made.
• Handle complexity: The LLM can leverage your build pipelines to better understand microservices architectures, and complex event flows.
• Adapt to your standards: Guide the AI to follow your organization’s naming conventions and topic structures by pointing to your organizations EDA and architectural guidelines.
• Enhance existing content: Leverage AI to explore your existing Event Portal content, whether added manually, via custom scripts or from an Event Portal Runtime Discovery scan, and enhance it to match your codebase, architectural guidelines and future plans.

Setting Up the Event Portal MCP Server

Prerequisites

• Solace Cloud account with Event Portal and API access
• MCP Client installed
• Your Solace API token

Installation Steps

These steps will vary, for the most up to date approach follow this Github readme.

Step 1: Export your API token

export SOLACE_CLOUD_TOKEN=your-api-token-here

**Step 2: Add the MCP server to your MCP Client

With Claude code it will be a claude mcp add command

Step 3: Launch your MCP Server and verify
claude

Inside Claude Code, type /mcp to see your running MCP servers. You should see the Solace Event Portal MCP Server listed.

Test it with a simple query:
What application domains exist?

Claude will reach out to Event Portal via the MCP server, and you’ll get a response listing your domains. You’re now ready to import your architecture.

Importing Your Existing Architecture

Crafting Your Prompt

The key to success is a well-crafted initial prompt. You’ll want to specify:

• Naming structure: How should components be named?
• Topic structure: Your organization’s topic hierarchy and versioning approach
• Human-readable names: Guidelines for creating clear, descriptive names
• Error handling: What should the LLM do when it encounters challenges?
• Scope constraints: Document only, don’t fill in gaps or make assumptions
• Domain boundaries: Whether to modify existing domains or create new ones

Example Workflow

Let’s walk through importing a credit card fraud detection architecture:

Navigate to your code directory and launch your MCP Client:
cd /path/to/your/architecture
claude

Provide your import prompt. Here’s an example structure:

Analyze this codebase and import the event-driven architecture into Event Portal.

Requirements:
- Create a new application domain for this architecture if one does not already exist
- Extract all schemas from the code and create schemas for them in event portal.
- Identify all events and their producers/consumers
- Create applications for each service
- Follow our topic naming convention: {organization}/{domain}/{event-type}/{version}/{variable}/{levels}/{as}/{required}
- Use descriptive, human-readable names
- Only document what exists - don't fill in gaps
- Link out to the relevant source code in the descriptions of objects created in event portal.
- Provide effective descriptions for all objects created.
- If you need to modify existing domains, ask for confirmation first

The codebase contains Gradle-based microservices for fraud detection.

Approve tool usage as Claude works. You’ll be prompted to approve:

• Creating application domains
• Creating schemas and schema versions
• Creating events
• Creating applications and versions

Monitor progress. Claude will report as it:

• Analyzes each service directory
• Extracts schema definitions
• Identifies event production and consumption patterns
• Creates the components in Event Portal

What Gets Created

In a typical import, you might see:

• Application Domain: A new domain for your architecture
• Schemas: JSON schemas extracted from your code
• Events: All events with their associated schemas
• Applications: Each microservice as an application
• Relationships: Producer and consumer connections wired up

Handling Issues and Edge Cases

LLMs may encounter limitations, such as:

• Character restrictions in custom attributes
• Naming conflicts with existing components
• Complex topic structures that need clarification

Your LLM will either work around these issues or ask for guidance. You can specify the exact way to handle issues in your prompt. You can also give guidance on how you want the process to be carried out and when your input is required. After the import, you can make manual adjustments in the Event Portal GUI or continue iterating with your MCP Client.

Reviewing Your Imported Architecture

Once the import completes, navigate to Event Portal and open your newly created application domain. You’ll see:

• Visual graph: Your architecture laid out visually with events (small dots) and applications (larger dots)
• Connections: Lines showing which applications produce and consume which events
• Details: All the information about schemas, versions, and configurations

The graph layout may need adjustment initially. You can refresh the layout calculation to get a cleaner view.

From here, you can:

• Continue iterating with your MCP Client to add new components
• Make manual tweaks and adjustments in the GUI
• Enforce governance policies on the imported architecture
• Use the architecture as a foundation for new feature design

Try It With Your Own Codebase

Here’s how to get started:

1. Get the MCP server: Visit https://github.com/SolaceLabs/solace-platform-mcp/tree/main/solace-event-portal-designer-mcp
2. Install and configure the Event Portal MCP server
3. Prepare your prompt with your organization’s standards and requirements
4. Start with a small architecture and test the process on a bounded domain first
5. Review, iterate and refine

What previously took days or weeks of manual documentation can now happen in minutes, with the AI handling the tedious extraction and entry work while you maintain control over the architectural decisions.

Explore More Solace MCP Servers

The Event Portal MCP server is part of a growing collection of Solace MCP servers designed to accelerate event-driven workflows. Visit the Solace Labs Github to explore other MCP servers and see what else you can automate.

Have you tried using MCP servers for your event-driven systems? Share your experience or reach out to a Solace Developer Advocate with questions.

If you would like to learn more about MCP Servers for Solace you can also check out our Office Hours on MCP Servers