Update app.py

app.py

@@ -341,36 +341,72 @@ def build_ascii_diagram(entities, relationships):
         return "No entities to visualize"
     
     diagram = "KNOWLEDGE GRAPH DIAGRAM:\n"
-    diagram += "=" * 50 + "\n\n"
+    diagram += "=" * 30 + "\n\n"  # Reduced line length
     
     # Show entities by type
     entity_types = {}
-    for entity in entities[:10]:  # Limit to 10
+    for entity in entities:  # Already limited by caller
         etype = entity.get("type", "UNKNOWN")
         if etype not in entity_types:
             entity_types[etype] = []
         entity_types[etype].append(entity.get("name", "Unknown"))
     
     for etype, names in entity_types.items():
-        diagram += f"📍 {etype}:\n"
+        diagram += f"{etype}:\n"  # Removed emoji for MCP compatibility
         for name in names:
-            diagram += f"   • {name}\n"
+            diagram += f"  - {name}\n"
         diagram += "\n"
     
     # Show relationships
     if relationships:
-        diagram += "🔗 RELATIONSHIPS:\n"
-        for rel in relationships[:8]:  # Limit to 8
+        diagram += "RELATIONSHIPS:\n"  # Removed emoji for MCP compatibility
+        for rel in relationships:  # Already limited by caller
             source = rel.get("source", "?")
             target = rel.get("target", "?")
             relation = rel.get("relation", "related")
-            diagram += f"   {source} --[{relation}]--> {target}\n"
-        
-        if len(relationships) > 8:
-            diagram += f"   ... and {len(relationships) - 8} more relationships\n"
+            diagram += f"  {source} -> {target} ({relation})\n"
     
     return diagram
 
