ApiLogicServer 14.5.3__py3-none-any.whl → 14.5.14__py3-none-any.whl

api_logic_server_cli/prototypes/basic_demo/README.md

@@ -1,34 +1,38 @@
 ---
 title: Instant Microservices - with Logic and Security
 notes: gold is proto (-- doc); alert for apostrophe
-version: 0.7 from pip
+version: 0.21 from pip
 ---
 
 See how to build a complete database system -- in minutes instead of weeks or months:
 
 1. **An API**, and, we'll add ui and logic to make it a microservice...
-2. **Logic and Security:** multi-table constraints and derivations, and role-based security
-3. **An Admin App:** and finally, a multi-page, multi-table web app
+2. **Logic and Security:** multi-table constraints and derivations, role-based security, and application integration
+3. **An Admin App:** a multi-page, multi-table web app 
+4. **Customizable:** use your IDE to customize with declarative rules and standard Python
 
-We'll use API Logic Server (open source), providing:
+ 
 
-| Key Feature       | Providing                                                           | Why It Matters                                      |
-| :---------------- | :------------------------------------------------------------------ | :-------------------------------------------------- |
-| **Automation**    | Instant Project Creation:<br>An API and an Admin web app            | Unblock UI App Dev<br>Instant Agile Collaboration   |
-| **Customization** | Declarative logic and security <br> 5 rules vs. 200 lines of Python | 40X less backend code                               |
-| **Iteration**     | Revising the data model, and <br>Adding rules plus Python           | Iterative development <br> Extensiblity with Python |
+We'll illustrate [API Logic Server](https://www.genai-logic.com/product/key-features){:target="_blank" rel="noopener"} basic GenAI-Logic operation: creating projects from new or existing databases, adding logic and security, and customizing your project using your IDE and Python.
 
-The entire process takes 10 minutes, instead of several weeks using traditional development.
+The entire process takes 20 minutes, instead of several weeks using traditional development.
 
 You can use this article in several ways:
 
