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

api_logic_server_cli/prototypes/base/integration/n8n/n8n_producer.py

@@ -19,7 +19,18 @@ from integration.system.RowDictMapper import RowDictMapper
 from flask import jsonify
 import api.system.api_utils as api_utils
 from config.config import Args
-
+'''
+    wh_scheme = "http"
+    wh_server = "localhost" # or cloud.n8n.io...
+    wh_port = 5678
+    wh_endpoint = "webhook-test"
+    wh_path = "002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69"
+    token = "YWRtaW46cA==" # Basic auth for n8n
+    N8N_PRODUCER = {"authorization": f"Basic {token}", "n8n_url": f'"{wh_scheme}://{wh_server}:{wh_port}/{wh_endpoint}/{wh_path}"'} 
+    # Or enter the n8n_url directly:
+    N8N_PRODUCER = {"authorization": f"Basic {token}","n8n_url":"http://localhost:5678/webhook-test/002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69"}    
+
+'''
 producer = None
 """ connected producer (or null if N8N not enabled in Config.py) """
 
@@ -31,27 +42,60 @@ logger.debug("n8n_connect imported")
 
 def n8n_producer():
     """
-    Called by api_logic_server_run>server_setup to listen on kafka using confluent_kafka
-
-    Enabled by config.KAFKA_CONNECT (dict, of bootstrap.servers, client.id)
 
+    Enabled by config (dict, of bootstrap.servers, client.id)
+    OR
+    token = getenv("N8N_TOKEN", Args.instance.wh_token) #basic auth
+    scheme = getenv("N8N_SCHEME",Args.instance.wh_scheme) # http or https
+    server = getenv("N8N_SERVER", Args.instance.wh_server)
+    port = getenv("N8N_PORT",Args.instance.wh_port)
+    endpoint = getenv("N8N_ENDPOINT", wh_endpoint) # this can change for different workflows
+    path = getenv("N8N_PATH", Args.instance.wh_path)
+    conf = getenv("N8N_PRODUCER", Args.instance.n8n_producer)
     Args:
         none
     """
+    
+    producer = configure_n8n_producer()
 
-    global conf
-    if Args.instance.n8n_producer:
-        conf = Args.instance.n8n_producer
-        producer = conf
-        # good place to do defaults, get api keys, etc
-        logger.debug('N8N producer initialized')
+def configure_n8n_producer(wh_endpoint: str = None, wh_path: str = None) -> dict:
+    """
+    Need to be able to change the endpoint for different workflows and webhooks
 
+    Args:
+        wh_endpoint (str, optional): _description_. Defaults to None.
 
-def send_n8n_message(http_method: str = "POST", ins_upd_dlt: str = "ins", msg: str = "",
+    Returns:
+        dict: _description_
+    """
+    global conf
+    conf = None
+    from os import getenv
+    endpoint = wh_endpoint if wh_endpoint is not None else Args.instance.wh_endpoint
+    n8n_path = wh_path if wh_path is not None else Args.instance.wh_path
+    token = getenv("N8N_TOKEN", Args.instance.wh_token)
+    scheme = getenv("N8N_SCHEME",Args.instance.wh_scheme)
+    server = getenv("N8N_SERVER", Args.instance.wh_server)
+    port = getenv("N8N_PORT",Args.instance.wh_port)
+    endpoint = getenv("N8N_ENDPOINT", endpoint)
+    path = getenv("N8N_PATH", n8n_path)
+    if token is None or scheme is None or server is None or port is None or path is None:
+        logger.debug('N8N producer not configured in config/Config.py or environment variables')
+        conf = getenv("N8N_PRODUCER", Args.instance.n8n_producer)
+    else:
+        conf = {"authorization": f"Basic {token}", "n8n_url": f'"{scheme}://{server}:{port}/{wh_endpoint if wh_endpoint is not None else endpoint}/{path}"'}
+            
+    return conf
+
+def send_n8n_message(http_method: str = "POST", 
+        ins_upd_dlt: str = "ins", 
+        msg: str = "",
         wh_entity: str = "unknown",
         logic_row: LogicRow = None, 
         row_dict_mapper: RowDictMapper = None, 
-        payload: dict = None) -> any:
+        payload: dict = None,
+        wh_endpoint: str = None,
+        wh_path: str= None) -> str:
     """ Send N8N webhook message regarding [logic_row, mapped by row_dict_mapper or by  payload]
 
     * Typically called from declare_logic event
@@ -64,13 +108,16 @@ def send_n8n_message(http_method: str = "POST", ins_upd_dlt: str = "ins", msg: s
         row_dict_mapper (RowDictMapper): (Optional) typically subclass of RowDictMapper, transforms row to dict
         payload (str): (Optional) JSON data to be sent as string (json.dumps(row.to_dict()))    
         wh_entity (str): the webhook entity name pass in header
+        wh_endpoint (str): (Optional) override the webhook endpoint name modify the producer
+        wh_path (str): (Optional) override the webhook path name modify the producer
     """
 
