Streamlining Messaging Operations with Solace Try-Me CLI

When you’re working on event-driven systems, speed and clarity matter. Whether you’re prototyping a new architecture, demonstrating messaging flows to a client, or troubleshooting a live environment, you need tools that get out of your way and just work.

That’s where Solace Try-Me CLI comes in – a lightweight, zero-code command-line interface purpose-built for developers, architects, and engineers working with Solace Event Brokers.

What is Solace Try-Me CLI?

Solace Try-Me CLI is a lightweight, zero-code command-line tool that simplifies how you interact with Solace Event Brokers. Whether you’re prototyping an event-driven system, building a proof-of-concept, or running a live demo, Try-Me lets you focus on messaging patterns without writing a single line of application code.

It supports a wide range of messaging operations through a clean and scriptable interface, including:

• Publishing messages to topics
• Subscribing to topics and viewing live messages
• Simulating request-response flows
• Working with queues
• Monitoring message flows

Try-Me integrates seamlessly with the Solace ecosystem and maintains a minimal footprint, making it ideal for quick experiments, live demonstrations, and integration into automated workflows.

Use Cases and Benefits

Rapid Prototyping and PoCs

One of the biggest strengths of Try-Me is how quickly it enables proof-of-concept development. Instead of setting up full applications or writing boilerplate code to simulate messaging behavior, developers can use a few CLI commands to:

• Validate topic hierarchies
• Test message routing logic
• Verify quality of service (QoS) configurations
• Demonstrate message persistence and guaranteed delivery

This hands-on flexibility empowers teams to experiment, iterate, and validate their architectural decisions early – before committing to full implementation.

Testing and Validation 

For developers building event-driven systems, Try-Me serves as a lightweight and reliable test tool – no need for harnesses or mocks. With Try-Me, you can:

• Craft test messages that match real production formats
• Ensure messages reach the intended subscribers
• Simulate error scenarios and handle edge cases
• Validate transformation and routing logic in isolation

These capabilities speed up development cycles and build confidence in your messaging layer before deeper integration.

Demo Creation 

Field engineers and professional services teams often need to showcase Solace capabilities under tight timelines. With Try-Me, it’s easy to:

• Set up clean, purpose-built demos in minutes
• Display live message flows across topics
• Highlight features like message filtering or partitioned queues or delivery QoS
• Tailor scenarios to match client-specific use cases

Try-Me’s portability and zero-dependency setup make it perfect for on-site presentations, workshops, or virtual walkthroughs.

Diagnostics and Troubleshooting

When production systems run into messaging issues, Try-Me becomes a powerful diagnostic ally. Operations and support teams can quickly:

• Validate broker connectivity and authentication
• Subscribe to key topics to inspect live traffic
• Confirm delivery paths and message metadata
• Identify performance issues or misconfigured clients

This allows teams to isolate issues without modifying applications – leading to faster resolution and less disruption.

Getting Started

Getting started with Solace Try-Me CLI is quick and beginner friendly. All you need is a system with Try-Me installed and access to a Solace Event Broker (either a local instance or one from Solace Cloud).

Installation

Choose whichever installation method suits your OS:

• macOS (via Homebrew)
  brew tap SolaceLabs/stm
brew install stm
• Linux/WSL via apt-get
  echo "deb [arch=amd64 trusted=yes] https://raw.githubusercontent.com/SolaceLabs/apt-stm/master stm main" \  | sudo tee /etc/apt/sources.list.d/solace-stm.list
sudo apt-get update
sudo apt-get install stm
• Manual Download
  Grab the appropriate binary for Windows, macOS, or Linux from the Solace Try-Me CLI GitHub repository

Verify Installation

Confirm Try-Me is installed and accessible via stm commands (short for Solace Try-Me):
stm -v
stm --help

You should see the version output and a command list including send, receive, request, reply, config, manage, etc.

Refer to Set Up the Solace Try-Me CLI Tool for more information.

Key Messaging Features

Publishing and Subscribing

• Publishing a message:
  stm send -t "sample/topic" -m "Hello Solace!"
• Subscribing to a topic:
  stm receive -t "sample/>"

These operations support various QoS levels, message properties, and structured headers, giving you fine-grained control over how messages are delivered and processed. For more details on each command and its extended options, use -hm or --help-more to view comprehensive usage guidance.

Message Formatting Options

Supported formats:

• Plain text
• JSON
• Binary

