Pricing Helper

.env

@@ -0,0 +1 @@
+ANTHROPIC_API_KEY=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

README.md

@@ -1,5 +1,5 @@
 ---
-title: PricingHelper
+title: Pricing Assistant
 emoji: 🐢
 colorFrom: indigo
 colorTo: blue

app.py

@@ -0,0 +1,384 @@
+import streamlit as st
+import pandas as pd
+import json
+from typing import List, Dict
+import os
+from dotenv import load_dotenv
+import plotly.express as px
+import plotly.graph_objects as go
+from anthropic import Anthropic
+import time
+
+# Import our modules
+from src.invoice_generator import InvoiceGenerator
+from src.vector_store import ContractVectorStore
+
+# Load environment variables
+load_dotenv()
+
+# Page configuration
+st.set_page_config(
+    page_title="Enterprise Pricing Audit Assistant",
+    page_icon="💰",
+    layout="wide"
+)
+
+# Load custom CSS
+def load_css():
+    with open("styles.css") as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+# Initialize LLM client
+@st.cache_resource
+def init_llm():
+    return Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+
+# Initialize the sentence transformer model
+@st.cache_resource
+def load_embedding_model():
+    from sentence_transformers import SentenceTransformer
+    return SentenceTransformer('all-MiniLM-L6-v2')
+
+def analyze_invoice_with_rag(invoice: Dict, contract: Dict, vector_store: ContractVectorStore) -> Dict:
+    base_rate = contract["terms"]["base_rate"]
+    quantity = invoice["quantity"]
+    charged_amount = invoice["amount_charged"]
+    correct_amount = invoice["correct_amount"]
+    
+    # Search for relevant contract terms
+    relevant_terms = vector_store.search_relevant_terms(
+        f"pricing rules for quantity {quantity} and amount {charged_amount}"
+    )
+    
+    # Prepare context for LLM
+    context = {
+        "invoice_details": {
+            "invoice_id": invoice["invoice_id"],
+            "quantity": quantity,
+            "charged_amount": charged_amount,
+            "correct_amount": correct_amount,
+            "date": invoice["date"]
+        },
+        "relevant_terms": [term["text"] for term in relevant_terms],
+        "discrepancy": round(charged_amount - correct_amount, 2),
+        "discrepancy_percentage": round((charged_amount - correct_amount) / correct_amount * 100, 2)
+    }
+    
+    # Generate explanation using LLM if there's a discrepancy
+    if abs(context["discrepancy"]) > 0.01:
+        prompt = f"""
+        Analyze this invoice for pricing accuracy:
+        
+        Invoice Details:
+        - Invoice ID: {context['invoice_details']['invoice_id']}
+        - Quantity: {context['invoice_details']['quantity']}
+        - Charged Amount: ${context['invoice_details']['charged_amount']:.2f}
+        - Correct Amount: ${context['invoice_details']['correct_amount']:.2f}
+        - Date: {context['invoice_details']['date']}
+        
+        Relevant Contract Terms:
+        {chr(10).join('- ' + term for term in context['relevant_terms'])}
+        
+        Discrepancy found:
+        - Amount Difference: ${context['discrepancy']:.2f}
+        - Percentage Difference: {context['discrepancy_percentage']:.2f}%
+        
+        Please provide a detailed explanation of:
+        1. Why there is a pricing discrepancy
+        2. Which contract terms were violated
+        3. How the correct price should have been calculated
+        
+        Keep the explanation clear and concise, focusing on the specific pricing rules that were not properly applied.
+        """
+        
+        anthropic = init_llm()
+        response = anthropic.messages.create(
+            model="claude-3-sonnet-20240229",
+            max_tokens=1000,
+            messages=[{"role": "user", "content": prompt}]
+        )
+        
+        explanation = response.content[0].text
+    else:
+        explanation = "Invoice pricing is correct according to contract terms."
+    
+    return {
+        **context,
+        "explanation": explanation,
+        "relevant_terms": relevant_terms
+    }
+
+def display_metrics(invoices_df):
+    with st.container():
+        st.markdown('<div class="metrics-container">', unsafe_allow_html=True)
+        col1, col2, col3, col4 = st.columns(4)
+        
+        total_invoices = len(invoices_df)
+        incorrect_invoices = len(invoices_df[invoices_df['has_error']])
+        total_value = invoices_df['amount_charged'].sum()
+        total_discrepancy = (invoices_df['amount_charged'] - invoices_df['correct_amount']).sum()
+        
+        with col1:
+            st.metric("Total Invoices", total_invoices)
+        with col2:
+            st.metric("Incorrect Invoices", incorrect_invoices)
+        with col3:
+            st.metric("Total Invoice Value", f"${total_value:,.2f}")
+        with col4:
+            st.metric("Total Pricing Discrepancy", f"${total_discrepancy:,.2f}")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+def display_invoice_tables(invoices_df):
+    st.markdown('<div class="invoice-table">', unsafe_allow_html=True)
+    
+    # Separate correct and incorrect invoices
+    correct_invoices = invoices_df[~invoices_df['has_error']].copy()
+    incorrect_invoices = invoices_df[invoices_df['has_error']].copy()
+    
+    # Format currency columns
+    currency_cols = ['amount_charged', 'correct_amount']
+    for df in [correct_invoices, incorrect_invoices]:
+        for col in currency_cols:
+            df[col] = df[col].apply(lambda x: f"${x:,.2f}")
+    
+    # Display tables in tabs
+    tab1, tab2 = st.tabs(["🟢 Correct Invoices", "🔴 Incorrect Invoices"])
+    
+    with tab1:
+        if not correct_invoices.empty:
+            st.dataframe(
+                correct_invoices,
+                column_config={
+                    "invoice_id": "Invoice ID",
+                    "date": "Date",
+                    "quantity": "Quantity",
+                    "amount_charged": "Amount",
+                },
+                hide_index=True
+            )
+        else:
+            st.info("No correctly priced invoices found.")
+    
+    with tab2:
+        if not incorrect_invoices.empty:
+            st.dataframe(
+                incorrect_invoices,
+                column_config={
+                    "invoice_id": "Invoice ID",
+                    "date": "Date",
+                    "quantity": "Quantity",
+                    "amount_charged": "Charged Amount",
+                    "correct_amount": "Correct Amount"
+                },
+                hide_index=True
+            )
+        else:
+            st.info("No pricing discrepancies found.")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def display_contract_details(contract):
+    st.markdown('<div class="contract-details">', unsafe_allow_html=True)
+    st.subheader("📄 Contract Details")
+    
+    # Basic contract information
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.write("**Contract ID:**", contract['contract_id'])
+    with col2:
+        st.write("**Client:**", contract['client'])
+    with col3:
+        st.write("**Base Rate:**", f"${contract['terms']['base_rate']}")
+    
+    # Pricing rules
+    with st.expander("🏷️ Pricing Rules"):
+        if "volume_discounts" in contract["terms"]:
+            st.write("**Volume Discounts:**")
+            for discount in contract["terms"]["volume_discounts"]:
+                st.write(f"• {discount['discount']*100}% off for quantities ≥ {discount['threshold']:,}")
+        
+        if "tiered_pricing" in contract["terms"]:
+            st.write("**Tiered Pricing:**")
+            for tier in contract["terms"]["tiered_pricing"]:
+                st.write(f"• {tier['tier']}: {tier['rate']}x base rate")
+    
+    # Special conditions
+    with st.expander("📋 Special Conditions"):
+        for condition in contract["terms"]["special_conditions"]:
+            st.write(f"• {condition}")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def initialize_data():
+    """Initialize data and models"""
+    try:
+        # Initialize embedding model
+        embedding_model = load_embedding_model()
+        
+        # Initialize invoice generator
+        generator = InvoiceGenerator(data_dir="data")
+        
+        # Ensure we have both contracts and invoices
+        if not os.path.exists("data/contracts.json") or not os.path.exists("data/invoices.json"):
+            generator.generate_and_save()
+        
+        # Load contracts and invoices
+        contracts = generator.load_contracts()
+        invoices = generator.load_or_generate_invoices()
+        
+        if not contracts or not invoices:
+            st.error("No data found. Generating new data...")
+            generator.generate_and_save()
+            contracts = generator.load_contracts()
+            invoices = generator.load_or_generate_invoices()
+        
+        # Initialize vector store
+        vector_store = ContractVectorStore(embedding_model)
+        for contract in contracts:
+            vector_store.add_contract_terms(contract)
+        
+        return contracts, invoices, vector_store
+    
+    except Exception as e:
+        st.error(f"Error initializing data: {str(e)}")
+        st.stop()
+
+def main():
+    # Load custom CSS
+    try:
+        load_css()
+    except Exception as e:
+        st.warning(f"Could not load custom CSS: {str(e)}")
+    
+    st.title("🔍 Enterprise Pricing Audit Assistant")
+    
+    try:
+        # Initialize data and models
+        with st.spinner('Loading data and initializing models...'):
+            contracts, invoices, vector_store = initialize_data()
+        
+        # Convert invoices to DataFrame
+        invoices_df = pd.DataFrame(invoices)    
+        
+        # Display metrics
+        display_metrics(invoices_df)
+        
+        # Display contract selection
+        selected_contract_id = st.selectbox(
+            "Select Contract",
+            options=[c["contract_id"] for c in contracts],
+            format_func=lambda x: f"{x} - {next(c['client'] for c in contracts if c['contract_id'] == x)}"
+        )
+        
+        # Get selected contract
+        selected_contract = next(c for c in contracts if c["contract_id"] == selected_contract_id)
+        
+        # Display contract details
+        display_contract_details(selected_contract)
+        
+        # Filter invoices for selected contract
+        contract_invoices_df = invoices_df[invoices_df['contract_id'] == selected_contract_id]
+        
+        # Display invoice analysis
+        st.subheader("📊 Invoice Analysis")
+        
+        # Create tabs for different views
+        tab1, tab2, tab3 = st.tabs(["📈 Overview", "📑 Invoice Details", "🔍 Detailed Analysis"])
+        
+        with tab1:
+            # Display summary metrics for the selected contract
+            total_contract_value = contract_invoices_df['amount_charged'].sum()
+            total_contract_discrepancy = (
+                contract_invoices_df['amount_charged'] - contract_invoices_df['correct_amount']
+            ).sum()
+            error_rate = (
+                len(contract_invoices_df[contract_invoices_df['has_error']]) / 
+                len(contract_invoices_df) * 100
+            )
+            
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Total Contract Value", f"${total_contract_value:,.2f}")
+            with col2:
+                st.metric("Total Discrepancy", f"${total_contract_discrepancy:,.2f}")
+            with col3:
+                st.metric("Error Rate", f"{error_rate:.1f}%")
+            
+            # Create visualization
+            if not contract_invoices_df.empty:
+                # Prepare data for visualization
+                contract_invoices_df['error_amount'] = (
+                    contract_invoices_df['amount_charged'] - 
+                    contract_invoices_df['correct_amount']
+                )
+                
+                # Create scatter plot
+                fig = go.Figure()
+                
+                # Add points for correct invoices
+                correct_invoices = contract_invoices_df[~contract_invoices_df['has_error']]
+                if not correct_invoices.empty:
+                    fig.add_trace(go.Scatter(
+                        x=correct_invoices['date'],
+                        y=correct_invoices['amount_charged'],
+                        mode='markers',
+                        name='Correct Invoices',
+                        marker=dict(color='green', size=10),
+                    ))
+                
+                # Add points for incorrect invoices
+                incorrect_invoices = contract_invoices_df[contract_invoices_df['has_error']]
+                if not incorrect_invoices.empty:
+                    fig.add_trace(go.Scatter(
+                        x=incorrect_invoices['date'],
+                        y=incorrect_invoices['amount_charged'],
+                        mode='markers',
+                        name='Incorrect Invoices',
+                        marker=dict(color='red', size=10),
+                    ))
+                
+                fig.update_layout(
+                    title='Invoice Amounts Over Time',
+                    xaxis_title='Date',
+                    yaxis_title='Amount ($)',
+                    hovermode='closest'
+                )
+                
+                st.plotly_chart(fig, use_container_width=True)
+        
+        with tab2:
+            # Display invoice tables
+            display_invoice_tables(contract_invoices_df)
+        
+        with tab3:
+            # Detailed analysis of incorrect invoices
+            incorrect_invoices = contract_invoices_df[contract_invoices_df['has_error']]
+            if not incorrect_invoices.empty:
+                for _, invoice in incorrect_invoices.iterrows():
+                    with st.expander(f"Invoice {invoice['invoice_id']} Analysis"):
+                        analysis = analyze_invoice_with_rag(
+                            invoice.to_dict(),
+                            selected_contract,
+                            vector_store
+                        )
+                        
+                        # Display analysis results
+                        st.write("**Discrepancy Amount:**", 
+                                f"${analysis['discrepancy']:.2f} "
+                                f"({analysis['discrepancy_percentage']}%)")
+                        
+                        st.write("**Relevant Contract Terms:**")
+                        for term in analysis['relevant_terms']:
+                            st.write(f"• {term['text']}")
+                        
+                        st.write("**Analysis:**")
+                        st.write(analysis['explanation'])
+            else:
+                st.info("No pricing discrepancies found for this contract.")
+    
+    except Exception as e:
+        st.error(f"An error occurred: {str(e)}")
+        st.stop()
+
+if __name__ == "__main__":
+    main()

