Upload app.py

app.py

@@ -17,27 +17,6 @@ from typing import Any, Dict, List, Optional
 import threading
 import time
 
-# CRITICAL: FORCE OVERRIDE ALL ENVIRONMENT VARIABLES THAT COULD INTERFERE
-print("🔧 FORCING ENVIRONMENT VARIABLE OVERRIDES...")
-
-# Remove any HF environment variables that could cause URL concatenation
-problematic_env_vars = [
-    'HF_API_URL',
-    'HF_INFERENCE_URL', 
-    'HF_ENDPOINT_URL',
-    'HF_MODEL',
-    'HUGGINGFACE_API_URL',
-    'HUGGINGFACE_INFERENCE_URL'
-]
-
-for var in problematic_env_vars:
-    if var in os.environ:
-        old_value = os.environ[var]
-        del os.environ[var]
-        print(f"🗑️ Removed environment variable: {var} = {old_value}")
-
-print("✅ Environment variables cleaned")
-
 # Add current directory to path
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
@@ -68,22 +47,14 @@ except ImportError:
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configuration - ABSOLUTELY HARDCODED VALUES (NO ENV VARS ALLOWED)
-HF_API_KEY = os.getenv('HF_API_KEY', '')  # Only this one env var is allowed
-# FORCE HARDCODED VALUES - IGNORE ALL OTHER ENVIRONMENT VARIABLES
+# Configuration - Your specific Hugging Face Inference Endpoint (hardcoded)
+HF_API_KEY = os.getenv('HF_API_KEY', '')  # Hugging Face API key from Secret
 HF_ENDPOINT_URL = "https://evxgv66ksxjlfrts.us-east-1.aws.endpoints.huggingface.cloud/v1/"
 HF_MODEL = "lmstudio-community/Llama-3.3-70B-Instruct-GGUF"  # Correct model name for your endpoint
 
-print(f"🔐 FORCED hardcoded endpoint: {HF_ENDPOINT_URL}")
-print(f"🔐 FORCED hardcoded model: {HF_MODEL}")
-print(f"🔑 HF_API_KEY configured: {'Yes' if HF_API_KEY else 'No'}")
-
-# EXTRA PROTECTION: Override any modules that might have cached env vars
-import sys
-if 'requests' in sys.modules:
-    print("🔄 Requests module detected - ensuring no cached env vars")
-if 'httpx' in sys.modules:
-    print("🔄 HTTPX module detected - ensuring no cached env vars")
+# AI Correction Configuration
+MAX_CORRECTION_ATTEMPTS = 3  # Maximum number of attempts to generate valid RDF
+ENABLE_VALIDATION_LOOP = True  # Set to False to disable validation loop for debugging
 
 # OpenAI client configuration for the endpoint
 def get_openai_client():
