Upload 6 files

Dockerfile

@@ -0,0 +1,49 @@
+# Use an official Python 3.11 slim image with Debian Bookworm (newer)
+FROM python:3.11-slim-bookworm
+
+# Set working directory in the container
+WORKDIR /app
+
+# Install system dependencies required by deepmost (and generally good for ML)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    git \
+    git-lfs \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    cmake \
+    rsync \
+    libgl1-mesa-glx \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/* \
+    && git lfs install
+
+# --- CRITICAL FIX: Create /.deepmost and set permissions ---
+# Docker images usually run as root during RUN steps.
+# Create the directory where deepmost wants to save its files.
+RUN mkdir -p /.deepmost && \
+    chmod 777 /.deepmost # Give read/write/execute permissions to all for this specific folder
+
+# Set Matplotlib cache directory
+ENV MPLCONFIGDIR=/tmp/.matplotlib
+
+
+# Copy requirements.txt and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of your application code
+COPY . .
+
+# Set the PORT environment variable. Hugging Face Spaces will
+# inject its own PORT value (e.g., 7860), which will override this
+# if it's set. This ensures the CMD always has a value.
+ENV PORT=7860 
+
+# Expose the port Flask will run on
+EXPOSE ${PORT}
+
+# Use the shell form of CMD to allow $PORT expansion
+# This command will start Gunicorn and bind it to the exposed port.
+CMD gunicorn --bind 0.0.0.0:${PORT} app:app --timeout 300 --workers 1

README.md

@@ -1,8 +1,8 @@
 ---
 title: SalesDocSpace
-emoji: 🏃
-colorFrom: green
-colorTo: gray
+emoji: 🌖
+colorFrom: indigo
+colorTo: red
 sdk: docker
 pinned: false
 ---

app.py

@@ -0,0 +1,332 @@
+import os
+import sys
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import numpy as np 
+import json 
+import google.api_core.exceptions
+
+from dotenv import load_dotenv
+
+import google.generativeai as genai
+from google.generativeai.types import GenerationConfig
+
+print("--- Script Start: app.py ---")
+
+# Load environment variables for local testing (Hugging Face handles secrets directly)
+load_dotenv()
+
+app = Flask(__name__)
+
+# IMPORTANT: Configure CORS to allow requests from your Vercel frontend
+# Replace 'https://sales-doc.vercel.app' with your actual Vercel URL.
+CORS(app, resources={r"/*": {"origins": "https://sales-doc.vercel.app"}}) 
+
+# --- Global Model Instances ---
+sales_agent = None
+gemini_model = None 
+gemini_api_key_status = "Not Set" # Track API key status for logs
+
+# --- Configure API Keys & Initialize Models ---
+print("\n--- Starting API Key and Model Initialization ---")
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if GEMINI_API_KEY:
+    try:
+        genai.configure(api_key=GEMINI_API_KEY)
+        gemini_api_key_status = "Configured"
+        print("Gemini API Key detected and configured.")
+    except Exception as e:
+        gemini_api_key_status = f"Configuration Failed: {e}"
+        print(f"ERROR: Failed to configure Gemini API: {e}")
+else:
+    print("WARNING: GEMINI_API_KEY environment variable not found. Gemini LLM features will be disabled.")
+    gemini_api_key_status = "Missing"
+
+# --- DEEPMOST IMPORT FIX ---
+try:
+    from deepmost import sales
+    print("Debug Point: Successfully imported deepmost.sales module.")
+except ImportError as e:
+    print(f"CRITICAL ERROR: Failed to import deepmost.sales module: {e}")
+    print("This means the 'deepmost' library is not correctly installed or its path is wrong.")
+    print("SalesRLAgent core model functionality will be disabled.")
+    sales = None # Set sales to None if import fails, to prevent NameError later
+
+# DeepMost SalesRLAgent Core Model Initialization
+print("Debug Point: Attempting to instantiate sales.Agent (core RL model).")
+if sales is not None: 
+    try:
+        # --- Relying on Dockerfile to make /.deepmost writable ---
+        # NO local_model_path argument here.
+        sales_agent = sales.Agent(
+            model_path="https://huggingface.co/DeepMostInnovations/sales-conversion-model-reinf-learning/resolve/main/sales_conversion_model.zip",
+            auto_download=True,
+            use_gpu=False      
+        )
+        if sales_agent is not None:
+            print("Debug Point: DeepMost SalesRLAgent core model initialized successfully.")
+        else:
+            print("ERROR: DeepMost SalesRLAgent core model failed to initialize after constructor call (returned None).")
+    except Exception as e:
+        print(f"CRITICAL ERROR: DeepMost SalesRLAgent core model loading or instantiation failed.")
+        print(f"Error Type: {type(e).__name__}")
+        print(f"Error Message: {e}")
+        import traceback
+        traceback.print_exc()
+        sales_agent = None
+        print("DeepMost model initialization set to None due to error.")
+else:
+    print("DeepMost SalesRLAgent core model instantiation skipped because 'sales' module could not be imported.")
+
+
+# Gemini LLM (1.5 Flash) Initialization
+print("\nDebug Point: Attempting to initialize Gemini 1.5 Flash model.")
+if GEMINI_API_KEY:
+    try:
+        gemini_model = genai.GenerativeModel('gemini-1.5-flash-latest') 
+        # Small test call to ensure connectivity
+        test_response = gemini_model.generate_content("Hello.", generation_config=GenerationConfig(max_output_tokens=10))
+        print(f"Debug Point: Gemini 1.5 Flash test response: {test_response.text[:50]}...")
+        print("Debug Point: Gemini LLM (1.5 Flash) initialized successfully.")
+    except Exception as e:
+        print(f"CRITICAL ERROR: Gemini LLM (1.5 Flash) initialization failed.")
+        print(f"Error Type: {type(e).__name__}") 
+        print(f"Error Message: {e}")
+        print("Ensure your GEMINI_API_KEY is correct and has access to Gemini 1.5 Flash.")
+        print("This means LLM chat functionality and enriched metrics will not work.")
+        import traceback
+        traceback.print_exc()
+        gemini_model = None 
+    print(f"Gemini Model Status: {'Initialized' if gemini_model else 'Failed to Initialize'}")
+else:
+    print("Debug Point: Skipping Gemini LLM initialization because GEMINI_API_KEY is not set.")
+    print("Gemini Model Status: Disabled (API Key Missing)")
+
+print("--- Finished Model Initialization Block ---\n")
+
+
+# --- Flask Routes (API Endpoints only) ---
+@app.route('/analyze_conversation', methods=['POST'])
+def analyze_conversation():
+    if sales_agent is None:
+        print("ERROR: API call received for analyze_conversation but sales_agent (core) is None.")
+        return jsonify({"error": "SalesRLAgent core model not initialized on backend. Check Space logs for DeepMost initialization errors."}), 500
+
+    try:
+        data = request.get_json()
+        if not data or 'conversation' not in data:
+            return jsonify({"error": "Invalid request. 'conversation' field is required."}), 400
+
+        conversation = data['conversation']
+        if not isinstance(conversation, list) or not all(isinstance(turn, str) for turn in conversation):
+            return jsonify({"error": "'conversation' must be a list of strings."}), 400
+
+        print(f"Processing /analyze_conversation for: {conversation}")
+
+        all_analysis_results = []
+        full_conversation_so_far = []
+
+        for i, turn_message in enumerate(conversation):
+            full_conversation_so_far.append(turn_message)
+            
+            deepmost_analysis = sales_agent.analyze_conversation_progression(full_conversation_so_far, print_results=False)
+            
+            probability = 0.0
+            if deepmost_analysis and len(deepmost_analysis) > 0:
+                probability = deepmost_analysis[-1]['probability']
+            
+            llm_metrics = {} 
+            llm_per_turn_suggestion = ""
+
+            turn_result = {
+                "turn": i + 1,
+                "speaker": turn_message.split(":")[0].strip() if ":" in turn_message else "Unknown",
+                "message": turn_message,
+                "probability": probability,
+                "status": "calculated", 
+                "metrics": llm_metrics, 
+                "llm_per_turn_suggestion": llm_per_turn_suggestion 
+            }
+            all_analysis_results.append(turn_result)
+        
+        print(f"Successfully processed /analyze_conversation. Returning {len(all_analysis_results)} results.")
+        return jsonify({"results": all_analysis_results, "llm_advice_pending": True}), 200
+
+    except Exception as e:
+        print(f"ERROR: Exception during /analyze_conversation: {e}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({"error": f"An error occurred during analysis: {str(e)}"}), 500
+
+@app.route('/get_llm_advice', methods=['POST'])
+def get_llm_advice():
+    if gemini_model is None:
+        print("ERROR: LLM advice requested but Gemini LLM is not initialized or available.")
+        return jsonify({"points": ["LLM advice unavailable. Gemini failed to load on backend. Check Space logs or add GEMINI_API_KEY secret."]}), 500
+
+    try:
+        data = request.get_json()
+        conversation = data.get('conversation', [])
+        if not conversation:
+            return jsonify({"points": ["No conversation provided for LLM advice."]}), 400
+
+        full_convo_text = "\n".join(conversation)
+        advice_prompt = (
+            f"Analyze the entire following sales conversation:\n\n"
+            f"{full_convo_text}\n\n"
+            f"As a concise sales coach, provide actionable advice to the salesperson on how to best progress this sales call towards a successful outcome. "
+            f"Provide this advice as a JSON object with a single key 'points' which is an array of strings, where each string is a distinct, actionable bullet point. "
+            f"Do NOT include any other text outside the JSON object. Ensure the JSON is well-formed and complete."
+        )
+        print(f"Processing /get_llm_advice. Prompting Gemini: {advice_prompt[:200]}...") 
+        try:
+            gemini_response = gemini_model.generate_content(
+                [advice_prompt],
+                generation_config=GenerationConfig(
+                    response_mime_type="application/json",
+                    response_schema={"type": "OBJECT", "properties": {"points": {"type": "ARRAY", "items": {"type": "STRING"}}}, "required": ["points"]},
+                    max_output_tokens=300,
+                    temperature=0.6
+                )
+            )
+            raw_json_string = ""
+            if gemini_response and gemini_response.candidates and len(gemini_response.candidates) > 0 and \
+               gemini_response.candidates[0].content and gemini_response.candidates[0].content.parts and \
+               len(gemini_response.candidates[0].content.parts) > 0:
+                raw_json_string = gemini_response.candidates[0].content.parts[0].text.strip()
+                print(f"Raw LLM JSON response: {raw_json_string}")
+            else:
+                print("WARNING: Empty or malformed LLM response for overall advice.")
+                return jsonify({"points": ["LLM returned an empty or malformed response. Try again or check conversation length."]}), 200
+
+            parsed_advice = {}
+            try:
+                parsed_advice = json.loads(raw_json_string)
+                if "points" in parsed_advice and isinstance(parsed_advice["points"], list):
+                    print(f"Successfully parsed Gemini advice: {parsed_advice}")
+                    return jsonify(parsed_advice), 200
+                else:
+                    print(f"WARNING: LLM did not return 'points' array in structured advice: {raw_json_string}")
+                    return jsonify({"points": ["LLM response was not structured as expected (missing 'points' array). Raw: " + raw_json_string[:100] + "..."]}), 200
+            except json.JSONDecodeError as json_e:
+                print(f"ERROR: JSON parsing error for overall advice: {json_e}. Raw string: {raw_json_string}")
+                return jsonify({"points": ["Error parsing LLM JSON advice. This happens with incomplete LLM responses (e.g., due to API rate limits or max tokens). Please try a shorter conversation or wait a moment. Raw response starts with: " + raw_json_string[:100] + "..."]})
+            except Exception as parse_e:
+                print(f"ERROR: General error parsing LLM JSON advice: {parse_e}. Raw string: {raw_json_string}")
+                return jsonify({"points": ["General error with LLM JSON parsing. Raw response starts with: " + raw_json_string[:100] + "..."]})
+                
+        except google.api_core.exceptions.ResourceExhausted as quota_e:
+            print(f"ERROR: Quota Exceeded for LLM advice: {quota_e}")
+            return jsonify({"points": ["Quota Exceeded: Cannot generate overall LLM advice due to API rate limits. Please try again in a minute or two."]}), 200
+        except Exception as e:
+            print(f"ERROR: Exception generating structured Gemini advice: {e}")
+            import traceback
+            traceback.print_exc()
+            return jsonify({"points": [f"Error generating LLM advice: {type(e).__name__} - {e}"]}), 200
+
+    except Exception as e:
+        print(f"ERROR: An unexpected error occurred in /get_llm_advice: {e}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({"points": [f"An unexpected error occurred: {type(e).__name__} - {e}"]}), 500
+
+
+@app.route('/chat_llm', methods=['POST'])
+def chat_llm():
+    if gemini_model is None:
+        print("ERROR: Gemini LLM instance is not initialized or available for chat.")
+        return jsonify({"error": "LLM chat functionality unavailable. Gemini failed to load."}), 500
+    
+    try:
+        data = request.get_json()
+        user_message = data.get('message', '')
+        if not user_message:
+            return jsonify({"error": "No message provided."}), 400
+
+        print(f"Processing /chat_llm. Received message: {user_message}")
+
+        general_chat_prompt = f"Respond to the following message concisely: '{user_message}'"
+        chat_response_obj = gemini_model.generate_content(
+            general_chat_prompt,
+            generation_config=GenerationConfig(max_output_tokens=150, temperature=0.7)
+        )
+        chat_response = chat_response_obj.text.strip()
+        print(f"Gemini Raw Chat Response: {chat_response}")
+
+        json_prompt = (
+            f"Analyze the following message: '{user_message}'. "
+            f"Provide a JSON object with 'summary', 'sentiment' (positive/neutral/negative), "
+            f"and 'keywords' (array of strings). Do not include any other text outside the JSON block."
+        )
+        json_response_obj = gemini_model.generate_content(
+            [json_prompt],
+            generation_config=GenerationConfig(
+                response_mime_type="application/json",
+                max_output_tokens=200,
+                temperature=0.1
+            )
+        )
+        json_response = json_response_obj.text.strip()
+        print(f"Gemini Raw JSON Prompt Response: {json_response}")
+        
+        parsed_json_output = None
+        try:
+            parsed_json_output = json.loads(json_response)
+            print(f"Parsed JSON from Gemini chat: {parsed_json_output}")
+
+        except json.JSONDecodeError as e:
+            print(f"ERROR: JSON parsing error for chat_llm (Gemini): {e}. Raw string: {json_response}")
+        except Exception as e:
+            print(f"ERROR: General error during JSON parsing attempt for chat_llm (Gemini): {e}. Raw string: {json_response}")
+
+        return jsonify({
+            "user_message": user_message,
+            "raw_chat_response": chat_response,
+            "raw_json_prompt_response": json_response,
+            "parsed_json_metrics": parsed_json_output,
+            "status": "success"
+        }), 200
+
+    except Exception as e:
+        print(f"ERROR: Error during LLM chat: {e}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({"error": f"An error occurred during LLM chat: {str(e)}"}), 500
+
+# Health check endpoint for Hugging Face Spaces (optional, but good practice)
+@app.route('/health', methods=['GET'])
+def health_check():
+    status = {
+        "status": "up",
+        "deepmost_model_initialized": sales_agent is not None,
+        "gemini_llm_initialized": gemini_model is not None,
+        "gemini_api_key_status": gemini_api_key_status,
+        "message": "Application is running"
+    }
+    # Provide more detail if a component failed
+    if sales_agent is None:
+        status["message"] = "Application running, but DeepMost model failed to initialize."
+        status["status"] = "degraded"
+    if gemini_model is None and gemini_api_key_status != "Missing": # Only degraded if API key was provided but init failed
+         status["message"] = "Application running, but Gemini LLM failed to initialize."
+         status["status"] = "degraded"
+    elif gemini_model is None and gemini_api_key_status == "Missing":
+        status["message"] = "Application running. Gemini LLM disabled (no API key)."
+
+
+    print(f"Health check requested. Status: {status}")
+    return jsonify(status), 200
+
+# --- Main Execution Block ---
+if __name__ == '__main__':
+    try:
+        print("Attempting to start Flask app (this block is primarily for local execution).")
+        print("Application setup complete. Expecting Gunicorn to take over.")
+        
+    except Exception as startup_exception:
+        print(f"CRITICAL: An unhandled exception occurred during Flask app setup: {startup_exception}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1) # Exit with error code if startup fails

config.json

@@ -0,0 +1,3 @@
+{
+  "python_version": "3.11"
+}

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

requirements.txt

@@ -0,0 +1,8 @@
+    Flask
+    Flask-Cors
+    numpy
+    python-dotenv
+    google-generativeai
+    deepmost
+    gunicorn  # Add this line!
+