+def validate_mcp_response(response_data):
+    """Validate and sanitize response for MCP compatibility"""
+    try:
+        # Ensure all string values are ASCII-safe
+        def sanitize_strings(obj):
+            if isinstance(obj, dict):
+                return {k: sanitize_strings(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [sanitize_strings(item) for item in obj]
+            elif isinstance(obj, str):
+                # Remove non-ASCII characters and control characters
+                return re.sub(r'[^\x20-\x7E\n\r\t]', '', obj)
+            else:
+                return obj
+        
+        sanitized = sanitize_strings(response_data)
+        
+        # Test JSON serialization
+        test_json = json.dumps(sanitized, ensure_ascii=True, separators=(',', ':'))
+        
+        # Size check
+        if len(test_json) > 100000:  # 100KB hard limit
+            # Drastically reduce content
+            sanitized["entities"] = sanitized.get("entities", [])[:5]
+            sanitized["relationships"] = sanitized.get("relationships", [])[:3]
+            sanitized["diagram"] = "Knowledge graph generated (content reduced for MCP)"
+            
+        return sanitized
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Response validation failed: {str(e)}",
+            "entities": [],
+            "relationships": [],
+            "diagram": "Error generating diagram",
+            "summary": "Analysis failed during response validation"
+        }
+
 def build_kg(url_or_text):
     """Main function to build knowledge graph from URL or text.
     
@@ -382,62 +418,67 @@ def build_kg(url_or_text):
     """
     try:
         if not url_or_text or len(url_or_text.strip()) == 0:
-            return json.dumps({"error": "Please provide some text or a URL to analyze."})
+            return json.dumps({"error": "Please provide some text or a URL to analyze."}, ensure_ascii=True)
         
         # Step 1: Fetch content
         content = fetch_content(url_or_text)
         
         if content.startswith("Error"):
-            return json.dumps({"error": content})
+            return json.dumps({"error": content}, ensure_ascii=True)
         
         # Step 2: Extract entities
         entities_data = extract_entities(content)
         
-        # Step 3: Create simple ASCII diagram
+        # Step 3: Create simple ASCII diagram (truncated for MCP)
         entities = entities_data.get("entities", [])
         relationships = entities_data.get("relationships", [])
-        ascii_diagram = build_ascii_diagram(entities, relationships)
         
-        # Step 4: Create summary
+        # Limit diagram size for MCP compatibility
+        limited_entities = entities[:8]  # Reduce from 10 to 8
+        limited_relationships = relationships[:6]  # Reduce from 8 to 6
+        ascii_diagram = build_ascii_diagram(limited_entities, limited_relationships)
+        
+        # Truncate diagram if too long
+        if len(ascii_diagram) > 1000:
+            ascii_diagram = ascii_diagram[:950] + "\n... (truncated for MCP compatibility)"
+        
+        # Step 4: Create summary (more concise for MCP)
         num_entities = len(entities)
         num_relationships = len(relationships)
         
-        summary = f"""Knowledge Graph Analysis Complete!
-
-Statistics:
-- Entities: {num_entities}
-- Relationships: {num_relationships}
-- Content length: {len(content)} characters
-
-Top Entities:"""
+        summary = f"Knowledge Graph Analysis Complete!\n\nStats: {num_entities} entities, {num_relationships} relationships\n\nTop Entities:"
         
-        for entity in entities[:5]:  # Show first 5
+        for entity in entities[:3]:  # Show only first 3 for MCP
             name = entity.get('name', 'Unknown')
             entity_type = entity.get('type', 'UNKNOWN')
             summary += f"\n• {name} ({entity_type})"
         
-        if len(entities) > 5:
-            summary += f"\n... and {len(entities) - 5} more"
+        if len(entities) > 3:
+            summary += f"\n... and {len(entities) - 3} more"
         
-        # Create MCP-friendly response
+        # Create MCP-friendly response with size limits
         response = {
             "success": True,
-            "entities": entities,
-            "relationships": relationships,
+            "entities": entities[:15],  # Limit entities for MCP
+            "relationships": relationships[:10],  # Limit relationships for MCP
             "diagram": ascii_diagram,
             "summary": summary,
             "stats": {
                 "entity_count": num_entities,
                 "relationship_count": num_relationships,
-                "content_length": len(content)
+                "content_length": min(len(content), 5000)  # Cap reported length
             }
         }
         
-        return json.dumps(response, ensure_ascii=True)
+        # Validate and sanitize response for MCP compatibility
+        validated_response = validate_mcp_response(response)
+        
+        # Return compact JSON
+        return json.dumps(validated_response, ensure_ascii=True, separators=(',', ':'))
             
     except Exception as e:
         error_msg = f"Analysis failed: {str(e)}"
-        return json.dumps({"success": False, "error": error_msg})
+        return json.dumps({"success": False, "error": error_msg}, ensure_ascii=True, separators=(',', ':'))
 
 # Create Gradio interface with error handling
 try:
@@ -484,20 +525,47 @@ except Exception as e:
 # Launch the demo
 if __name__ == "__main__":
     try:
-        demo.launch(
-            mcp_server=True, 
-            share=False,
-            show_error=True,
-            quiet=False
-        )
+        # Check if running in HuggingFace Spaces or other cloud environment
+        is_hf_space = os.environ.get("SPACE_ID") is not None
+        
+        if is_hf_space:
+            # HuggingFace Spaces configuration
+            demo.launch(
+                mcp_server=True,
+                share=False,
+                show_error=True,
+                quiet=False,
+                server_name="0.0.0.0",  # Allow external connections
+                server_port=7860       # Standard HF port
+            )
+        else:
+            # Local development configuration
+            demo.launch(
+                mcp_server=True, 
+                share=False,
+                show_error=True,
+                quiet=False
+            )
     except Exception as e:
-        print(f"Launch failed: {e}")
+        print(f"MCP Launch failed: {e}")
         # Try without MCP server as fallback
         try:
             demo.launch(
                 mcp_server=False,
                 share=False,
-                show_error=True
+                show_error=True,
+                quiet=True
             )
         except Exception as e2:
             print(f"Complete failure: {e2}")
+            # Create minimal working demo
+            def error_demo(text):
+                return json.dumps({"error": f"Server startup failed: {str(e2)}"}, ensure_ascii=True)
+            
+            minimal_demo = gr.Interface(
+                fn=error_demo,
+                inputs="text",
+                outputs="text",
+                title="KG Builder - Error Mode"
+            )
+            minimal_demo.launch(share=False, quiet=True)