ApiLogicServer 14.3.25__py3-none-any.whl → 14.5.0__py3-none-any.whl

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/1_langchain_loader.py

@@ -0,0 +1,71 @@
+"""
+==========================================================================================
+ LangChain OpenAPI Loader – JSON:API Planner Tool (1_langchain_loader.py)
+==========================================================================================
+
+Alert:
+------
+This does not work - hours of import version madness.
+
+
+Purpose:
+--------
+This script loads an OpenAPI 3.0 specification (e.g., nw_swagger_3.yaml) using LangChain's
+OpenAPI tools to dynamically generate a structured LangChain Tool. It can be used as a 
+building block in an AI system that automatically interprets natural language goals and 
+calls API endpoints by mapping them to OpenAPI operations.
+
+How It's Used:
+--------------
+- Reads the OpenAPI schema and extracts available endpoints.
+- Instantiates a tool for a specific operation (e.g., getCustomer).
+- Allows GPT agents or scripts to call the tool using structured input.
+- Typically used in multi-agent or planner + executor systems (e.g., AutoGen, LangGraph).
+- It is *not* required to run integration/mcp/3_executor_test_agent.py 
+
+Limitations:
+------------
+- This script does not itself parse natural language input.
+- The operation_id must be known and match one in the OpenAPI spec.
+- Requires LangChain and OpenAPI tool support installed.
+
+Dependencies:
+-------------
+- langchain
+- openapi-spec-validator
+
+Recommended Next Step:
+----------------------
+Use this in conjunction with a GPT planner that:
+1. Converts natural language into structured intent.
+2. Selects the correct operation_id.
+3. Provides parameters as expected by the OpenAPI operation.
+
+"""
+
+from langchain.tools.openapi.utils.openapi_utils import OpenAPISpec
+from langchain.tools.openapi.tool import OpenAPITool
+
+# Load your OpenAPI spec
+spec = OpenAPISpec.from_file("resources/nw_swagger_3.yaml")
+spec = OpenAPISpec.from_file("resources/nw_swagger_2.yaml")
+
+# List available operation IDs (optional debugging)
+print("Available operation IDs:")
+for path, methods in spec.raw_spec["paths"].items():
+    for method, details in methods.items():
+        print(f"- {details.get('operationId')}")
+        
+# Create LangChain tool from a specific endpoint
+customer_tool = OpenAPITool.from_openapi_spec(
+    spec=spec,
+    operation_id="getCustomer",  # use actual operationId from your spec
+    verbose=True
+)
+
+# Run a test call
+result = customer_tool.run({
+    "filter[Country]": "USA",
+    "page[limit]": 3
+})
+print(result)

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/2_gpt_mcp_prompt.txt

@@ -0,0 +1,19 @@
+You are an AI planner that builds tool_context blocks for a JSON:API server using OpenAPI 3.0.
+
+Use this OpenAPI file: [insert contents of nw_swagger_3.yaml]
+
+Given the goal: "List all customers from Germany, limited to 2 results", generate a JSON MCP tool_context like this:
+
+{
+  "tool": "json-api",
+  "method": "GET",
+  "url": "https://your-api-domain.com/Customer",
+  "query_params": {
+    "filter[Country]": "Germany",
+    "page[limit]": 2
+  },
+  "headers": {
+    "Accept": "application/vnd.api+json"
+  },
+  "expected_output": "List of customer records"
+}

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/README_mcp.md