This makes Try-Me suitable for simulating real-world message flows.

Monitoring Message Flows

Observe real-time message activity:
stm receive -t "sample/>" –output-mode FULL

Get live visibility into contents, properties, and metadata – essential for debugging.

Control Message Flow Characteristics

You can assess message flow characteristics like throughput and delivery timing using:
stm send -t "perf/test" –-file sample.json --count 1000 --interval 1000

This command publishes 1000 messages from the sample.json payload file, sending one message per second – useful for observing broker behavior under sustained load and validating end-to-end message handling.

Real-World Scenarios

To understand where Try-Me shines, let’s look at how it’s used in real-world workflows across different roles:

Validating Event-Driven Designs Early

An enterprise architect designing a new event-driven architecture can use Try-Me to validate topic structures and routing logic before any application code is written. By publishing test events and subscribing to key topics, they can confirm that the messaging design behaves as intended – catching issues early, saving time, and avoiding costly rework downstream.

Client-Facing Demonstrations Without the Bloat

Meeting with prospective customers often need to showcase Solace capabilities – fast. Try-Me makes it easy to demonstrate features like message filtering, queue-based delivery, or high availability using just a terminal. The result: a focused, hands-on experience that communicates value without the overhead of building custom apps or wrangling UI tools.

Rapid Troubleshooting Without Touching Production

When messaging problems surface in production, operations teams can turn to Try-Me for quick diagnostics. By subscribing to affected topics or replaying message flows, they can pinpoint issues – whether they stem from the publisher, subscriber, or broker configuration – without interfering with running applications.

Technical Deep Dive

For those requiring more advanced functionality, Try-Me offers sophisticated features that extend beyond basic messaging operations.

Command Reference and Syntax

The Try-Me CLI follows a consistent pattern of command groups and subcommands:

stm
├── -v, --version                   /* output the version number        */
├── -h, --help                      /* display help for command         */
├── -he, --help-examples            /* display examples                 */
├── send                            /* execute a send command           */
├── receive                         /* execute a receive command        */
├── request                         /* execute a request command        */
├── reply                           /* execute a reply command          */
├── config                          /* manage command configurations    */
│   ├── -h, --help                  /* display help for command         */
│   ├── -he, --help-examples        /* display examples                 */
│   ├── init                        /* initialize command configuration */
│   ├── list                        /* list command configurations      */
│   └── delete                      /* delete command configuration     */
└── manage                          /* manage connection and resources  */
     ├── -h, --help                 /* display help for command         */
     ├── -he, --help-examples       /* display examples                 */
     ├── connection                 /* manage VPN connection            */
     ├── semp-connection            /* manage VPN SEMP connection       */
     ├── queue                      /* manage queue                     */
     ├── client-profile             /* manage client-profile            */
     ├── acl-profile                /* manage acl-profile               */
     └── client-username            /* manage client-username           */
                

Each command supports numerous options for fine-tuning behavior, all documented in the help system (stm [command] -h or --help).

Advanced Options

Each command supports a rich set of advanced options for fine-tuning behavior. To explore these, use the -hm or --help-more flag, which reveals extended settings and lesser-known capabilities specific to each command.

Integration with Other Tools

While powerful on its own, Try-Me truly shines when integrated into larger workflows:

• It can be incorporated into shell scripts for automated testing
• Output can be piped to other command-line tools for processing
• It can be used in CI/CD pipelines to validate messaging components

This integration capability makes Try-Me valuable not just for ad-hoc testing but as part of systematic development and operations processes.

Conclusion

Solace Try-Me CLI transforms the way developers, architects, and field teams interact with event brokers. By eliminating the need for boilerplate code and heavyweight client applications, it democratizes access to core messaging capabilities and dramatically shortens the feedback loop for event-driven development.

Whether you’re validating a new architecture, showcasing features to stakeholders, troubleshooting production systems, or simply exploring event-driven concepts, Try-Me provides everything you need – in a fast, flexible, and lightweight package.

As event-driven architectures become more central to modern enterprise systems, tools like Try-Me will be essential. By abstracting the complexity of messaging mechanics, Try-Me enables teams to focus on what really matters: business logic, system behavior, and delivery outcomes. The result? Faster experimentation, cleaner demos, smoother ops, and a shorter path to production.

Ready to dive in?

Visit the Solace Try-Me CLI GitHub repository to get started. A few minutes of setup can yield hours of development speed, clarity, and confidence. Or ask the Solace Community.