data/contracts.json

@@ -0,0 +1,46 @@
+{
+    "contracts": [
+        {
+            "contract_id": "CNT001",
+            "client": "TechCorp Solutions",
+            "start_date": "2024-01-01",
+            "end_date": "2024-12-31",
+            "terms": {
+                "base_rate": 100,
+                "volume_discounts": [
+                    {"threshold": 1000, "discount": 0.10},
+                    {"threshold": 5000, "discount": 0.15},
+                    {"threshold": 10000, "discount": 0.20}
+                ],
+                "special_conditions": [
+                    "Holiday surcharge: 15% on federal holidays",
+                    "Rush order fee: Additional 25% for same-day delivery",
+                    "Bulk order minimum: 500 units per order for volume pricing",
+                    "Early payment discount: 2% if paid within 10 days",
+                    "Multi-year commitment: 5% additional discount for 3+ year contract"
+                ]
+            }
+        },
+        {
+            "contract_id": "CNT002",
+            "client": "Global Manufacturing Inc",
+            "start_date": "2024-01-01",
+            "end_date": "2024-12-31",
+            "terms": {
+                "base_rate": 85,
+                "tiered_pricing": [
+                    {"tier": "Standard", "rate": 1.0},
+                    {"tier": "Premium", "rate": 1.25},
+                    {"tier": "Enterprise", "rate": 1.5}
+                ],
+                "special_conditions": [
+                    "Annual commitment discount: 5% off base rate",
+                    "Multi-location discount: 3% per additional location",
+                    "Payment terms: 2% discount for payment within 10 days",
+                    "Volume guarantee: Minimum 1000 units per quarter",
+                    "Service level agreement: 99.9% delivery accuracy required"
+                ]
+            }
+        }
+    ]
+}

