v2.0: Dynamic result formatting and natural language customer selection

Major features:
- Added target_customers field to SemanticQueryPlan for natural language database selection
- Updated query understanding agent to extract customer references (customer_a, customer A, etc.)
- Modified orchestrator to use extracted target_customers from query plan
- Fixed result harmonizer to include aggregation columns (count, sum, avg, etc.)
- Implemented dynamic table formatting in app.py that filters null columns
- Customer column now displays as A, B, C instead of customer_a, customer_b
- Removed customer_name and industry_sector concepts from knowledge graph
- Updated all tests to reflect schema changes (156 tests passing)

Key improvements:
- Queries like 'show contracts from customer A' now work naturally
- Count/sum/aggregation queries display correctly with only relevant columns
- No more empty columns with dashes in result tables
- Smart Customer column display (shown when querying multiple databases)
- All query types supported: regular, count, sum, filtered, multi-customer

app.py

@@ -45,44 +45,101 @@ def format_result_table(result, limit: int = 10) -> str:
     first_row = result.results[0]
     all_columns = list(first_row.data.keys())
     
-    # Define preferred field order and nice names
-    field_order = [
-        'contract_identifier',
-        'customer_name', 
-        'contract_name',
-        'industry_sector',
-        'contract_value',
-        'contract_status',
-        'contract_expiration'
-    ]
-    
-    nice_names = {
-        'contract_identifier': 'Contract ID',
-        'contract_name': 'Contract Name',
-        'customer_name': 'Company',  # Changed from Customer to Company
-        'contract_value': 'Value',
-        'contract_status': 'Status',
-        'contract_expiration': 'Expiration',
-        'contract_start': 'Start Date',
-        'industry_sector': 'Industry'
-    }
-    
-    # Order columns: preferred order first, then any remaining
-    columns = []
-    for field in field_order:
-        if field in all_columns:
-            columns.append(field)
-    
-    # Add any remaining columns not in preferred order
+    # Add source database to the data (from customer_id in HarmonizedRow)
+    # Convert customer_a -> A, customer_b -> B, etc. for display
+    for row in result.results:
+        if 'source_db' not in row.data:
+            # Extract letter from customer_id (customer_a -> A)
+            customer_letter = row.customer_id.replace('customer_', '').upper()
+            row.data['source_db'] = customer_letter
+    
+    # Add source_db to all_columns if not already there
+    if 'source_db' not in all_columns:
+        all_columns.insert(0, 'source_db')
+    
+    # Filter to only columns that have non-null values in at least one row
+    columns_with_values = set()
     for col in all_columns:
-        if col not in columns:
-            columns.append(col)
+        if any(row.data.get(col) is not None for row in result.results):
+            columns_with_values.add(col)
+    
+    # Check if multiple customers are being queried
+    multiple_customers = len(result.customers_queried) > 1
+    
+    # Always include source_db if querying multiple customers
+    if multiple_customers and 'source_db' not in columns_with_values:
+        columns_with_values.add('source_db')
+    
+    # Check if this is an aggregation/count query (no contract_identifier or all null)
+    is_aggregation = 'contract_identifier' not in columns_with_values
+    
+    if is_aggregation:
+        # For aggregations, show source_db first, then all other non-null columns
+        columns = []
+        if 'source_db' in columns_with_values:
+            columns.append('source_db')
+        for col in columns_with_values:
+            if col != 'source_db':
+                columns.append(col)
+        
+        # Nice names for aggregation fields
+        nice_names = {
+            'source_db': 'Customer',
+            'count_contract_identifier': 'Count',
+            'sum_contract_value': 'Total Value',
+            'avg_contract_value': 'Avg Value',
+            'max_contract_value': 'Max Value',
+            'min_contract_value': 'Min Value',
+            'count': 'Count',
+            'sum': 'Sum',
+            'average': 'Average',
+            'max': 'Max',
+            'min': 'Min'
+        }
+    else:
+        # For regular queries, use preferred field order (only for columns with values)
+        field_order = [
+            'source_db',  # Show which customer (A, B, C, etc.)
+            'contract_identifier',  # Contract ID
+            'contract_value',
+            'contract_status',
+            'contract_expiration',
+            'contract_start'
+        ]
+        
+        nice_names = {
+            'source_db': 'Customer',  # Which database (A, B, C, D, E, F)
+            'contract_identifier': 'Contract ID',
+            'contract_value': 'Value',
+            'contract_status': 'Status',
+            'contract_expiration': 'Expiration',
+            'contract_start': 'Start Date'
+        }
+        
+        # Order columns: preferred order first (only include if they have values)
+        columns = []
+        for field in field_order:
+            if field in columns_with_values:
+                columns.append(field)
+        
+        # Add any remaining columns not in preferred order (that have values)
+        for col in columns_with_values:
+            if col not in columns:
+                columns.append(col)
     
     # Build markdown table with better formatting
     lines = []
     
     # Header with nicer column names
-    display_cols = [nice_names.get(col, col) for col in columns]
+    display_cols = []
+    for col in columns:
+        # Get nice name or convert snake_case to Title Case
+        if col in nice_names:
+            display_cols.append(nice_names[col])
+        else:
+            # Convert snake_case to Title Case
+            display_cols.append(col.replace('_', ' ').title())
+    
     header = "| " + " | ".join(display_cols) + " |"
     separator = "|" + "|".join(["---" for _ in columns]) + "|"
     lines.append(header)