@@ -0,0 +1,13 @@
+Model Context Protocol is a way for:
+
+1. **Bus User ad hoc flows** using existing published mcp services (vs. hard-coding in IT as an endpoint; flows can be cached for repeated use)
+
+    * ***Natural Language access*** to corporate databases for improved user interfaces
+
+    * LLMs ***choreograph*** multiple MCP calls (to 1 or more MCP servers) in a chain of calls - an agentic workflow. MCPs support shared contexts and goals, enabling the LLM to use the result from 1 call to determine whether the goals has been reached, or which service is appropriate to call next
+
+3. Chat agents to ***discover*** and ***call*** external servers, be they databases, APIs, file systems, etc. MCPs support shared contexts and goals, enabling the LLM
+
+    * ***Corporate database participation*** in such flows, by making key functions available as MCP calls.
+
+This example is [explained here](https://apilogicserver.github.io/Docs/Integration-MCP/).

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/mcp_client_executor.py

@@ -0,0 +1,295 @@
+""" 
+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
+
+ToDo - email example is incomplete:
+1. Add email event handler (ala nw_sample/logic/declare_logic.py#send_n8n_message())
+2. And, respect the customer email_opt_out
+3. Needs to use date range
+4. Data incomplete
+
+"""
+
+import json
+import os
+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. """
+
+    global test_type
+        # this doesn't work -- missing commands for mcp_server_executor....
+    default_request = "List the orders created more than 30 days ago, and post an email message to the order's customer offering a discount"
+
+    default_request = "List the orders created more than 30 days ago, and send a discount email to the customer for each one."
+    # date range?  curl -X GET "http://localhost:5656/api/Order?filter=[{\’name\'}: {\’CreatedOn\’}, {\’op\’}: {\’gt\’}, {\’val\’}: {\’2022-05-14\’}]”
+
+    default_request = "List the orders for customer 5, and send a discount email to the customer for each one."
+
+    if test_type != 'orchestration':
+        default_request = "List customers with credit over 1000"
+
+    query = sys.argv[1] if len(sys.argv) > 1 else default_request
+
+    query += """
+Respond with a JSON array of tool context blocks using:
+- tool: 'json-api'
+- JSON:API-compliant filtering (e.g., filter[CreatedOn][lt])
+- Use {{ order.customer_id }} as a placeholder in the second step.
+- Include method, url, query_params or body, headers, expected_output.
+"""
+    return query
+
+
+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": "json-api",
+                    "method": "GET",
+                    "url": "http://localhost:5656/api/Order",
+                    "query_params": {
+                        "filter[customer_id]": 5
+                    },
+                    "headers": {
+                        "Content-Type": "application/vnd.api+json"
+                    },
+                    "expected_output": "JSON array of orders for customer 5"
+                },
+                {
+                    "tool": "email",
+                    "method": "POST",
+                    "url": "http://localhost:5656/api/Email",
+                    "body": {
+                        "to": "{{ order.customer_id }}",
+                        "subject": "Discount Offer",
+                        "message": "Dear Customer, We are offering a discount on your recent orders. Please check your account for more details."
+                    },
+                    "headers": {
+                        "Content-Type": "application/json"
+                    },
+                    "expected_output": "Email sent confirmation"
+                }
+            ]
+    else:                                   # simple get request - list customers with credit over 4000 
+        tool_context = \
+            [
+                {
+                    "tool": "json-api",
+                    "method": "GET",
+                    "url": "http://localhost:5656/api/Customer",
+                    "query_params": {
+                        "filter[credit_limit][gt]": 1000
+                    },
+                    "headers": {
+                        "Content-Type": "application/vnd.api+json"
+                    },
+                    "expected_output": "JSON array of customers with credit limit over 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
+      try:
+          tool_context = json.loads(tool_context_str)
+      except json.JSONDecodeError:
+          print("Failed to decode JSON from response:", tool_context_str)
+          return None
+
+    print("\n2. 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
+        
+        query_params might be:
+            "query_params": {
+                "filter[credit_limit][gt]": 1000 }
+        or:
+            "query_params": {
+                "filter[customer_id]": 5},
+
+        """
+        query_param_filter = ''
+        if isinstance(query_params, dict):
+            for each_key, each_value in query_params.items():
+                if isinstance(each_value, dict):
+                    for sub_key, sub_value in each_value.items():
+                        query_param_filter += f"&{each_key}[{sub_key}]={sub_value}"
+                else:
+                    query_param_filter += f"&{each_key}={each_value}"
+            # query_params = ''
+        elif isinstance(query_params, dict):
+            assert False, "Query Params dict tbd"
+        return query_param_filter
+
+
+    if isinstance(tool_context, dict):
+        query_params = tool_context["query_params"]
+        query_param_filter = get_query_param_filter(query_params) 
+        mcp_response = requests.get(
+            tool_context["url"],
+            headers=tool_context["headers"],
+            params=query_param_filter
+        )
+    elif isinstance(tool_context, list):
+        context_data = {}
+        added_rows = 0
+
+        for each_block in tool_context:
+            if each_block["tool"] in ["json-api", "email"]:
+                if each_block["method"] == "GET":
+                        query_param_filter = get_query_param_filter(each_block["query_params"])
+                        mcp_response = requests.get(
+                            url = each_block["url"],
+                            headers=each_block["headers"],
+                            params=query_param_filter
+                        )
+                        context_data = mcp_response.json()['data']  # result rows...
+                elif each_block["method"] in ["POST"]:
+                        add_rows = 0
+                        for each_order in context_data:
+                            url = each_block["url"]
+                            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"]
+                            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.'}}}}
+                            mcp_response = requests.post(  
+                                url=url,
+                                headers=each_block["headers"],
+                                json=json_update_data
+                            )
+                            add_rows += 1
+            pass
+    else:
+        print("Invalid tool context format. Expected a dictionary or a list.")
+        return None
+    print("\n3. MCP Server (als) Response:\n", mcp_response.text)
+    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")

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/mcp_schema.txt

@@ -0,0 +1,47 @@
+Customer:
+  - id (INTEGER)
+  - name (VARCHAR)
+  - balance (DECIMAL)
+  - credit_limit (DECIMAL)
+  * Filterable: name, balance, credit_limit
+  * Example: 'List customers with credit over 5000'
+
+Item:
+  - id (INTEGER)
+  - order_id (INTEGER)
+  - product_id (INTEGER)
+  - quantity (INTEGER)
+  - amount (DECIMAL)
+  - unit_price (DECIMAL)
+  * Filterable: order_id, product_id, unit_price
+  * Relationships:
+    ↪ relates to Order
+    ↪ relates to Product
+  * Example: 'Find all items for order 42'
+
+Email:
+  - id (INTEGER)
+  - message (VARCHAR)
+  - customer_id (INTEGER)
+  * Relationships:
+    ↪ relates to Customer
+  * Example: 'Post an message "text" for customer 2 means POST to this resource'
+
+Order:
+  - id (INTEGER)
+  - notes (VARCHAR)
+  - customer_id (INTEGER)
+  - CreatedOn (DATE)
+  - date_shipped (DATE)
+  - amount_total (DECIMAL)
+  * Filterable: notes, customer_id, date_shipped, amount_total
+  * Relationships:
+    ↪ relates to Customer
+  * Example: 'Get orders shipped in 2024'
+
+Product:
+  - id (INTEGER)
+  - name (VARCHAR)
+  - unit_price (DECIMAL)
+  * Filterable: name, unit_price
+  * Example: 'Show products with price over 100'

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/mcp_server_discovery.json

@@ -0,0 +1,9 @@
+{
+  "servers": [
+    {
+      "name": "API Logic Server: basic_demo",
+      "base_url": "http://localhost:5656",
+      "schema_url": "http://localhost:5656/.well-known/mcp.json"
+    }
+  ]
+}

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/multi_mcp_flow/multi_mcp_orchestration.yaml

@@ -0,0 +1,49 @@
+
+description: Flag high-value customers with recent activity and send to marketing service
+
+steps:
+  - id: fetch_2024_orders
+    server: https://erp.company.com
+    tool_context:
+      tool: json-api
+      method: GET
+      url: /Order
+      query_params:
+        filter[date_shipped][gte]: "2024-01-01"
+        filter[date_shipped][lte]: "2024-12-31"
+      headers:
+        Accept: application/vnd.api+json
+      expected_output: Orders shipped in 2024
+
+  - id: aggregate_by_customer
+    type: local_processing
+    input: fetch_2024_orders
+    operation: |
+      Group orders by customer_id and sum amount_total.
+      Return list of customer_ids with total > 10000.
+
+  - id: fetch_customer_details
+    server: https://crm.company.com
+    tool_context:
+      tool: json-api
+      method: GET
+      url: /Customer
+      query_params:
+        filter[id]: "{{ aggregate_by_customer.output.customer_ids }}"
+      headers:
+        Accept: application/vnd.api+json
+      expected_output: High-value customer details
+
+  - id: notify_marketing
+    server: https://marketing.company.com
+    tool_context:
+      tool: json-api
+      method: POST
+      url: /CampaignTrigger
+      body:
+        campaign: "VIP Outreach Q1"
+        customer_ids: "{{ aggregate_by_customer.output.customer_ids }}"
+      headers:
+        Accept: application/vnd.api+json
+        Content-Type: application/json
+      expected_output: Marketing campaign initiated

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/natlang_to_api.py

@@ -0,0 +1,73 @@
+import openai
+import requests
+import json
+import os
+
+# Set your OpenAI API key here or via environment variable
+openai.api_key = os.getenv("OPENAI_API_KEY") or "sk-proj-..."
+
+# The base ngrok URL of your live JSON:API server
+NGROK_BASE_URL = "https://mcp_url.ngrok-free.app"
+
+def ask_gpt_for_tool_context(natural_language_goal):
+    prompt = f"""
+You are an API planning assistant.
+
+You receive a natural language goal and must generate a JSON tool_context for an API call.
+
+The API follows JSON:API 1.1 and lives at: {NGROK_BASE_URL}/api  
+Available resources: Customer, Order, Product
+
+Goal: "{natural_language_goal}"
+
+Respond ONLY with JSON in the following format:
+{{
+  "method": "GET",
+  "url": "<full URL>",
+  "query_params": {{ ... }},
+  "headers": {{
+    "Accept": "application/vnd.api+json"
+  }},
+  "expected_output": "Brief description of expected result"
+}}
+"""
+
+    response = openai.ChatCompletion.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0
+    )
+
+    # Extract tool_context JSON block from the assistant message
+    message = response["choices"][0]["message"]["content"]
+    try:
+        tool_context = json.loads(message)
+        return tool_context
+    except json.JSONDecodeError:
+        print("Failed to parse GPT response as JSON:")
+        print(message)
+        return None
+
+def execute_tool_context(tool_context):
+    try:
+        response = requests.get(
+            tool_context["url"],
+            headers=tool_context["headers"],
+            params=tool_context["query_params"],
+            timeout=10
+        )
+        print(f"✅ Response ({response.status_code}):")
+        print(json.dumps(response.json(), indent=2))
+    except Exception as e:
+        print(f"❌ Request failed: {e}")
+
+if __name__ == "__main__":
+    print("Enter your natural language goal (e.g., 'List 3 customers from Germany'):")
+    goal = input("> ")
+
+    tc = ask_gpt_for_tool_context(goal)
+    if tc:
+        print("GPT tool_context:")
+        print(json.dumps(tc, indent=2))
+        print("Executing API call...")
+        execute_tool_context(tc)

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/resources/curl.txt