data/invoices.json

@@ -0,0 +1,175 @@
+{
+  "invoices": [
+    {
+      "invoice_id": "INV6886",
+      "contract_id": "CNT001",
+      "date": "2024-01-19",
+      "quantity": 1315,
+      "amount_charged": 118350.0,
+      "correct_amount": 118350.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV5025",
+      "contract_id": "CNT002",
+      "date": "2024-01-25",
+      "quantity": 5058,
+      "amount_charged": 429930.0,
+      "correct_amount": 429930.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV8930",
+      "contract_id": "CNT001",
+      "date": "2024-03-15",
+      "quantity": 1927,
+      "amount_charged": 173430.0,
+      "correct_amount": 173430.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV2619",
+      "contract_id": "CNT002",
+      "date": "2024-03-15",
+      "quantity": 7024,
+      "amount_charged": 826096.41,
+      "correct_amount": 746300.0,
+      "has_error": true
+    },
+    {
+      "invoice_id": "INV7771",
+      "contract_id": "CNT002",
+      "date": "2024-05-07",
+      "quantity": 3872,
+      "amount_charged": 329120.0,
+      "correct_amount": 329120.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV8599",
+      "contract_id": "CNT002",
+      "date": "2024-05-08",
+      "quantity": 3108,
+      "amount_charged": 264180.0,
+      "correct_amount": 264180.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV2289",
+      "contract_id": "CNT002",
+      "date": "2024-05-09",
+      "quantity": 10046,
+      "amount_charged": 1280865.0,
+      "correct_amount": 1280865.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV1743",
+      "contract_id": "CNT001",
+      "date": "2024-07-25",
+      "quantity": 8237,
+      "amount_charged": 700145.0,
+      "correct_amount": 700145.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV3707",
+      "contract_id": "CNT002",
+      "date": "2024-08-06",
+      "quantity": 14421,
+      "amount_charged": 1532231.25,
+      "correct_amount": 1532231.25,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV7751",
+      "contract_id": "CNT001",
+      "date": "2024-09-25",
+      "quantity": 6043,
+      "amount_charged": 513655.0,
+      "correct_amount": 513655.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV8916",
+      "contract_id": "CNT001",
+      "date": "2024-10-29",
+      "quantity": 12740,
+      "amount_charged": 1019200.0,
+      "correct_amount": 1019200.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV5521",
+      "contract_id": "CNT002",
+      "date": "2024-11-11",
+      "quantity": 3530,
+      "amount_charged": 450075.0,
+      "correct_amount": 450075.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV9580",
+      "contract_id": "CNT001",
+      "date": "2024-11-14",
+      "quantity": 11679,
+      "amount_charged": 934320.0,
+      "correct_amount": 934320.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV8276",
+      "contract_id": "CNT001",
+      "date": "2024-11-17",
+      "quantity": 5203,
+      "amount_charged": 442255.0,
+      "correct_amount": 442255.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV3439",
+      "contract_id": "CNT001",
+      "date": "2024-11-18",
+      "quantity": 5043,
+      "amount_charged": 489773.94,
+      "correct_amount": 428655.0,
+      "has_error": true
+    },
+    {
+      "invoice_id": "INV3344",
+      "contract_id": "CNT002",
+      "date": "2024-11-20",
+      "quantity": 5737,
+      "amount_charged": 609556.25,
+      "correct_amount": 609556.25,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV5645",
+      "contract_id": "CNT001",
+      "date": "2024-11-24",
+      "quantity": 7168,
+      "amount_charged": 609280.0,
+      "correct_amount": 609280.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV6786",
+      "contract_id": "CNT002",
+      "date": "2024-12-09",
+      "quantity": 8757,
+      "amount_charged": 744345.0,
+      "correct_amount": 744345.0,
+      "has_error": false
+    },
+    {
+      "invoice_id": "INV3445",
+      "contract_id": "CNT001",
+      "date": "2024-12-15",
+      "quantity": 4979,
+      "amount_charged": 448110.0,
+      "correct_amount": 448110.0,
+      "has_error": false
+    }
+  ]
+}

