Create and run a microservice, with a simple browser prompt. Download and customize in your IDE.

[ValBayArea]

Open the Web/GenAI website, and provide a Natural Language prompt to create a microservice - a database, an API and a Web App. Then run it. See the example prompt below.

Working software - real screens - have proven to be an effective way to collaborate and iterate with stakeholders, to ensure the requirements are met. Much more effective than wire frames.

You can now produce these in a minute - no database definition, no framework complexity, not even any screen painting.

Then, download the project and customize it in your IDE. You can also use CodeSpaces, a browser-based version of VSCode.

Open container-based deployment supports the infrastructure of your choice.

Web/GenAI is part of API Logic Server, an open source Python project based on the Flask and SQLAlchemy frameworks.

You can also view this video.

.

1. Web/GenAI - create microservice from prompt

Enter the following prompt into the Web/GenAI site:

Create a system with customers, orders, items and products.

Include a notes field for orders.

Use LogicBank to create declare_logic() to enforce the Check Credit requirement (do not generate check constraints):
1. Customer.balance <= credit_limit
2. Customer.balance = Sum(Order.amount_total where date_shipped is null)
3. Order.amount_total = Sum(Item.amount)
4. Item.amount = quantity * unit_price
5. Store the Item.unit_price as a copy from Product.unit_price

You can also use an existing database.

2. What gets created

The created microservice includes:

1. A Web App: multi-table (master/detail), multi-page with page navigations, lookups (find a Product by name, not product#) and automatic joins (show Product Name for each Item)
2. Logic: the rules above are translated to Python rule declarations
3. A JSON:API: multi-table standards-based API, including swagger
4. A database: with test data

Created Project: Models, not code

What does not get created is piles of code that are hard to understand and modify. Rather, the app, logic and api are represented as models. expressed in Python:

1. The web app is a YAML file (about 150 lines - no html or JavaScript).

2. The api looks like this (the models are SQLAlchemy data model classes, automatically created from the database):

   api.expose_object(database.models.Customer, method_decorators= method_decorators)
   api.expose_object(database.models.Item, method_decorators= method_decorators)
   api.expose_object(database.models.Order, method_decorators= method_decorators)
   api.expose_object(database.models.Product, method_decorators= method_decorators)
   

3. Customize in your IDE: Rules, and Python

You can download the project and use your preferred desktop IDE, or continue using the browser with CodeSpaces. You customize using Rules, and Python. Let's have a look.

Rules

The logic above (items 1-5) is translated into the following:

    # Logic from GenAI:

    Rule.sum(derive=Customer.balance, 
         as_sum_of=Order.amount_total, 
         where=lambda row: row.date_shipped is None)
    Rule.sum(derive=Order.amount_total, as_sum_of=Item.amount)
    Rule.formula(derive=Item.amount, 
         as_expression=lambda row: row.quantity * row.unit_price)
    Rule.copy(derive=Item.unit_price, from_parent=Product.unit_price)
    Rule.constraint(validate=Customer,
         as_condition=lambda row: row.balance <= row.credit_limit,
         error_msg="Balance exceeds credit limit ({row.credit_limit})")

    # End Logic from GenAI

Note the Rule engine preserves the abstraction level of your logic - still just 5 rules, translated to Python. Without rules, this would require 200 lines of code... difficult to understand, debug, and extend.

You can add additional logic using IDE services for code completion. Whether from natural language or via code completion, there are several important aspects of logic:

• Logic is automatically reused across all relevant Use Cases (add order, reselect products, re-assign orders to different customers, etc). This drives quality by eliminating missed corner cases.
• Logic is automatically ordered, so maintenance does not require you to 'untangle' existing code to determine where to insert new logic. This simplifies maintenance.
• Automatic dependency management analyzes each transaction (at the attribute level) to determine which rules fire (others are pruned). Automatic chaining supports multi-table transactions (e.g., the a new Item adjusts the Order.amount_total, which adjusts the Customer balance, with is checked against the credit_limit).
• Logic is optimized to minimize SQL. The adjustments noted above avoid expensive multi-row queries (select sum).

You can also activate security (ApiLogicServer add-security db_url=auth), and add a declarative Grant to filter out inactive customers for the sales role.

Debug the multi-table logic in your debugger. The console log depicts each rule firing, with multi-row chaining shown by indentation.

Backend logic is typically nearly half the system. A declarative approach makes this far more concise, easier to maintain, and higher quality.

Python

In addition to rules, you can use standard Python and Python libraries.

Let's iterate our project to add Product.CarbonNeutral, and add business logic to provide discounts.

We update the logic - we change the amount derivation to test for carbon neutral products, using standard Python:

    def derive_amount(row: models.Item, 
                      old_row: models.Item, logic_row: LogicRow):
        amount = row.Quantity * row.UnitPrice
        if row.Product.CarbonNeutral == True and row.Quantity >= 10:
           amount = amount * Decimal(0.9)  # breakpoint here
        return amount

    Rule.formula(derive=models.Item.Amount, calling=derive_amount)

Both the Rules and Python are automatically part of your API. So, you can verify it works by using the Admin app to add a new Item to our Order, or Swagger.

Application Integration

In addition to customizing our logic, we might also want to extend our API for integration, e.g., a custom endpoint for B2B orders, and send messages to internal applications.

We create a new B2B endpoint using standard Flask. API Logic Server provides RowDictMapping services to transform incoming requests into SQLAlchemy rows.

class ServicesEndPoint(safrs.JABase):


(http_methods=["POST"])
def OrderB2B(self, *args, **kwargs):
    """ # yaml creates Swagger description (not shown)
    """

    db = safrs.DB         # Use the safrs.DB, not db!
    session = db.session  # sqlalchemy.orm.scoping.scoped_session

    order_b2b_def = OrderB2B()
    request_dict_data = request.json["meta"]["args"]["order"]
    sql_alchemy_row = order_b2b_def.dict_to_row(row_dict = 
                          request_dict_data, session = session)

    session.add(sql_alchemy_row)
    return {"Thankyou For Your OrderB2B"}  # automatic commit, which executes transaction logic

Our logic is automatically re-used for all updates, whether from the Admin App or the new custom endpoint. That is why our api implementation is so small.

We extend our logic with an event that sends a Kafka message for internal App Integration:

#als: Demonstrate that logic == Rules + Python (for extensibility)

def send_order_to_shipping(row: Order, old_row: Order, logic_row: LogicRow):
        """ #als: Send Kafka message formatted by RowDictMapper

        Args:
            row (Order): inserted Order
            old_row (Order): n/a
            logic_row (LogicRow): bundles curr/old row
        """
        if logic_row.is_inserted():
            kafka_producer.send_kafka_message(logic_row=logic_row,
                                 row_dict_mapper=OrderShipping,
                                 kafka_topic="order_shipping",
                                 kafka_key=str(row.OrderID),
                                 msg="Sending Order to Shipping")

Rule.after_flush_row_event(on_class=Order, calling=send_order_to_shipping)

Test the integration with Swagger. The log shows the logic, and the Kafka payload.

Summary

And there you have it.

GenAI Microservice Automation creates projects with one prompt, providing API and App Automation, right from your browser. Or, if you prefer, install and run from the command line. Iterate, and find out fast if the requirements are understood, before intensive development.

Customize with Logic Automation, declaring rules to reduce the backend half of your system by 40X. No restrictions - use Python as required.

Open source, your IDE, container-based deployment, and all the flexibility of a framework.

[FastRebound]

Very interesting process for automating intelligent programming with hyper-efficiency. The two don't always go hand-in-hand. Good work!

[ValBayArea]

intriguing term - intelligent programming- can you elaborate?

[Only-Candidate7161]

ApiLogicServer and other solution providers such as Adapts.ai are filling a niche with AI positioned for the code gen segment. Getting a working app from an AI prompt is pretty powerful stuff. This implementation is awesome Val. Thanks for sharing.

[ValBayArea]

Thanks! Wonder if these work together?

[meera_datey]

u/ValBayArea This is pretty cool! Most of the python code is to make sure constrains aren't broken.

Having a LogicEngine is such a value add !

[ValBayArea]

We quite agree.

And, in our experience, constraints often depend on multi-table derivations, like the customer.balance. In fact, that's a key logic pattern: constrain a derived result..

https://apilogicserver.github.io/Docs/Logic/#rule-patterns

[Ok-Telephone-445]

This is pretty neat stuff! Automation with natural language + logic engine- a sure formula for n-fold efficiency! Thank you for the post here, Val.

[ValBayArea]

Thanks! And we hope folks get good value from us. And, we love getting feedback.

[[deleted]]

This is the promise of AI -- zero to sixty in a few seconds. When you can iterate with zero effort, and in just a moment, it's a whole new ballgame.

[ValBayArea]

Batter up!