@@ -0,0 +1,5 @@
+curl -X 'GET' \
+  'http://localhost:5656/api/Customer/?filter%5BCountry%5D=Germany' \
+  -H 'accept: application/vnd.api+json' \
+  -H 'Content-Type: application/vnd.api+json'
+

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/resources/invoke_llm/1 - prompt_messages_array.json

@@ -0,0 +1,10 @@
+[
+  {
+    "role": "system",
+    "content": "You are a backend planner that translates natural language queries into JSON:API tool context blocks. You are given a resource schema and a user query. Respond only with a JSON block that specifies how to call the JSON:API using filter parameters."
+  },
+  {
+    "role": "user",
+    "content": "Schema:\n\nCustomer:\n  - id (INTEGER)\n  - name (VARCHAR)\n  - balance (DECIMAL)\n  - credit_limit (DECIMAL)\n  * Filterable: name, balance, credit_limit\n  * Example: 'List customers with credit over 5000'\n\nItem:\n  - id (INTEGER)\n  - order_id (INTEGER)\n  - product_id (INTEGER)\n  - quantity (INTEGER)\n  - amount (DECIMAL)\n  - unit_price (DECIMAL)\n  * Filterable: order_id, product_id, unit_price\n  * Relationships:\n    ↪ relates to Order\n    ↪ relates to Product\n  * Example: 'Find all items for order 42'\n\nOrder:\n  - id (INTEGER)\n  - notes (VARCHAR)\n  - customer_id (INTEGER)\n  - date_shipped (DATE)\n  - amount_total (DECIMAL)\n  * Filterable: notes, customer_id, date_shipped, amount_total\n  * Relationships:\n    ↪ relates to Customer\n  * Example: 'Get orders shipped in 2024'\n\nProduct:\n  - id (INTEGER)\n  - name (VARCHAR)\n  - unit_price (DECIMAL)\n  * Filterable: name, unit_price\n  * Example: 'Show products with price over 100'\n\n---\n\nNatural language query: 'List all customers with credit limits over 4000.'\n\nRespond with a JSON object like:\n{\n  \"tool\": \"json-api\",\n  \"method\": \"GET\",\n  \"url\": \"https://your-api-server/Customer\",\n  \"query_params\": { \"filter[credit_limit][gt]\": \"4000\" },\n  \"headers\": { \"Accept\": \"application/vnd.api+json\" },\n  \"expected_output\": \"List of customers with high credit limits\"\n}"
+  }
+]

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/resources/invoke_llm/2 - completion_tool_context.json