requirements.txt

@@ -0,0 +1,9 @@
+streamlit 
+pandas 
+numpy 
+sentence-transformers 
+faiss-cpu 
+torch 
+anthropic 
+python-dotenv
+plotly

src/invoice_generator.py

@@ -0,0 +1,184 @@
+import json
+from datetime import datetime
+import random
+import pandas as pd
+from typing import List, Dict
+import os
+
+class InvoiceGenerator:
+    def __init__(self, data_dir: str = "data"):
+        """Initialize the invoice generator with a data directory."""
+        self.data_dir = data_dir
+        os.makedirs(data_dir, exist_ok=True)
+        self.ensure_contract_file()
+    
+    def ensure_contract_file(self) -> None:
+        """Ensure contracts.json exists with initial data."""
+        contracts_file = os.path.join(self.data_dir, "contracts.json")
+        if not os.path.exists(contracts_file):
+            initial_contracts = {
+                "contracts": [
+                    {
+                        "contract_id": "CNT001",
+                        "client": "TechCorp Solutions",
+                        "start_date": "2024-01-01",
+                        "end_date": "2024-12-31",
+                        "terms": {
+                            "base_rate": 100,
+                            "volume_discounts": [
+                                {"threshold": 1000, "discount": 0.10},
+                                {"threshold": 5000, "discount": 0.15},
+                                {"threshold": 10000, "discount": 0.20}
+                            ],
+                            "special_conditions": [
+                                "Holiday surcharge: 15% on federal holidays",
+                                "Rush order fee: Additional 25% for same-day delivery",
+                                "Bulk order minimum: 500 units per order for volume pricing",
+                                "Early payment discount: 2% if paid within 10 days",
+                                "Multi-year commitment: 5% additional discount for 3+ year contract"
+                            ]
+                        }
+                    },
+                    {
+                        "contract_id": "CNT002",
+                        "client": "Global Manufacturing Inc",
+                        "start_date": "2024-01-01",
+                        "end_date": "2024-12-31",
+                        "terms": {
+                            "base_rate": 85,
+                            "tiered_pricing": [
+                                {"tier": "Standard", "rate": 1.0},
+                                {"tier": "Premium", "rate": 1.25},
+                                {"tier": "Enterprise", "rate": 1.5}
+                            ],
+                            "special_conditions": [
+                                "Annual commitment discount: 5% off base rate",
+                                "Multi-location discount: 3% per additional location",
+                                "Payment terms: 2% discount for payment within 10 days",
+                                "Volume guarantee: Minimum 1000 units per quarter",
+                                "Service level agreement: 99.9% delivery accuracy required"
+                            ]
+                        }
+                    }
+                ]
+            }
+            with open(contracts_file, 'w') as f:
+                json.dump(initial_contracts, f, indent=4)
+    
+    def load_contracts(self) -> List[Dict]:
+        """Load contracts from JSON file."""
+        contracts_file = os.path.join(self.data_dir, "contracts.json")
+        try:
+            with open(contracts_file, 'r') as f:
+                contracts_data = json.load(f)
+                return contracts_data['contracts']
+        except Exception as e:
+            raise Exception(f"Error loading contracts: {str(e)}")
+
+    def calculate_correct_price(self, contract: Dict, quantity: int) -> float:
+        """Calculate the correct price based on contract terms and quantity."""
+        base_amount = contract["terms"]["base_rate"]
+        price = base_amount * quantity
+        
+        # Apply volume discounts if applicable
+        if "volume_discounts" in contract["terms"]:
+            applicable_discount = 0
+            for discount in sorted(
+                contract["terms"]["volume_discounts"], 
+                key=lambda x: x["threshold"], 
+                reverse=True
+            ):
+                if quantity >= discount["threshold"]:
+                    applicable_discount = discount["discount"]
+                    break
+            if applicable_discount > 0:
+                price *= (1 - applicable_discount)
+        
+        # Apply tiered pricing if applicable
+        if "tiered_pricing" in contract["terms"]:
+            # Randomly select a tier for this invoice
+            tier = random.choice(contract["terms"]["tiered_pricing"])
+            price *= tier["rate"]
+        
+        return round(price, 2)
+
+    def generate_invoices(self, contracts: List[Dict]) -> List[Dict]:
+        """Generate synthetic invoices based on contract data."""
+        invoices = []
+        for contract in contracts:
+            # Generate multiple invoices per contract
+            for _ in range(random.randint(5, 10)):  # Random number of invoices per contract
+                # Randomly decide if this invoice will have an error
+                has_error = random.random() < 0.3  # 30% chance of error
+                
+                # Generate random quantity between contract minimums and maximums
+                min_quantity = 500  # Minimum from special conditions
+                max_quantity = 15000  # Arbitrary maximum
+                quantity = random.randint(min_quantity, max_quantity)
+                
+                # Calculate correct price
+                correct_price = self.calculate_correct_price(contract, quantity)
+                
+                # If we want an error, modify the price slightly
+                charged_amount = correct_price
+                if has_error:
+                    error_factor = random.uniform(1.05, 1.15)  # 5-15% overcharge
+                    charged_amount *= error_factor
+                
+                # Generate random date within contract period
+                start_date = datetime.strptime(contract["start_date"], "%Y-%m-%d")
+                end_date = datetime.strptime(contract["end_date"], "%Y-%m-%d")
+                random_days = random.randint(0, (end_date - start_date).days)
+                invoice_date = start_date + pd.Timedelta(days=random_days)
+                
+                invoice = {
+                    "invoice_id": f"INV{random.randint(1000, 9999)}",
+                    "contract_id": contract["contract_id"],
+                    "date": invoice_date.strftime("%Y-%m-%d"),
+                    "quantity": quantity,
+                    "amount_charged": round(charged_amount, 2),
+                    "correct_amount": round(correct_price, 2),
+                    "has_error": has_error
+                }
+                invoices.append(invoice)
+        
+        return sorted(invoices, key=lambda x: x["date"])
+
+    def save_invoices(self, invoices: List[Dict]) -> None:
+        """Save generated invoices to JSON file."""
+        invoices_file = os.path.join(self.data_dir, "invoices.json")
+        with open(invoices_file, 'w') as f:
+            json.dump({"invoices": invoices}, f, indent=2)
+
+    def generate_and_save(self) -> None:
+        """Generate and save invoices in one step."""
+        contracts = self.load_contracts()
+        invoices = self.generate_invoices(contracts)
+        self.save_invoices(invoices)
+        
+    def load_or_generate_invoices(self) -> List[Dict]:
+        """Load existing invoices or generate new ones if they don't exist."""
+        invoices_file = os.path.join(self.data_dir, "invoices.json")
+        try:
+            if os.path.exists(invoices_file):
+                with open(invoices_file, 'r') as f:
+                    data = json.load(f)
+                    return data.get('invoices', [])
+            else:
+                self.generate_and_save()
+                with open(invoices_file, 'r') as f:
+                    data = json.load(f)
+                    return data.get('invoices', [])
+        except Exception as e:
+            print(f"Error loading invoices: {str(e)}")
+            print("Generating new invoices...")
+            self.generate_and_save()
+            with open(invoices_file, 'r') as f:
+                data = json.load(f)
+                return data.get('invoices', [])
+
+if __name__ == "__main__":
+    # This allows running the generator directly to create/update the files
+    generator = InvoiceGenerator()
+    generator.generate_and_save()
+    print("Successfully generated invoice and contract data!")