-- Conceptual Overview - focus on the basic process.  Operational details are moved to the Appendix to retain focus on the concepts.
-- Self-demo - you can create this system yourself.
-- Self-demo with video - you can also use [this video](https://www.youtube.com/watch?v=sD6RFp8S6Fg) (it's the same system, but the database is created with ChatGPT).
+* Conceptual Overview - the main article focuses on the concepts and basic process.  Operational details are moved to the Appendix to retain focus.
+
+* Self-demo - [install](Install-Express.md){:target="_blank" rel="noopener"} and create this system yourself.
+
+* Self-demo with video - you can also use [this video](https://www.youtube.com/watch?v=sD6RFp8S6Fg) (it's the same system, but the database is created with ChatGPT).
 
 &nbsp;
 
-## 1. Automation: Instant Project
+## 1. Automation: Project Creation
+
+API Logic Server can create projects from existing databases, or use GenAI to create projects with new databases.  See the sub-sections below.
+
+&nbsp;
+### Create From Existing Database
 
 This project was created with a command like:
 
@@ -36,41 +40,78 @@ This project was created with a command like:
 $ ApiLogicServer create --project_name=basic_demo --db_url=basic_demo
 ```
 
-> Note: the `db_url` value is [an abbreviation](https://apilogicserver.github.io/Docs/Data-Model-Examples/).  You would normally supply a SQLAlchemy URI.
+> Note: the `db_url` value is [an abbreviation](https://apilogicserver.github.io/Docs/Data-Model-Examples/){:target="_blank" rel="noopener"} for a test database provided as part of the installation.  You would normally supply a SQLAlchemy URI to your existing database.
 
-This creates a project by reading your schema.  The database is Customer, Orders, Items and Product, as shown in the Appendix.  
+This creates a project by reading your schema.  The database is Customer, Orders, Items and Product, as shown in the Appendix.
+
+&nbsp;
+
+### Create With New Database
+
+You can create a project from a prompt using GenAI, either by [WebGenAI](WebGenAI.md), or the the [GenAI CLI](WebGenAI-CLI.md){:target="_blank" rel="noopener"} as shown here.
+
+Use the GenAI CLI with or without signup:
+
+1. If you have signed up (see *Obtain a OpenAI API Key*, below), this will create and open a project called `genai_demo` from `genai_demo.prompt` (available in left Explorer pane):
+
+```bash
+als genai --using=system/genai/examples/genai_demo/genai_demo.prompt --project-name=genai_demo
+```
+
+  
+
+2. ***Or,*** you can simulate the process (no signup) using:
+
+```bash
+
+als genai --repaired-response=system/genai/examples/genai_demo/genai_demo.response_example --project-name=genai_demo
+
+```
+
+&nbsp;
+### Open in your IDE and Run
 
 You can open with VSCode, and run it as follows:
 
 1. **Create Virtual Environment:** as shown in the Appendix.
+
 2. **Start the Server:** F5 (also described in the Appendix).
+
 3. **Start the Admin App:** either use the links provided in the IDE console, or click [http://localhost:5656/](http://localhost:5656/).  The screen shown below should appear in your Browser.
 
 The sections below explore the system that has been created (which would be similar for your own database).
+<br><br>
 
-&nbsp;
+!!! pied-piper ":bulb: Automation: Instant API, Admin App (enable UI dev, agile collaboration)"
+
+    ### a. API with Swagger
+
+    The system creates an API with end points for each table, with filtering, sorting, pagination, optimistic locking and related data access -- **[self-serve](https://apilogicserver.github.io/Docs/API-Self-Serve/), ready for custom app dev.**
 
-### API with Swagger
+    <img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/api-swagger.jpeg?raw=true">
 
-The system creates an API with end points for each table, with filtering, sorting, pagination, optimistic locking and related data access -- **[self-serve](https://apilogicserver.github.io/Docs/API-Self-Serve/), ready for custom app dev.**
+    ### b. Admin App
 
-![api-swagger](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/api-swagger.jpeg?raw=true)
+    It also creates an Admin App: multi-page, multi-table -- ready for **[business user agile collaboration](https://apilogicserver.github.io/Docs/Tech-AI/),** and back office data maintenance.  This complements custom UIs created with the API.
 
-### Admin App
+    You can click Customer 2, and see their Orders, and Items.
 
-It also creates an Admin App: multi-page, multi-table apps -- ready for **[business user agile collaboration](https://apilogicserver.github.io/Docs/Tech-AI/),** and back office data maintenance.  This complements custom UIs created with the API.
+    <img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/admin-app-initial.jpeg?raw=true">
 
-You can click Customer 2, see their Orders, and Items.
+&nbsp;
+
+## 2. Declare Logic And Security
 
-![admin-app-initial](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/api-swagger.jpeg?raw=true)
+While API/UI automation is a great start, it's critical to enforce logic and security.  You do this in your IDE.  Here's how.
 
-## 2. Customize in your IDE
+The following `add_customizations` process simulates:
 
-While API/UI automation is a great start, it's critical to enforce logic and security.  Here's how.
+* Adding security to your project, and
+* Using your IDE to declare logic and security in `logic/declare_logic.sh` and `security/declare_security.py`.
 
-The follwing *add customizations* process simulates adding security to your project, and using your IDE to declare logic and security in `logic/declare_logic.sh` and `security/declare_security.py`.  You can diff these files to their created versions, and/or examine the declared logic.
+> Declared security and logic are shown in the screenshots below.<br>It's quite short - 5 rules, 7 security settings.
 
-In a terminal window for your project:
+To add customizations, in a terminal window for your project:
 
 **1. Stop the Server** (Red Stop button, or Shift-F5 -- see Appendix)
 
@@ -79,12 +120,11 @@ In a terminal window for your project:
 ```bash
 als add-cust
 ```
-
 &nbsp;
 
 ### Declare Security
 
-The *add customizations* process above has simulated the `ApiLogicServer add-auth` command, and using your IDE to declare security in `logic/declare_logic.sh`.
+The `add_customizations` process above has simulated the `ApiLogicServer add-auth` command, and using your IDE to declare security in `logic/declare_logic.sh`.
 
 To see security in action:
 
@@ -96,9 +136,25 @@ To see security in action:
 
 **4. Click Customers**
 
-In the IDE Console Log, observe the how the logging assists in debugging, by showing which Grants (`+ Grant:`) are applied:
+&nbsp;
+
+!!! pied-piper ":bulb: Security: Authentication, Role-based Filtering, Logging"
+
+    #### 1. Login now required
+
+    #### 2. Role-Based Filtering
+
+    Observe you now see fewer customers, since user `s1` has role `sales`.  This role has a declared filter, as shown in the screenshot below.
 
-<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/security-filters.jpeg?raw=true">
+    #### 3. Transparent Logging
+
+    The screenhot below illustrates security declaration and operation:
+
+    * The declarative Grants in the upper code panel, and
+
+    *  The logging in the lower panel, to assist in debugging by showing which Grants (`+ Grant:`) are applied:
+
+    <img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/security-filters.jpeg?raw=true">
 
 &nbsp;
 
@@ -108,11 +164,13 @@ Logic (multi-table derivations and constraints) is a significant portion of a sy
 
 Rules are declared in Python, simplified with IDE code completion.  The screen below shows the 5 rules for **Check Credit Logic.**
 
-The *add customizations* process above has simulated the process of using your IDE to declare logic in `logic/declare_logic.sh`.
+The `add_customizations` process above has simulated the process of using your IDE to declare logic in `logic/declare_logic.sh`.
 
 To see logic in action:
 
-**1. Test: Start the Server, and use the Admin App to add an Order and Item**
+**1. In the admin app, Logout (upper right), and login as admin, p**
+
+**2. Use the Admin App to add an Order and Item for `Customer 1`** (see Appendix)
 
 Observe the rules firing in the console log, as shown in the next screenshot.
 
@@ -120,37 +178,36 @@ Logic provides significant improvements over procedural logic, as described belo
 
 &nbsp;
 
-#### a. Complexity Scaling
+!!! pied-piper ":bulb: Logic: Multi-table Derivations and Constraint Rules, 40X More Concise"
 
-The screenshot below shows our logic declarations, and the logging for inserting an `Item`.  Each line represents a rule firing, and shows the complete state of the row.
+    #### a. Chaining
 
-Note that it's `Multi-Table Transaction`, as indicating by the indentation.  This is because - like a spreadsheet - **rules automatically chain, *including across tables.***
+    The screenshot below shows our logic declarations, and the logging for inserting an `Item`.  Each line represents a rule firing, and shows the complete state of the row.
 
-<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/logic-chaining.jpeg?raw=true">
+    Note that it's a `Multi-Table Transaction`, as indicated by the indentation.  This is because - like a spreadsheet - **rules automatically chain, *including across tables.***
 
-#### b. 40X More Concise
+    <img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/logic-chaining.jpeg?raw=true">
 
-The 5 spreadsheet-like rules represent the same logic as 200 lines of code, [shown here](https://github.com/valhuber/LogicBank/wiki/by-code).  That's a remarkable 40X decrease in the backend half of the system.
+    #### b. 40X More Concise
 
-&nbsp;
+    The 5 spreadsheet-like rules represent the same logic as 200 lines of code, [shown here](https://github.com/valhuber/LogicBank/wiki/by-code).  That's a remarkable 40X decrease in the backend half of the system.
+    <br><br>
 
-#### c. Automatic Re-use
+    #### c. Automatic Re-use
 
-The logic above, perhaps conceived for Place order, applies automatically to all transactions: deleting an order, changing items, moving an order to a new customer, etc.
+    The logic above, perhaps conceived for Place order, applies automatically to all transactions: deleting an order, changing items, moving an order to a new customer, etc.  This reduces code, and promotes quality (no missed corner cases).
+    <br><br>
 
-&nbsp;
+    #### d. Automatic Optimizations
 
-#### d. Automatic Optimizations
+    SQL overhead is minimized by pruning, and by elimination of expensive aggregate queries.  These can result in orders of magnitude impact.
+    <br><br>
 
-SQL overhead is minimized by pruning, and by elimination of expensive aggregate queries.  These can result in orders of magnitude impact.
+    #### e. Transparent
 
-&nbsp;
-
-#### e. Transparent
+    Rules are an executable design.  Note they map exactly to our natural language design (shown in comments) - readable by business users.  
 
-Rules are an executable design.  Note they map exactly to our natural language design (shown in comments) - readable by business users.  
-
-Optionally, you can use the Behave TDD approach to define tests, and the Rules Report will show the rules that execute for each test.  For more information, [click here](https://apilogicserver.github.io/Docs/Behave-Logic-Report/).
+    Optionally, you can use the Behave TDD approach to define tests, and the Rules Report will show the rules that execute for each test.  For more information, [click here](https://apilogicserver.github.io/Docs/Behave-Logic-Report/).
 
 &nbsp;
 
@@ -160,11 +217,17 @@ Not only are spreadsheet-like rules 40X more concise, they meaningfully simplify
 
 >> Give a 10% discount for carbon-neutral products for 10 items or more.
 
-The follwing `apply_iteration` process simulates an iteration:
+&nbsp;
+
+The following `add_iteration` process simulates an iteration:
+
+* acquires a new database with `Product.CarbonNeutral`
+
+* issues the `ApiLogicServer rebuild-from-database` command that rebuilds your project (the database models, the api), while preserving the customizations we made above.
 
-- acquires a new database with `Product.CarbonNeutral`
-- and a revised `ui/admin/admin.yaml` that shows this new column
-- revised logic - in `logic/declare_logic.py`, we replace the 2 lines for the `models.Item.Amount` formula with this (next screenshot shows revised logic executing with breakpoint):
+* acquires a revised `ui/admin/admin.yaml` that shows this new column in the admin app
+
+* acquires this revised logic - in `logic/declare_logic.py`, we replaced the 2 lines for the `models.Item.Amount` formula with this (next screenshot shows revised logic executing with breakpoint):
 
 ```python
     def derive_amount(row: models.Item, old_row: models.Item, logic_row: LogicRow):
@@ -176,70 +239,77 @@ The follwing `apply_iteration` process simulates an iteration:
     Rule.formula(derive=models.Item.Amount, calling=derive_amount)
 ```
 
-In a terminal window for your project:
+&nbsp;
+
+To add this iteration, repeat the process above - in a terminal window for your project:
 
 **1. Stop the Server** (Red Stop button, or Shift-F5 -- see Appendix)
 
-**2. Apply Iteration**
+**2. Add Iteration**
 
 ```bash
 als add-cust
-als rebuild-from-database
 ```
-
 &nbsp;
 
-**3. Set the breakpoint as shown**
+**3. Set the breakpoint as shown in the screenshot below**
 
-&nbsp;
+**4. Test: Start the Server, login as Admin**
 
-**4. Test: Start the Server, and use the Admin App to update your Order by adding a `Green` Item**
+**5. Use the Admin App to update your Order by adding 12 `Green` Items**
 
-At the breakpoint, note you can use standard debugger services to debug your logic (examine `Item` attributes, step, etc).
+At the breakpoint, observe you can use standard debugger services to debug your logic (examine `Item` attributes, step, etc).
 
-![logic-debugging](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/logic-debugging.jpeg?raw=true)!
+<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/logic-debugging.jpeg?raw=true">
 
 &nbsp;
 
-This simple example illustrates some significant aspects of iteration, described in the sub-sections bdelow.
+This simple example illustrates some significant aspects of iteration, described in the sub-sections below.
 
-&nbsp;
+!!! pied-piper ":bulb: Iteration: Automatic Invocation/Ordering, Extensible, Rebuild Preserves Customizations"
 
-### a. Maintenance Automation
+    ### a. Dependency Automation
 
-Along with perhaps documentation, one of the tasks programmers most loathe is maintenance.  That's because it's not about writing code, but it's mainly archaeology - deciphering code someone else wrote, just so you can add 4 or 5 lines that will hopefully be called and function correctly.
+    Along with perhaps documentation, one of the tasks programmers most loathe is maintenance.  That's because it's not about writing code, but it's mainly archaeology - deciphering code someone else wrote, just so you can add 4 or 5 lines that will hopefully be called and function correctly.
 
-Rules change that, since they **self-order their execution** (and pruning) based on system-discovered dependencies.  So, to alter logic, you just "drop a new rule in the bucket", and the system will ensure it's called in the proper order, and re-used over all the Use Cases to which it applies.
+    Rules change that, since they **self-order their execution** (and pruning) based on system-discovered dependencies.  So, to alter logic, you just "drop a new rule in the bucket", and the system will ensure it's called in the proper order, and re-used over all the Use Cases to which it applies.  Maintenance is **faster, and higher quality.**
+    <br><br>
 
-&nbsp;
+    ### b. Extensibile with Python
 
-### b. Extensibile with Python
+    In this case, we needed to do some if/else testing, and it was convenient to add a pinch of Python. Using "Python as a 4GL" is remarkably simple, even if you are new to Python.
 
-In this case, we needed to do some if/else testing, and it was convenient to add a pinch of Python. Using "Python as a 4GL" is remarkably simple, even if you are new to Python.
+    Of course, you have the full object-oriented power of Python and its many libraries, so there are *no automation penalty* restrictions.  
+    <br>
 
-Of course, you have the full object-oriented power of Python and its many libraries, so there are *no automation penalty* restrictions.  
+    ### c. Debugging: IDE, Logging
 
-&nbsp;
+    The screenshot above illustrates that debugging logic is what you'd expect: use your IDE's debugger.  This "standard-based" approach applies to other development activities, such as source code management, and container-based deployment.
+    <br><br>
 
-### c. Debugging: IDE, Logging
+    ### d. Customizations Retained
 
-The screenshot above illustrates that debugging logic is what you'd expect: use your IDE's debugger.  This "standard-based" approach applies to other development activities, such as source code management, and container-based deployment.
+    Note we rebuilt the project from our altered database, illustrating we can **iterate, while *preserving customizations.***
 
 &nbsp;
 
-### d. Customizations Retained
+## 4. API Customization: Standard
+
+Of course, we all know that all businesses the world over depend on the `hello world` app.  This is provided in `api/customize_api`.  Observe that it's:
+
+* standard Python
+
+* using Flask
 
-Note we rebuilt the project from our altered database, illustrating we can **iterate, while *preserving customizations.***
+* and, for database access, SQLAlchemy.  Note all updates from custom APIs also enforce your logic.
 
 &nbsp;
 
-## 4. API Customization: Standard
+### Messaging With Kafka
 
-Of course, we all know that all businesses the world over depend on the `hello world` app.  This is provided in `api/customize_api`.  Observe that it's:
+Along with APIs, messaging is another technology commonly employed for application integration.  See the screenshot below; for more information, see [Sample Integration](Sample-Integration.md##produce-ordershipping-message){:target="_blank" rel="noopener"}.
 
-- standard Python
-- using Flask
-- and, for database access, SQLAlchemy.  Note all updates from custom APIs also enforce your logic.
+<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/integration/order-to-shipping.jpg?raw=true">
 
 &nbsp;
 
@@ -255,11 +325,13 @@ API Logic Server also creates scripts for deployment.  While these are ***not re
 
 ## Summary
 
-![summary](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/summary.jpeg?raw=true)
+<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/summary.jpeg?raw=true">
 
-In minutes - not days or weeks - you've used API Logic Server to convert an idea into **working software,** added **logic and security,** and **iterated** to meet new requirements.
-
-To dive deeper, you can install [API Logic Server](https://apilogicserver.github.io/Docs) and execute this demo - or create a system from your own databases.
+!!! pied-piper ":bulb: Instant Creation, Rules, Open Standards"
+    
+    In minutes - not days or weeks - you've used API Logic Server to convert an idea into **working software**, customized using **rule-based logic and security**, and **iterated** to meet new requirements.
+    
+    To dive deeper, you can install [API Logic Server](https://apilogicserver.github.io/Docs) and execute this demo - or create a system from your own databases.
 
 &nbsp;
 
@@ -267,9 +339,39 @@ To dive deeper, you can install [API Logic Server](https://apilogicserver.github
 
 ## Appendix: Database Schema
 
+Initial version:
+
+<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/basic_demo_data_model.jpeg?raw=true" width="500">
 
+End version:
+
+<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/basic_demo_data_model_end.png?raw=true" width="500">
+
+&nbsp;
+
+## Appendix: Quick Basic Demo
+
+This is a "cheat sheet" for experienced ALS users, e.g., to show your colleagues:
+
+```bash title="Quick Basic Demo"
+
+# Microservice Automation
+# Admin App, API, Project
+als create --project-name=basic_demo --db-url=basic_demo
+
+# Logic, Security and MCP example
+# see logic (logic/declare_logic.py, logic/cocktail-napkin.jpg);  add an Order and Item
+# see security (security/declare_security.py); compare customers, s1 vs. admin
+als add-cust
+als add-auth --db_url=auth
+
+# Python Extensibility, Kafka Integration, Rebuild Iteration
+# see logic/declare_logic.py (breakpoint for Kafka)
+# Swagger: ServicesEndPoint.OrderB2B
+als add-cust
+als rebuild-from-database --db_url=sqlite:///database/db.sqlite
+```
 
-![basic_demo_data_model](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/basic_demo_data_model.jpeg?raw=true" width="500")
 &nbsp;
 
 ## Appendix: Procedures
@@ -284,7 +386,16 @@ You can use either VSCode or Pycharm.
 
 Python employs a virtual environment for project-specific dependencies.  Create one as shown below, depending on your IDE.
 
-For VSCode, there is nothing to do.  Your `venv` has been created automatically.
+For VSCode:
+
+Establish your `venv`, and run it via the first pre-built Run Configuration.  To establish your venv:
+
+```bash
+python -m venv venv; venv\Scripts\activate     # win
+python3 -m venv venv; . venv/bin/activate      # mac/linux
+
+pip install -r requirements.txt
+```
 
 For PyCharm, you will get a dialog requesting to create the `venv`; say yes.
 
@@ -307,19 +418,28 @@ For PyCharm, start the server with CTL-D, Stop with red stop button.
 To enter a new Order:
 
 1. Click `Customer 1``
+
 2. Click `+ ADD NEW ORDER`
+
 3. Set `Notes` to "hurry", and press `SAVE AND SHOW`
+
 4. Click `+ ADD NEW ITEM`
+
 5. Enter Quantity 1, lookup "Product 1", and click `SAVE AND ADD ANOTHER`
+
 6. Enter Quantity 2000, lookup "Product 2", and click `SAVE`
+
 7. Observe the constraint error, triggered by rollups from the `Item` to the `Order` and `Customer`
+
 8. Correct the quantity to 2, and click `Save`
 
+
 **4. Update the Order**
 
 To explore our new logic for green products:
 
 1. Access the previous order, and `ADD NEW ITEM`
+
 2. Enter quantity 11, lookup product `Green`, and click `Save`.
 
 &nbsp;
@@ -334,4 +454,44 @@ $ sqlite3 database/db.sqlite
 >   .exit
 ```
 
-The SQLite DBMS is installed with API Logic Server, but the **CLI** is not provided on all systems.  If it's not installed, [you can install it like this](https://apilogicserver.github.io/Docs/Database-Connectivity/#sqlite).
+The SQLite DBMS is installed with API Logic Server, but the **CLI** is not provided on all systems.  If it's not installed, [you can install it like this](https://apilogicserver.github.io/Docs/Database-Connectivity/#sqlite).
+
+## Appendix: Setup Codespaces
+
+Codespaces enables you to run in the cloud: VSCode via your Browser, courtesy GitHub.  You can use codespaces on your GenAI project:
+
+__1. Open your project on GitHub__
+
+![API Logic Server Intro](images/sample-ai/genai/open-github.png)
+
+__2. Open it in Codespaces (takes a minute or 2):__
+
+![API Logic Server Intro](images/sample-ai/genai/start-codespaces.png)
+
+> You will now see your project - running in VSCode, _in the Browser._  But that's just what you _see..._
+
+> Behind the scenes, Codespaces has requisitioned a cloud machine, and loaded your project - with a _complete development environment_ - Python, your dependencies, git, etc.  
+
+> You are attached to this machine in your Browser, running VSCode.
+
+> :trophy: Pretty remarkable.
+
+__3. Start the Server and open the App in the Browser__
+
+* Use the pre-defined Launch Configuration
+
+![API Logic Server Intro](images/git-codespaces/start-codespaces.png)
+
+
+We think you'll find Codespaces pretty amazing - check it out!
+
+&nbsp;
+
+## Appendix: Obtain an OpenAI ApiKey
+
+To obtain a ChatGPT API Key
+<br>GenAI-Logic uses OpenAI, which requires an Open API Key:
+
+1. Obtain one from [here](https://platform.openai.com/account/api-keys) or [here](https://platform.openai.com/api-keys)
+
+2. Authorize payments [here](https://platform.openai.com/settings/organization/billing/overview)

api_logic_server_cli/prototypes/basic_demo/customizations/api/api_discovery/mcp_discovery.py

@@ -62,49 +62,6 @@ def add_service(app, api, project_dir, swagger_host: str, PORT: str, method_deco
         pass
     
 
-    @app.route('/mcp_server_executor', methods=['GET'])
-    def mcp_server_executor(path=None):
-        ''' sample response printed in mcp_client_executor.py:
-        FIXME - incorrect.
-        But do provide: https://localhost:5656/.well-known/mcp.json
-        ```
-            MCP MCP Response (simulated):
-            {
-            "get_json": {
-                "filter": {
-                "filter": {
-                    "credit_limit": {
-                    "gt": 4000
-                    }
-                },
-                "headers": {
-                    "Accept": "application/vnd.api+json",
-                    "Authorization": "Bearer your_token"
-                },
-                "type": "Customer",
-                "url": "http://localhost:5656/api/Customer"
-                }
-            },
-            "name": "mcp_server_executor",
-            "openapiUrl": "TUNNEL_URL/api/openapi.json",
-            "serverUrl": "TUNNEL_URL/api"
-            }
-        ```
-        '''
-        get_json = request.get_json()
-        app_logger.info(f"mcp_server_executor sees mcp request: \n{json.dumps(get_json, indent=4)}")
-
-        # process verb, filter here (stub for now)
-        filter_json = get_json['filter']  # {"credit_limit": {"gt": 4000}}  # todo: bunch'o parsing here
-        
-        filter_json = {"name": "credit_limit",  "op": "gt", "val":4000}     # https://github.com/thomaxxl/safrs/wiki/JsonApi-filtering
-        filter = json.dumps(filter_json)                                    # {"name": "credit_limit",  "op": "gt",  "val": 4000}
-        get_uri = get_json['url'] + '?filter=' + filter  # get_uri = "http://localhost:5656/api/Customer?filter[credit_limit]=1000"
-        response = requests.get(url=get_uri, headers= request.headers)
-
-        return response.json(), 200, {'Content-Type': 'application/json; charset=utf-8'}
-
-
     @app.route('/.well-known/mcp.json', methods=['GET'])
     def mcp_discovery(path=None):
         ''' called by mcp_client_executor for discovery, eg:
@@ -128,7 +85,7 @@ def add_service(app, api, project_dir, swagger_host: str, PORT: str, method_deco
         test: curl -X GET "http://localhost:5656/.well-known/mcp.json"
         '''
         # return docs/mcp_schema.json
-        schema_path = os.path.join(project_dir, "docs", "mcp_schema.json")
+        schema_path = os.path.join(project_dir, "docs/mcp_learning/mcp_schema.json")
         try:
             with open(schema_path, "r") as schema_file:
                 schema = json.load(schema_file)