Initial deployment of RDF validation app to new mcp4rdf space

MonographDCTAP/Monograph_AdminMetadata.tsv

@@ -0,0 +1,3 @@
+shapeID	shapeLabel	target	propertyID	propertyLabel	valueShape	mandatory	severity	valueNodeType	repeatable	note
+big:AdminMetadata	Admin Metadata	bf:AdminMetadata	bf:creationDate	Date Cataloged or Updated/Changed		true	Violation 	literal	false	
+big:AdminMetadata	Admin Metadata	bf:AdminMetadata	bf:assigner	Cataloging institution		true	Violation 	IRI; bnode	false	

MonographDCTAP/Monograph_Instance_Print.tsv

@@ -0,0 +1,23 @@
+shapeID	shapeLabel	target	propertyID	propertyLabel	valueShape	mandatory	severity	valueNodeType	repeatable	note
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:instanceOf	Instance of	big:Monograph:Work	true	Violation	IRI; bnode	true	
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:title	Instance Title	big:Title	true	Violation	IRI; bnode	true	
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:editionStatement	Edition Statement		true	Warning	literal	true	
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:provisionActivity	Provision Activity--Publication Information	big:ProvisionActivity	true	Violation	IRI; bnode	true	
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:seriesStatement	Series Statement		true	Warning	literal	true	
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:identifiedBy	Identifiers		true	Warning	IRI; bnode	true	e.g., ISBN
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:issuance	Mode of Issuance		true	Violation	IRI; bnode	false	
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:media	Media type		true	Violation	IRI; bnode	true	 
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:carrier	Carrier type		true	Violation	IRI; bnode	true	
+big:Monograph:Instance:Print	Instance (Monograph) Print	bf:Print	bf:adminMetadata	Administrative metadata		true	Violation	IRI; bnode	true	*adminMetadata should be at the Work and Instance levels but the requirements are the same for both
+big:Title	Instance Title	bf:Title	bf:mainTitle	Main Title		true	Violation	literal	false	Move to Title Sheet and add other title types
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity	bf:agent	Agent	big:Agent	true	Warning	IRI; bnode	true	prefer use of bf:agent in Provision Activity but if no bf:agent exists, then use bf:simpleAgent (below)
+big:Agent		bf:Agent ; bf:Person ; bf:Family ; bf:Organization ; bf:Jurisdiction ; bf:Meeting	rdfs:label	Agent Label		true	Warning	literal	true	
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity	bflc:simpleAgent	Agent Simple Label	   	true	Warning	literal	true	prefer use of bf:agent (above) in Provision Activity but if no bf:agent exists, then use bf:simpleAgent
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity; bf:Distribution; bf:Manufacture; bf:Production; bf:Publication; bf:Modification	bf:date	Date		true	Warning	literal	true	Pull both types of dates if they exist as the formatting may differ
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity; bf:Distribution; bf:Manufacture; bf:Production; bf:Publication; bf:Modification	bflc:simpleDate	Simple Date		true	Warning	literal	true	Pull both types of dates if they exist as the formatting may differ
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity; bf:Distribution; bf:Manufacture; bf:Production; bf:Publication; bf:Modification	bf:place 	Place	big:Place	true	Warning	IRI; bnode	true	Pull both bf:place and bf:simplePlace LC uses bf:place to indicate the country of publication
+big:Place		bf:Place	rdfs:label	Place Label		true	Warning	literal	true	
+ProvisionActivityShape	Provision Activity	bf:ProvisionActivity; bf:Distribution; bf:Manufacture; bf:Production; bf:Publication; bf:Modification	bflc:simplePlace	Place Simple Label		true	Warning	literal	true	
+										
+										
+						   				

MonographDCTAP/Monograph_Prefixes.tsv

@@ -0,0 +1,5 @@
+Vocabulary	Prefix	Namespace
+BIBFRAME	bf:	http://id.loc.gov/ontologies/bibframe/
+BIBFRAME LC Extension Ontology	bflc:	http://id.loc.gov/ontologies/bflc/
+Resource Description Framework Schema	rdfs:	http://www.w3.org/2000/01/rdf-schema#
+BIBFRAME Interoperbility Group Shapes	big:	https://example.org/

MonographDCTAP/Monograph_Work_Text.tsv

@@ -0,0 +1,16 @@
+shapeID	shapeLabel	target	propertyID	propertyLabel	valueShape	mandatory	severity	valueNodeType	repeatable	note
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:title	Work Title	big:Title	true	Violation 	IRI ; bnode	true	Change to 'SeeTitle Sheet' per AdminMetadata
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:contribution	Contribution	big:Contribution	true	Warning 	IRI ; bnode	true	required if applicable.  Should be included if it is there
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:genreForm	Form/Genre of Work		true	Warning 	IRI ; bnode	true	From discussion - consider Work subclasses as sufficient
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:originDate	Date of Work		true	Warning	literal	true	
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:originPlace	Place of Origin of the Work		true	Warning	IRI ; bnode	false	
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:language	Language		true	Violation	IRI	true	
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:subject	Subject of the Work		true	Warning	IRI ; bnode	true	
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:classification	Classification numbers		true	Warning	IRI ; bnode	true	
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:content 	Content Type		true	Violation	IRI ; bnode	true	*Thought to make this false, leveraging the subclass information for the same - will this fulfill this need?  If not, how to address missing data here?  uncontrolled labels .  Essential for differentiation/identification.
+big:Monograph:Work	Work (Monograph) Text	bf:Text ; bf:Monograph	bf:adminMetadata	Administrative metadata		true	Violation	IRI ; bnode	true	See AdminMetadata Sheet
+big:Title	Monograph Title	bf:Title	bf:mainTitle	Main Title		true	Violation	literal	false	Move to Title Sheet and add other title types
+big:Contribution	Contribution	bf:Contribution; bf:PrimaryContribution	bf:agent	Agent	big:Agent	true	Warning	IRI ; bnode	true	
+big:Contribution	Contribution	bf:Contribution; bf:PrimaryContribution	bf:role	Role	big:Role	true	Warning	IRI ; bnode	true	
+big:Agent	Agent	bf:Agent ; bf:Person ; bf:Family ; bf:Organization ; bf:Jurisdiction ; bf:Meeting	rdfs:label	Agent Label		true	Warning	literal	true	
+big:Role	Role	bf:Role	rdfs:label	Role Label		true	Warning	literal	true	