@@ -106,92 +77,53 @@ def get_openai_client():
 SAMPLE_VALID_RDF = '''<?xml version="1.0" encoding="UTF-8"?>
 <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
          xmlns:bf="http://id.loc.gov/ontologies/bibframe/"
-         xmlns:bflc="http://id.loc.gov/ontologies/bflc/"
          xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
     
     <bf:Work rdf:about="http://example.org/work/1">
         <rdf:type rdf:resource="http://id.loc.gov/ontologies/bibframe/Text"/>
         <bf:title>
             <bf:Title>
-                <bf:mainTitle>Complete Valid Monograph Title</bf:mainTitle>
-                <bf:subtitle>A Comprehensive Example for SHACL Validation</bf:subtitle>
-            </bf:Title>
-        </bf:title>
-        <bf:creator>
-            <bf:Agent>
-                <rdf:type rdf:resource="http://id.loc.gov/ontologies/bibframe/Person"/>
-                <rdfs:label>Valid Author Name</rdfs:label>
-            </bf:Agent>
-        </bf:creator>
-        <bf:subject>
-            <bf:Topic>
-                <rdfs:label>Library Science</rdfs:label>
-            </bf:Topic>
-        </bf:subject>
-        <bf:language>
-            <bf:Language rdf:about="http://id.loc.gov/vocabulary/languages/eng"/>
-        </bf:language>
-        <bf:hasInstance rdf:resource="http://example.org/instance/1"/>
-    </bf:Work>
-    
-    <bf:Instance rdf:about="http://example.org/instance/1">
-        <rdf:type rdf:resource="http://id.loc.gov/ontologies/bibframe/Print"/>
-        <bf:instanceOf rdf:resource="http://example.org/work/1"/>
-        <bf:title>
-            <bf:Title>
-                <bf:mainTitle>Complete Valid Monograph Title</bf:mainTitle>
+                <bf:mainTitle>Sample Monograph Title</bf:mainTitle>
             </bf:Title>
         </bf:title>
-        <bf:provisionActivity>
-            <bf:Publication>
-                <bf:date>2024</bf:date>
-                <bf:place>
-                    <bf:Place>
-                        <rdfs:label>Washington, DC</rdfs:label>
-                    </bf:Place>
-                </bf:place>
+        <bf:contribution>
+            <bf:Contribution>
                 <bf:agent>
                     <bf:Agent>
-                        <rdfs:label>Sample Publisher</rdfs:label>
+                        <rdfs:label>Sample Author</rdfs:label>
                     </bf:Agent>
                 </bf:agent>
-            </bf:Publication>
-        </bf:provisionActivity>
-        <bf:extent>
-            <bf:Extent>
-                <rdfs:label>256 pages</rdfs:label>
-            </bf:Extent>
-        </bf:extent>
-    </bf:Instance>
+                <bf:role>
+                    <bf:Role>
+                        <rdfs:label>Author</rdfs:label>
+                    </bf:Role>
+                </bf:role>
+            </bf:Contribution>
+        </bf:contribution>
+        <bf:language rdf:resource="http://id.loc.gov/vocabulary/languages/eng"/>
+        <bf:content rdf:resource="http://id.loc.gov/vocabulary/contentTypes/txt"/>
+        <bf:adminMetadata>
+            <bf:AdminMetadata>
+                <bf:assigner>
+                    <bf:Organization>
+                        <rdfs:label>Example Library</rdfs:label>
+                    </bf:Organization>
+                </bf:assigner>
+            </bf:AdminMetadata>
+        </bf:adminMetadata>
+    </bf:Work>
     
 </rdf:RDF>'''
 
 SAMPLE_INVALID_RDF = '''<?xml version="1.0" encoding="UTF-8"?>
-<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-         xmlns:bf="http://id.loc.gov/ontologies/bibframe/"
-         xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
-    
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+    <!-- Missing namespace declarations -->
+    <!-- Missing required properties -->
     <bf:Work rdf:about="http://example.org/work/1">
-        <!-- Missing rdf:type - this should cause SHACL validation failure -->
-        <bf:title>
-            <!-- Missing bf:Title wrapper - improper title structure -->
-            <bf:mainTitle>Invalid Monograph Title Structure</bf:mainTitle>
-        </bf:title>
-        <!-- Missing required bf:creator property -->
-        <!-- Missing other required properties like bf:language -->
+        <bf:title>Incomplete Title</bf:title>
+        <!-- Missing rdf:type -->
+        <!-- Missing proper title structure -->
     </bf:Work>
-    
-    <bf:Instance rdf:about="http://example.org/instance/1">
-        <rdf:type rdf:resource="http://id.loc.gov/ontologies/bibframe/Print"/>
-        <!-- Missing bf:instanceOf property - should link to Work -->
-        <bf:title>
-            <bf:Title>
-                <bf:mainTitle>Invalid Instance Title</bf:mainTitle>
-            </bf:Title>
-        </bf:title>
-        <!-- Missing required bf:provisionActivity -->
-    </bf:Instance>
-    
 </rdf:RDF>'''
 
 # MCP Server Tools (can be used independently)
@@ -265,16 +197,13 @@ def get_ai_suggestions(validation_results: str, rdf_content: str) -> str:
     
     try:
         # Use OpenAI client with your Hugging Face Inference Endpoint
-        print("🔍 Attempting to get OpenAI client for suggestions...")
         client = get_openai_client()
         if not client:
