---
schema_version: "1"
id: 1b969951ec33703ffb6559f802dca9eb02d873dca797c8b11eef604eddb423dd
title: Mulesoft Vibes Example Messages
collection: mulesoft
version: current
locale: en-us
portal_url: https://docs.salesforce.com/mulesoft/current/en-us/anypoint-code-builder/vibes-prompt-examples.md
canonical_url: https://docs.mulesoft.com/anypoint-code-builder/vibes-prompt-examples
source_site: docs.mulesoft.com
content_type: documentation
content_hash: 627c8f7895253fd97d760038290b7e8b32eadfa17b07f92005e9cce19c008802
description: MuleSoft Documentation Site
latest: true
---
---
product: Anypoint Code Builder
version: master
---

# Mulesoft Vibes Example Messages

> For the full documentation index, see: https://docs.mulesoft.com/llms.txt

Use these example messages to guide Mulesoft Vibes in completing common tasks. Customize the values
to match your project or environment.

## Application Deployment and Projects

- **Task**: Deploy an app to CloudHub or Runtime Fabric.

  **Prompt**: Deploy the \[application\_name\] app from Anypoint Exchange.

- **Task**: Create an integration project.

  **Prompt**: Create a Mule project that creates an order in NetSuite every time an opportunity in
  Salesforce is updated to the ‘Closed Won’ stage.

- **Task**: Deploy an integration application.

  **Prompt**: Deploy \[application\_name\] app in the current project. Deploy it with high security,
  high availability, and performance optimized settings.

- **Task**: Modify an existing application.

  **Prompt**: Update \[application\_name\] so that it meets \[specific business requirements\].

- **Task**: Generate an MCP server using Anypoint connectors.

  **Prompt**: Generate an MCP server that exposes three tools from the following operations:
  Workday - Absence Management - Get Time Off Plan Balances, Workday - Absence Management - Enter
  Time Off, and Google Calendar - Create Calendar Event.

## Exchange Asset Management

- **Task**: Create an asset in Exchange.

  **Prompt**: Publish \[this asset type\] in Exchange using this \[name\].

- **Task**: Search for an asset in Exchange.

  **Prompt**: Do I have any assets for order notifications in Exchange?

- **Task**: Search for an asset within a specific organization.

  **Prompt**: Find \[asset name\] in \[organization name\].

## API Instances

- **Task**: Create an app instance and apply a policy.

  **Prompt**: Create an instance for the \[application\_name\] and apply the rate limiting policy to
  that instance.

- **Task**: View performance metrics for your APIs or apps.

  **Prompt**: Which apps generated the most errors this month?

## Custom Metadata

- **Task**: Set custom metadata that uses sample data.

  **Prompt**: Can you help me define custom metadata on the following component? This is how the
  sample data looks: \[sample data\].

- **Task**: Set custom metadata using a file.

  **Prompt**: Define custom metadata using the sample file below and attach it to
  \[processor\_name\] @\[path\_to\_file\].

## Agent Network Operations

- **Task**: Create an Agent Network

  **Prompt**: Create an Agent Network for called "Employee Onboarding".

- **Task**: Publish an Agent Network.

  **Prompt**: Publish the "Employee Onboarding" Agent Network project to Exchange.

- **Task**: Deploy an instance of the "Employee Onboarding" Agent Network to staging.

  **Prompt**: Deploy this Agent Network project.

## Order Management

Your company manages a growing e-commerce platform and needs a way to streamline the handling of
customer orders. You want to build an API specification that allows your backend systems to create,
retrieve, update, and delete orders, ensuring consistent data models and robust error handling
across all operations.

To generate a specification for this task, enter a message like:
`Generate an API specification for an order management system for an e-commerce platform. The API should include endpoints to create, retrieve, update, and delete orders, along with detailed definitions for request and response payloads, versioning details, and error handling mechanisms.`

This message generates an API specification using the same specification language as the file that
was in focus:

