Deploy BIBFRAME MCP Server - 2025-10-04 11:16:33

.gitignore

@@ -0,0 +1,33 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store

README.md

@@ -0,0 +1,167 @@
+# 📚 BIBFRAME Ontology Documentation MCP Server
+
+A Model Context Protocol (MCP) server that provides BIBFRAME ontology documentation for LLMs like Claude. Built with Gradio, this server dynamically loads from the official BIBFRAME ontology at id.loc.gov.
+
+## 🌐 Live Server
+
+**Deployed at:** https://jimfhahn-mcp4bibframe-docs.hf.space  
+**MCP Endpoint:** https://jimfhahn-mcp4bibframe-docs.hf.space/gradio_api/mcp/
+
+## ✨ Features
+
+- ✅ **MCP Server**: Full MCP protocol support for LLM integration
+- 📚 **Live Ontology Data**: Loads from official BIBFRAME ontology
+- 🔍 **Four MCP Tools**:
+  - `get_property_info` - Detailed property information with examples
+  - `get_class_info` - Class documentation with applicable properties
+  - `search_ontology` - Search for properties or classes
+  - `get_property_usage` - Context-specific usage information
+- 🌐 **Web UI**: Interactive Gradio interface for testing
+- ☁️ **Deployed on HF Spaces**: Hosted for free on Hugging Face
+
+## 🚀 Quick Start with Claude Desktop
+
+Add this to your Claude Desktop configuration:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`  
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "bibframe-docs": {
+      "url": "https://jimfhahn-mcp4bibframe-docs.hf.space/gradio_api/mcp/"
+    }
+  }
+}
+```
+
+For a hosted version on Hugging Face Spaces:
+
+```json
+{
+  "mcpServers": {
+    "bibframe-docs": {
+      "url": "https://YOUR-USERNAME-mcp4bibframe-docs.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+**Note**: Claude Desktop currently requires the `mcp-remote` bridge for SSE servers:
+
+```json
+{
+  "mcpServers": {
+    "bibframe-docs": {
+      "command": "npx",
+      "args": [
+        "mcp-remote",
+        "http://localhost:7860/gradio_api/mcp/sse"
+      ]
+    }
+  }
+}
+```
+
+## Deploying to Hugging Face Spaces
+
+1. Create a new Space on [Hugging Face](https://huggingface.co/spaces)
+2. Choose "Gradio" as the SDK
+3. Push this repository to your Space
+4. The MCP server will be available at: `https://YOUR-USERNAME-SPACE-NAME.hf.space/gradio_api/mcp/sse`
+
+### Private Spaces
+
+For private Spaces, add your Hugging Face token:
+
+```json
+{
+  "mcpServers": {
+    "bibframe-docs": {
+      "url": "https://YOUR-SPACE.hf.space/gradio_api/mcp/sse",
+      "headers": {
+        "Authorization": "Bearer YOUR-HF-TOKEN"
+      }
+    }
+  }
+}
+```
+
+## MCP Tools Reference
+
+### get_property_info
+```
+Get detailed information about a BIBFRAME property from the official ontology.
+
+Args:
+    property_uri (str): Full URI or short name (e.g., "bf:assigner" or "assigner")
+
+Returns:
+    JSON with property information, domain, range, examples, and usage guidance
+```
+
+### get_class_info
+```
+Get detailed information about a BIBFRAME class from the official ontology.
+
+Args:
+    class_name (str): Class name (e.g., "Work", "bf:Work", or full URI)
+
+Returns:
+    JSON with class information and applicable properties
+```
+
+### search_ontology
+```
+Search the BIBFRAME ontology for properties or classes matching a term.
+
+Args:
+    search_term (str): Term to search for
+    search_type (str): Type of search - "properties", "classes", or "all"
+
+Returns:
+    JSON with matching properties and/or classes
+```
+
+### get_property_usage
+```
+Get usage information for a property, optionally in the context of a specific class.
+
+Args:
+    property_name (str): Property name (e.g., "assigner" or "bf:assigner")
+    class_name (str): Optional class context (e.g., "AdminMetadata")
+
+Returns:
+    JSON with usage information and examples
+```
+
+## Testing with MCP Inspector
+
+```bash
+# Install MCP Inspector
+npm install -g @modelcontextprotocol/inspector
+
+# Test your server
+npx @modelcontextprotocol/inspector http://localhost:7860/gradio_api/mcp/sse
+```
+
+## Data Sources
+
+- [BIBFRAME Ontology](https://id.loc.gov/ontologies/bibframe.html) - Official ontology from Library of Congress
+- [LC BIBFRAME Profiles](https://github.com/lcnetdev/bfe-profiles) - Application profiles
+- [DCTap Validation](https://github.com/bf-interop/DCTap) - Community validation patterns
+
+## Related Projects
+
+- **For SHACL validation**: [mcp4rdf validator](https://huggingface.co/spaces/jimfhahn/mcp4rdf)
+- **BIBFRAME Homepage**: https://www.loc.gov/bibframe/
+- **BIBFRAME Documentation**: https://www.loc.gov/bibframe/docs/
+
+## License
+
+MIT License - See LICENSE file for details
+
+## Contributing
+
+Contributions welcome! Please open an issue or PR on GitHub.

app.py

@@ -0,0 +1,516 @@
+#!/usr/bin/env python3
+"""
+BIBFRAME Ontology Documentation MCP Server
+
+Provides BIBFRAME ontology documentation via MCP tools.
+Dynamically loads from the official BIBFRAME ontology at id.loc.gov.
+
+This server focuses on ontology documentation - properties, classes, domains, ranges, and usage examples.
+For SHACL validation, use the separate mcp4rdf validator.
+
+Deploy as a Hugging Face Space for your RDF applications to query.
+"""
+
+import gradio as gr
+import json
+import requests
+from typing import Dict, List, Optional, Any
+from rdflib import Graph, URIRef, Literal, Namespace, RDFS, RDF
+from functools import lru_cache
+import re
+
+# Namespaces
+BF = Namespace("http://id.loc.gov/ontologies/bibframe/")
+BFLC = Namespace("http://id.loc.gov/ontologies/bflc/")
+MADSRDF = Namespace("http://www.loc.gov/mads/rdf/v1#")
+
+class BIBFRAMEKnowledgeBase:
+    """Loads and caches BIBFRAME ontology data"""
+    
+    def __init__(self):
+        self.ontology_graph = Graph()
+        self.properties = {}
+        self.classes = {}
+        self._loaded = False
+        
+    @lru_cache(maxsize=1)
+    def load_ontology(self):
+        """Load the BIBFRAME ontology from the official source"""
+        try:
+            print("📚 Loading BIBFRAME ontology from id.loc.gov...")
+            self.ontology_graph.parse("http://id.loc.gov/ontologies/bibframe.rdf", format="xml")
+            
+            # Extract properties
+            for prop in self.ontology_graph.subjects(RDF.type, RDF.Property):
+                if str(prop).startswith(str(BF)):
+                    local_name = str(prop).replace(str(BF), "")
+                    self.properties[f"bf:{local_name}"] = {
+                        "uri": str(prop),
+                        "label": self._get_label(prop),
+                        "definition": self._get_comment(prop),
+                        "domain": self._get_domains(prop),
+                        "range": self._get_ranges(prop),
+                        "subPropertyOf": self._get_super_properties(prop)
+                    }
+            
+            # Extract classes
+            for cls in self.ontology_graph.subjects(RDF.type, RDFS.Class):
+                if str(cls).startswith(str(BF)):
+                    local_name = str(cls).replace(str(BF), "")
+                    self.classes[f"bf:{local_name}"] = {
+                        "uri": str(cls),
+                        "label": self._get_label(cls),
+                        "definition": self._get_comment(cls),
+                        "subClassOf": self._get_super_classes(cls)
+                    }
+            
+            self._loaded = True
+            print(f"✅ Loaded {len(self.properties)} properties and {len(self.classes)} classes")
+            
+        except Exception as e:
+            print(f"⚠️ Error loading ontology: {e}")
+            print("📦 Using minimal fallback data")
+            self._load_minimal_fallback()
+    
+    def _load_minimal_fallback(self):
+        """Minimal fallback data if ontology loading fails"""
+        self.properties = {
+            "bf:assigner": {
+                "uri": "http://id.loc.gov/ontologies/bibframe/assigner",
+                "label": "Assigner",
+                "definition": "Entity who assigned the identifier or other metadata value",
+                "domain": ["http://id.loc.gov/ontologies/bibframe/AdminMetadata"],
+                "range": ["http://id.loc.gov/ontologies/bibframe/Agent"],
+                "subPropertyOf": []
+            }
+        }
+        self._loaded = True
+    
+    def _get_label(self, resource):
+        return str(self.ontology_graph.value(resource, RDFS.label) or "")
+    
+    def _get_comment(self, resource):
+        return str(self.ontology_graph.value(resource, RDFS.comment) or "")
+    
+    def _get_domains(self, prop):
+        return [str(d) for d in self.ontology_graph.objects(prop, RDFS.domain)]
+    
+    def _get_ranges(self, prop):
+        return [str(r) for r in self.ontology_graph.objects(prop, RDFS.range)]
+    
+    def _get_super_properties(self, prop):
+        return [str(sp) for sp in self.ontology_graph.objects(prop, RDFS.subPropertyOf)]
+    
+    def _get_super_classes(self, cls):
+        return [str(sc) for sc in self.ontology_graph.objects(cls, RDFS.subClassOf)]
+
+# Global instance
+kb = BIBFRAMEKnowledgeBase()
+kb.load_ontology()
+
+# Helper functions
+def _simplify_uri(uri: str) -> str:
+    """Convert full URI to simplified form (e.g., bf:Work)"""
+    if not uri:
+        return ""
+    if "bibframe/" in uri:
+        return "bf:" + uri.split("bibframe/")[-1]
+    elif "rdf-schema#" in uri:
+        return "rdfs:" + uri.split("#")[-1]
+    elif "XMLSchema#" in uri:
+        return "xsd:" + uri.split("#")[-1]
+    return uri
+
+def _generate_property_examples(prop_name: str, prop_info: Dict) -> List[str]:
+    """Generate RDF/XML usage examples based on property range"""
+    examples = []
+    
+    for range_type in prop_info.get("range", []):
+        range_simplified = _simplify_uri(range_type)
+        
+        if "Agent" in range_simplified or "Organization" in range_simplified or "Person" in range_simplified:
+            examples.append(f'<{prop_name} rdf:resource="http://id.loc.gov/rwo/agents/n123"/>')
+            examples.append(f'''<{prop_name}>
+  <bf:Organization>
+    <rdfs:label>Organization Name</rdfs:label>
+  </bf:Organization>
+</{prop_name}>''')
+        elif "date" in range_simplified.lower():
+            examples.append(f'<{prop_name}>2024</{prop_name}>')
+            examples.append(f'<{prop_name} rdf:datatype="http://www.w3.org/2001/XMLSchema#date">2024-01-15</{prop_name}>')
+        elif "Place" in range_simplified:
+            examples.append(f'<{prop_name} rdf:resource="http://id.loc.gov/vocabulary/countries/nyu"/>')
+            examples.append(f'''<{prop_name}>
+  <bf:Place>
+    <rdfs:label>New York</rdfs:label>
+  </bf:Place>
+</{prop_name}>''')
+        elif "Title" in range_simplified:
+            examples.append(f'''<{prop_name}>
+  <bf:Title>
+    <bf:mainTitle>Main Title Here</bf:mainTitle>
+  </bf:Title>
+</{prop_name}>''')
+        elif "string" in range_simplified.lower() or "Literal" in range_simplified:
+            examples.append(f'<{prop_name}>Text value here</{prop_name}>')
+        else:
+            # Generic object property
+            examples.append(f'<{prop_name} rdf:resource="http://example.org/resource"/>')
+    
+    if not examples:
+        # Fallback if no range specified
+        examples.append(f'<{prop_name}>Value</{prop_name}>')
+    
+    return examples
+
+def _generate_usage_notes(prop_name: str, prop_info: Dict) -> str:
+    """Generate helpful usage notes based on property metadata"""
+    notes = []
+    
+    # Note about domains
+    if prop_info.get("domain"):
+        domains = [_simplify_uri(d) for d in prop_info["domain"]]
+        notes.append(f"Used with: {', '.join(domains)}")
+    
+    # Note about ranges
+    if prop_info.get("range"):
+        ranges = [_simplify_uri(r) for r in prop_info["range"]]
+        notes.append(f"Expected values: {', '.join(ranges)}")
+    
+    # Special notes for common properties
+    if prop_name == "bf:assigner":
+        notes.append("Commonly required for AdminMetadata. Often same as bf:agent or bf:descriptionModifier")
+    elif prop_name == "bf:adminMetadata":
+        notes.append("Required for Work and Instance. Contains cataloging metadata")
+    elif prop_name == "bf:title":
+        notes.append("Required for Work and Instance. Use bf:Title with bf:mainTitle")
+    
+    return "; ".join(notes) if notes else "No special usage notes"
+
+def get_property_info(property_uri: str) -> str:
+    """
+    Get detailed information about a BIBFRAME property from the official ontology.
+    
+    Args:
+        property_uri (str): Full URI or short name (e.g., "bf:assigner" or "assigner")
+    
+    Returns:
+        str: JSON string with property information, examples, and usage guidance
+    """
+    # Normalize property name
+    if not property_uri.startswith("bf:") and not property_uri.startswith("http"):
+        property_uri = f"bf:{property_uri}"
+    
+    prop_info = kb.properties.get(property_uri, {})
+    
+    if not prop_info:
+        # Find partial matches
+        matches = [k for k in kb.properties.keys() if property_uri.lower() in k.lower()]
+        return {
+            "error": f"Property '{property_uri}' not found in BIBFRAME ontology",
+            "suggestions": matches[:10] if matches else list(kb.properties.keys())[:10],
+            "total_properties": len(kb.properties)
+        }
+    
+    # Generate examples based on range
+    examples = _generate_property_examples(property_uri, prop_info)
+    
+    # Generate usage notes
+    usage_notes = _generate_usage_notes(property_uri, prop_info)
+    
+    result = {
+        "property": property_uri,
+        "uri": prop_info["uri"],
+        "label": prop_info["label"],
+        "definition": prop_info["definition"],
+        "domain": [_simplify_uri(d) for d in prop_info["domain"]],
+        "range": [_simplify_uri(r) for r in prop_info["range"]],
+        "examples": examples,
+        "usage_notes": usage_notes,
+        "documentation_url": f"https://id.loc.gov/ontologies/bibframe.html#{property_uri.replace('bf:', '')}"
+    }
+    return json.dumps(result, indent=2)
+
+def get_class_info(class_name: str) -> str:
+    """
+    Get detailed information about a BIBFRAME class from the official ontology.
+    
+    Args:
+        class_name (str): Class name (e.g., "Work", "bf:Work", or full URI)
+    
+    Returns:
+        str: JSON string with class information and typical properties
+    """
+    # Normalize class name
+    if not class_name.startswith("bf:") and not class_name.startswith("http"):
+        class_name = f"bf:{class_name}"
+    
+    class_info = kb.classes.get(class_name, {})
+    
+    if not class_info:
+        # Find partial matches
+        matches = [k for k in kb.classes.keys() if class_name.lower() in k.lower()]
+        return {
+            "error": f"Class '{class_name}' not found in BIBFRAME ontology",
+            "suggestions": matches[:10] if matches else list(kb.classes.keys())[:10],
+            "total_classes": len(kb.classes)
+        }
+    
+    # Find properties that have this class in their domain
+    applicable_properties = []
+    for prop_name, prop_data in kb.properties.items():
+        if class_info["uri"] in prop_data.get("domain", []):
+            applicable_properties.append({
+                "property": prop_name,
+                "label": prop_data.get("label", ""),
+                "definition": prop_data.get("definition", "")
+            })
+    
+    result = {
+        "class": class_name,
+        "uri": class_info["uri"],
+        "label": class_info["label"],
+        "definition": class_info["definition"],
+        "superClasses": [_simplify_uri(sc) for sc in class_info.get("subClassOf", [])],
+        "applicable_properties": applicable_properties[:20],  # Limit to first 20
+        "total_properties": len(applicable_properties),
+        "documentation_url": f"https://id.loc.gov/ontologies/bibframe.html#{class_name.replace('bf:', '')}"
+    }
+    return json.dumps(result, indent=2)
+
+def search_ontology(search_term: str, search_type: str = "all") -> str:
+    """
+    Search the BIBFRAME ontology for properties or classes matching a term.
+    
+    Args:
+        search_term (str): Term to search for
+        search_type (str): Type of search - "properties", "classes", or "all"
+    
+    Returns:
+        str: JSON string with matching properties and/or classes
+    """
+    results = {
+        "search_term": search_term,
+        "properties": [],
+        "classes": []
+    }
+    
+    search_lower = search_term.lower()
+    
+    # Search properties
+    if search_type in ["properties", "all"]:
+        for prop_name, prop_data in kb.properties.items():
+            if (search_lower in prop_name.lower() or 
+                search_lower in prop_data.get("label", "").lower() or
+                search_lower in prop_data.get("definition", "").lower()):
+                results["properties"].append({
+                    "property": prop_name,
+                    "label": prop_data.get("label", ""),
+                    "definition": prop_data.get("definition", "")[:100] + "..." if len(prop_data.get("definition", "")) > 100 else prop_data.get("definition", "")
+                })
+    
+    # Search classes
+    if search_type in ["classes", "all"]:
+        for class_name, class_data in kb.classes.items():
+            if (search_lower in class_name.lower() or 
+                search_lower in class_data.get("label", "").lower() or
+                search_lower in class_data.get("definition", "").lower()):
+                results["classes"].append({
+                    "class": class_name,
+                    "label": class_data.get("label", ""),
+                    "definition": class_data.get("definition", "")[:100] + "..." if len(class_data.get("definition", "")) > 100 else class_data.get("definition", "")
+                })
+    
+    # Limit results
+    results["properties"] = results["properties"][:20]
+    results["classes"] = results["classes"][:20]
+    results["total_found"] = len(results["properties"]) + len(results["classes"])
+    
+    return json.dumps(results, indent=2)
+
+def get_property_usage(property_name: str, class_name: str = "") -> str:
+    """
+    Get usage information for a property, optionally in the context of a specific class.
+    
+    Args:
+        property_name (str): Property name (e.g., "assigner" or "bf:assigner")
+        class_name (str): Optional class context (e.g., "AdminMetadata")
+    
+    Returns:
+        str: JSON string with usage information and examples
+    """
+    # Normalize property name
+    if not property_name.startswith("bf:"):
+        property_name = f"bf:{property_name}"
+    
+    prop_info = kb.properties.get(property_name, {})
+    
+    if not prop_info:
+        return {"error": f"Property '{property_name}' not found in BIBFRAME ontology"}
+    
+    usage = {
+        "property": property_name,
+        "label": prop_info.get("label", ""),
+        "definition": prop_info.get("definition", ""),
+        "domain": [_simplify_uri(d) for d in prop_info.get("domain", [])],
+        "range": [_simplify_uri(r) for r in prop_info.get("range", [])],
+        "examples": _generate_property_examples(property_name, prop_info)
+    }
+    
+    # Add class-specific context if provided
+    if class_name:
+        if not class_name.startswith("bf:"):
+            class_name = f"bf:{class_name}"
+        
+        class_info = kb.classes.get(class_name, {})
+        if class_info:
+            class_uri = class_info["uri"]
+            if class_uri in prop_info.get("domain", []):
+                usage["applies_to_class"] = True
+                usage["context_note"] = f"{property_name} is applicable to {class_name}"
+            else:
+                usage["applies_to_class"] = False
+                usage["context_note"] = f"{property_name} is not typically used with {class_name}"
+        else:
+            usage["context_note"] = f"Class '{class_name}' not found in ontology"
+    
+    return json.dumps(usage, indent=2)
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="BIBFRAME Ontology Documentation MCP Server") as demo:
+        gr.Markdown(f"""
+        # 📚 BIBFRAME Ontology Documentation MCP Server
+        
+        **Status:** {'✅ Loaded' if kb._loaded else '⚠️ Using fallback data'} - {len(kb.properties)} properties, {len(kb.classes)} classes
+        
+        This server provides BIBFRAME ontology documentation via MCP tools.
+        Data is loaded from the official BIBFRAME ontology at [id.loc.gov](https://id.loc.gov/ontologies/bibframe.html).
+        
+        ## Available MCP Tools:
+        - `get_property_info`: Get detailed information about a BIBFRAME property
+        - `get_class_info`: Get detailed information about a BIBFRAME class
+        - `search_ontology`: Search for properties or classes by term
+        - `get_property_usage`: Get usage information for a property in context
+        
+        ## MCP Configuration:
+        ```json
+        {{
+          "mcpServers": {{
+            "bibframe-docs": {{
+              "url": "https://your-space.hf.space/gradio_api/mcp/"
+            }}
+          }}
+        }}
+        ```
+        
+        ## Data Sources:
+        - [BIBFRAME Ontology](https://id.loc.gov/ontologies/bibframe.html) - Official ontology from Library of Congress
+        - [LC BIBFRAME Profiles](https://github.com/lcnetdev/bfe-profiles) - Application profiles
+        - [DCTap Validation](https://github.com/bf-interop/DCTap) - Community validation patterns
+        """)
+        
+        with gr.Tabs():
+            # Tab 1: Property Lookup
+            with gr.Tab("Property Lookup"):
+                with gr.Row():
+                    with gr.Column():
+                        property_input = gr.Textbox(
+                            label="Property Name",
+                            value="assigner",
+                            placeholder="e.g., assigner, bf:assigner, or title"
+                        )
+                        property_btn = gr.Button("🔍 Look Up Property", variant="primary")
+                        property_output = gr.Textbox(label="Property Information", lines=20)
+                        
+                        property_btn.click(
+                            fn=get_property_info,
+                            inputs=[property_input],
+                            outputs=[property_output]
+                        )
+            
+            # Tab 2: Class Lookup
+            with gr.Tab("Class Lookup"):
+                with gr.Row():
+                    with gr.Column():
+                        class_input = gr.Textbox(
+                            label="Class Name",
+                            value="Work",
+                            placeholder="e.g., Work, AdminMetadata, or Instance"
+                        )
+                        class_btn = gr.Button("🔍 Look Up Class", variant="primary")
+                        class_output = gr.Textbox(label="Class Information", lines=20)
+                        
+                        class_btn.click(
+                            fn=get_class_info,
+                            inputs=[class_input],
+                            outputs=[class_output]
+                        )
+            
+            # Tab 3: Search
+            with gr.Tab("Search Ontology"):
+                with gr.Row():
+                    with gr.Column():
+                        search_input = gr.Textbox(
+                            label="Search Term",
+                            placeholder="e.g., title, agent, date, or admin"
+                        )
+                        search_type = gr.Radio(
+                            label="Search Type",
+                            choices=["all", "properties", "classes"],
+                            value="all"
+                        )
+                        search_btn = gr.Button("🔍 Search", variant="primary")
+                        search_output = gr.Textbox(label="Search Results", lines=20)
+                        
+                        search_btn.click(
+                            fn=search_ontology,
+                            inputs=[search_input, search_type],
+                            outputs=[search_output]
+                        )
+            
+            # Tab 4: Property Usage
+            with gr.Tab("Property Usage Context"):
+                with gr.Row():
+                    with gr.Column():
+                        usage_prop_input = gr.Textbox(
+                            label="Property Name",
+                            value="assigner",
+                            placeholder="e.g., assigner, title, or adminMetadata"
+                        )
+                        usage_class_input = gr.Textbox(
+                            label="Class Context (optional)",
+                            placeholder="e.g., AdminMetadata, Work, or Instance"
+                        )
+                        usage_btn = gr.Button("🔍 Get Usage Info", variant="primary")
+                        usage_output = gr.Textbox(label="Usage Information", lines=20)
+                        
+                        usage_btn.click(
+                            fn=get_property_usage,
+                            inputs=[usage_prop_input, usage_class_input],
+                            outputs=[usage_output]
+                        )
+        
+        gr.Markdown("""
+        ---
+        ### 💡 Usage Tips:
+        - Property names can be entered with or without the `bf:` prefix
+        - Search is case-insensitive and matches against names, labels, and definitions
+        - Use the "Property Usage Context" tab to understand how properties work with specific classes
+        
+        ### 🔗 Related Resources:
+        - **For SHACL validation**: Use the [mcp4rdf validator](https://huggingface.co/spaces/jimfhahn/mcp4rdf)
+        - **BIBFRAME Homepage**: [https://www.loc.gov/bibframe/](https://www.loc.gov/bibframe/)
+        - **BIBFRAME Documentation**: [https://www.loc.gov/bibframe/docs/](https://www.loc.gov/bibframe/docs/)
+        """)
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_api=True,
+        mcp_server=True  # Enable MCP server
+    )

requirements.txt

@@ -0,0 +1,3 @@
+gradio[mcp]>=5.0.0
+rdflib>=7.0.0
+requests>=2.31.0