-            print("❌ OpenAI client is None for suggestions.")
             return f"""
-🔑 **AI suggestions disabled**: HF_API_KEY not configured or client creation failed.
+🔑 **AI suggestions disabled**: HF_API_KEY not configured.
 
 {generate_manual_suggestions(validation_results)}
 """
-        print(f"✅ OpenAI client obtained for suggestions. Client timeout: {client.timeout}")
         
         prompt = f"""You are an expert in RDF/XML and SHACL validation. Analyze the following validation results and provide clear, actionable suggestions for fixing the RDF issues.
 
@@ -293,9 +222,9 @@ Please provide:
 Format your response in a helpful, structured way using markdown."""
         
         # Make API call using OpenAI client
-        print(f"🔄 Making SUGGESTION API call to: {HF_ENDPOINT_URL} with model: {HF_MODEL}")
+        print(f"🔄 Making API call to: {HF_ENDPOINT_URL}")
+        print(f"🔄 Using model: {HF_MODEL}")
         print(f"🔄 Client base_url: {client.base_url}")
-        print("⏳ Attempting client.chat.completions.create() for suggestions...")
         
         chat_completion = client.chat.completions.create(
             model=HF_MODEL,
@@ -310,34 +239,73 @@ Format your response in a helpful, structured way using markdown."""
             top_p=0.9
         )
         
-        print(f"✅ client.chat.completions.create() returned for suggestions. Type: {type(chat_completion)}")
+        print("✅ API call successful")
         generated_text = chat_completion.choices[0].message.content
-        print("✅ Suggestion API call successful, content extracted.")
         return f"🤖 **AI-Powered Suggestions:**\n\n{generated_text}"
         
     except Exception as e:
-        logger.error(f"OpenAI/HF Inference Endpoint error (suggestions): {str(e)}", exc_info=True) # Added exc_info for full traceback
+        logger.error(f"OpenAI/HF Inference Endpoint error: {str(e)}")
         return f"""
 ❌ **AI suggestions error**: {str(e)}
 
 {generate_manual_suggestions(validation_results)}
 """
 
-def get_ai_correction(validation_results: str, rdf_content: str) -> str:
+def extract_rdf_from_response(response: str) -> str:
+    """
+    Extract RDF/XML content from AI response, handling code blocks.
+    
+    Args:
+        response (str): AI response that may contain RDF wrapped in code blocks
+    
+    Returns:
+        str: Extracted RDF/XML content
+    """
+    response = response.strip()
+    
+    # Handle ```xml code blocks
+    if "```xml" in response:
+        try:
+            return response.split("```xml")[1].split("```")[0].strip()
+        except IndexError:
+            pass
+    
+    # Handle generic ``` code blocks
+    if "```" in response and response.count("```") >= 2:
+        try:
+            return response.split("```")[1].split("```")[0].strip()
+        except IndexError:
+            pass
+    
+    # If no code blocks found, return the response as-is
+    return response
+
+def get_ai_correction(validation_results: str, rdf_content: str, template: str = 'monograph', max_attempts: int = None) -> str:
     """
     Generate AI-powered corrected RDF/XML based on validation errors.
     
     This tool takes invalid RDF/XML and validation results, then generates
     a corrected version that addresses all identified validation issues.
+    The generated correction is validated before being returned to the user.
     
     Args:
         validation_results (str): The validation error messages
         rdf_content (str): The original invalid RDF/XML content
+        template (str): The validation template to use
+        max_attempts (int): Maximum number of attempts to generate valid RDF (uses MAX_CORRECTION_ATTEMPTS if None)
     
     Returns:
         str: Corrected RDF/XML that should pass validation
     """
     
+    # Use configuration default if not specified
+    if max_attempts is None:
+        max_attempts = MAX_CORRECTION_ATTEMPTS
+    
+    # Check if validation loop is enabled
+    if not ENABLE_VALIDATION_LOOP:
+        max_attempts = 1  # Fall back to single attempt if validation loop disabled
+    
     if not OPENAI_AVAILABLE:
         return generate_manual_correction_hints(validation_results, rdf_content)
     
@@ -349,17 +317,15 @@ def get_ai_correction(validation_results: str, rdf_content: str) -> str:
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
     
     try:
-        # Use OpenAI client with your Hugging Face Inference Endpoint
-        print("🔍 Attempting to get OpenAI client for correction...")
         client = get_openai_client()
         if not client:
-            print("❌ OpenAI client is None for correction.")
-            return f"""<!-- AI correction disabled: HF_API_KEY not configured or client creation failed. -->
+            return f"""<!-- AI correction disabled: HF_API_KEY not configured -->
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
-        print(f"✅ OpenAI client obtained for correction. Client timeout: {client.timeout}")
         
-        prompt = f"""You are an expert in RDF/XML. Fix the following RDF/XML based on the validation errors provided.
+        # Try multiple attempts to generate valid RDF
+        for attempt in range(max_attempts):
+            prompt = f"""You are an expert in RDF/XML. Fix the following RDF/XML based on the validation errors provided.
 
 Validation Errors:
 {validation_results}
@@ -367,39 +333,69 @@ Validation Errors:
 Original RDF/XML:
 {rdf_content}
 
+{f"Previous attempt {attempt} still had validation errors. Please fix ALL issues this time." if attempt > 0 else ""}
+
 Please provide the corrected RDF/XML that addresses all validation issues.
 - Return only the corrected XML without additional explanation
 - Maintain the original structure as much as possible while fixing errors
 - Ensure all namespace declarations are present
 - Add any missing required properties
 - Fix any syntax or structural issues"""
+            
+            print(f"🔄 Correction attempt {attempt + 1}/{max_attempts}")
+            print(f"🔄 Using endpoint: {HF_ENDPOINT_URL}")
+            print(f"🔄 Using model: {HF_MODEL}")
+            
+            chat_completion = client.chat.completions.create(
+                model=HF_MODEL,
+                messages=[
+                    {
+                        "role": "user", 
+                        "content": prompt
+                    }
+                ],
+                max_tokens=2000,
+                temperature=0.3  # Lower temperature for more consistent output
+            )
+            
+            corrected_rdf = chat_completion.choices[0].message.content.strip()
+            
+            # Extract RDF content if it's wrapped in code blocks
+            corrected_rdf = extract_rdf_from_response(corrected_rdf)
+            
+            # Validate the corrected RDF
+            if VALIDATOR_AVAILABLE:
+                try:
+                    # Validate the corrected RDF using the same template
+                    conforms, new_results = validate_rdf(corrected_rdf.encode('utf-8'), template)
+                    
+                    if conforms:
+                        print(f"✅ Correction validated successfully on attempt {attempt + 1}")
+                        return f"""<!-- AI-generated correction validated successfully -->
+{corrected_rdf}"""
+                    else:
+                        print(f"❌ Correction attempt {attempt + 1} still has validation errors")
+                        # Update validation_results for next attempt
+                        validation_results = new_results
+                        
+                except Exception as e:
+                    print(f"⚠️ Error validating correction attempt {attempt + 1}: {str(e)}")
+                    # Continue to next attempt
+            else:
+                # If validator not available, return the first attempt
+                print("⚠️ Validator not available, returning unvalidated correction")
+                return corrected_rdf
         
-        # Make API call using OpenAI client
-        print(f"🔄 Making CORRECTION API call to: {HF_ENDPOINT_URL} with model: {HF_MODEL}")
-        print(f"🔄 Client base_url: {client.base_url}")
-        print("⏳ Attempting client.chat.completions.create() for correction...")
-        
-        chat_completion = client.chat.completions.create(
-            model=HF_MODEL,
-            messages=[
-                {
-                    "role": "user", 
-                    "content": prompt
-                }
-            ],
-            max_tokens=2000,
-            temperature=0.3,
-            top_p=0.9
-        )
-        
-        print(f"✅ client.chat.completions.create() returned for correction. Type: {type(chat_completion)}")
-        corrected_text = chat_completion.choices[0].message.content
-        print("✅ Correction API call successful, content extracted.")
-        return corrected_text
+        # All attempts failed
+        return f"""<!-- AI correction failed after {max_attempts} attempts to generate valid RDF -->
+<!-- The AI-generated corrections still contained validation errors -->
+<!-- Please correct manually using the validation results as a guide -->
+
+{generate_manual_correction_hints(validation_results, rdf_content)}"""
         
     except Exception as e:
-        logger.error(f"OpenAI/HF Inference Endpoint error (correction): {str(e)}", exc_info=True) # Added exc_info for full traceback
-        return f"""<!-- AI correction error: {str(e)} -->
+        logger.error(f"LLM API error: {str(e)}")
+        return f"""<!-- Error generating AI correction: {str(e)} -->
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
 
@@ -485,7 +481,7 @@ def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True)
     else:
         if use_ai:
             suggestions = get_ai_suggestions(results_text, rdf_content)