```xml
openapi: 3.0.0
info:
  title: Order Management API
  version: 1.0.0
  description: API for managing orders in an e-commerce platform.
servers:
  - url: https://api.ecommerce.com/v1
paths:
  /orders:
    post: (1)
      summary: Create a new order
      operationId: createOrder
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Order'
      responses:
        '201':
          description: Order created successfully
        '400':
          description: Bad request
        '401':
          description: Unauthorized
        '500':
          description: Internal server error
      security:
        - bearerAuth: []
    get: (2)
      summary: Retrieve all orders
      operationId: getOrders
      responses:
        '200':
          description: A list of orders
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Order'
        '401':
          description: Unauthorized
        '500':
          description: Internal server error
      security:
        - bearerAuth: []
  /orders/{orderId}: (3)
    get:
      summary: Retrieve a specific order
      operationId: getOrder
      parameters:
        - name: orderId
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Order details
        '404':
          description: Order not found
    put:
      summary: Update an existing order
      operationId: updateOrder
      parameters:
        - name: orderId
          in: path
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Order'
      responses:
        '200':
          description: Order updated successfully
        '404':
          description: Order not found
    delete:
      summary: Delete an order
      operationId: deleteOrder
      parameters:
        - name: orderId
          in: path
          required: true
          schema:
            type: string
      responses:
        '204':
          description: Order deleted successfully
        '404':
          description: Order not found
components:
  securitySchemes: (4)
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
  schemas: (5)
    Order:
      type: object
      properties:
        id:
          type: string
        customerId:
          type: string
        items:
          type: array
          items:
            $ref: '#/components/schemas/OrderItem'
        totalAmount:
          type: number
          format: float
        status:
          type: string
          enum: [pending, processing, completed, cancelled]
    OrderItem:
      type: object
      properties:
        productId:
          type: string
        quantity:
          type: integer
        price:
          type: number
          format: float
```

<table><tbody><tr><td><i data-value="1"></i><b>1</b></td><td><strong>Creates a new order</strong>: The <code>POST /orders</code> operation accepts a JSON payload and returns a success or error response.</td></tr><tr><td><i data-value="2"></i><b>2</b></td><td><strong>Retrieves a list of all orders</strong>: The <code>GET /orders</code> operation returns an array of order objects.</td></tr><tr><td><i data-value="3"></i><b>3</b></td><td><strong>Handles operations for a specific order</strong>: Includes <code>GET</code>, <code>PUT</code>, and <code>DELETE</code> methods on <code>/orders/{orderId}</code> with path parameter validation.</td></tr><tr><td><i data-value="4"></i><b>4</b></td><td><strong>Uses bearer token authentication</strong>: The <code>bearerAuth</code> scheme is applied to secure all endpoints.</td></tr><tr><td><i data-value="5"></i><b>5</b></td><td><strong>Defines reusable data models</strong>: The <code>Order</code> and <code>OrderItem</code> schemas provide consistent structure for request and response payloads.</td></tr></tbody></table>

## Inventory Management

Your business needs to track and manage product stock across multiple warehouses and storefronts. To
ensure accurate inventory levels and prevent overselling, you want to generate an API specification
that supports creating, updating, deleting, and listing products. The specification should include
clear data models, input validation rules, and proper security mechanisms.

To generate a specification for this task, enter a message like:
`Generate an API specification for an inventory management system. The API should expose endpoints to manage products and stock levels, support operations to add, update, delete, and list products, and include clear definitions for data models, input validation rules, and security considerations.`

```xml
openapi: 3.0.0
info:
  title: Inventory Management API
  version: 1.0.0
  description: API for managing products and stock levels.
servers:
  - url: https://api.inventory.com/v1
paths:
  /products:
    post: (1)
      summary: Add a new product
      operationId: addProduct
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Product'
      responses:
        '201':
          description: Product added successfully
        '400':
          description: Invalid input
      security:
        - bearerAuth: []
    get: (2)
      summary: List all products
      operationId: listProducts
      responses:
        '200':
          description: A list of products
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Product'
        '500':
          description: Internal server error
      security:
        - bearerAuth: []
  /products/{productId}: (3)
    get:
      summary: Get product details
      operationId: getProduct
      parameters:
        - name: productId
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Product data
        '404':
          description: Product not found
    put:
      summary: Update a product
      operationId: updateProduct
      parameters:
        - name: productId
          in: path
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Product'
      responses:
        '200':
          description: Product updated
        '400':
          description: Invalid input
        '404':
          description: Product not found
    delete:
      summary: Delete a product
      operationId: deleteProduct
      parameters:
        - name: productId
          in: path
          required: true
          schema:
            type: string
      responses:
        '204':
          description: Product deleted
        '404':
          description: Product not found
components:
  securitySchemes:(4)
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
  schemas: (5)
    Product:
      type: object
      required: [id, name, quantity, price]
      properties:
        id:
          type: string
        name:
          type: string
        description:
          type: string
        quantity:
          type: integer
          minimum: 0
        price:
          type: number
          format: float
```