src/vector_store.py

@@ -0,0 +1,80 @@
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from typing import List, Dict
+import faiss
+
+class ContractVectorStore:
+    def __init__(self, model: SentenceTransformer):
+        self.model = model
+        self.index = None
+        self.texts = []
+        self.dimension = 384  # dimension for 'all-MiniLM-L6-v2'
+
+    def add_contract_terms(self, contract: Dict) -> None:
+        """Add contract terms to the vector store"""
+        terms = []
+        
+        # Add volume discounts
+        if "volume_discounts" in contract["terms"]:
+            for discount in contract["terms"]["volume_discounts"]:
+                terms.append(
+                    f"Volume discount: {discount['discount']*100}% off for quantities >= {discount['threshold']}"
+                )
+        
+        # Add tiered pricing
+        if "tiered_pricing" in contract["terms"]:
+            for tier in contract["terms"]["tiered_pricing"]:
+                terms.append(
+                    f"Tier {tier['tier']}: Rate multiplier of {tier['rate']}x base rate"
+                )
+        
+        # Add special conditions
+        for condition in contract["terms"]["special_conditions"]:
+            terms.append(condition)
+        
+        # Add base rate
+        terms.append(f"Base rate is ${contract['terms']['base_rate']} per unit")
+        
+        # Create embeddings and update index
+        self._add_texts(terms)
+
+    def _add_texts(self, texts: List[str]) -> None:
+        """Add texts to the vector store"""
+        if not texts:
+            return
+            
+        # Generate embeddings
+        embeddings = self.model.encode(texts)
+        
+        # Initialize index if needed
+        if self.index is None:
+            self.index = faiss.IndexFlatL2(self.dimension)
+        
+        # Add to index
+        self.index.add(np.array(embeddings).astype('float32'))
+        self.texts.extend(texts)
+
+    def search_relevant_terms(self, query: str, k: int = 3) -> List[Dict]:
+        """Search for relevant terms using the query"""
+        if not self.index or not self.texts:
+            return []
+        
+        # Generate query embedding
+        query_embedding = self.model.encode([query])[0].reshape(1, -1)
+        
+        # Search
+        distances, indices = self.index.search(
+            np.array(query_embedding).astype('float32'), 
+            k
+        )
+        
+        # Return results
+        results = []
+        for i, (dist, idx) in enumerate(zip(distances[0], indices[0])):
+            if idx < len(self.texts):  # Ensure valid index
+                results.append({
+                    "text": self.texts[idx],
+                    "score": float(1 / (1 + dist))  # Convert distance to similarity score
+                })
+        
+        return results

