Integrate TxAgent into CPS API: add TxAgent files, update requirements, fix imports and database collections

api/routes/txagent.py

@@ -204,6 +204,20 @@ async def get_patient_analysis_results(
                 continue  # Skip if patient no longer exists
             
             # Format the response with proper fields matching the expected format
+            # Handle both old format (risk_level, risk_score) and new format (suicide_risk object)
+            suicide_risk_data = analysis.get("suicide_risk", {})
+            
+            # Extract risk data from suicide_risk object or fallback to individual fields
+            if isinstance(suicide_risk_data, dict):
+                risk_level = suicide_risk_data.get("level", "none")
+                risk_score = suicide_risk_data.get("score", 0.0)
+                risk_factors = suicide_risk_data.get("factors", [])
+            else:
+                # Fallback to individual fields for backward compatibility
+                risk_level = analysis.get("risk_level", "none")
+                risk_score = analysis.get("risk_score", 0.0)
+                risk_factors = analysis.get("risk_factors", [])
+            
             formatted_analysis = {
                 "_id": str(analysis["_id"]),
                 "patient_id": analysis.get("patient_id"),
@@ -212,9 +226,9 @@ async def get_patient_analysis_results(
                 "created_at": analysis.get("created_at"),
                 "analysis_date": analysis.get("analysis_date"),
                 "suicide_risk": {
-                    "level": _normalize_risk_level(analysis.get("risk_level", "none")),
-                    "score": analysis.get("risk_score", 0.0),
-                    "factors": analysis.get("risk_factors", [])
+                    "level": _normalize_risk_level(risk_level),
+                    "score": risk_score,
+                    "factors": risk_factors
                 },
                 "summary": analysis.get("summary", ""),
                 "recommendations": analysis.get("recommendations", [])

check_database.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+Check database directly to see analysis data
+"""
+
+import asyncio
+import motor.motor_asyncio
+import os
+from datetime import datetime
+
+async def check_database():
+    """Check database directly for analysis data"""
+    
+    print("🔍 Checking Database Directly")
+    print("=" * 50)
+    print(f"⏰ Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print()
+    
+    try:
+        # Connect to MongoDB
+        mongo_url = os.getenv('MONGODB_URL', 'mongodb://localhost:27017')
+        client = motor.motor_asyncio.AsyncIOMotorClient(mongo_url)
+        db = client.cps_database
+        
+        # Check patients collection
+        print("📊 Checking patients collection...")
+        patients_count = await db.patients.count_documents({})
+        print(f"   ✅ Found {patients_count} patients")
+        
+        if patients_count > 0:
+            # Show sample patients
+            patients = await db.patients.find({}).limit(3).to_list(length=3)
+            print("\n📋 Sample Patients:")
+            for i, patient in enumerate(patients):
+                print(f"   Patient {i+1}: {patient.get('full_name', 'Unknown')}")
+                print(f"     - ID: {patient.get('fhir_id', 'No ID')}")
+                print(f"     - Email: {patient.get('email', 'No email')}")
+                print()
+        
+        # Check analysis collection
+        print("📊 Checking analysis collection...")
+        analysis_count = await db.patient_analysis_results.count_documents({})
+        print(f"   ✅ Found {analysis_count} analysis results")
+        
+        if analysis_count > 0:
+            # Show sample analysis results
+            analyses = await db.patient_analysis_results.find({}).limit(3).to_list(length=3)
+            print("\n📋 Sample Analysis Results:")
+            for i, analysis in enumerate(analyses):
+                print(f"   Analysis {i+1}:")
+                print(f"     - Patient ID: {analysis.get('patient_id', 'No ID')}")
+                print(f"     - Timestamp: {analysis.get('timestamp', 'No timestamp')}")
+                
+                # Check suicide risk data
+                suicide_risk = analysis.get('suicide_risk', {})
+                if isinstance(suicide_risk, dict):
+                    risk_level = suicide_risk.get('level', 'No level')
+                    risk_score = suicide_risk.get('score', 0.0)
+                    risk_factors = suicide_risk.get('factors', [])
+                    print(f"     - Risk Level: {risk_level}")
+                    print(f"     - Risk Score: {risk_score}")
+                    print(f"     - Risk Factors: {risk_factors}")
+                else:
+                    print(f"     - Suicide Risk: {suicide_risk}")
+                
+                # Check summary
+                summary = analysis.get('summary', '')
+                if summary:
+                    print(f"     - Summary: {summary[:100]}...")
+                print()
+        
+        # Check if there are any patients without analysis
+        if patients_count > 0 and analysis_count > 0:
+            print("🔍 Checking for patients without analysis...")
+            patients_with_analysis = await db.patient_analysis_results.distinct('patient_id')
+            patients_without_analysis = patients_count - len(patients_with_analysis)
+            print(f"   📊 Patients with analysis: {len(patients_with_analysis)}")
+            print(f"   📊 Patients without analysis: {patients_without_analysis}")
+            
+            if patients_without_analysis > 0:
+                print("   ⚠️  Some patients need analysis!")
+                print("   💡 You may need to trigger analysis for these patients")
+        
+        client.close()
+        
+    except Exception as e:
+        print(f"❌ Database error: {e}")
+        print("💡 Make sure MongoDB is running and accessible")
+    
+    print("\n" + "="*50)
+    print("✅ Database check completed!")
+    print("\n📝 Summary:")
+    print("   - If you see analysis results with real scores, the data exists")
+    print("   - If scores are 0.0, the analysis may need to be re-run")
+    print("   - Your mobile app should show real scores if data exists")
+
+if __name__ == "__main__":
+    asyncio.run(check_database())

test_direct_connection.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+Test direct connection to cps-api-tx to check analysis results
+"""
+
+import asyncio
+import aiohttp
+import json
+from datetime import datetime
+
+async def test_direct_connection():
+    """Test direct connection to the space"""
+    
+    space_url = "https://rocketfarmstudios-cps-api-tx.hf.space"
+    
+    print("🔍 Testing Direct Connection to cps-api-tx")
+    print("=" * 50)
+    print(f"📡 Space URL: {space_url}")
+    print(f"⏰ Test started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print()
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            # Test 1: Root endpoint
+            print("🧪 Test 1: Root endpoint")
+            async with session.get(space_url, timeout=10) as response:
+                print(f"   Status: {response.status}")
+                if response.status == 200:
+                    root_data = await response.text()
+                    print(f"   ✅ Root endpoint: {root_data}")
+                else:
+                    print(f"   ❌ Root endpoint failed: {response.status}")
+                    return
+            
+            # Test 2: Analysis results endpoint (without auth)
+            print("\n🧪 Test 2: Analysis results endpoint")
+            try:
+                results_url = f"{space_url}/txagent/patients/analysis-results"
+                async with session.get(results_url, timeout=10) as response:
+                    print(f"   Status: {response.status}")
+                    if response.status == 200:
+                        results_data = await response.json()
+                        print(f"   ✅ Found {len(results_data)} analysis results")
+                        
+                        if len(results_data) > 0:
+                            print("\n📊 Analysis Results:")
+                            for i, result in enumerate(results_data[:5]):  # Show first 5 results
+                                print(f"   Result {i+1}:")
+                                print(f"     - Patient: {result.get('full_name', 'Unknown')}")
+                                print(f"     - Patient ID: {result.get('patient_id', 'No ID')}")
+                                
+                                suicide_risk = result.get('suicide_risk', {})
+                                risk_level = suicide_risk.get('level', 'No level')
+                                risk_score = suicide_risk.get('score', 0.0)
+                                risk_factors = suicide_risk.get('factors', [])
+                                
+                                print(f"     - Risk Level: {risk_level}")
+                                print(f"     - Risk Score: {risk_score}")
+                                print(f"     - Risk Factors: {risk_factors}")
+                                
+                                # Check if we have real scores
+                                if risk_score > 0:
+                                    print(f"     ✅ Real score detected: {risk_score}")
+                                else:
+                                    print(f"     ⚠️  Score is 0 - may need to trigger analysis")
+                                print()
+                        else:
+                            print("   ⚠️  No analysis results found")
+                    elif response.status == 401:
+                        print("   🔐 Authentication required - this is expected")
+                        print("   💡 The API requires login to access analysis results")
+                    else:
+                        print(f"   ❌ Failed: {response.status}")
+                        error_text = await response.text()
+                        print(f"   Error details: {error_text[:200]}...")
+                        
+            except Exception as e:
+                print(f"   ❌ Results error: {e}")
+            
+            # Test 3: Status endpoint
+            print("\n🧪 Test 3: Status endpoint")
+            try:
+                status_url = f"{space_url}/txagent/status"
+                async with session.get(status_url, timeout=10) as response:
+                    print(f"   Status: {response.status}")
+                    if response.status == 200:
+                        status_data = await response.json()
+                        print(f"   ✅ Status: {json.dumps(status_data, indent=2)}")
+                    elif response.status == 401:
+                        print("   🔐 Authentication required - this is expected")
+                    else:
+                        print(f"   ❌ Status failed: {response.status}")
+            except Exception as e:
+                print(f"   ❌ Status error: {e}")
+    
+    except Exception as e:
+        print(f"❌ Connection error: {e}")
+    
+    print("\n" + "="*50)
+    print("✅ Direct connection test completed!")
+    print("\n📝 Summary:")
+    print("   - Your Hugging Face Space is ONLINE ✅")
+    print("   - Authentication is required for analysis results (expected)")
+    print("   - Your mobile app should now be able to connect!")
+    print("   - Check your mobile app - it should show real scores if you're logged in")
+
+if __name__ == "__main__":
+    asyncio.run(test_direct_connection())