@@ -97,9 +154,17 @@ def format_result_table(result, limit: int = 10) -> str:
             # Format values for better display
             if val is None or val == "None":
                 val = "—"
-            elif isinstance(val, (int, float)) and col == 'contract_value':
-                # Format currency values
-                val = f"${val:,.0f}"
+            elif isinstance(val, (int, float)):
+                # Format numbers based on column type
+                if 'value' in col.lower() or 'sum' in col.lower():
+                    # Format currency values
+                    val = f"${val:,.0f}"
+                elif 'avg' in col.lower() or 'average' in col.lower():
+                    # Format averages with 2 decimals
+                    val = f"${val:,.2f}" if 'value' in col.lower() else f"{val:,.2f}"
+                else:
+                    # Format counts and other integers
+                    val = f"{val:,}"
             else:
                 val = str(val)
             values.append(val)
@@ -206,11 +271,15 @@ Welcome! I'm running in **{mode}**.
 I can help you query customer databases using natural language. Just ask me questions like:
 - "Show me all contracts"
 - "Find active contracts with value over 10000"
+- "Show contracts from customer A" or "from customer_a"
+- "List contracts in customer B and C"
 - "Count contracts by status"
-- "List all customers"
+
+**Note:** Results show Customer column (A, B, C, etc.) indicating which database each contract is from.
 
 ### Available Commands:
-- `/customers` - List available customers
+- `/customers` - List available databases (customer_a through customer_f)
+- `/select <customer_id>` - Query specific database (e.g., `/select customer_a`)
 - `/limit <number>` - Set max rows to display (default: 10)
 - `/debug on/off` - Toggle debug mode
 - `/stats` - Show query statistics
@@ -282,18 +351,32 @@ async def main(message: cl.Message):
             # Show available fields
             if result.results:
                 fields = list(result.results[0].data.keys())
+                # Filter out None values to get actual fields returned
+                actual_fields = [f for f in fields if any(
+                    row.data.get(f) is not None for row in result.results
+                )]
+                
                 field_names = {
+                    'source_db': 'Customer',
                     'contract_identifier': 'Contract ID',
-                    'contract_name': 'Contract Name',
-                    'customer_name': 'Company',  # Changed from Customer to Company
                     'contract_value': 'Value',
                     'contract_status': 'Status',
                     'contract_expiration': 'Expiration Date',
                     'contract_start': 'Start Date',
-                    'industry_sector': 'Industry'
+                    'count_contract_identifier': 'Count',
+                    'sum_contract_value': 'Total Value',
+                    'avg_contract_value': 'Avg Value',
+                    'max_contract_value': 'Max Value',
+                    'min_contract_value': 'Min Value'
                 }
-                field_list = ', '.join([f"`{field_names.get(f, f)}`" for f in fields])
-                content_parts.append(f"**Showing {len(fields)} fields:** {field_list}\n")
+                
+                field_display = []
+                for f in actual_fields:
+                    nice_name = field_names.get(f, f.replace('_', ' ').title())
+                    field_display.append(f"`{nice_name}`")
+                
+                field_list = ', '.join(field_display)
+                content_parts.append(f"**Showing {len(actual_fields)} fields:** {field_list}\n")
             
             # Results table
             content_parts.append("### ✅ Query Results")
