ApiLogicServer 14.5.3__tar.gz → 14.5.4__tar.gz

{apilogicserver-14.5.3 → apilogicserver-14.5.4}/ApiLogicServer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ApiLogicServer
-Version: 14.5.3
+Version: 14.5.4
 Author-email: Val Huber <apilogicserver@gmail.com>
 License: BSD-3-Clause
 Project-URL: Homepage, https://www.genai-logic.com

{apilogicserver-14.5.3 → apilogicserver-14.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ApiLogicServer
-Version: 14.5.3
+Version: 14.5.4
 Author-email: Val Huber <apilogicserver@gmail.com>
 License: BSD-3-Clause
 Project-URL: Homepage, https://www.genai-logic.com

{apilogicserver-14.5.3 → apilogicserver-14.5.4}/api_logic_server_cli/api_logic_server.py

@@ -12,10 +12,10 @@ ApiLogicServer CLI: given a database url, create [and run] customizable ApiLogic
 Called from api_logic_server_cli.py, by instantiating the ProjectRun object.
 '''
 
-__version__ = "14.05.03"  # last public release: 14.04.00
+__version__ = "14.05.04"  # last public release: 14.05.00
 recent_changes = \
     f'\n\nRecent Changes:\n' +\
-    "\t05/19/2024 - 14.05.03: mcp filters with working date range (AND), email stub, use basic_demo custs for genai_demo \n"\
+    "\t05/20/2024 - 14.05.04: factored mcp filters with working date range (AND), email stub, use basic_demo custs for genai_demo \n"\
     "\t05/16/2024 - 14.05.00: safrs 3.1.7, running mcp preview \n"\
     "\t04/27/2024 - 14.04.00: Graphics preview, Vibe install fix, Improved IDE Chat Logic, MCP Exploration \n"\
     "\t03/30/2024 - 14.03.25: WebGenAI fixes for Kafka and Keycloak \n"\

apilogicserver-14.5.4/api_logic_server_cli/api_logic_server_info.yaml

@@ -0,0 +1,3 @@
+last_created_date: May 20, 2025 15:00:15
+last_created_project_name: ../../../servers/basic_demo
+last_created_version: 14.05.03

{apilogicserver-14.5.3 → apilogicserver-14.5.4}/api_logic_server_cli/create_from_model/dbml.py

@@ -74,6 +74,9 @@ class DBMLCreator(object):
                 "tool_type": "json-api",
                 "schema_version": "1.0",
                 "base_url": "http://localhost:5656/api",
+                "query_params": "- JSON:API custom filtering using a filter array (e.g., filter=[{\"name\":\"date_shipped\",\"op\":\"gt\",\"val\":\"2023-07-14\"}])",
+                "expected_response": "Respond with a JSON object with tool_type, schema_version, base_url, and an array of resources including: path, method, query_params array or body, headers, expected_output.",
+                "email_services": "iff email is requested, Send email by issing a POST request to the Email endpoint, setting the customer_id and message in the body.",
                 "description": f"API Logic Project: {self.mod_gen.project.project_name_last_node}",
                 "resources": [
                 ]

{apilogicserver-14.5.3 → apilogicserver-14.5.4}/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:

{apilogicserver-14.5.3 → apilogicserver-14.5.4}/api_logic_server_cli/prototypes/basic_demo/customizations/database/system/SAFRSBaseX.py

@@ -118,7 +118,10 @@ class SAFRSBaseX(SAFRSBase, safrs.DB.Model):
                 op = getattr(operator, op_name)
                 expressions.append(op(attr, attr_val))
 
-        return query.filter(operator.and_(*expressions))
+        if len(filters) > 1:
+            return query.filter(operator.and_(*expressions))
+        else:
+            return query.filter(*expressions)
 
 
 class TestBase(Base):

apilogicserver-14.5.4/api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/mcp_client_executor.py

@@ -0,0 +1,308 @@
+""" 
+This simulates the MCP Client Executor, 
+which takes a natural language query and converts it into a tool context block:
+
+1. Discovers MCP servers (from config)
+2. Queries OpenAI's GPT-4 model to obtain the tool context based on a provided schema and a natural language query
+3. Processes the tool context (calls the indicated MCP (als) endpoints)
+
+Notes:
+* See: integration/mcp/README_mcp.md
+* python api_logic_server_run.py
+
+"""
+
+import json
+import os
+import re
+import openai
+import requests
+
+# Set your OpenAI API key
+openai.api_key = os.getenv("APILOGICSERVER_CHATGPT_APIKEY")
+
+server_url = os.getenv("APILOGICSERVER_URL", "http://localhost:5656/api")
+
+# debug settings
+test_type = 'orchestration'  # 'simple_get' or 'orchestration'
+create_tool_context_from_llm = True
+''' set to False to bypass LLM call and save 2-3 secs in testing '''
+use_test_schema = False
+''' True means bypass discovery, use hard-coded schedma file '''
+
+def discover_mcp_servers():
+    """ Discover the MCP servers by calling the /api/.well-known/mcp.json endpoint.
+    This function retrieves the list of available MCP servers and their capabilities.
+    """
+    global server_url, use_test_schema
+
+    # create schema_text (for prompt), by reading integration/mcp/mcp_schema.txt
+    if use_test_schema:
+        schema_file_path = os.path.join(os.path.dirname(__file__), "mcp_schema.txt")
+        try:
+            with open(schema_file_path, "r") as schema_file:
+                schema_text = schema_file.read()
+        except FileNotFoundError:
+                print(f"Schema file not found at {schema_file_path}.")
+                exit(1)
+        finally:
+            print(f"Schema file loaded from {schema_file_path}.")
+        return schema_text
+
+    # find the servers - read the mcp_server_discovery.json file
+    discovery_file_path = os.path.join(os.path.dirname(__file__), "mcp_server_discovery.json")
+    try:
+        with open(discovery_file_path, "r") as discovery_file:
+            discovery_data = json.load(discovery_file)
+            print(f"\nDiscovered MCP servers from config file: {discovery_file_path}:" + json.dumps(discovery_data, indent=4))
+    except FileNotFoundError:
+        print(f"Discovery file not found at {discovery_file_path}.")
+    except json.JSONDecodeError as e:
+        print(f"Error decoding JSON from {discovery_file_path}: {e}")
+    
+    for each_server in discovery_data["servers"]:
+        discovery_url = each_server["schema_url"]
+
+        # Call the discovery_url to get the MCP/API schema
+        try:
+            response = requests.get(discovery_url)
+            if response.status_code == 200:
+                api_schema = response.json()
+                print()
+                print(f"\n1. API Schema from discovery schema_url: {discovery_url}:\n" +json.dumps(api_schema, indent=4))
+            else:
+                print(f"Failed to retrieve API schema from {discovery_url}: {response.status_code}")
+        except requests.RequestException as e:
+            print(f"Error calling OpenAPI URL: {e}")
+    return json.dumps(api_schema)
+
+
+def get_user_nl_query():
+    """ Get the natural language query from the user. 
+    Add instructions for the LLM to generate a tool context block.
+    
+    """
+
+    global test_type
+
+    if len(sys.argv) > 1 and sys.argv[1] != 'go':
+        request = sys.argv[1]
+    else:
+        request = "List the unshipped orders created before 2023-07-14, and send a discount email to the customer for each one."
+        if test_type != 'orchestration':
+            request = "List customers with credit over 1000"
+    return request
+
+
+def query_llm_with_nl(nl_query):
+    """ 
+    Query the LLM with a natural language query and schema text to generate a tool context block.
+
+    It handles both orchestration and simple GET requests.
+    """
+
+    global test_type, create_tool_context_from_llm
+
+    messages = [
+        {
+            "role": "system",
+            "content": "You are an API planner that converts natural language queries into MCP Tool Context blocks using JSON:API. Return only the tool context as JSON."
+        },
+        {
+            "role": "user",
+            "content": f"Schema:\n{schema_text}\n\nNatural language query: '{nl_query}'"
+        }
+    ]
+
+    # setup default tool_context to bypass LLM call and save 2-3 secs in testing
+    if test_type == 'orchestration':     # orchestration: emails to pending orders
+
+        tool_context = \
+            {
+                "tool_type": "json-api",
+                "schema_version": "1.0",
+                "base_url": "http://localhost:5656/api",
+                "resources": [
+                    {
+                        "path": "/Order",
+                        "method": "GET",
+                        "query_params": [
+                            {
+                                "name": "date_shipped",
+                                "op": "eq",
+                                "val": None
+                            },
+                            {
+                                "name": "date_created",
+                                "op": "lt",
+                                "val": "2023-07-14"
+                            }
+                        ],
+                        "headers": [],
+                        "expected_output": []
+                    },
+                    {
+                        "path": "/Email",
+                        "method": "POST",
+                        "body": {
+                            "customer_id": "{{ order.customer_id }}",
+                            "message": "You have a discount on your unshipped order."
+                        },
+                        "headers": [],
+                        "expected_output": []
+                    }
+                ]
+            }
+    else:                                   # simple get request - list customers with credit over 1000 
+        tool_context = \
+            {
+                "tool_type": "json-api",
+                "schema_version": "1.0",
+                "base_url": "http://localhost:5656/api",
+                "resources": [
+                    {
+                        "path": "/Customer",
+                        "method": "GET",
+                        "query_params": [
+                            {
+                                "name": "credit_limit",
+                                "op": "gt",
+                                "val": "1000"
+                            }
+                        ]
+                    }
+                ]
+            }    # Call the OpenAI API to generate the tool context        
+    if create_tool_context_from_llm:  # saves 2-3 seconds...
+      response = openai.chat.completions.create(
+          model="gpt-4",
+          messages=messages,
+          temperature=0.2
+      )
+
+      tool_context_str = response.choices[0].message.content
+      tool_context_str_no_cr = tool_context_str.replace("\n", '')  # convert single quotes to double quotes
+      try:
+          tool_context = json.loads(tool_context_str_no_cr)
+      except json.JSONDecodeError:
+          print("Failed to decode JSON from response:", tool_context_str)
+          return None
+
+    print("\n\n2a. LLM request:\n", json.dumps(messages, indent=4))
+    print("\n2b. NL Query:\n", nl_query)
+    print("\n2c. schema_text: \n", json.dumps(json.loads(schema_text), indent=4))  #schema_text[0:100])
+    print("\n2d. generated tool context from LLM:\n", json.dumps(tool_context, indent=4))
+    return tool_context
+
+
+def process_tool_context(tool_context):
+    """ Process the orchestration request by executing multiple tool context blocks.
+    This function simulates the MCP Client Executor by executing the tool context blocks
+    against a live JSON:API server. It handles both GET and POST requests, and it can
+    orchestrate multiple requests based on the provided tool context.
+
+    Note the orchestration is processed by the client executor (here), not the server executor.
+
+    Research: 
+
+    1. How is this a "USB", since the request was specific about JSON:API?
+    2. How is it clear to loop through the tool_context[0] and call tool_context[1]?
+    """
+    global server_url
+
+    def get_query_param_filter(query_params):
+        """ return json:api filter
+
+        eg
+            curl -qg 'http://localhost:5656/api/Order?filter=[{"name":"date_shipped","op":"eq","val":null},{"name":"CreatedOn","op":"lt","val":"2023-07-14"}]'
+
+            curl -qg 'http://localhost:5656/api/Order?filter=[{"name":"date_shipped","op":"gt","val":"2023-07-14"}]'
+            curl -qg 'http://localhost:5656/api/Order?filter=[{"name":"date_shipped","op":"eq","val":null}]'
+            curl -qg 'http://localhost:5656/api/Customer?filter=[{"name":"credit_limit","op":"gt","val":"1000"}]'
+        
+        query_params might be simple:
+            "query_params": [ {"name": "credit_limit", "op": "gt", "val": "1000"} ]
+            ==> ?filter=[{"name":"credit_limit","op":"gt","val":"1000"}]
+
+        or a list:
+            "query_params": [
+                {
+                    "name": "date_shipped",
+                    "op": "eq",
+                    "val": None
+                },
+                {
+                    "name": "date_created",
+                    "op": "lt",
+                    "val": "2023-07-14"
+                }
+            ],
+
+        """
+
+        added_rows = 0
+
+        query_param_filter = ''
+        assert isinstance(query_params, list), "Query Params filter expected to be a list"
+        query_param_filter = 'filter=' + str(query_params)
+        # use urlencode to convert to JSON:API format...
+        # val urllib.parse.quote() or urllib.parse.urlencode()
+        # tool instructions... filtering, email etc
+        query_param_filter = query_param_filter.replace("'", '"')  # convert single quotes to double quotes
+        query_param_filter = query_param_filter.replace("None", 'null')
+        query_param_filter = query_param_filter.replace("date_created", 'CreatedOn')  # TODO - why this name?
+        return query_param_filter  # end get_query_param_filter
+
+    assert isinstance(tool_context, (dict, list)), "Tool context expected to be a dictionary"
+    context_data = {}
+    added_rows = 0
+
+    for each_block in tool_context["resources"]:
+        if True:  # TODO - add check for "tool": "json-api"
+            if each_block["method"] == "GET":
+                    query_param_filter = get_query_param_filter(each_block["query_params"])
+                    headers = {"Content-Type": "application/vnd.api+json"}
+                    if "headers" in each_block:
+                        headers.update(each_block["headers"])
+                    mcp_response = requests.get(
+                        url = tool_context["base_url"] + each_block["path"],
+                        headers=headers,
+                        params=query_param_filter
+                    )
+                    context_data = mcp_response.json()['data']  # result rows...
+            elif each_block["method"] in ["POST"]:
+                    for each_order in context_data:
+                        url = tool_context["base_url"] + each_block["path"]
+                        json_update_data =  { 'data': {"type": "Email", 'attributes': {} } }  
+                        json_update_data_attributes = json_update_data["data"]["attributes"]
+                        json_update_data_attributes["customer_id"] = context_data[0]['attributes']["customer_id"]  # TODO - fix
+                        json_update_data_attributes["message"] = each_block["body"]["message"] 
+                        # eg: POST http://localhost:5656/api/Email {'data': {'type': 'Email', 'attributes': {'customer_id': 5, 'message': {'to': '{{ order.customer_id }}', 'subject': 'Discount for your order', 'body': 'Dear customer, you have a discount for your recent order. Thank you for shopping with us.'}}}}
+                        headers = {"Content-Type": "application/vnd.api+json"}
+                        if "headers" in each_block:
+                            headers.update(each_block["headers"])
+                        mcp_response = requests.post(  
+                            url=url,
+                            headers=headers,
+                            json=json_update_data
+                        )
+                        added_rows += 1
+        pass
+    print("\n3. MCP Server (als) Response:\n", mcp_response.text)
+    if added_rows > 0:
+        print(f"...Added {added_rows} rows to the database; last row (only) shown above.")
+    return mcp_response 
+
+
+if __name__ == "__main__":
+    import sys
+
+    schema_text = discover_mcp_servers()                # see: 1-discovery-from-als
+
+    query = get_user_nl_query()
+
+    tool_context = query_llm_with_nl(query)             # see: 2-tool-context-from-LLM   
+
+    mcp_response = process_tool_context(tool_context)   # see: 3-MCP-server response
+
+    print("\nTest complete.\n")

apilogicserver-14.5.3/api_logic_server_cli/api_logic_server_info.yaml

@@ -1,3 +0,0 @@
-last_created_date: May 18, 2025 16:45:45
-last_created_project_name: ../../../servers/basic_demo
-last_created_version: 14.05.02