<table><tbody><tr><td><i data-value="1"></i><b>1</b></td><td><strong>Creates a new product</strong>: The <code>POST /products</code> operation uses a JSON payload to define the product.</td></tr><tr><td><i data-value="2"></i><b>2</b></td><td><strong>Lists all products</strong>: The <code>GET /products</code> operation returns an array of products in stock.</td></tr><tr><td><i data-value="3"></i><b>3</b></td><td><strong>Manages individual products</strong>: Includes operations to retrieve, update, or delete a specific product using its ID.</td></tr><tr><td><i data-value="4"></i><b>4</b></td><td><strong>Secures endpoints with bearer authentication</strong>: The API uses <code>bearerAuth</code> to protect inventory operations.</td></tr><tr><td><i data-value="5"></i><b>5</b></td><td><strong>Includes a validated product schema</strong>: The Product schema enforces required fields and validation like minimum: 0 for quantity.</td></tr></tbody></table>

## User authentication and management

Your application requires secure and reliable user authentication to protect user data and manage
access to services. To support this, you want to generate an API specification that handles user
registration, login, token management, and password resets. The specification should include proper
input validation, error responses, and security best practices.

To generate a specification for this task, enter a message like:

`Generate an API specification for a user authentication and management service. The API should support endpoints for user registration, login, token management, and password resets, including thorough details on input validation, error responses, and necessary security protocols.`

This message generates an API specification using the same specification language as the file that
was in focus:

```xml
openapi: 3.0.0
info:
  title: User Auth API
  version: 1.0.0
  description: API for managing user authentication and credentials.
servers:
  - url: https://api.example.com/v1
paths:
  /register:  (1)
    post:
      summary: Register a new user
      operationId: registerUser
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/RegisterRequest'
      responses:
        '201':
          description: User created
        '400':
          description: Invalid input
  /login:  (2)
    post:
      summary: Authenticate a user
      operationId: loginUser
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/LoginRequest'
      responses:
        '200':
          description: Login successful
        '401':
          description: Unauthorized
  /token/refresh: (3)
    post:
      summary: Refresh an access token
      operationId: refreshToken
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/RefreshRequest'
      responses:
        '200':
          description: Token refreshed
        '401':
          description: Invalid refresh token
  /reset-password:    (4)
    post:
      summary: Request password reset
      operationId: resetPassword
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ResetRequest'
      responses:
        '200':
          description: Password reset email sent
        '404':
          description: User not found
components:
  securitySchemes:    (5)
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
  schemas:      (6)
    RegisterRequest:
      type: object
      required: [email, password]
      properties:
        email:
          type: string
          format: email
        password:
          type: string
          minLength: 8
    LoginRequest:
      type: object
      required: [email, password]
      properties:
        email:
          type: string
        password:
          type: string
    RefreshRequest:
      type: object
      required: [refreshToken]
      properties:
        refreshToken:
          type: string
    ResetRequest:
      type: object
      required: [email]
      properties:
        email:
          type: string
```

<table><tbody><tr><td><i data-value="1"></i><b>1</b></td><td><strong>Registers a new user</strong>: <code>POST /register</code> validates input and creates a new user account.</td></tr><tr><td><i data-value="2"></i><b>2</b></td><td><strong>Logs in a user</strong>: <code>POST /login</code> checks credentials and returns a token on success.</td></tr><tr><td><i data-value="3"></i><b>3</b></td><td><strong>Refreshes token</strong>: <code>POST /token/refresh</code> issues a new access token using a refresh token.</td></tr><tr><td><i data-value="4"></i><b>4</b></td><td><strong>Initiates password reset</strong>: <code>POST /reset-password</code> sends a reset email if the user exists.</td></tr><tr><td><i data-value="5"></i><b>5</b></td><td><strong>Secures endpoints</strong>: All protected routes use JWT bearer authentication.</td></tr><tr><td><i data-value="6"></i><b>6</b></td><td><strong>Defines schemas</strong>: <code>UserRegistration</code> and <code>UserLogin</code> schemas include input validation like <code>minLength</code> and <code>format: email</code>.</td></tr></tbody></table>

## MUnit tests for Mule flows

Your Mule application exposes APIs and orchestrates calls to backend services. To improve
reliability, create MUnit tests for a flow that processes requests, transforms payloads, and returns
responses under different conditions.

To generate tests for this task, enter a message like:

`Create MUnit tests for the <flow-name> flow. Add one test for the happy path, one test for invalid input, and one test for a downstream service failure. Mock the external dependencies, use sample event payloads, and verify the expected response payload and status code in each case.`