-    global conf
-    if conf is None:
-        conf = Args.instance.n8n_producer #FIXME not sure why this fails - conf is None
+    #global conf
+    #if conf is None:
+    #    conf = Args.instance.n8n_producer #FIXME not sure why this fails - conf is None
         #return "N8N not enabled in Config.py"
-        
+    conf = configure_n8n_producer(wh_endpoint, wh_path)
+    logger.debug(f"n8n_producer: conf: {conf}")
     if row_dict_mapper is None and payload is None and logic_row is None:
         return "send_n8n_message: payload, logic_row, row_dict_mapper are all None - must provide one"
     row_obj_dict = None
@@ -96,17 +143,18 @@ def send_n8n_message(http_method: str = "POST", ins_upd_dlt: str = "ins", msg: s
         status = {"status_code": 500}
 
         if conf is None:
-            logger.debug(f"n8n_producer: not configured in config/Config.py")
+            logger.debug(f"n8n_producer.py: N8N not configured in config/Config.py or environment variables")
         else:
             headers = {
                 "Authorization": conf['authorization'],
                 "Content-Type": "application/json",
                 "wh_state": wh_state,
-                "wh_entity": wh_entity
+                "wh_entity": wh_entity,
+                "wh_source": "api_logic_server",
             }
             endpoint = f'{conf["n8n_url"]}'
             status = {"status_code": 500}
-            if http_method in {"post", "POST"}:
+            if http_method.lower() == "post":
                 #Only passing payload in this example
                 status = requests.post(endpoint, json=row_obj_dict, headers=headers)
             elif http_method.lower() == "get":
@@ -121,5 +169,4 @@ def send_n8n_message(http_method: str = "POST", ins_upd_dlt: str = "ins", msg: s
         logger.error(f"\nn8n_producer fails with: {e}")
         long_message = traceback.format_exc()
         logger.error(long_message)
-        return long_message
-
+        return long_message

api_logic_server_cli/prototypes/base/integration/n8n/n8n_readme.md

@@ -45,4 +45,23 @@ in the workflow (e.g. SendGrid email)
             logic_row.debug(status)
 
     Rule.after_flush_row_event(on_class=models.Customer, calling=call_n8n_workflow)
+```
+## Environment override
+You can override the configuration of the N8N_PRODUCER or the components used to build the producer.
+```
+# source n8n.env
+# to configure your n8n webhook
+export N8N_TOKEN=YWRtaW46cA==
+export N8N_SCHEME=http
+export N8N_SERVER=localhost
+export N8N_PORT=5678
+# each webhook may have a unique name
+export N8N_ENDPOINT=webhook_test
+
+# the path will change between dev and production
+export N8N_PATH=002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69
+
+# OR set the n8n producer before calling the webhook
+# {"authorization": f"Basic {token}", "n8n_url": f'"{scheme}://{server}:{port}/{wh_endpoint if wh_endpoint is not None else endpoint}/{path}"'}
+export N8N_PRODUCER=http://localhost:5678/webhook-test/002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69
 ```

api_logic_server_cli/prototypes/base/test/basic/server_test.py

@@ -26,7 +26,7 @@ def server_tests(host, port, version):
             port - server port
             version - ApiLogicServer version
     """
-    pass  # Your Code Goes Here
+    ...  # Your Code Goes Here
 
 if __name__ == "__main__":
    # only to run when not called via 'import' here

api_logic_server_cli/prototypes/basic_demo/README.md

@@ -12,21 +12,19 @@ See how to build a complete database system -- in minutes instead of weeks or mo
 
 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 |
+| 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 |
 
 The entire process takes 10 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 - 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).
 
 &nbsp;
 
@@ -45,9 +43,7 @@ This creates a project by reading your schema.  The database is Customer, Orders
 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).
@@ -58,7 +54,7 @@ The sections below explore the system that has been created (which would be simi
 
 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.**
 
-<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/api-swagger.jpeg?raw=true">
+![api-swagger](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/api-swagger.jpeg?raw=true)
 
 ### Admin App
 
@@ -66,32 +62,29 @@ It also creates an Admin App: multi-page, multi-table apps -- ready for **[busin
 
 You can click Customer 2, see their Orders, and Items.
 
-<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/admin-app-initial.jpeg?raw=true">
+![admin-app-initial](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/api-swagger.jpeg?raw=true)
 
 ## 2. Customize in your IDE
 
 While API/UI automation is a great start, it's critical to enforce logic and security.  Here's how.
 
-The follwing `apply_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.
+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.
 
 In a terminal window for your project:
 
 **1. Stop the Server** (Red Stop button, or Shift-F5 -- see Appendix)
 
-**2. Apply Customizations**
+**2. Add Customizations**
 
 ```bash
-# mac, linux
-sh apply_customizations.sh
-
-#windows
-./apply_customizations.ps1
+als add-cust
 ```
+
 &nbsp;
 
 ### Declare Security
 
-The `apply_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:
 
@@ -115,7 +108,7 @@ 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 `apply_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:
 
@@ -169,11 +162,9 @@ Not only are spreadsheet-like rules 40X more concise, they meaningfully simplify
 
 The follwing `apply_iteration` process simulates an iteration:
 
-* 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 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):
 
 ```python
     def derive_amount(row: models.Item, old_row: models.Item, logic_row: LogicRow):
@@ -185,8 +176,6 @@ The follwing `apply_iteration` process simulates an iteration:
     Rule.formula(derive=models.Item.Amount, calling=derive_amount)
 ```
 
-* issues the `ApiLogicServer rebuild-from-database` command that rebuilds your project (the database models, the api), while preserving the customizations we made above.
-
 In a terminal window for your project:
 
 **1. Stop the Server** (Red Stop button, or Shift-F5 -- see Appendix)
@@ -194,12 +183,10 @@ In a terminal window for your project:
 **2. Apply Iteration**
 
 ```bash
-# mac, linux
-sh apply_iteration.sh
-
-#windows
-./apply_iteration.ps1
+als add-cust
+als rebuild-from-database
 ```
+
 &nbsp;
 
 **3. Set the breakpoint as shown**
@@ -210,7 +197,7 @@ sh apply_iteration.sh
 
 At the breakpoint, note you can use standard debugger services to debug your logic (examine `Item` attributes, step, etc).
 
-<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/logic-debugging.jpeg?raw=true">
+![logic-debugging](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/logic-debugging.jpeg?raw=true)!
 
 &nbsp;
 
@@ -250,11 +237,9 @@ Note we rebuilt the project from our altered database, illustrating we can **ite
 
 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
-
-* and, for database access, SQLAlchemy.  Note all updates from custom APIs also enforce your logic.
+- standard Python
+- using Flask
+- and, for database access, SQLAlchemy.  Note all updates from custom APIs also enforce your logic.
 
 &nbsp;
 
@@ -270,7 +255,7 @@ API Logic Server also creates scripts for deployment.  While these are ***not re
 
 ## Summary
 
-<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/summary.jpeg?raw=true">
+![summary](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.
 
@@ -282,8 +267,9 @@ To dive deeper, you can install [API Logic Server](https://apilogicserver.github
 
 ## Appendix: Database Schema
 
-<img src="https://github.com/ApiLogicServer/Docs/blob/main/docs/images/basic_demo/basic_demo_data_model.jpeg?raw=true" width="500">
 
+
+![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
@@ -321,28 +307,19 @@ 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;

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

@@ -0,0 +1,139 @@
+from flask import request, jsonify
+from flask import Flask, redirect, send_from_directory, send_file
+import logging
+import os
+import json
+import io
+
+import requests
+from config.config import Args  # circular import error if at top
+
+app_logger = logging.getLogger("api_logic_server_app")
+
+def add_service(app, api, project_dir, swagger_host: str, PORT: str, method_decorators = []):
+    pass
+
+    def get_server_url():
+        """ return the server URL for the OpenAPI spec """
+        result = f'http://{Args.instance.swagger_host}:{Args.instance.swagger_port}'
+        # get env variable API_LOGIC_SERVER_TUNNEL (or None)
+        if tunnel_url := os.getenv("API_LOGIC_SERVER_TUNNEL", None):
+            app_logger.info(f".. tunnel URL: {tunnel_url}")
+            result = tunnel_url
+        return result  #  + '/api'
+        
+
+    @app.before_request
+    def before_any_request():
+        # print(f"[DEBUG] Incoming request: {request.method} {request.url}")
+        if activate_openapi_logging := True:
+            if request.content_type == 'application/json' and request.method in ['POST', 'PUT', 'PATCH']:
+                # openapi: Incoming request: PATCH http://localhost:5656/api/Customer/1/ {'data': {'attributes': {'credit_limit': 5555}, 'type': 'Customer', 'id': '1'}}
+                # openapi: Incoming request: PATCH http://6f6f-2601-644-4900-d6f0-ecc9-6df3-8863-c5b2.ngrok-free.app/api/Customer/1 {'credit_limit': 5555}
+
+                app_logger.info(f"openapi: Incoming request: {request.method} {request.url} {str(request.json)}")
+            else:
+                app_logger.info(f"openapi: Incoming request: {request.method} {request.url}")
+            # app_logger.info(f"openapi: Incoming request headers: {request.headers}")
+
+            chatgpt_request_json = {
+                        "credit_limit": 25000,
+            }
+            standard_request_json = {
+                "data": {
+                    "type": "Customer",
+                    "id": "ALFKI",
+                    "attributes": {
+                        "name": "Alice",
+                        "credit_limit": 25000,
+                        "balance": 12345
+                    }
+                }
+            }
+            swagger_request_json = {
+                'data': {
+                    'attributes': {
+                        'credit_limit': 5555
+                        }, 
+                    'type': 'Customer', 
+                    'id': '1'
+                }
+            }
+        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:
+        ```
+        {
+            "tool_type": "json-api",
+            "schema_version": "1.0",
+            "base_url": "https://crm.company.com",
+            "resources": [
+                {
+                "name": "Customer",
+                "path": "/Customer",
+                "methods": ["GET", "PATCH"],
+                "fields": ["id", "name", "balance", "credit_limit"],
+                "filterable": ["name", "credit_limit"],
+                "example": "List customers with credit over 5000"
+                }
+            ]
+        }
+        ```
+        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")
+        try:
+            with open(schema_path, "r") as schema_file:
+                schema = json.load(schema_file)
+                return jsonify(schema), 200
+        except Exception as e:
+            app_logger.error(f"Error loading MCP schema: {e}")
+            return jsonify({"error": "MCP schema not found"}), 404
+        pass

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

@@ -0,0 +1,92 @@
+from flask import request, jsonify
+from flask import Flask, redirect, send_from_directory, send_file
+import logging
+import os
+import json
+import io
+from config.config import Args  # circular import error if at top
+
+app_logger = logging.getLogger("api_logic_server_app")
+
+
+
+def add_service(app, api, project_dir, swagger_host: str, PORT: str, method_decorators = []):
+    pass
+
+    def get_server_url():
+        """ return the server URL for the OpenAPI spec """
+        result = f'http://{Args.instance.swagger_host}:{Args.instance.swagger_port}'
+        # get env variable API_LOGIC_SERVER_TUNNEL (or None)
+        if tunnel_url := os.getenv("API_LOGIC_SERVER_TUNNEL", None):
+            app_logger.info(f".. tunnel URL: {tunnel_url}")
+            result = tunnel_url
+        return result  #  + '/api'
+        
+    @app.route('/mcp.json')
+    def mcp(path=None):
+        '''
+        test: curl -X GET http://localhost:5656/mcp.json
+        '''
+
+        mcp_json = {
+            "name": "MCP genai_demo test",
+            "description": "You are an AI Planner + Executor for a live JSON:API server.",
+            "instructions": [
+                "When a user gives you a natural language goal (e.g., 'list customers from Germany'), you:",
+                "Identify the resource (Customer, Order, Product).",
+                "Map filters (e.g., Country=Germany).",
+                "Construct a JSON:API call to the live endpoint (through a function called fetch_resource).",
+                "Execute the live API call through the function.",
+                "Format and display the results neatly."
+            ],
+            "serverUrl": "http://localhost:5656/api",
+            "openapiUrl": "http://localhost:5656/api/openapi.json",
+            "apiStandard": "JSON:API (application/vnd.api+json)"
+            }
+        mcp_json["serverUrl"] =  get_server_url() + '/api'
+        mcp_json["openapiUrl"] = get_server_url() + '/api/openapi.json' 
+        # return jsonify(mcp), 200, {'Content-Type': 'text/plain; charset=utf-8'}
+        return jsonify(mcp_json), 200, {'Content-Type': 'application/json; charset=utf-8'}
+
+
+    @app.route('/api/openapi.json')
+    def openapi(path=None):
+        """ return integration/openai_plugin/swagger_3.json 
+        * with updated tunnel URL if API_LOGIC_SERVER_TUNNEL is set
+
+        test: curl -X GET http://localhost:5656/api/openapi.json
+        like: curl -X GET http://localhost:5656/api/swagger.json
+        """
+            
+        # read dict from json file integration/openai_plugin/swagger_3.json
+        with open("integration/openai_function/swagger_3.json", "r") as json_file:
+            swagger_dict = json.load(json_file)
+        app_logger.info(f"openapi: Swagger JSON loaded: {swagger_dict}")
+
+        server_url = get_server_url()
+        swagger_dict["servers"][0]["url"] = server_url + '/api'
+
+        # convert dict to buffered stream
+        swagger_dict_mem = io.BytesIO(json.dumps(swagger_dict).encode('utf-8'))
+        return send_file(swagger_dict_mem, mimetype='text/json')
+
+
+    @app.route('/api/ai_plugin')
+    def ai_plugin(path=None):
+        """ return integration/openai_plugin/ai_plugin.json (disparaged)
+        * with updated tunnel URL if API_LOGIC_SERVER_TUNNEL is set
+
+        test: curl -X GET http://localhost:5656/api/ai_plugin
+        """
+
+        # read dict from json file integration/openai_plugin/swagger_3.json
+        with open("integration/openai_plugin/ai_plugin.json", "r") as json_file:
+            swagger_dict = json.load(json_file)
+        app_logger.info(f"openapi: ai_plugin JSON loaded: {swagger_dict}")
+
+        server_url = get_server_url()
+        swagger_dict["servers"][0]["url"] = server_url
+
+        # convert dict to buffered stream
+        swagger_dict_mem = io.BytesIO(json.dumps(swagger_dict).encode('utf-8'))
+        return send_file(swagger_dict_mem, mimetype='text/json')

api_logic_server_cli/prototypes/basic_demo/customizations/config/default.env

@@ -0,0 +1,13 @@
+SECRET_KEY = "whatnothow"
+SQLALCHEMY_TRACK_MODIFICATIONS = False
+SQLAlCHEMY_ECHO = False
+# AGGREGATE_DEFAULTS =  True
+# ALL_DEFAULTS = True
+# APILOGICPROJECT_KAFKA_PRODUCER = "{\"bootstrap.servers\": \"localhost:9092\"}"
+# SQLALCHEMY_DATABASE_URI=db.sqlite
+
+SECURITY_ENABLED = false
+
+# if using tunnel for mcp, function, or ai_plugin
+# eg, https://tunnel_url.ngrok-free.app
+API_LOGIC_SERVER_TUNNEL = "TUNNEL_URL"