app.py

@@ -0,0 +1,703 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Gradio App for RDF Validation with MCP Server and Anthropic AI
+
+This app serves both as a web interface and can expose MCP server functionality.
+Deploy this on Hugging Face Spaces with your Anthropic API key.
+"""
+
+import gradio as gr
+import os
+import json
+import sys
+import asyncio
+import logging
+import requests
+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__)))
+
+# Import our validation logic
+try:
+    from validator import validate_rdf
+    VALIDATOR_AVAILABLE = True
+except ImportError:
+    VALIDATOR_AVAILABLE = False
+    print("⚠️ Warning: validator.py not found. Some features may be limited.")
+
+# Optional: Check if OpenAI and requests are available
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    print("💡 Install 'openai' package for AI-powered corrections: pip install openai")
+
+try:
+    import requests
+    HF_INFERENCE_AVAILABLE = True
+except ImportError:
+    HF_INFERENCE_AVAILABLE = False
+    print("💡 Install 'requests' package for AI-powered corrections: pip install requests")
+
+# Set up logging
+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
+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")
+
+# OpenAI client configuration for the endpoint
+def get_openai_client():
+    """Get configured OpenAI client for HF Inference Endpoint"""
+    if not HF_API_KEY:
+        print("❌ No HF_API_KEY available for OpenAI client")
+        return None
+    
+    print(f"🔗 Creating OpenAI client with:")
+    print(f"   base_url: {HF_ENDPOINT_URL}")
+    print(f"   api_key: {'***' + HF_API_KEY[-4:] if len(HF_API_KEY) > 4 else 'HIDDEN'}")
+    
+    return OpenAI(
+        base_url=HF_ENDPOINT_URL,
+        api_key=HF_API_KEY,
+        timeout=120.0  # Increase timeout for cold starts
+    )
+
+# Sample RDF data for examples
+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: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>Sample Monograph Title</bf:mainTitle>
+            </bf:Title>
+        </bf:title>
+        <bf:creator>
+            <bf:Agent>
+                <rdfs:label>Sample Author</rdfs:label>
+            </bf:Agent>
+        </bf:creator>
+    </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#">
+    <!-- Missing namespace declarations -->
+    <!-- Missing required properties -->
+    <bf:Work rdf:about="http://example.org/work/1">
+        <bf:title>Incomplete Title</bf:title>
+        <!-- Missing rdf:type -->
+        <!-- Missing proper title structure -->
+    </bf:Work>
+</rdf:RDF>'''
+
+# MCP Server Tools (can be used independently)
+def validate_rdf_tool(rdf_content: str, template: str = "monograph") -> dict:
+    """
+    Validate RDF/XML content against SHACL templates.
+    
+    This tool validates RDF/XML data against predefined SHACL shapes to ensure
+    compliance with metadata standards like BIBFRAME. Returns detailed validation
+    results with conformance status and specific violation information.
+    
+    Args:
+        rdf_content (str): The RDF/XML content to validate
+        template (str): Validation template to use ('monograph' or 'custom')
+    
+    Returns:
+        dict: Validation results with conformance status and detailed feedback
+    """
+    if not rdf_content:
+        return {"error": "No RDF/XML content provided", "conforms": False}
+    
+    if not VALIDATOR_AVAILABLE:
+        return {
+            "error": "Validator not available - ensure validator.py is present",
+            "conforms": False
+        }
+    
+    try:
+        conforms, results_text = validate_rdf(rdf_content.encode('utf-8'), template)
+        
+        return {
+            "conforms": conforms,
+            "results": results_text,
+            "template": template,
+            "status": "✅ Valid RDF" if conforms else "❌ Invalid RDF"
+        }
+        
+    except Exception as e:
+        logger.error(f"Validation error: {str(e)}")
+        return {
+            "error": f"Validation failed: {str(e)}",
+            "conforms": False
+        }
+
+def get_ai_suggestions(validation_results: str, rdf_content: str) -> str:
+    """
+    Generate AI-powered fix suggestions for invalid RDF/XML.
+    
+    This tool analyzes validation results and provides actionable suggestions
+    for fixing RDF/XML validation errors using AI or rule-based analysis.
+    
+    Args:
+        validation_results (str): The validation error messages
+        rdf_content (str): The original RDF/XML content that failed validation
+    
+    Returns:
+        str: Detailed suggestions for fixing the RDF validation issues
+    """
+    
+    if not OPENAI_AVAILABLE:
+        return generate_manual_suggestions(validation_results)
+    
+    # Get API key dynamically at runtime
+    current_api_key = os.getenv('HF_API_KEY', '')
+    if not current_api_key:
+        return f"""
+🔑 **AI suggestions disabled**: Please set your Hugging Face API key as a Secret in your Space settings.
+
+{generate_manual_suggestions(validation_results)}
+"""
+    
+    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.
+
+{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.
+
+Validation Results:
+{validation_results}
+
+Original RDF (first 1000 chars):
+{rdf_content[:1000]}...
+
+Please provide:
+1. A clear summary of what's wrong
+2. Specific step-by-step instructions to fix each issue
+3. Example corrections where applicable
+4. Best practices to prevent similar issues
+
+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"🔄 Client base_url: {client.base_url}")
+        print("⏳ Attempting client.chat.completions.create() for suggestions...")
+        
+        chat_completion = client.chat.completions.create(
+            model=HF_MODEL,
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ],
+            max_tokens=1500,
+            temperature=0.7,
+            top_p=0.9
+        )
+        
+        print(f"✅ client.chat.completions.create() returned for suggestions. Type: {type(chat_completion)}")
+        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
+        return f"""
+❌ **AI suggestions error**: {str(e)}
+
+{generate_manual_suggestions(validation_results)}
+"""
+
+def get_ai_correction(validation_results: str, rdf_content: str) -> 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.
+    
+    Args:
+        validation_results (str): The validation error messages
+        rdf_content (str): The original invalid RDF/XML content
+    
+    Returns:
+        str: Corrected RDF/XML that should pass validation
+    """
+    
+    if not OPENAI_AVAILABLE:
+        return generate_manual_correction_hints(validation_results, rdf_content)
+    
+    # Get API key dynamically at runtime
+    current_api_key = os.getenv('HF_API_KEY', '')
+    if not current_api_key:
+        return f"""<!-- AI correction disabled: Set HF_API_KEY as a Secret in your Space settings -->
+
+{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. -->
+
+{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.
+
+Validation Errors:
+{validation_results}
+
+Original RDF/XML:
+{rdf_content}
+
+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"""
+        
+        # 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
+        
+    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)} -->
+
+{generate_manual_correction_hints(validation_results, rdf_content)}"""
+
+def generate_manual_suggestions(validation_results: str) -> str:
+    """Generate rule-based suggestions when AI is not available"""
+    suggestions = []
+    
+    if "Constraint Violation" in validation_results:
+        suggestions.append("• Fix SHACL constraint violations by ensuring required properties are present")
+    
+    if "Missing property" in validation_results or "missing" in validation_results.lower():
+        suggestions.append("• Add missing required properties (check template requirements)")
+    
+    if "datatype" in validation_results.lower():
+        suggestions.append("• Correct data type mismatches (ensure proper literal types)")
+    
+    if "namespace" in validation_results.lower() or "prefix" in validation_results.lower():
+        suggestions.append("• Add missing namespace declarations at the top of your RDF")
+    
+    if "XML" in validation_results or "syntax" in validation_results.lower():
+        suggestions.append("• Fix XML syntax errors (check for unclosed tags, invalid characters)")
+    
+    if not suggestions:
+        suggestions.append("• Review detailed validation results for specific issues")
+        suggestions.append("• Ensure your RDF follows the selected template requirements")
+    
+    suggestions_text = "\n".join(suggestions)
+    
+    return f"""
+📋 **Manual Analysis:**
+
+{suggestions_text}
+
+💡 **General Tips:**
+• Check namespace declarations at the top of your RDF
+• Ensure all required properties are present
+• Verify data types match expected formats
+• Make sure XML structure is well-formed
+
+🔧 **Common Fixes:**
+• Add missing namespace prefixes
+• Include required properties like rdf:type
+• Fix malformed URIs or literals
+• Ensure proper XML syntax
+"""
+
+def generate_manual_correction_hints(validation_results: str, rdf_content: str) -> str:
+    """Generate manual correction hints when AI is not available"""
+    return f"""<!-- Manual correction hints based on validation results -->
+<!-- Set HF_API_KEY as a Secret in your Space settings for AI-powered corrections -->
+
+{rdf_content}
+
+<!-- 
+VALIDATION ISSUES FOUND:
+{validation_results[:500]}...
+
+MANUAL CORRECTION STEPS:
+1. Add missing namespace declarations
+2. Include required properties (rdf:type, etc.)
+3. Fix XML syntax errors
+4. Ensure proper URI formats
+5. Validate data types
+-->"""
+
+def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True):
+    """Main validation function for Gradio interface"""
+    if not rdf_content.strip():
+        return "❌ Error", "No RDF/XML data provided", "", ""
+    
+    # Validate RDF
+    result = validate_rdf_tool(rdf_content, template)
+    
+    if "error" in result:
+        return f"❌ Error: {result['error']}", "", "", ""
+    
+    status = result["status"]
+    results_text = result["results"]
+    
+    if result["conforms"]:
+        suggestions = "✅ No issues found! Your RDF/XML is valid according to the selected template."
+        corrected_rdf = "<!-- Already valid - no corrections needed -->\n" + rdf_content
+    else:
+        if use_ai:
+            suggestions = get_ai_suggestions(results_text, rdf_content)
+            corrected_rdf = get_ai_correction(results_text, rdf_content)
+        else:
+            suggestions = generate_manual_suggestions(results_text)
+            corrected_rdf = generate_manual_correction_hints(results_text, rdf_content)
+    
+    return status, results_text, suggestions, corrected_rdf
+
+def get_rdf_examples(example_type: str = "valid") -> str:
+    """
+    Retrieve example RDF/XML snippets for testing and learning.
+    
+    This tool provides sample RDF/XML content that can be used to test
+    the validation system or learn proper RDF structure.
+    
+    Args:
+        example_type (str): Type of example ('valid', 'invalid', or 'bibframe')
+    
+    Returns:
+        str: RDF/XML example content
+    """
+    examples = {
+        "valid": SAMPLE_VALID_RDF,
+        "invalid": SAMPLE_INVALID_RDF,
+        "bibframe": '''<?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#">
+    
+    <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>Example Book Title</bf:mainTitle>
+            </bf:Title>
+        </bf:title>
+        <bf:provisionActivity>
+            <bf:Publication>
+                <bf:date>2024</bf:date>
+                <bf:place>
+                    <bf:Place>
+                        <rdfs:label>New York</rdfs:label>
+                    </bf:Place>
+                </bf:place>
+            </bf:Publication>
+        </bf:provisionActivity>
+    </bf:Instance>
+    
+</rdf:RDF>'''
+    }
+    
+    return examples.get(example_type, examples["valid"])
+
+# Create Gradio Interface
+def create_interface():
+    """Create the main Gradio interface"""
+    
+    # Check API key status dynamically
+    current_api_key = os.getenv('HF_API_KEY', '')
+    api_status = "🔑 AI features enabled" if (OPENAI_AVAILABLE and current_api_key) else "⚠️ AI features disabled (set HF_API_KEY)"
+    
+    with gr.Blocks(
+        title="RDF Validation Server with AI",
+        theme=gr.themes.Soft(),
+        css="""
+        .status-box { 
+            font-weight: bold; 
+            padding: 10px; 
+            border-radius: 5px; 
+        }
+        .header-text {
+            text-align: center;
+            padding: 20px;
+        }
+        """
+    ) as demo:
+        
+        # Header
+        debug_info = f"""
+        Debug Info:
+        - OPENAI_AVAILABLE: {OPENAI_AVAILABLE}
+        - HF_INFERENCE_AVAILABLE: {HF_INFERENCE_AVAILABLE}
+        - HF_API_KEY set: {'Yes' if current_api_key else 'No'}
+        - HF_API_KEY length: {len(current_api_key) if current_api_key else 0}
+        - HF_ENDPOINT_URL: {HF_ENDPOINT_URL}
+        - HF_MODEL: {HF_MODEL}
+        """
+        
+        gr.HTML(f"""
+        <div class="header-text">
+            <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>
+        </div>
+        """)
+        
+        # Main interface
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📝 Input")
+                
+                rdf_input = gr.Textbox(
+                    label="RDF/XML Content",
+                    placeholder="Paste your RDF/XML content here...",
+                    lines=15,
+                    show_copy_button=True
+                )
+                
+                with gr.Row():
+                    template_dropdown = gr.Dropdown(
+                        label="Validation Template",
+                        choices=["monograph", "custom"],
+                        value="monograph",
+                        info="Select the SHACL template to validate against"
+                    )
+                    
+                    use_ai_checkbox = gr.Checkbox(
+                        label="Use AI Features",
+                        value=True,
+                        info="Enable AI-powered suggestions and corrections"
+                    )
+                
+                validate_btn = gr.Button("🔍 Validate RDF", variant="primary", size="lg")
+        
+        # Results section
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 📊 Results")
+                
+                status_output = gr.Textbox(
+                    label="Validation Status",
+                    interactive=False,
+                    lines=1,
+                    elem_classes=["status-box"]
+                )
+                
+                results_output = gr.Textbox(
+                    label="Detailed Validation Results",
+                    interactive=False,
+                    lines=8,
+                    show_copy_button=True
+                )
+                
+                suggestions_output = gr.Textbox(
+                    label="💡 Fix Suggestions",
+                    interactive=False,
+                    lines=8,
+                    show_copy_button=True
+                )
+        
+        # Corrected RDF section
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 🛠️ AI-Generated Corrections")
+                
+                corrected_output = gr.Textbox(
+                    label="Corrected RDF/XML",
+                    interactive=False,
+                    lines=15,
+                    show_copy_button=True,
+                    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,
+            inputs=[rdf_input, template_dropdown, use_ai_checkbox],
+            outputs=[status_output, results_output, suggestions_output, corrected_output]
+        )
+        
+        # Auto-validate on input change (debounced)
+        rdf_input.change(
+            fn=validate_rdf_interface,
+            inputs=[rdf_input, template_dropdown, use_ai_checkbox],
+            outputs=[status_output, results_output, suggestions_output, corrected_output]
+        )
+        
+        # Example buttons
+        example1_btn.click(
+            lambda: get_rdf_examples("valid"),
+            outputs=[rdf_input]
+        )
+        
+        example2_btn.click(
+            lambda: get_rdf_examples("invalid"),
+            outputs=[rdf_input]
+        )
+        
+        example3_btn.click(
+            lambda: get_rdf_examples("bibframe"),
+            outputs=[rdf_input]
+        )
+        
+        clear_btn.click(
+            lambda: ("", "", "", "", ""),
+            outputs=[rdf_input, status_output, results_output, suggestions_output, corrected_output]
+        )
+        
+        # Footer with instructions
+        gr.Markdown("""
+        ---
+        ### 🚀 **Deployment Instructions for Hugging Face Spaces:**
+        
+        1. **Create a new Space** on [Hugging Face](https://huggingface.co/spaces)
+        2. **Set up your Hugging Face Inference Endpoint** and get the endpoint URL
+        3. **Set your tokens** in Space settings (use Secrets for security):
+           - Go to Settings → Repository secrets  
+           - Add: `HF_API_KEY` = `your_huggingface_api_key_here`
+           - Endpoint is now hardcoded to your specific Inference Endpoint
+        4. **Upload these files** to your Space repository
+        5. **Install requirements**: The Space will auto-install from `requirements.txt`
+        
+        ### 🔧 **MCP Server Mode:**
+        This app functions as both a web interface AND an MCP server for Claude Desktop and other MCP clients.
+        
+        **Available MCP Tools (via SSE):**
+        - `validate_rdf_tool`: Validate RDF/XML against SHACL shapes
+        - `get_ai_suggestions`: Get AI-powered fix suggestions  
+        - `get_ai_correction`: Generate corrected RDF/XML
+        - `get_rdf_examples`: Retrieve example RDF snippets
+        
+        **MCP Connection:** 
+        1. When deployed on Hugging Face Spaces, the MCP server is available at:
+           `https://your-space-id.hf.space/gradio_api/mcp/sse`
+        2. Use this URL in Claude Desktop's MCP configuration
+        3. The app automatically exposes functions with proper docstrings as MCP tools
+        
+        ### 💡 **Features:**
+        - ✅ Real-time RDF/XML validation against SHACL schemas
+        - 🤖 AI-powered error suggestions and corrections (with HF Inference Endpoint)
+        - 📚 Built-in examples and templates
+        - 🔄 Auto-validation as you type
+        - 📋 Copy results with one click
+        
+        **Note:** AI features require a valid Hugging Face API key (HF_API_KEY) set as a Secret. Manual suggestions are provided as fallback.
+        """)
+    
+    return demo
+
+# 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
+    port = int(os.getenv('PORT', 7860))  # Hugging Face uses PORT env variable
+    
+    demo.launch(
+        server_name="0.0.0.0",      # Important for external hosting
+        server_port=port,           # Use environment PORT or default to 7860
+        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
+    )

electronic_MonographDCTAP/Monograph_Instance_Electronic.tsv

@@ -0,0 +1,24 @@
+shapeID	shapeLabel	target	propertyID	propertyLabel	valueShape	mandatory	severity	valueNodeType	repeatable	note
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:instanceOf	Instance of	big:Monograph:Work	true	Violation	IRI; bnode	true	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:title	Instance Title	big:Title	true	Violation	IRI; bnode	true	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:editionStatement	Edition Statement		true	Warning	literal	true	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:provisionActivity	Provision Activity--Publication Information	big:ProvisionActivity	true	Violation	IRI; bnode	true	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:seriesStatement	Series Statement		true	Warning 	literal	true	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:identifiedBy	Identifiers		true	Warning 	IRI; bnode	true	e.g., ISBN
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:issuance	Mode of Issuance		true	Violation	IRI; bnode	false	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:media	Media type		true	Violation	IRI; bnode	true	 
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:carrier	Carrier type		true	Violation	IRI; bnode	true	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:electronicLocator	Uniform Resource Locator for resource		true	Warning	IRI; bnode	true	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:digitalCharacteristic	Digital Characteristic	big:DigitalCharacteristic	true	Warning	IRI; bnode	false	
+big:Monograph:Instance:Electronic	Instance (Monograph) Electronic	bf:Electronic	bf:adminMetadata	Administrative metadata		true	Violation	IRI; bnode	true	*adminMetadata should be at the Work and Instance levels but the requirements are the same for both
+big:Title	Instance Title	bf:Title	bf:mainTitle	Main Title		true	Violation	literal	false	Move to Title Sheet and add other title types
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity ; bf:Distribution ; bf:Manufacture ; bf:Production ; bf:Publication ; bf:Modification	bf:agent	Agent	big:AgentShape	true	Warning	IRI; bnode	true	prefer use of bf:agent in Provision Activity but if no bf:agent exists, then use bf:simpleAgent (below)
+big:Agent		bf:Agent ; bf:Person ; bf:Family ; bf:Organization ; bf:Jurisdiction ; bf:Meeting	rdfs:label	Agent Label		true	Warning	literal	true	
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity ; bf:Distribution ; bf:Manufacture ; bf:Production ; bf:Publication ; bf:Modification	bflc:simpleAgent	Agent Simple Label	big:Agent	true	Warning	literal	true	prefer use of bf:agent (above) in Provision Activity but if no bf:agent exists, then use bf:simpleAgent
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity ; bf:Distribution ; bf:Manufacture ; bf:Production ; bf:Publication ; bf:Modification	bf:date	Date		true	Warning	literal	true	Pull both types of dates if they exist as the formatting may differ
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity ; bf:Distribution ; bf:Manufacture ; bf:Production ; bf:Publication ; bf:Modification	bflc:simpleDate	Simple Date		true	Warning	literal	true	Pull both types of dates if they exist as the formatting may differ
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity ; bf:Distribution ; bf:Manufacture ; bf:Production ; bf:Publication ; bf:Modification	bf:place 	Place	big:Place	true	Warning	IRI; bnode	true	Pull both bf:place and bf:simplePlace LC uses bf:place to indicate the country of publication
+big:Place		bf:Place	rdfs:label	Place Label		true	Warning	literal	true	
+big:ProvisionActivity	Provision Activity	bf:ProvisionActivity ; bf:Distribution ; bf:Manufacture ; bf:Production ; bf:Publication ; bf:Modification	bflc:simplePlace	Place Simple Label		true	Warning	literal	true	
+big:DigitalCharacteristic	Digital Characteristic	bf:FileType	bf:digitalCharacteristic	File Type		true	Warning	literal	true	
+big:DigitalCharacteristic	Digital Characteristic	bf:EncodingFormat	bf:digitalCharacteristic	Encoding Format		true	Warning	literal	true	

requirements.txt

@@ -0,0 +1,24 @@
+# Requirements for Hugging Face Gradio App with MCP Server
+# Core dependencies
+gradio>=4.0.0
+rdflib>=7.0.0
+pySHACL>=0.25.0
+pandas>=2.0.0
+
+# AI integrations
+huggingface_hub>=0.20.0
+openai>=1.0.0
+
+# MCP support (optional)
+mcp>=0.9.0
+
+# Web and utilities
+flask>=2.3.0
+flask-cors>=4.0.0
+requests>=2.31.0
+waitress>=2.1.0
+
+# Additional utilities
+python-dotenv>=1.0.0
+aiofiles>=23.0.0
+asyncio-mqtt>=0.13.0

validator.py

@@ -0,0 +1,313 @@
+import os
+import logging
+import pandas as pd
+import rdflib
+from rdflib import Namespace, Literal, BNode, RDF, RDFS
+from pyshacl import validate
+
+# Set up basic logging (use DEBUG level to see detailed output)
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
+
+BASE_DIR = os.path.join(os.path.dirname(__file__), "MonographDCTAP")
+
+TSV_FILES = [
+    "MonographDCTAP/Monograph_Work_Text.tsv",
+    "MonographDCTAP/Monograph_AdminMetadata.tsv",
+    "MonographDCTAP/Monograph_Instance_Print.tsv",
+    "electronic_MonographDCTAP/Monograph_Instance_Electronic.tsv",
+]
+PREFIX_FILE = "./MonographDCTAP/Monograph_Prefixes.tsv"
+
+# Add a global constant for fixed prefixes.
+FIXED_PREFIXES = {
+    "bf": "http://id.loc.gov/ontologies/bibframe/",
+    "bflc": "http://id.loc.gov/ontologies/bflc/",
+    "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
+    "big": "https://example.org/"
+}
+
+# Replace load_prefixes() with a simplified function:
+def load_prefixes(prefixes_file):
+    logging.info("Using hardcoded prefixes:")
+    for p, ns in FIXED_PREFIXES.items():
+        logging.info(f"{p} -> {ns}")
+    return FIXED_PREFIXES
+
+# Optionally simplify register_prefixes and _bind_namespaces:
+def register_prefixes(graph, prefixes):
+    for prefix, uri in prefixes.items():
+        graph.bind(prefix, Namespace(uri), override=True)
+        
+def _bind_namespaces(graph: rdflib.Graph):
+    # Hard-code the fixed namespaces as well.
+    graph.namespace_manager.bind("bf", Namespace(FIXED_PREFIXES["bf"]))
+    graph.namespace_manager.bind("bflc", Namespace(FIXED_PREFIXES["bflc"]))
+    graph.namespace_manager.bind("rdfs", Namespace(FIXED_PREFIXES["rdfs"]))
+    graph.namespace_manager.bind("big", Namespace(FIXED_PREFIXES["big"]))
+
+def _prop_id_to_uri(property_id, prefixes):
+    if ":" in property_id:
+        prefix, suffix = property_id.split(":", 1)
+        ns = prefixes.get(prefix.strip())
+        if ns:
+            return rdflib.URIRef(ns + suffix.strip())
+    if property_id.startswith("http"):
+        return rdflib.URIRef(property_id)
+    return Literal(property_id)
+
+def add_shape_from_row(graph, row, prefixes):
+    shape_uri = rdflib.URIRef(row['shapeID'])
+    logging.info(f"Processing shape: {shape_uri}")
+    if (shape_uri, RDF.type, rdflib.URIRef("http://www.w3.org/ns/shacl#NodeShape")) not in graph:
+        graph.add((shape_uri, RDF.type, rdflib.URIRef("http://www.w3.org/ns/shacl#NodeShape")))
+        graph.add((shape_uri, RDFS.label, Literal(row['shapeLabel'])))
+        logging.info(f"Added NodeShape: {shape_uri} with label {row['shapeLabel']}")
+    targets = [t.strip() for t in str(row['target']).split(";")]
+    for target in targets:
+        target_uri = _prop_id_to_uri(target, prefixes)
+        graph.add((shape_uri, rdflib.URIRef("http://www.w3.org/ns/shacl#targetClass"), target_uri))
+        logging.info(f"Added target '{target_uri}' to shape {shape_uri}")
+    
+    # If the property is mandatory, add a SPARQLTarget to force evaluation of nodes missing the property.
+    if str(row['mandatory']).strip().lower() == "true":
+        property_uri = _prop_id_to_uri(row['propertyID'], prefixes)
+        target_uris = [ _prop_id_to_uri(t, prefixes) for t in targets ]
+        union_clause = " UNION ".join([f"{{ ?this a <{uri}> }}" for uri in target_uris])
+        query = f"SELECT ?this WHERE {{ {union_clause} FILTER NOT EXISTS {{ ?this <{property_uri}> ?o }} }}"
+        bnode = BNode()
+        sh = rdflib.URIRef("http://www.w3.org/ns/shacl#")
+        # Use RDF.type triple to mark the bnode as a SPARQLTarget
+        graph.add((bnode, RDF.type, rdflib.URIRef("http://www.w3.org/ns/shacl#SPARQLTarget")))
+        graph.add((bnode, rdflib.URIRef("http://www.w3.org/ns/shacl#select"), Literal(query)))
+        graph.add((shape_uri, rdflib.URIRef("http://www.w3.org/ns/shacl#target"), bnode))
+        logging.info(f"Added SPARQLTarget with query: {query} to shape {shape_uri}")
+
+    property_bnode = BNode()
+    graph.add((shape_uri, rdflib.URIRef("http://www.w3.org/ns/shacl#property"), property_bnode))
+    graph.add((property_bnode, RDF.type, rdflib.URIRef("http://www.w3.org/ns/shacl#PropertyShape")))
+    graph.add((property_bnode, RDFS.label, Literal(row['propertyLabel'])))
+    path_uri = _prop_id_to_uri(row['propertyID'], prefixes)
+    graph.add((property_bnode, rdflib.URIRef("http://www.w3.org/ns/shacl#path"), path_uri))
+    logging.info(f"Added property shape for property {row['propertyID']} with label {row['propertyLabel']}")
+    if str(row['mandatory']).strip().lower() == "true":
+        graph.add((property_bnode, rdflib.URIRef("http://www.w3.org/ns/shacl#minCount"), Literal(1)))
+        logging.info(f"Set minCount 1 for property {row['propertyID']}")
+    if str(row['repeatable']).strip().lower() == "false":
+        graph.add((property_bnode, rdflib.URIRef("http://www.w3.org/ns/shacl#maxCount"), Literal(1)))
+        logging.info(f"Set maxCount 1 for property {row['propertyID']}")
+    severity = str(row.get("severity", "")).strip()
+    if severity:
+        sev_ns = rdflib.URIRef("http://www.w3.org/ns/shacl#")
+        if severity == "Violation":
+            graph.add((property_bnode, rdflib.URIRef("http://www.w3.org/ns/shacl#severity"), 
+                       rdflib.URIRef(sev_ns + "Violation")))
+        elif severity == "Warning":
+            graph.add((property_bnode, rdflib.URIRef("http://www.w3.org/ns/shacl#severity"), 
+                       rdflib.URIRef(sev_ns + "Warning")))
+        else:
+            graph.add((property_bnode, rdflib.URIRef("http://www.w3.org/ns/shacl#severity"), 
+                       rdflib.URIRef(sev_ns + "Info")))
+        logging.info(f"Set severity {severity} for property {row['propertyID']}")
+    if pd.notna(row.get("valueShape")) and row["valueShape"].strip():
+        value_shape_uri = _prop_id_to_uri(row["valueShape"], prefixes)
+        graph.add((property_bnode, rdflib.URIRef("http://www.w3.org/ns/shacl#node"), value_shape_uri))
+        logging.info(f"Linked valueShape {value_shape_uri} for property {row['propertyID']}")
+    return graph
+
+def build_shacl_graphs():
+    logging.info("Building individual SHACL graphs from TSV files")
+    module_graphs = {}  # Initialize the dictionary for module graphs
+    prefixes = load_prefixes(PREFIX_FILE)
+    for tsv in TSV_FILES:
+        tsv_path = tsv  # already an absolute path
+        if not os.path.exists(tsv_path):
+            logging.error(f"TSV file not found: {tsv_path}")
+        logging.info(f"Processing TSV file: {tsv_path}")
+        graph = rdflib.Graph()
+        register_prefixes(graph, prefixes)
+        _bind_namespaces(graph)  # Bind fixed namespaces for the SHACL graph
+        df = pd.read_csv(tsv_path, sep='\t', comment='/')
+        for _, row in df.iterrows():
+            if pd.isna(row.get("shapeID")):
+                continue
+            add_shape_from_row(graph, row, prefixes)
+        module_graphs[tsv] = graph
+    logging.info("Completed building individual SHACL graphs")
+    return module_graphs
+
+def parse_results_text(results_text: str) -> str:
+    """
+    Parse and reformat raw results_text for nicer display.
+    Adjust the logic to suit your output format.
+    """
+    lines = results_text.strip().splitlines()
+    formatted_lines = []
+    for line in lines:
+        line = line.strip()
+        if line.startswith("==="):
+            # Start of a module section
+            formatted_lines.append("\n" + line)
+        elif line.startswith("Validation Result"):
+            # Start a new violation
+            formatted_lines.append("\n" + line)
+        else:
+            formatted_lines.append("\t" + line)
+    return "\n".join(formatted_lines)
+
+def validate_rdf(rdf_data, template):
+    logging.info("Starting validation")
+    data_graph = rdflib.Graph()
+    logging.info("Parsing RDF data")
+    try:
+        data_graph.parse(data=rdf_data, format='xml')
+    except Exception as e:
+        logging.error(f"Error parsing RDF data: {e}")
+        raise e
+    logging.info(f"Data graph has {len(data_graph)} triples.")
+
+    # Bind known namespaces explicitly from the input RDF/XML
+    namespaces = {
+        "bf": "http://id.loc.gov/ontologies/bibframe/",
+        "bflc": "http://id.loc.gov/ontologies/bflc/",
+        "bfsimple": "http://id.loc.gov/ontologies/bfsimple/",
+        "cc": "http://creativecommons.org/ns#",
+        "datatypes": "http://id.loc.gov/datatypes/",
+        "dcterms": "http://purl.org/dc/terms/",
+        "foaf": "http://xmlns.com/foaf/0.1/",
+        "lcc": "http://id.loc.gov/ontologies/lcc#",
+        "lclocal": "http://id.loc.gov/ontologies/lclocal/",
+        "madsrdf": "http://www.loc.gov/mads/rdf/v1#",
+        "mnotetype": "http://id.loc.gov/vocabulary/mnotetype/",
+        "mstatus": "https://id.loc.gov/vocabulary/mstatus/",
+        "owl": "http://www.w3.org/2002/07/owl#",
+        "pmo": "http://performedmusicontology.org/ontology/",
+        "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+        "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
+        "skos": "http://www.w3.org/2004/02/skos/core#",
+        "vartitletype": "http://id.loc.gov/vocabulary/vartitletype/",
+        "void": "http://rdfs.org/ns/void#",
+        "xsd": "http://www.w3.org/2001/XMLSchema#"
+    }
+    for prefix, uri in namespaces.items():
+        data_graph.bind(prefix, uri)
+    
+    logging.info(f"Data graph has {len(data_graph)} triples.")
+    for s, p, o in list(data_graph)[:10]:
+        logging.debug(f"Parsed triple: {s} {p} {o}")
+    # New: Log the full RDF graph in turtle format
+    serialized_graph = data_graph.serialize(format='turtle')
+    logging.info("Full RDF graph:\n" + (serialized_graph.decode('utf-8') if isinstance(serialized_graph, bytes) else serialized_graph))
+
+    # Extra debugging: log all rdf:type values from the data graph
+    classes = set()
+    for s, o in data_graph.subject_objects(RDF.type):
+        classes.add(o)
+    logging.debug(f"Data graph contains these types: {list(classes)}")
+    
+    # === Added debugging to check expected target class URIs ===
+    prefixes = load_prefixes(PREFIX_FILE)
+    # List your expected target class identifiers as they are used in your TSV
+    expected_targets = ["https:Agent", "big:Contribution"]
+    expanded_targets = [ _prop_id_to_uri(t, prefixes) for t in expected_targets ]
+    logging.debug(f"Expected target classes per TSV: {expanded_targets}")
+
+    if template.lower() == 'monograph':
+        logging.info("Using Monograph template; processing individual TSV modules")
+        module_graphs = build_shacl_graphs()
+        
+        # Debug: inspect declared target classes in each module and query focus nodes.
+        for tsv, module in module_graphs.items():
+            logging.debug(f"Module {tsv} declared targets:")
+            for shape in module.subjects(RDF.type, rdflib.URIRef("http://www.w3.org/ns/shacl#NodeShape")):
+                for target in module.objects(shape, rdflib.URIRef("http://www.w3.org/ns/shacl#targetClass")):
+                    logging.debug(f"Shape {shape} declares target: {target}")
+                    q = f"SELECT ?x WHERE {{ ?x a <{target}> . }}"
+                    matches = list(data_graph.query(q))
+                    logging.debug(f"Found {len(matches)} focus node(s) for target {target}")
+                    for match in matches:
+                        logging.debug(f"Focus node: {match.x}")
+
+        all_results = []
+        overall_conforms = True
+        for tsv, graph in module_graphs.items():
+            shacl_text = graph.serialize(format='turtle')
+            logging.info(f"Module {tsv} SHACL shapes:")
+            logging.info(shacl_text.decode('utf-8') if isinstance(shacl_text, bytes) else shacl_text)
+            conforms, results_graph, results_text = validate(data_graph, shacl_graph=graph, inference='rdfs', debug=True)
+            # Override conform status if any violation has severity sh:Violation.
+            violation_query = """
+            PREFIX sh: <http://www.w3.org/ns/shacl#>
+            SELECT ?severity WHERE {
+                ?vr a sh:ValidationResult ;
+                    sh:resultSeverity ?severity .
+            }
+            """
+            severities = [str(row.severity) for row in results_graph.query(violation_query)]
+            module_conforms = False if any("http://www.w3.org/ns/shacl#Violation" in s for s in severities) else True
+            logging.info(f"Module {tsv} - Overridden Conforms: {module_conforms}")
+            
+            # Build a nicely formatted summary of the results.
+            query_formatted = """
+            PREFIX sh: <http://www.w3.org/ns/shacl#>
+            SELECT ?component ?severity ?sourceShape ?focus ?resultPath ?message
+            WHERE {
+              ?vr a sh:ValidationResult ;
+                  sh:sourceConstraintComponent ?component ;
+                  sh:resultSeverity ?severity ;
+                  sh:sourceShape ?sourceShape ;
+                  sh:focusNode ?focus ;
+                  sh:resultPath ?resultPath ;
+                  sh:resultMessage ?message .
+            }
+            ORDER BY ?component
+            """
+            formatted_results = ""
+            count = 0
+            for row in results_graph.query(query_formatted):
+                count += 1
+                formatted_results += f"Validation Result in {row.component}:\n"
+                formatted_results += f"\tSeverity: {row.severity}\n"
+                formatted_results += f"\tSource Shape: {row.sourceShape}\n"
+                formatted_results += f"\tFocus Node: {row.focus}\n"
+                formatted_results += f"\tResult Path: {row.resultPath}\n"
+                formatted_results += f"\tMessage: {row.message}\n"
+            formatted_results = f"Results ({count}):\n" + formatted_results
+            
+            # Assemble module output.
+            module_output = (
+                f"\n=== Module: {tsv} ===\n"
+                f"Overridden Conforms: {module_conforms}\n"
+                f"{formatted_results}\n"
+                "------------------------\n"
+            )
+            all_results.append(module_output)
+            if not module_conforms:
+                overall_conforms = False
+        combined_results = "\n".join(all_results)
+        # Optionally, parse the combined results for easier display.
+        combined_results = parse_results_text(combined_results)
+        return overall_conforms, combined_results
+    else:
+        logging.info("Using default SHACL template")
+        shacl_text = """
+        @prefix sh: <http://www.w3.org/ns/shacl#> .
+        @prefix ex: <http://example.org/> .
+        ex:DefaultShape a sh:NodeShape ;
+            sh:targetNode ex:SomeNode ;
+            sh:property [
+                sh:path ex:someProperty ;
+                sh:datatype xsd:string ;
+            ] .
+        """
+        shacl_graph = rdflib.Graph()
+        shacl_graph.parse(data=shacl_text, format='turtle')
+        conforms, results_graph, results_text = validate(data_graph, shacl_graph=shacl_graph, inference='rdfs', debug=True)
+        logging.info(f"Validation completed; Conforms: {conforms}")
+        logging.info("Results text:")
+        logging.info(results_text)
+        serialized_results = results_graph.serialize(format='turtle')
+        logging.info("Detailed results graph:")
+        logging.info(serialized_results.decode('utf-8') if isinstance(serialized_results, bytes) else serialized_results)
+        combined_results = (f"{results_text.strip()}\nDetailed Results:\n"
+                            f"{serialized_results.decode('utf-8') if isinstance(serialized_results, bytes) else serialized_results}")
+        return conforms, combined_results