-            corrected_rdf = get_ai_correction(results_text, rdf_content)
+            corrected_rdf = get_ai_correction(results_text, rdf_content, template)
         else:
             suggestions = generate_manual_suggestions(results_text)
             corrected_rdf = generate_manual_correction_hints(results_text, rdf_content)
@@ -575,7 +571,7 @@ def create_interface():
         
         gr.HTML(f"""
         <div class="header-text">
-            <h1>🔗 RDF Validation Server with AI</h1>
+            <h1>🔍 RDF Validation Server with AI</h1>
             <p>Validate RDF/XML against SHACL schemas with AI-powered suggestions and corrections</p>
             <p><strong>Status:</strong> {api_status}</p>
             <details><summary>Debug Info</summary><pre>{debug_info}</pre></details>
@@ -609,15 +605,6 @@ def create_interface():
                     )
                 
                 validate_btn = gr.Button("🔍 Validate RDF", variant="primary", size="lg")
-                
-                # Examples and controls
-                gr.Markdown("### 📚 Examples & Tools")
-                
-                with gr.Row():
-                    example1_btn = gr.Button("✅ Valid RDF Example", variant="secondary")
-                    example2_btn = gr.Button("❌ Invalid RDF Example", variant="secondary")
-                    example3_btn = gr.Button("📖 BibFrame Example", variant="secondary")
-                    clear_btn = gr.Button("🗑️ Clear All", variant="stop")
         
         # Results section
         with gr.Row():
@@ -658,6 +645,16 @@ def create_interface():
                     placeholder="Corrected RDF will appear here after validation..."
                 )
         
+        # Examples and controls
+        with gr.Row():
+            gr.Markdown("### 📚 Examples & Tools")
+            
+        with gr.Row():
+            example1_btn = gr.Button("✅ Valid RDF Example", variant="secondary")
+            example2_btn = gr.Button("❌ Invalid RDF Example", variant="secondary")
+            example3_btn = gr.Button("📖 BibFrame Example", variant="secondary")
+            clear_btn = gr.Button("🗑️ Clear All", variant="stop")
+        
         # Event handlers
         validate_btn.click(
             fn=validate_rdf_interface,
@@ -736,16 +733,6 @@ def create_interface():
 
 # Launch configuration
 if __name__ == "__main__":
-    # Force verify environment is clean
-    print("🔍 FINAL CHECK: Verifying problematic environment variables are removed...")
-    for var in problematic_env_vars:
-        if var in os.environ:
-            print(f"⚠️ WARNING: {var} still exists! Value: {os.environ[var]}")
-            del os.environ[var]
-            print(f"🗑️ FORCE REMOVED: {var}")
-        else:
-            print(f"✅ {var} confirmed not in environment")
-    
     demo = create_interface()
     
     # Configuration for different environments
@@ -757,5 +744,6 @@ if __name__ == "__main__":
         share=False,                # Don't create gradio.live links in production
         show_error=True,            # Show errors in the interface
         show_api=True,              # Enable API endpoints
-        allowed_paths=["."]         # Allow serving files from current directory
+        allowed_paths=["."],        # Allow serving files from current directory
+        mcp_server=True             # Enable MCP server functionality (Gradio 5.28+)
     )