Update app.py

app.py

@@ -4,6 +4,8 @@ import json
 import requests
 from bs4 import BeautifulSoup
 import networkx as nx
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
 import matplotlib.pyplot as plt
 import numpy as np
 import io
@@ -17,8 +19,10 @@ import warnings
 plt.rcParams['font.family'] = ['DejaVu Sans']
 plt.rcParams['font.size'] = 10
 plt.rcParams['font.weight'] = 'normal'
+plt.rcParams['figure.max_open_warning'] = 0  # Disable figure warnings
 warnings.filterwarnings('ignore', category=UserWarning)
 warnings.filterwarnings('ignore', message='.*Font family.*not found.*')
+warnings.filterwarnings('ignore', message='.*Matplotlib.*')
 
 def clean_text_for_display(text):
     """Clean text to remove characters that might cause font issues."""
@@ -331,69 +335,96 @@ def build_knowledge_graph(entities_data):
         
         return pil_image
 
-def knowledge_graph_builder(url_or_text):
+def build_kg(url_or_text):
     """Main function to build knowledge graph from URL or text.
     
     Args:
         url_or_text: URL to analyze or direct text input
         
     Returns:
-        Tuple of (entities_json, graph_image, summary)
+        String: JSON containing entities, relationships, and summary
     """
     try:
         if not url_or_text or len(url_or_text.strip()) == 0:
-            return "{}", None, "Please provide some text or a URL to analyze."
+            return json.dumps({"error": "Please provide some text or a URL to analyze."})
         
         # Step 1: Fetch content
         content = fetch_content(url_or_text)
         
         if content.startswith("Error"):
-            return json.dumps({"error": content}), None, content
+            return json.dumps({"error": content})
         
         # Step 2: Extract entities
         entities_data = extract_entities(content)
         
-        # Step 3: Build knowledge graph
-        graph_image = build_knowledge_graph(entities_data)
-        
-        # Step 4: Create summary
+        # Step 3: Create summary (no image for MCP compatibility)
         num_entities = len(entities_data.get("entities", []))
         num_relationships = len(entities_data.get("relationships", []))
         
-        summary = f"""## Knowledge Graph Analysis Complete!
+        summary = f"""Knowledge Graph Analysis Complete!
 
-📊 **Statistics:**
+Statistics:
 - Entities found: {num_entities}
 - Relationships found: {num_relationships}
 - Content length: {len(content)} characters
 
-🔍 **Extracted Entities:**"""
+Extracted Entities:"""
         
         for entity in entities_data.get("entities", [])[:8]:  # Show first 8
             name = entity.get('name', 'Unknown')
             entity_type = entity.get('type', 'UNKNOWN')
             desc = entity.get('description', 'No description')
-            summary += f"\n• **{name}** ({entity_type}): {desc}"
+            summary += f"\n• {name} ({entity_type}): {desc}"
         
         if len(entities_data.get("entities", [])) > 8:
-            summary += f"\n\n... and {len(entities_data.get('entities', [])) - 8} more entities"
-        
-        # Ensure valid JSON output
-        try:
-            json_output = json.dumps(entities_data, indent=2, ensure_ascii=True)
-        except Exception as e:
-            json_output = json.dumps({"error": f"JSON serialization failed: {str(e)}"})
+            summary += f"\n... and {len(entities_data.get('entities', [])) - 8} more entities"
+        
+        # Create complete response
+        response = {
+            "success": True,
+            "entities": entities_data.get("entities", []),
+            "relationships": entities_data.get("relationships", []),
+            "summary": summary,
+            "statistics": {
+                "entity_count": num_entities,
+                "relationship_count": num_relationships,
+                "content_length": len(content)
+            }
+        }
         
-        return json_output, graph_image, summary
+        return json.dumps(response, indent=2, ensure_ascii=True)
             
     except Exception as e:
         error_msg = f"Analysis failed: {str(e)}"
-        return json.dumps({"error": error_msg}), None, error_msg
+        print(f"Function error: {error_msg}")
+        return json.dumps({"success": False, "error": error_msg})
 
 # Create Gradio interface with error handling
 try:
+    def parse_kg_output(json_result):
+        """Parse the JSON result and return separate components for UI"""
+        try:
+            data = json.loads(json_result) if isinstance(json_result, str) else json_result
+            if data.get("success"):
+                entities_json = {
+                    "entities": data.get("entities", []),
+                    "relationships": data.get("relationships", [])
+                }
+                summary = data.get("summary", "No summary available")
+                return json.dumps(entities_json, indent=2), summary
+            else:
+                error_msg = data.get("error", "Unknown error")
+                return json.dumps({"error": error_msg}), f"Error: {error_msg}"
+        except Exception as e:
+            return json.dumps({"error": str(e)}), f"Parse error: {str(e)}"
+    
+    def kg_interface(url_or_text):
+        """Interface wrapper for the knowledge graph builder"""
+        result = build_kg(url_or_text)
+        return parse_kg_output(result)
+    
     demo = gr.Interface(
-        fn=knowledge_graph_builder,
+        fn=kg_interface,
         inputs=[
             gr.Textbox(
                 label="URL or Text Input", 
@@ -404,18 +435,16 @@ try:
         ],
         outputs=[
             gr.JSON(label="Extracted Entities & Relationships"),
-            gr.Image(label="Knowledge Graph Visualization", type="pil"),
             gr.Markdown(label="Analysis Summary")
         ],
-        title="🧠 AI Knowledge Graph Builder",
+        title="🧠 KG Builder",
         description="""
-        **Transform any text or webpage into an interactive knowledge graph!**
+        **Transform any text or webpage into knowledge graphs!**
         
         This tool:
         1. 📖 Extracts content from URLs or analyzes your text
         2. 🤖 Uses AI to identify entities and relationships  
-        3. 🕸️ Builds and visualizes knowledge graphs
-        4. 📊 Provides detailed analysis summaries
+        3. 📊 Provides detailed analysis summaries
         
         **Try with:** news articles, Wikipedia pages, or any text content
         """,
@@ -430,18 +459,30 @@ except Exception as e:
     def simple_demo(text):
         return json.dumps({"error": f"Startup failed: {str(e)}"}), None, "Application failed to start properly."
     
-    demo = gr.Interface(
-        fn=simple_demo,
-        inputs=[gr.Textbox(label="Input", placeholder="Enter text...")],
-        outputs=[
-            gr.JSON(label="Error Output"),
-            gr.Image(label="No Image"),
-            gr.Markdown(label="Error Message")
-        ],
-        title="⚠️ Knowledge Graph Builder - Startup Error",
-        allow_flagging="never",
-        cache_examples=False
-    )
+    try:
+        demo = gr.Interface(
+            fn=simple_demo,
+            inputs=[gr.Textbox(label="Input", placeholder="Enter text...")],
+            outputs=[
+                gr.JSON(label="Error Output"),
+                gr.Image(label="No Image", type="filepath"),
+                gr.Markdown(label="Error Message")
+            ],
+            title="⚠️ KG Builder - Startup Error",
+            allow_flagging="never",
+            cache_examples=False
+        )
+    except Exception as e2:
+        # Ultimate fallback - minimal interface
+        def minimal_demo(text):
+            return {"error": str(e2)}
+        
+        demo = gr.Interface(
+            fn=minimal_demo,
+            inputs="text",
+            outputs="json",
+            title="KG Builder Error"
+        )
 
 # Launch the demo
 if __name__ == "__main__":