@@ -408,14 +491,21 @@ async def handle_command(command: str, orchestrator: ChatOrchestrator, debug_mod
 **Example Queries:**
 - "Show me all contracts"
 - "Find active contracts"
+- "Show contracts from customer A" or "from customer_a"
+- "Query customer B and customer C databases"
 - "Count contracts by status"
 - "List contracts with value over 10000"
-- "Show contracts expiring soon"
+- "Show active contracts in customer_a expiring in 2026"
+
+**Important Notes:**
+- You can query specific customers by saying "customer A", "customer_a", "from customer B", etc.
+- Without specifying, queries run across all available databases
+- **Customer** column in results shows which database (A, B, C, etc.) each contract came from
 
 **Commands:**
-- `/customers` - List available customers
-- `/select <customer_id>` - Query specific customer(s)
-- `/select all` - Query all customers (default)
+- `/customers` - List available databases (customer_a through customer_f)
+- `/select <customer_id>` - Query specific database (e.g., `/select customer_a`)
+- `/select all` - Query all databases (default)
 - `/limit <number>` - Set max rows to display (default: 10)
 - `/debug on/off` - Toggle debug mode
 - `/stats` - Show query statistics
@@ -425,8 +515,8 @@ async def handle_command(command: str, orchestrator: ChatOrchestrator, debug_mod
 **Tips:**
 - Use natural language - I'll understand it!
 - Be specific about what you want to see
-- Use filters like "active", "over 1000", "expiring soon"
-- Enable debug mode to see SQL queries
+- Use filters like "active", "over 10000", "expiring in 90 days"
+- Enable debug mode to see SQL queries and semantic plans
 """
         await cl.Message(content=help_msg).send()
     

initialize_kg.py

@@ -280,137 +280,13 @@ def initialize_knowledge_graph() -> SchemaKnowledgeGraph:
     )
     
     # ========================================================================
-    # 5. INDUSTRY SECTOR
+    # 5. CONTRACT START
     # ========================================================================
-    print("  Adding concept: industry_sector")
-    kg.add_concept(
-        concept_id="industry_sector",
-        concept_name="Industry Sector",
-        description="Business industry or vertical of the customer",
-        aliases=["industry", "sector", "vertical", "business_sector"]
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="industry_sector",
-        customer_id="customer_a",
-        table_name="contracts",
-        column_name="industry",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="industry_sector",
-        customer_id="customer_b",
-        table_name="contract_headers",
-        column_name="sector",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="industry_sector",
-        customer_id="customer_c",
-        table_name="contracts",
-        column_name="business_sector",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="industry_sector",
-        customer_id="customer_d",
-        table_name="contracts",
-        column_name="industry",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="industry_sector",
-        customer_id="customer_e",
-        table_name="contracts",
-        column_name="industry",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="industry_sector",
-        customer_id="customer_f",
-        table_name="contracts",
-        column_name="sector",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    # ========================================================================
-    # 6. CUSTOMER NAME
-    # ========================================================================
-    print("  Adding concept: customer_name")
-    kg.add_concept(
-        concept_id="customer_name",
-        concept_name="Customer Name",
-        description="Name of the customer/client organization",
-        aliases=["client", "account", "organization", "client_name"]
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="customer_name",
-        customer_id="customer_a",
-        table_name="contracts",
-        column_name="customer_name",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="customer_name",
-        customer_id="customer_b",
-        table_name="contract_headers",
-        column_name="client_name",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="customer_name",
-        customer_id="customer_c",
-        table_name="contracts",
-        column_name="account",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="customer_name",
-        customer_id="customer_d",
-        table_name="contracts",
-        column_name="customer_org",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="customer_name",
-        customer_id="customer_e",
-        table_name="contracts",
-        column_name="customer_name",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    kg.add_customer_mapping(
-        concept_id="customer_name",
-        customer_id="customer_f",
-        table_name="contracts",
-        column_name="account",
-        data_type="TEXT",
-        semantic_type=SemanticType.TEXT
-    )
-    
-    # ========================================================================
-    # 7. CONTRACT START
+    # NOTE: industry_sector and customer_name concepts were removed.
+    # - customer_name: Refers to company names in contracts (e.g., "Global Tech Inc")
+    #   which conflicts with database selection (customer_a, customer_b, etc.)
+    # - industry_sector: Internal attribute that doesn't represent typical
+    #   business queries users would make.
     # ========================================================================
     print("  Adding concept: contract_start")
     kg.add_concept(

knowledge_graph.json

@@ -271,140 +271,6 @@
         }
       }
     },
-    "industry_sector": {
-      "concept_id": "industry_sector",
-      "concept_name": "Industry Sector",
-      "description": "Business industry or vertical of the customer",
-      "aliases": [
-        "industry",
-        "sector",
-        "vertical",
-        "business_sector"
-      ],
-      "customer_mappings": {
-        "customer_a": {
-          "customer_id": "customer_a",
-          "table_name": "contracts",
-          "column_name": "industry",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_b": {
-          "customer_id": "customer_b",
-          "table_name": "contract_headers",
-          "column_name": "sector",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_c": {
-          "customer_id": "customer_c",
-          "table_name": "contracts",
-          "column_name": "business_sector",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_d": {
-          "customer_id": "customer_d",
-          "table_name": "contracts",
-          "column_name": "industry",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_e": {
-          "customer_id": "customer_e",
-          "table_name": "contracts",
-          "column_name": "industry",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_f": {
-          "customer_id": "customer_f",
-          "table_name": "contracts",
-          "column_name": "sector",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        }
-      }
-    },
-    "customer_name": {
-      "concept_id": "customer_name",
-      "concept_name": "Customer Name",
-      "description": "Name of the customer/client organization",
-      "aliases": [
-        "client",
-        "account",
-        "organization",
-        "client_name"
-      ],
-      "customer_mappings": {
-        "customer_a": {
-          "customer_id": "customer_a",
-          "table_name": "contracts",
-          "column_name": "customer_name",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_b": {
-          "customer_id": "customer_b",
-          "table_name": "contract_headers",
-          "column_name": "client_name",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_c": {
-          "customer_id": "customer_c",
-          "table_name": "contracts",
-          "column_name": "account",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_d": {
-          "customer_id": "customer_d",
-          "table_name": "contracts",
-          "column_name": "customer_org",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_e": {
-          "customer_id": "customer_e",
-          "table_name": "contracts",
-          "column_name": "customer_name",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_f": {
-          "customer_id": "customer_f",
-          "table_name": "contracts",
-          "column_name": "account",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        }
-      }
-    },
     "contract_start": {
       "concept_id": "contract_start",
       "concept_name": "Contract Start Date",
@@ -471,73 +337,6 @@
           "join_requirements": []
         }
       }
-    },
-    "contract_name": {
-      "concept_id": "contract_name",
-      "concept_name": "Contract Name",
-      "description": "The name or title of the contract",
-      "aliases": [
-        "name",
-        "title",
-        "contract title",
-        "agreement name"
-      ],
-      "customer_mappings": {
-        "customer_a": {
-          "customer_id": "customer_a",
-          "table_name": "contracts",
-          "column_name": "contract_name",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_b": {
-          "customer_id": "customer_b",
-          "table_name": "contract_headers",
-          "column_name": "name",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_c": {
-          "customer_id": "customer_c",
-          "table_name": "contracts",
-          "column_name": "name",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_d": {
-          "customer_id": "customer_d",
-          "table_name": "contracts",
-          "column_name": "name",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_e": {
-          "customer_id": "customer_e",
-          "table_name": "contracts",
-          "column_name": "contract_title",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        },
-        "customer_f": {
-          "customer_id": "customer_f",
-          "table_name": "contracts",
-          "column_name": "agreement_name",
-          "data_type": "TEXT",
-          "semantic_type": "text",
-          "transformation": null,
-          "join_requirements": []
-        }
-      }
     }
   },
   "transformations": {

schema_translator/agents/query_understanding.py

@@ -43,6 +43,18 @@ class QueryUnderstandingAgent:
 Available Semantic Concepts:
 {concept_list}
 
+CRITICAL RULE - Database Selection:
+When users mention "customer" or database references, extract them into target_customers field:
+- "customer_a", "customer_b", "customer_c", "customer_d", "customer_e", "customer_f"
+- "customer A", "customer B", "database A", "from customer_a", "customer a database"
+- Any reference to which specific database(s) to query
+
+DO NOT create semantic filters for these - use the target_customers field instead.
+Examples:
+- "Show contracts from customer_a" → target_customers: ["customer_a"]
+- "Query customer A and B" → target_customers: ["customer_a", "customer_b"]  
+- "Show all contracts" → target_customers: null (means query all)
+
 Your task is to:
 1. Identify the user's query intent (find_contracts, count_contracts, aggregate_values)
 2. Determine which semantic concepts are relevant
@@ -88,7 +100,8 @@ Return ONLY valid JSON matching this schema:
         "function": "count" | "sum" | "average",
         "concept": "concept_name"
     }}],  // optional, for aggregate_values intent
-    "limit": 10  // optional, for find_contracts intent
+    "limit": 10,  // optional, for find_contracts intent
+    "target_customers": ["customer_a", "customer_b"]  // optional, null or omit for all customers
 }}
 
 IMPORTANT: 
@@ -110,7 +123,8 @@ Result:
     "intent": "find_contracts",
     "filters": [],
     "projections": [],  // Empty projections means return ALL available fields
-    "limit": 100
+    "limit": 100,
+    "target_customers": null  // null means query all customers
 }}
 
 Query: "Show me all active contracts"
@@ -125,7 +139,18 @@ Result:
         }}
     ],
     "projections": [],  // Empty projections means return ALL available fields
-    "limit": 100
+    "limit": 100,
+    "target_customers": null
+}}
+
+Query: "Show contracts from customer_a" or "Query customer A database"
+Result:
+{{
+    "intent": "find_contracts",
+    "filters": [],
+    "projections": [],
+    "limit": 100,
+    "target_customers": ["customer_a"]  // Extract database reference
 }}
 
 Query: "How many contracts expire in the next 90 days?"
@@ -156,26 +181,21 @@ Result:
             "value": 2000000
         }}
     ],
-    "projections": ["contract_identifier", "contract_value", "customer_name"]
+    "projections": ["contract_identifier", "contract_value", "contract_status"]
 }}
 
-Query: "List technology contracts expiring in 2026"
+Query: "List contracts expiring in 2026"
 Result:
 {{
     "intent": "find_contracts",
     "filters": [
-        {{
-            "concept": "industry_sector",
-            "operator": "equals",
-            "value": "Technology"
-        }},
         {{
             "concept": "contract_expiration",
             "operator": "between",
             "value": ["2026-01-01", "2026-12-31"]
         }}
     ],
-    "projections": ["contract_identifier", "industry_sector", "contract_expiration"],
+    "projections": ["contract_identifier", "contract_expiration", "contract_value"],
     "limit": 50
 }}
 

schema_translator/mock_data.py

@@ -108,22 +108,18 @@ class MockDataGenerator:
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
         
-        # Create table
+        # Create table (removed customer_name and industry - not in knowledge graph)
         cursor.execute("""
             CREATE TABLE IF NOT EXISTS contracts (
                 contract_id INTEGER PRIMARY KEY,
-                contract_name TEXT NOT NULL,
-                customer_name TEXT NOT NULL,
                 contract_value INTEGER NOT NULL,
                 status TEXT NOT NULL,
                 expiry_date TEXT NOT NULL,
-                start_date TEXT NOT NULL,
-                industry TEXT NOT NULL
+                start_date TEXT NOT NULL
             )
         """)
         
         # Generate data
-        industries = self.INDUSTRIES["customer_a"]
         for i in range(1, 51):
             start_date, expiry_date = self.generate_dates()
             
@@ -135,18 +131,14 @@ class MockDataGenerator:
             
             cursor.execute("""
                 INSERT INTO contracts 
-                (contract_id, contract_name, customer_name, contract_value, status, 
-                 expiry_date, start_date, industry)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                (contract_id, contract_value, status, expiry_date, start_date)
+                VALUES (?, ?, ?, ?, ?)
             """, (
                 i,
-                self.generate_contract_name(i),
-                self.generate_company_name(),
                 self.generate_contract_value(is_annual=False),
                 status,
                 expiry_date.strftime("%Y-%m-%d"),
-                start_date.strftime("%Y-%m-%d"),
-                random.choice(industries)
+                start_date.strftime("%Y-%m-%d")
             ))
         
         conn.commit()
@@ -159,15 +151,12 @@ class MockDataGenerator:
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
         
-        # Create tables
+        # Create tables (removed client_name and sector)
         cursor.execute("""
             CREATE TABLE IF NOT EXISTS contract_headers (
                 id INTEGER PRIMARY KEY,
-                contract_name TEXT NOT NULL,
-                client_name TEXT NOT NULL,
                 contract_value INTEGER NOT NULL,
-                start_date TEXT NOT NULL,
-                sector TEXT NOT NULL
+                start_date TEXT NOT NULL
             )
         """)
         
@@ -191,22 +180,18 @@ class MockDataGenerator:
         """)
         
         # Generate data
-        industries = self.INDUSTRIES["customer_b"]
         for i in range(1, 51):
             start_date, expiry_date = self.generate_dates()
             
             # Insert header
             cursor.execute("""
                 INSERT INTO contract_headers 
-                (id, contract_name, client_name, contract_value, start_date, sector)
-                VALUES (?, ?, ?, ?, ?, ?)
+                (id, contract_value, start_date)
+                VALUES (?, ?, ?)
             """, (
                 i,
-                self.generate_contract_name(i),
-                self.generate_company_name(),
                 self.generate_contract_value(is_annual=False),
-                start_date.strftime("%Y-%m-%d"),
-                random.choice(industries)
+                start_date.strftime("%Y-%m-%d")
             ))
             
             # Insert status history (1-3 status changes)
@@ -244,22 +229,18 @@ class MockDataGenerator:
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
         
-        # Create table with different column names
+        # Create table with different column names (removed account and business_sector)
         cursor.execute("""
             CREATE TABLE IF NOT EXISTS contracts (
                 id INTEGER PRIMARY KEY,
-                name TEXT NOT NULL,
-                account TEXT NOT NULL,
                 total_value INTEGER NOT NULL,
                 current_status TEXT NOT NULL,
                 expiration_date TEXT NOT NULL,
-                inception_date TEXT NOT NULL,
-                business_sector TEXT NOT NULL
+                inception_date TEXT NOT NULL
             )
         """)
         
         # Generate data
-        industries = self.INDUSTRIES["customer_c"]
         for i in range(1, 51):
             start_date, expiry_date = self.generate_dates()
             
@@ -270,18 +251,14 @@ class MockDataGenerator:
             
             cursor.execute("""
                 INSERT INTO contracts 
-                (id, name, account, total_value, current_status, 
-                 expiration_date, inception_date, business_sector)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                (id, total_value, current_status, expiration_date, inception_date)
+                VALUES (?, ?, ?, ?, ?)
             """, (
                 i,
-                self.generate_contract_name(i),
-                self.generate_company_name(),
                 self.generate_contract_value(is_annual=False),
                 status,
                 expiry_date.strftime("%Y-%m-%d"),
-                start_date.strftime("%Y-%m-%d"),
-                random.choice(industries)
+                start_date.strftime("%Y-%m-%d")
             ))
         
         conn.commit()
@@ -294,22 +271,18 @@ class MockDataGenerator:
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
         
-        # Create table with days_remaining instead of date
+        # Create table with days_remaining instead of date (removed customer_org and industry)
         cursor.execute("""
             CREATE TABLE IF NOT EXISTS contracts (
                 contract_id INTEGER PRIMARY KEY,
-                contract_title TEXT NOT NULL,
-                customer_org TEXT NOT NULL,
                 contract_value INTEGER NOT NULL,
                 status TEXT NOT NULL,
                 days_remaining INTEGER NOT NULL,
-                start_date TEXT NOT NULL,
-                industry TEXT NOT NULL
+                start_date TEXT NOT NULL
             )
         """)
         
         # Generate data
-        industries = self.INDUSTRIES["customer_d"]
         for i in range(1, 51):
             start_date, expiry_date = self.generate_dates()
             
@@ -323,18 +296,14 @@ class MockDataGenerator:
             
             cursor.execute("""
                 INSERT INTO contracts 
-                (contract_id, contract_title, customer_org, contract_value, status, 
-                 days_remaining, start_date, industry)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                (contract_id, contract_value, status, days_remaining, start_date)
+                VALUES (?, ?, ?, ?, ?)
             """, (
                 i,
-                self.generate_contract_name(i),
-                self.generate_company_name(),
                 self.generate_contract_value(is_annual=False),
                 status,
                 days_remaining,
-                start_date.strftime("%Y-%m-%d"),
-                random.choice(industries)
+                start_date.strftime("%Y-%m-%d")
             ))
         
         conn.commit()
@@ -347,23 +316,19 @@ class MockDataGenerator:
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
         
-        # Create table
+        # Create table (removed customer_name and industry)
         cursor.execute("""
             CREATE TABLE IF NOT EXISTS contracts (
                 contract_id INTEGER PRIMARY KEY,
-                contract_name TEXT NOT NULL,
-                customer_name TEXT NOT NULL,
                 contract_value INTEGER NOT NULL,
                 term_years REAL NOT NULL,
                 status TEXT NOT NULL,
                 expiry_date TEXT NOT NULL,
-                start_date TEXT NOT NULL,
-                industry TEXT NOT NULL
+                start_date TEXT NOT NULL
             )
         """)
         
         # Generate data
-        industries = self.INDUSTRIES["customer_e"]
         for i in range(1, 51):
             start_date, expiry_date = self.generate_dates()
             
@@ -378,19 +343,15 @@ class MockDataGenerator:
             
             cursor.execute("""
                 INSERT INTO contracts 
-                (contract_id, contract_name, customer_name, contract_value, term_years,
-                 status, expiry_date, start_date, industry)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                (contract_id, contract_value, term_years, status, expiry_date, start_date)
+                VALUES (?, ?, ?, ?, ?, ?)
             """, (
                 i,
-                self.generate_contract_name(i),
-                self.generate_company_name(),
                 self.generate_contract_value(is_annual=False),
                 term_years,
                 status,
                 expiry_date.strftime("%Y-%m-%d"),
-                start_date.strftime("%Y-%m-%d"),
-                random.choice(industries)
+                start_date.strftime("%Y-%m-%d")
             ))
         
         conn.commit()
@@ -403,23 +364,19 @@ class MockDataGenerator:
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
         
-        # Create table
+        # Create table (removed account and sector)
         cursor.execute("""
             CREATE TABLE IF NOT EXISTS contracts (
                 contract_id INTEGER PRIMARY KEY,
-                name TEXT NOT NULL,
-                account TEXT NOT NULL,
                 contract_value INTEGER NOT NULL,
                 term_years REAL NOT NULL,
                 status TEXT NOT NULL,
                 expiration_date TEXT NOT NULL,
-                start_date TEXT NOT NULL,
-                sector TEXT NOT NULL
+                start_date TEXT NOT NULL
             )
         """)
         
         # Generate data
-        industries = self.INDUSTRIES["customer_f"]
         for i in range(1, 51):
             start_date, expiry_date = self.generate_dates()
             
@@ -434,19 +391,15 @@ class MockDataGenerator:
             
             cursor.execute("""
                 INSERT INTO contracts 
-                (contract_id, name, account, contract_value, term_years,
-                 status, expiration_date, start_date, sector)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                (contract_id, contract_value, term_years, status, expiration_date, start_date)
+                VALUES (?, ?, ?, ?, ?, ?)
             """, (
                 i,
-                self.generate_contract_name(i),
-                self.generate_company_name(),
                 self.generate_contract_value(is_annual=True),  # ANNUAL value
                 term_years,
                 status,
                 expiry_date.strftime("%Y-%m-%d"),
-                start_date.strftime("%Y-%m-%d"),
-                random.choice(industries)
+                start_date.strftime("%Y-%m-%d")
             ))
         
         conn.commit()

schema_translator/models.py

@@ -90,8 +90,8 @@ class SchemaTable(BaseModel):
 
 class CustomerSchema(BaseModel):
     """Represents the complete schema for a customer database."""
-    customer_id: str = Field(..., description="Unique customer identifier")
-    customer_name: str = Field(..., description="Customer display name")
+    customer_id: str = Field(..., description="Unique customer identifier (e.g., customer_a)")
+    customer_name: Optional[str] = Field(None, description="Optional customer display name")
     tables: List[SchemaTable] = Field(..., description="Tables in this schema")
     semantic_notes: Dict[str, str] = Field(
         default_factory=dict,
@@ -170,6 +170,10 @@ class SemanticQueryPlan(BaseModel):
         description="Ordering (concept, direction) pairs"
     )
     limit: Optional[int] = Field(None, description="Maximum number of results")
+    target_customers: Optional[List[str]] = Field(
+        None, 
+        description="Specific customer databases to query (e.g., ['customer_a', 'customer_b']). None means all customers."
+    )
     
     model_config = {"use_enum_values": True}
 

schema_translator/orchestrator.py

@@ -122,14 +122,21 @@ class ChatOrchestrator:
             if debug:
                 logger.info(f"Semantic plan: {semantic_plan}")
             
-            # Step 3: Execute query across customers
-            logger.info(f"Executing query across {len(customer_ids) if customer_ids else 'all'} customers...")
+            # Step 3: Determine which customers to query
+            # Priority: explicit customer_ids parameter > target_customers from query > all customers
+            target_customers = customer_ids
+            if target_customers is None and semantic_plan.target_customers:
+                target_customers = semantic_plan.target_customers
+                logger.info(f"Extracted target customers from query: {target_customers}")
+            
+            # Step 4: Execute query across customers
+            logger.info(f"Executing query across {len(target_customers) if target_customers else 'all'} customers...")
             result = self.result_harmonizer.execute_across_customers(
                 semantic_plan,
-                customer_ids=customer_ids
+                customer_ids=target_customers
             )
             
-            # Step 4: Calculate total execution time
+            # Step 5: Calculate total execution time
             total_time_ms = (time.time() - start_time) * 1000
             
             logger.info(
@@ -138,7 +145,7 @@ class ChatOrchestrator:
                 f"{total_time_ms:.2f}ms"
             )
             
-            # Step 5: Add to history
+            # Step 6: Add to history
             self._add_to_history(
                 query_text=query_text,
                 semantic_plan=semantic_plan,
@@ -147,7 +154,7 @@ class ChatOrchestrator:
                 error=None
             )
             
-            # Step 6: Build response
+            # Step 7: Build response
             response = {
                 "success": True,
                 "query_text": query_text,

schema_translator/result_harmonizer.py

@@ -687,6 +687,7 @@ class ResultHarmonizer:
         """
         harmonized = {}
         
+        # First, map all fields that have concept mappings
         for customer_field, concept_id in field_mappings.items():
             if customer_field in row:
                 value = row[customer_field]
@@ -702,4 +703,12 @@ class ResultHarmonizer:
                 # Field not present in row
                 harmonized[concept_id] = None
         
+        # Second, include any unmapped columns (like aggregation results)
+        # These are columns like count_contract_identifier, sum_contract_value, etc.
+        for field_name, value in row.items():
+            if field_name not in field_mappings:
+                # This is an unmapped column (likely an aggregation)
+                # Include it as-is with its original name
+                harmonized[field_name] = value
+        
         return harmonized

tests/test_agents.py

@@ -98,11 +98,11 @@ class TestQueryUnderstandingAgent:
 
     def test_multi_filter_query(self, query_agent):
         """Test parsing a query with multiple filters."""
-        query = "List technology contracts expiring in 2026"
+        query = "List active contracts worth more than 1 million expiring in 2026"
         plan = query_agent.understand_query(query)
 
         assert plan.intent == QueryIntent.FIND_CONTRACTS
-        assert len(plan.filters) >= 2
+        assert len(plan.filters) >= 2  # Should have status + value + date filters
 
     def test_explain_query_plan(self, query_agent):
         """Test generating human-readable explanations."""
@@ -122,7 +122,6 @@ class TestSchemaAnalyzerAgent:
         # Create a simple test schema
         schema = CustomerSchema(
             customer_id="test_customer",
-            customer_name="Test Customer",
             tables=[
                 SchemaTable(
                     name="contracts",
@@ -173,7 +172,6 @@ class TestSchemaAnalyzerAgent:
 
         schema = CustomerSchema(
             customer_id="test_customer",
-            customer_name="Test Customer",
             tables=[
                 SchemaTable(
                     name="contracts",
@@ -301,7 +299,6 @@ class TestEndToEndAgent:
         # Create a test schema
         schema = CustomerSchema(
             customer_id="test_new_customer",
-            customer_name="Test New Customer",
             tables=[
                 SchemaTable(
                     name="agreements",

tests/test_knowledge_graph.py

@@ -269,12 +269,13 @@ class TestLoadedKnowledgeGraph:
         kg = SchemaKnowledgeGraph()
         kg.load()
         
-        # Check concepts exist (8 concepts including contract_name)
-        assert len(kg.concepts) == 8
+        # Check concepts exist (5 concepts, removed customer_name and industry_sector)
+        assert len(kg.concepts) == 5
         assert kg.get_concept("contract_identifier") is not None
-        assert kg.get_concept("contract_name") is not None
         assert kg.get_concept("contract_value") is not None
         assert kg.get_concept("contract_expiration") is not None
+        assert kg.get_concept("contract_status") is not None
+        assert kg.get_concept("contract_start") is not None
     
     def test_all_customers_mapped(self):
         """Test that all 6 customers have mappings."""

tests/test_models.py

@@ -89,7 +89,6 @@ class TestSchemaModels:
         
         schema = CustomerSchema(
             customer_id="customer_a",
-            customer_name="Customer A",
             tables=[table],
             semantic_notes={"contract_value": "lifetime total"}
         )

tests/test_query_execution.py

@@ -151,16 +151,16 @@ class TestQueryCompiler:
         
         assert "LIMIT 10" in sql
     
-    def test_industry_filter(self, compiler):
-        """Test filtering by industry."""
+    def test_status_filter(self, compiler):
+        """Test filtering by contract status."""
         plan = SemanticQueryPlan(
             intent=QueryIntent.FIND_CONTRACTS,
-            projections=["contract_identifier", "industry_sector"],
+            projections=["contract_identifier", "contract_status"],
             filters=[
                 QueryFilter(
-                    concept="industry_sector",
+                    concept="contract_status",
                     operator=QueryOperator.EQUALS,
-                    value="Technology"
+                    value="active"
                 )
             ]
         )
@@ -168,8 +168,8 @@ class TestQueryCompiler:
         sql = compiler.compile_for_customer(plan, "customer_a")
         
         assert "WHERE" in sql
-        assert "industry" in sql
-        assert "Technology" in sql
+        assert "status" in sql
+        assert "active" in sql
 
 
 class TestDatabaseExecutor:
@@ -182,7 +182,7 @@ class TestDatabaseExecutor:
     
     def test_simple_query(self, executor):
         """Test executing a simple query."""
-        sql = "SELECT contract_id, contract_name FROM contracts LIMIT 5"
+        sql = "SELECT contract_id, contract_value FROM contracts LIMIT 5"
         result = executor.execute_query("customer_a", sql)
         
         assert result.success
@@ -197,7 +197,7 @@ class TestDatabaseExecutor:
         
         assert result.success
         assert result.row_count == 1
-        assert result.data[0]["count"] == 100
+        assert result.data[0]["count"] == 50  # 50 contracts per database
     
     def test_invalid_sql(self, executor):
         """Test handling of invalid SQL."""
@@ -223,12 +223,12 @@ class TestDatabaseExecutor:
     def test_count_rows(self, executor):
         """Test counting rows in a table."""
         count = executor.count_rows("customer_a", "contracts")
-        assert count == 100
+        assert count == 50  # 50 contracts per database
     
     def test_customer_b_multi_table(self, executor):
         """Test querying Customer B's multi-table schema."""
         sql = """
-            SELECT h.id, h.contract_name, r.renewal_date
+            SELECT h.id, h.contract_value, r.renewal_date
             FROM contract_headers AS h
             JOIN renewal_schedule AS r ON h.id = r.contract_id
             LIMIT 5
@@ -262,7 +262,7 @@ class TestIntegration:
         # Create query plan
         plan = SemanticQueryPlan(
             intent=QueryIntent.FIND_CONTRACTS,
-            projections=["contract_identifier", "contract_value", "customer_name"],
+            projections=["contract_identifier", "contract_value", "contract_status"],
             filters=[],
             limit=10
         )
@@ -355,7 +355,7 @@ class TestIntegration:
         """Test executing the same semantic query across all customers."""
         plan = SemanticQueryPlan(
             intent=QueryIntent.FIND_CONTRACTS,
-            projections=["contract_identifier", "contract_value", "customer_name"],
+            projections=["contract_identifier", "contract_value", "contract_status"],
             filters=[],
             limit=5
         )

tests/test_result_harmonization.py

@@ -157,21 +157,21 @@ class TestValueHarmonizer:
         assert harmonized["contract_status"] == "Active"
         assert harmonized["contract_value"] == 100000.0
     
-    def test_harmonize_row_with_industry(self, result_harmonizer):
-        """Test harmonizing a row with industry normalization."""
+    def test_harmonize_row_with_status(self, result_harmonizer):
+        """Test harmonizing a row with status normalization."""
         row = {
             "contract_id": "A001",
-            "industry": "tech"
+            "status": "active"
         }
         
         field_mappings = {
             "contract_id": "contract_identifier",
-            "industry": "industry_sector"
+            "status": "contract_status"
         }
         
         harmonized = result_harmonizer._harmonize_row(row, "customer_a", field_mappings)
         
-        assert harmonized["industry_sector"] == "Technology"
+        assert harmonized["contract_status"] == "active"
 
 
 class TestResultHarmonizer:
@@ -393,20 +393,20 @@ class TestResultHarmonizer:
         assert all(row.data["contract_status"] == "Active" for row in filtered_result.results)
     
     def test_aggregate_results_count(self, result_harmonizer):
-        """Test aggregating results with count."""
+        """Test aggregating results with count by status."""
         harmonized = HarmonizedResult(
             results=[
                 HarmonizedRow(
                     customer_id="customer_a",
-                    data={"industry_sector": "Technology", "contract_value": 100000}
+                    data={"contract_status": "active", "contract_value": 100000}
                 ),
                 HarmonizedRow(
                     customer_id="customer_a",
-                    data={"industry_sector": "Technology", "contract_value": 200000}
+                    data={"contract_status": "active", "contract_value": 200000}
                 ),
                 HarmonizedRow(
                     customer_id="customer_a",
-                    data={"industry_sector": "Healthcare", "contract_value": 150000}
+                    data={"contract_status": "inactive", "contract_value": 150000}
                 ),
             ],
             total_count=3,
@@ -417,19 +417,19 @@ class TestResultHarmonizer:
         
         aggregated = result_harmonizer.aggregate_results(
             harmonized,
-            group_by=["industry_sector"],
+            group_by=["contract_status"],
             aggregations={"contract_value": "count"}
         )
         
-        assert aggregated.total_count == 2  # Two industries
+        assert aggregated.total_count == 2  # Two statuses
         
-        # Find Technology group
-        tech_row = next(
-            (r for r in aggregated.results if r.data.get("industry_sector") == "Technology"),
+        # Find active group
+        active_row = next(
+            (r for r in aggregated.results if r.data.get("contract_status") == "active"),
             None
         )
-        assert tech_row is not None
-        assert tech_row.data["contract_value_count"] == 2
+        assert active_row is not None
+        assert active_row.data["contract_value_count"] == 2
     
     def test_aggregate_results_sum(self, result_harmonizer):
         """Test aggregating results with sum."""
@@ -437,11 +437,11 @@ class TestResultHarmonizer:
             results=[
                 HarmonizedRow(
                     customer_id="customer_a",
-                    data={"industry_sector": "Technology", "contract_value": 100000}
+                    data={"contract_status": "active", "contract_value": 100000}
                 ),
                 HarmonizedRow(
                     customer_id="customer_a",
-                    data={"industry_sector": "Technology", "contract_value": 200000}
+                    data={"contract_status": "active", "contract_value": 200000}
                 ),
             ],
             total_count=2,
@@ -452,7 +452,7 @@ class TestResultHarmonizer:
         
         aggregated = result_harmonizer.aggregate_results(
             harmonized,
-            group_by=["industry_sector"],
+            group_by=["contract_status"],
             aggregations={"contract_value": "sum"}
         )
         
@@ -465,11 +465,11 @@ class TestResultHarmonizer:
             results=[
                 HarmonizedRow(
                     customer_id="customer_a",
-                    data={"industry_sector": "Technology", "contract_value": 100000}
+                    data={"contract_status": "active", "contract_value": 100000}
                 ),
                 HarmonizedRow(
                     customer_id="customer_a",
-                    data={"industry_sector": "Technology", "contract_value": 200000}
+                    data={"contract_status": "active", "contract_value": 200000}
                 ),
             ],
             total_count=2,
@@ -480,7 +480,7 @@ class TestResultHarmonizer:
         
         aggregated = result_harmonizer.aggregate_results(
             harmonized,
-            group_by=["industry_sector"],
+            group_by=["contract_status"],
             aggregations={"contract_value": "avg"}
         )