@@ -0,0 +1,12 @@
+{
+  "tool": "json-api",
+  "method": "GET",
+  "url": "https://your-api-server/Customer",
+  "query_params": {
+    "filter[credit_limit][gt]": "4000"
+  },
+  "headers": {
+    "Accept": "application/vnd.api+json"
+  },
+  "expected_output": "List of customers with high credit limits"
+}

api_logic_server_cli/prototypes/basic_demo/customizations/integration/mcp/resources/llm_schema.txt

@@ -0,0 +1,38 @@
+Customer:
+  - id (INTEGER)
+  - name (VARCHAR)
+  - balance (DECIMAL)
+  - credit_limit (DECIMAL)
+  * Filterable: name, balance, credit_limit
+  * Example: 'List customers with credit over 5000'
+
+Item:
+  - id (INTEGER)
+  - order_id (INTEGER)
+  - product_id (INTEGER)
+  - quantity (INTEGER)
+  - amount (DECIMAL)
+  - unit_price (DECIMAL)
+  * Filterable: order_id, product_id, unit_price
+  * Relationships:
+    ↪ relates to Order
+    ↪ relates to Product
+  * Example: 'Find all items for order 42'
+
+Order:
+  - id (INTEGER)
+  - notes (VARCHAR)
+  - customer_id (INTEGER)
+  - date_shipped (DATE)
+  - amount_total (DECIMAL)
+  * Filterable: notes, customer_id, date_shipped, amount_total
+  * Relationships:
+    ↪ relates to Customer
+  * Example: 'Get orders shipped in 2024'
+
+Product:
+  - id (INTEGER)
+  - name (VARCHAR)
+  - unit_price (DECIMAL)
+  * Filterable: name, unit_price
+  * Example: 'Show products with price over 100'