styles.css

@@ -0,0 +1,58 @@
+.main {
+    padding: 0rem 1rem;
+}
+
+.stAlert {
+    padding: 1rem;
+    margin: 1rem 0;
+    border-radius: 0.5rem;
+}
+
+.pricing-card {
+    padding: 1.5rem;
+    border-radius: 0.5rem;
+    background-color: #f8f9fa;
+    margin: 1rem 0;
+}
+
+.metric-card {
+    background-color: white;
+    padding: 1rem;
+    border-radius: 0.5rem;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+/* Dashboard specific styles */
+.st-emotion-cache-16idsys p {
+    font-size: 14px;
+    margin-bottom: 0.5rem;
+}
+
+/* Contract details styles */
+.contract-details {
+    background-color: #f8f9fa;
+    padding: 1rem;
+    border-radius: 0.5rem;
+    margin: 1rem 0;
+}
+
+/* Invoice table styles */
+.invoice-table {
+    margin-top: 1rem;
+}
+
+/* Metrics section */
+.metrics-container {
+    margin: 1.5rem 0;
+}
+
+/* Alert styles */
+.alert-error {
+    background-color: #ffe6e6;
+    border-left: 4px solid #ff0000;
+}
+
+.alert-success {
+    background-color: #e6ffe6;
+    border-left: 4px solid #00ff00;
+}