fix mcp with true

app.py

@@ -220,48 +220,53 @@ class VDIHeatPumpParser:
         
         os.makedirs(download_dir, exist_ok=True)
         
-        # Get catalog information
-        catalog_xml = self.check_catalogs_for_part(part)
-        root = ET.fromstring(catalog_xml)
-        result = root.find('.//{urn:bdhmcc}CheckCatalogsForPartResult')
-        
-        if result is None:
-            raise Exception("No catalog results found")
-        
-        catalogs_xml = ET.fromstring(result.text)
-        
-        # Extract catalog information
-        data = []
-        for catalog in catalogs_xml.findall('Catalog'):
-            data.append({
-                'mfr': catalog.get('mfr'),
-                'nick': catalog.get('nick').split('/')[0].strip(),
-                'part': f"{int(catalog.get('part')):02d}",
-            })
-
-        df = pd.DataFrame(data)
-        df['slug'] = df['nick'] + df['part']
-        df['download_url'] = f"https://www.catalogue.{self.domain}/" + df['slug'] + "/Downloads/PART" + df['part'] + "_" + df['nick'] + ".zip"
-        
-        # Download files
-        downloaded_files = []
-        for _, row in df.iterrows():
-            download_url = row['download_url']
-            file_name = os.path.join(download_dir, f"PART{row['part']}_{row['nick']}.zip")
+        try:
+            # Get catalog information
+            catalog_xml = self.check_catalogs_for_part(part)
+            root = ET.fromstring(catalog_xml)
+            result = root.find('.//{urn:bdhmcc}CheckCatalogsForPartResult')
             
-            try:
-                response = requests.get(download_url, timeout=30)
-                response.raise_for_status()
-                
-                with open(file_name, 'wb') as file:
-                    file.write(response.content)
+            if result is None:
+                raise Exception("No catalog results found")
+            
+            catalogs_xml = ET.fromstring(result.text)
+            
+            # Extract catalog information
+            data = []
+            for catalog in catalogs_xml.findall('Catalog'):
+                data.append({
+                    'mfr': catalog.get('mfr'),
+                    'nick': catalog.get('nick').split('/')[0].strip(),
+                    'part': f"{int(catalog.get('part')):02d}",
+                })
+
+            df = pd.DataFrame(data)
+            df['slug'] = df['nick'] + df['part']
+            df['download_url'] = f"https://www.catalogue.{self.domain}/" + df['slug'] + "/Downloads/PART" + df['part'] + "_" + df['nick'] + ".zip"
+            
+            # Download files
+            downloaded_files = []
+            for _, row in df.iterrows():
+                download_url = row['download_url']
+                file_name = os.path.join(download_dir, f"PART{row['part']}_{row['nick']}.zip")
                 
-                downloaded_files.append(file_name)
-                logger.info(f"Downloaded: {file_name}")
-            except Exception as e:
-                logger.error(f"Failed to download {download_url}: {e}")
-        
-        return downloaded_files
+                try:
+                    response = requests.get(download_url, timeout=30)
+                    response.raise_for_status()
+                    
+                    with open(file_name, 'wb') as file:
+                        file.write(response.content)
+                    
+                    downloaded_files.append(file_name)
+                    logger.info(f"Downloaded: {file_name}")
+                except Exception as e:
+                    logger.error(f"Failed to download {download_url}: {e}")
+            
+            return downloaded_files
+            
+        except Exception as e:
+            logger.error(f"Error downloading VDI files: {e}")
+            return []
 
     def parse_vdi_file(self, file_path: str, nick: str) -> pd.DataFrame:
         """Parse a single VDI file"""
@@ -370,7 +375,8 @@ class VDIHeatPumpParser:
             return df
             
         except Exception as e:
-            raise Exception(f"Error parsing VDI file {file_path}: {str(e)}")
+            logger.error(f"Error parsing VDI file {file_path}: {str(e)}")
+            return pd.DataFrame()
 
     def extract_and_parse_zip(self, zip_path: str) -> pd.DataFrame:
         """Extract ZIP file and parse VDI files"""
@@ -385,7 +391,8 @@ class VDIHeatPumpParser:
                 vdi_files = list(Path(temp_dir).rglob("*.VDI"))
             
             if not vdi_files:
-                raise Exception(f"No VDI files found in {zip_path}")
+                logger.warning(f"No VDI files found in {zip_path}")
+                return pd.DataFrame()
             
             all_data = []
             for vdi_file in vdi_files:
@@ -407,8 +414,7 @@ class VDIHeatPumpParser:
 # Initialize the parser
 parser = VDIHeatPumpParser()
 
-# Gradio functions (these will become MCP tools)
-
+# MCP Tool Functions - These will be automatically exposed as MCP tools
 def download_vdi_files(part: str, download_dir: str = "") -> str:
     """
     Download VDI files for a specific part number.
@@ -416,11 +422,13 @@ def download_vdi_files(part: str, download_dir: str = "") -> str:
     Args:
         part (str): Part number (e.g., 2 for heat generators, 22 for heat pumps)
         download_dir (str): Directory to save downloaded files (optional)
+    
+    Returns:
+        str: JSON response with download results
     """
     try:
         part_int = int(part)
         download_dir = download_dir.strip() if download_dir.strip() else None
-        
         downloaded_files = parser.download_vdi_files(part_int, download_dir)
         
         result = {
@@ -431,7 +439,6 @@ def download_vdi_files(part: str, download_dir: str = "") -> str:
             "download_directory": download_dir or f"temp directory for part {part_int}"
         }
         return json.dumps(result, indent=2)
-        
     except Exception as e:
         return f"Error downloading VDI files: {str(e)}"
 
@@ -442,6 +449,9 @@ def download_and_parse_part(part: str, download_dir: str = "") -> str:
     Args:
         part (str): Part number (e.g., 2 for heat generators, 22 for heat pumps)
         download_dir (str): Directory to save downloaded files (optional)
+    
+    Returns:
+        str: JSON response with parsing results including heat pump count and manufacturers
     """
     try:
         part_int = int(part)
@@ -450,6 +460,9 @@ def download_and_parse_part(part: str, download_dir: str = "") -> str:
         # Download files first
         downloaded_files = parser.download_vdi_files(part_int, download_dir)
         
+        if not downloaded_files:
+            return f"No files were downloaded for part {part_int}. Check your internet connection or try a different part number."
+        
         # Parse all downloaded files
         all_data = []
         for file_path in downloaded_files:
@@ -470,19 +483,18 @@ def download_and_parse_part(part: str, download_dir: str = "") -> str:
                 "message": f"Successfully downloaded and parsed {len(combined_df)} heat pump records for part {part_int}",
                 "part": part_int,
                 "record_count": len(combined_df),
-                "manufacturers": sorted(combined_df['hersteller'].dropna().unique().tolist()),
+                "manufacturers": sorted(combined_df['hersteller'].dropna().unique().tolist()) if 'hersteller' in combined_df.columns else [],
                 "download_directory": download_dir or f"temp directory for part {part_int}"
             }
         else:
             result = {
                 "status": "warning",
-                "message": f"No heat pump data found for part {part_int}",
+                "message": f"Files downloaded but no heat pump data found for part {part_int}",
                 "part": part_int,
                 "record_count": 0
             }
         
         return json.dumps(result, indent=2)
-        
     except Exception as e:
         return f"Error downloading and parsing part {part}: {str(e)}"
 
@@ -492,6 +504,9 @@ def parse_vdi_file(file_path: str) -> str:
     
     Args:
         file_path (str): Path to the VDI ZIP file
+    
+    Returns:
+        str: JSON response with parsing results
     """
     try:
         if not os.path.exists(file_path):
@@ -506,12 +521,17 @@ def parse_vdi_file(file_path: str) -> str:
             "record_count": len(df)
         }
         return json.dumps(result, indent=2)
-        
     except Exception as e:
         return f"Error parsing file: {str(e)}"
 
-def search_heatpump(manufacturer: str = "", product_name: str = "", article_number: str = "", 
-                   heating_power_min: str = "", heating_power_max: str = "", type_filter: str = "") -> str:
+def search_heatpump(
+    manufacturer: str = "", 
+    product_name: str = "", 
+    article_number: str = "", 
+    heating_power_min: str = "", 
+    heating_power_max: str = "", 
+    type: str = ""
+) -> str:
     """
     Search for specific heat pump by criteria.
     
@@ -521,7 +541,10 @@ def search_heatpump(manufacturer: str = "", product_name: str = "", article_numb
         article_number (str): Article number (optional)
         heating_power_min (str): Minimum heating power in kW (optional)
         heating_power_max (str): Maximum heating power in kW (optional)
-        type_filter (str): Heat pump type (e.g., 'Luft-Wasser') (optional)
+        type (str): Heat pump type (e.g., 'Luft-Wasser') (optional)
+    
+    Returns:
+        str: JSON array of matching heat pumps with their specifications
     """
     try:
         # Combine all parsed data
@@ -530,51 +553,62 @@ def search_heatpump(manufacturer: str = "", product_name: str = "", article_numb
             all_data.append(df)
         
         if not all_data:
-            return "No data available. Please parse VDI files first."
+            return "No data available. Please download and parse VDI files first using download_and_parse_part."
         
         combined_df = pd.concat(all_data, ignore_index=True)
         filtered_df = combined_df.copy()
         
         # Apply filters
         if manufacturer.strip():
-            filtered_df = filtered_df[
-                filtered_df['hersteller'].str.contains(manufacturer.strip(), case=False, na=False)
-            ]
+            if 'hersteller' in filtered_df.columns:
+                filtered_df = filtered_df[
+                    filtered_df['hersteller'].str.contains(manufacturer.strip(), case=False, na=False)
+                ]
         
         if product_name.strip():
-            filtered_df = filtered_df[
-                filtered_df['produktname'].str.contains(product_name.strip(), case=False, na=False)
-            ]
+            if 'produktname' in filtered_df.columns:
+                filtered_df = filtered_df[
+                    filtered_df['produktname'].str.contains(product_name.strip(), case=False, na=False)
+                ]
         
         if article_number.strip():
-            filtered_df = filtered_df[
-                filtered_df['artikelnummer'].str.contains(article_number.strip(), case=False, na=False)
-            ]
+            if 'artikelnummer' in filtered_df.columns:
+                filtered_df = filtered_df[
+                    filtered_df['artikelnummer'].str.contains(article_number.strip(), case=False, na=False)
+                ]
         
-        if type_filter.strip():
-            filtered_df = filtered_df[
-                filtered_df['typ'].str.contains(type_filter.strip(), case=False, na=False)
-            ]
+        if type.strip():
+            if 'typ' in filtered_df.columns:
+                filtered_df = filtered_df[
+                    filtered_df['typ'].str.contains(type.strip(), case=False, na=False)
+                ]
         
         # Filter by heating power
         if heating_power_min.strip() or heating_power_max.strip():
-            filtered_df['heizleistung_numeric'] = pd.to_numeric(filtered_df['heizleistung'], errors='coerce')
-            
-            if heating_power_min.strip():
-                min_power = float(heating_power_min.strip())
-                filtered_df = filtered_df[filtered_df['heizleistung_numeric'] >= min_power]
-            
-            if heating_power_max.strip():
-                max_power = float(heating_power_max.strip())
-                filtered_df = filtered_df[filtered_df['heizleistung_numeric'] <= max_power]
+            if 'heizleistung' in filtered_df.columns:
+                filtered_df['heizleistung_numeric'] = pd.to_numeric(filtered_df['heizleistung'], errors='coerce')
+                
+                if heating_power_min.strip():
+                    min_power = float(heating_power_min.strip())
+                    filtered_df = filtered_df[filtered_df['heizleistung_numeric'] >= min_power]
+                
+                if heating_power_max.strip():
+                    max_power = float(heating_power_max.strip())
+                    filtered_df = filtered_df[filtered_df['heizleistung_numeric'] <= max_power]
         
         # Return results
         result_columns = ['hersteller', 'produktname', 'artikelnummer', 'heizleistung', 'typ', 'energieeffizienzklasse']
         available_columns = [col for col in result_columns if col in filtered_df.columns]
+        
+        if not available_columns:
+            return "No matching columns found in the data."
+        
         result_df = filtered_df[available_columns].head(20)  # Limit to 20 results
         
-        return result_df.to_json(orient='records', indent=2)
+        if result_df.empty:
+            return "No heat pumps found matching your criteria."
         
+        return result_df.to_json(orient='records', indent=2)
     except Exception as e:
         return f"Error searching heat pumps: {str(e)}"
 
@@ -584,25 +618,31 @@ def get_heatpump_details(article_number: str) -> str:
     
     Args:
         article_number (str): Article number of the heat pump
+    
+    Returns:
+        str: JSON object with all available heat pump specifications and technical details
     """
     try:
         # Search across all parsed data
         for df in parser.parsed_files.values():
-            matching_rows = df[df['artikelnummer'] == article_number.strip()]
-            if not matching_rows.empty:
-                details = matching_rows.iloc[0].to_dict()
-                # Clean up None values
-                details = {k: v for k, v in details.items() if v is not None and v != ''}
-                return json.dumps(details, indent=2, default=str)
+            if 'artikelnummer' in df.columns:
+                matching_rows = df[df['artikelnummer'] == article_number.strip()]
+                if not matching_rows.empty:
+                    details = matching_rows.iloc[0].to_dict()
+                    # Clean up None values
+                    details = {k: v for k, v in details.items() if v is not None and v != ''}
+                    return json.dumps(details, indent=2, default=str)
         
         return f"Heat pump with article number '{article_number}' not found"
-        
     except Exception as e:
         return f"Error getting heat pump details: {str(e)}"
 
 def list_manufacturers() -> str:
     """
     List all available manufacturers in parsed data.
+    
+    Returns:
+        str: JSON object with list of manufacturers and count
     """
     try:
         all_manufacturers = set()
@@ -612,20 +652,22 @@ def list_manufacturers() -> str:
                 all_manufacturers.update(manufacturers)
         
         if not all_manufacturers:
-            return "No manufacturers available in the parsed data. Please parse VDI files first."
+            return "No manufacturers available in the parsed data. Please parse VDI files first using download_and_parse_part."
         
         result = {
             "manufacturers": sorted(list(all_manufacturers)),
             "count": len(all_manufacturers)
         }
         return json.dumps(result, indent=2)
-        
     except Exception as e:
         return f"Error listing manufacturers: {str(e)}"
 
 def check_storage() -> str:
     """
     Check available storage locations and permissions.
+    
+    Returns:
+        str: JSON object with storage location information and recommendations
     """
     try:
         import tempfile
@@ -656,193 +698,43 @@ def check_storage() -> str:
         }
         
         return json.dumps(result, indent=2)
-        
     except Exception as e:
         return f"Error checking storage: {str(e)}"
 
-# Create MCP tool definitions
-MCP_TOOLS = [
-    {
-        "name": "download_vdi_files",
-        "description": "Download VDI files for a specific part number",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "part": {
-                    "type": "integer",
-                    "description": "Part number (e.g., 2 for heat generators, 22 for heat pumps)"
-                },
-                "download_dir": {
-                    "type": "string",
-                    "description": "Directory to save downloaded files (optional)"
-                }
-            },
-            "required": ["part"]
-        }
-    },
-    {
-        "name": "download_and_parse_part",
-        "description": "Download and automatically parse all VDI files for a part",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "part": {
-                    "type": "integer",
-                    "description": "Part number (e.g., 2 for heat generators, 22 for heat pumps)"
-                },
-                "download_dir": {
-                    "type": "string",
-                    "description": "Directory to save downloaded files (optional)"
-                }
-            },
-            "required": ["part"]
-        }
-    },
-    {
-        "name": "parse_vdi_file",
-        "description": "Parse a VDI ZIP file and extract heat pump data",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "file_path": {
-                    "type": "string",
-                    "description": "Path to the VDI ZIP file"
-                }
-            },
-            "required": ["file_path"]
-        }
-    },
-    {
-        "name": "search_heatpump",
-        "description": "Search for specific heat pump by criteria",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "manufacturer": {
-                    "type": "string",
-                    "description": "Manufacturer name (optional)"
-                },
-                "product_name": {
-                    "type": "string",
-                    "description": "Product name or partial match (optional)"
-                },
-                "article_number": {
-                    "type": "string",
-                    "description": "Article number (optional)"
-                },
-                "type": {
-                    "type": "string",
-                    "description": "Heat pump type (e.g., 'Luft-Wasser') (optional)"
-                },
-                "heating_power_min": {
-                    "type": "number",
-                    "description": "Minimum heating power in kW (optional)"
-                },
-                "heating_power_max": {
-                    "type": "number",
-                    "description": "Maximum heating power in kW (optional)"
-                }
-            }
-        }
-    },
-    {
-        "name": "get_heatpump_details",
-        "description": "Get detailed information about a specific heat pump",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "article_number": {
-                    "type": "string",
-                    "description": "Article number of the heat pump"
-                }
-            },
-            "required": ["article_number"]
-        }
-    },
-    {
-        "name": "list_manufacturers",
-        "description": "List all available manufacturers in parsed data",
-        "inputSchema": {
-            "type": "object",
-            "properties": {}
-        }
-    },
-    {
-        "name": "check_storage",
-        "description": "Check available storage locations and permissions",
-        "inputSchema": {
-            "type": "object",
-            "properties": {}
-        }
-    }
-]
-
-# MCP tool router
-def route_mcp_tool(tool_name: str, arguments: dict) -> str:
-    """Route MCP tool calls to the appropriate functions"""
-    try:
-        if tool_name == "download_vdi_files":
-            return download_vdi_files(
-                str(arguments.get("part", "")),
-                arguments.get("download_dir", "")
-            )
-        elif tool_name == "download_and_parse_part":
-            return download_and_parse_part(
-                str(arguments.get("part", "")),
-                arguments.get("download_dir", "")
-            )
-        elif tool_name == "parse_vdi_file":
-            return parse_vdi_file(arguments.get("file_path", ""))
-        elif tool_name == "search_heatpump":
-            return search_heatpump(
-                arguments.get("manufacturer", ""),
-                arguments.get("product_name", ""),
-                arguments.get("article_number", ""),
-                str(arguments.get("heating_power_min", "")),
-                str(arguments.get("heating_power_max", "")),
-                arguments.get("type", "")
-            )
-        elif tool_name == "get_heatpump_details":
-            return get_heatpump_details(arguments.get("article_number", ""))
-        elif tool_name == "list_manufacturers":
-            return list_manufacturers()
-        elif tool_name == "check_storage":
-            return check_storage()
-        else:
-            return f"Unknown tool: {tool_name}"
-    except Exception as e:
-        return f"Error executing tool {tool_name}: {str(e)}"
-
-# Create the Gradio interface with multiple tabs for different functions
-with gr.Blocks(title="VDI Heat Pump Parser", theme=gr.themes.Default()) as demo:
-    gr.Markdown("# VDI Heat Pump Data Parser")
-    gr.Markdown("Download, parse, and query VDI heat pump specification files")
+# Create the Gradio interface with MCP tool functions
+with gr.Blocks(title="VDI Heat Pump Parser - MCP Server", theme=gr.themes.Default()) as demo:
+    gr.Markdown("# 🔥 VDI Heat Pump Data Parser - MCP Server")
+    gr.Markdown("This application provides heat pump data tools for both web interface and Claude Desktop via MCP protocol.")
     
     with gr.Tabs():
         # Tab 1: Download and Parse
-        with gr.TabItem("Download & Parse"):
+        with gr.TabItem("📥 Download & Parse"):
             gr.Markdown("## Download and Parse VDI Files")
+            gr.Markdown("Download real heat pump data from VDI catalogs and parse it for analysis.")
             
             with gr.Row():
                 with gr.Column():
                     part_input = gr.Textbox(
                         label="Part Number", 
                         placeholder="Enter part number (e.g., 22 for heat pumps)",
-                        value="22"
+                        value="22",
+                        info="Part 22 = Heat Pumps, Part 2 = Heat Generators"
                     )
                     download_dir_input = gr.Textbox(
                         label="Download Directory (optional)", 
-                        placeholder="Leave empty for automatic temp directory"
+                        placeholder="Leave empty for automatic temp directory",
+                        info="Files will be saved to this directory"
                     )
                     
                 with gr.Column():
-                    download_btn = gr.Button("Download Files Only", variant="secondary")
-                    parse_btn = gr.Button("Download & Parse", variant="primary")
+                    download_btn = gr.Button("📁 Download Files Only", variant="secondary")
+                    parse_btn = gr.Button("🚀 Download & Parse", variant="primary")
             
             download_output = gr.Textbox(
                 label="Results", 
-                lines=10, 
-                interactive=False
+                lines=12, 
+                interactive=False,
+                placeholder="Results will appear here..."
             )
             
             download_btn.click(
@@ -858,26 +750,52 @@ with gr.Blocks(title="VDI Heat Pump Parser", theme=gr.themes.Default()) as demo:
             )
         
         # Tab 2: Search Heat Pumps
-        with gr.TabItem("Search Heat Pumps"):
+        with gr.TabItem("🔍 Search Heat Pumps"):
             gr.Markdown("## Search for Heat Pumps")
+            gr.Markdown("Search through parsed heat pump data using various criteria.")
             
             with gr.Row():
                 with gr.Column():
-                    manufacturer_input = gr.Textbox(label="Manufacturer", placeholder="e.g., Viessmann")
-                    product_name_input = gr.Textbox(label="Product Name", placeholder="e.g., Vitocal")
-                    article_number_input = gr.Textbox(label="Article Number", placeholder="Exact article number")
+                    manufacturer_input = gr.Textbox(
+                        label="Manufacturer", 
+                        placeholder="e.g., Viessmann, Vaillant, Bosch",
+                        info="Search by manufacturer name"
+                    )
+                    product_name_input = gr.Textbox(
+                        label="Product Name", 
+                        placeholder="e.g., Vitocal, EcoTEC",
+                        info="Search by product name or series"
+                    )
+                    article_number_input = gr.Textbox(
+                        label="Article Number", 
+                        placeholder="Exact or partial article number",
+                        info="Search by specific article number"
+                    )
                 
                 with gr.Column():
-                    type_input = gr.Textbox(label="Heat Pump Type", placeholder="e.g., Luft-Wasser")
-                    min_power_input = gr.Textbox(label="Min Heating Power (kW)", placeholder="e.g., 5")
-                    max_power_input = gr.Textbox(label="Max Heating Power (kW)", placeholder="e.g., 20")
+                    type_input = gr.Textbox(
+                        label="Heat Pump Type", 
+                        placeholder="e.g., Luft-Wasser, Wasser-Wasser",
+                        info="Search by heat pump technology type"
+                    )
+                    min_power_input = gr.Textbox(
+                        label="Min Heating Power (kW)", 
+                        placeholder="e.g., 5",
+                        info="Minimum heating power in kilowatts"
+                    )
+                    max_power_input = gr.Textbox(
+                        label="Max Heating Power (kW)", 
+                        placeholder="e.g., 20",
+                        info="Maximum heating power in kilowatts"
+                    )
             
-            search_btn = gr.Button("Search Heat Pumps", variant="primary")
+            search_btn = gr.Button("🔍 Search Heat Pumps", variant="primary")
             
             search_output = gr.Textbox(
                 label="Search Results", 
-                lines=15, 
-                interactive=False
+                lines=18, 
+                interactive=False,
+                placeholder="Search results will appear here..."
             )
             
             search_btn.click(
@@ -888,20 +806,23 @@ with gr.Blocks(title="VDI Heat Pump Parser", theme=gr.themes.Default()) as demo:
             )
         
         # Tab 3: Heat Pump Details
-        with gr.TabItem("Heat Pump Details"):
+        with gr.TabItem("📋 Heat Pump Details"):
             gr.Markdown("## Get Detailed Information")
+            gr.Markdown("Enter an article number to get complete technical specifications.")
             
             article_detail_input = gr.Textbox(
                 label="Article Number", 
-                placeholder="Enter exact article number"
+                placeholder="Enter exact article number",
+                info="Copy an article number from search results"
             )
             
-            detail_btn = gr.Button("Get Details", variant="primary")
+            detail_btn = gr.Button("📋 Get Details", variant="primary")
             
             detail_output = gr.Textbox(
                 label="Heat Pump Details", 
-                lines=20, 
-                interactive=False
+                lines=25, 
+                interactive=False,
+                placeholder="Detailed specifications will appear here..."
             )
             
             detail_btn.click(
@@ -911,17 +832,24 @@ with gr.Blocks(title="VDI Heat Pump Parser", theme=gr.themes.Default()) as demo:
             )
         
         # Tab 4: Utilities
-        with gr.TabItem("Utilities"):
+        with gr.TabItem("🛠️ Utilities"):
             gr.Markdown("## Utility Functions")
+            gr.Markdown("Check system status and list available manufacturers.")
             
             with gr.Row():
-                manufacturers_btn = gr.Button("List Manufacturers", variant="secondary")
-                storage_btn = gr.Button("Check Storage", variant="secondary")
+                with gr.Column():
+                    manufacturers_btn = gr.Button("👥 List Manufacturers", variant="secondary")
+                    gr.Markdown("*Shows all manufacturers in the parsed data*")
+                
+                with gr.Column():
+                    storage_btn = gr.Button("💾 Check Storage", variant="secondary")
+                    gr.Markdown("*Checks file system permissions and storage locations*")
             
             utility_output = gr.Textbox(
                 label="Results", 
-                lines=10, 
-                interactive=False
+                lines=12, 
+                interactive=False,
+                placeholder="Utility results will appear here..."
             )
             
             manufacturers_btn.click(
@@ -935,20 +863,23 @@ with gr.Blocks(title="VDI Heat Pump Parser", theme=gr.themes.Default()) as demo:
             )
         
         # Tab 5: Parse Local File
-        with gr.TabItem("Parse Local File"):
+        with gr.TabItem("📁 Parse Local File"):
             gr.Markdown("## Parse Local VDI ZIP File")
+            gr.Markdown("Parse VDI files that you have downloaded manually.")
             
             file_path_input = gr.Textbox(
                 label="File Path", 
-                placeholder="Enter full path to VDI ZIP file"
+                placeholder="Enter full path to VDI ZIP file",
+                info="e.g., /path/to/PART22_manufacturer.zip"
             )
             
-            parse_file_btn = gr.Button("Parse File", variant="primary")
+            parse_file_btn = gr.Button("📁 Parse File", variant="primary")
             
             parse_file_output = gr.Textbox(
                 label="Parse Results", 
-                lines=10, 
-                interactive=False
+                lines=12, 
+                interactive=False,
+                placeholder="Parse results will appear here..."
             )
             
             parse_file_btn.click(
@@ -956,115 +887,58 @@ with gr.Blocks(title="VDI Heat Pump Parser", theme=gr.themes.Default()) as demo:
                 inputs=file_path_input,
                 outputs=parse_file_output
             )
-
-# Add MCP endpoints to the Gradio app
-@demo.additional_routes()
-def add_mcp_routes():
-    from fastapi import Request
-    from fastapi.responses import JSONResponse, StreamingResponse
-    import asyncio
-    from datetime import datetime
-    
-    @demo.app.get("/gradio_api/mcp/sse")
-    async def mcp_sse():
-        """MCP Server-Sent Events endpoint"""
         
-        async def event_stream():
-            # Send initial connection event
-            yield f"data: {json.dumps({'type': 'connection', 'status': 'connected'})}\n\n"
-            
-            # Keep connection alive
-            while True:
-                await asyncio.sleep(30)  # Send heartbeat every 30 seconds
-                yield f"data: {json.dumps({'type': 'heartbeat', 'timestamp': datetime.now().isoformat()})}\n\n"
-        
-        return StreamingResponse(
-            event_stream(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "Access-Control-Allow-Origin": "*",
-                "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-                "Access-Control-Allow-Headers": "*"
-            }
-        )
-    
-    @demo.app.post("/gradio_api/mcp/rpc")
-    async def mcp_rpc(request: Request):
-        """MCP JSON-RPC endpoint"""
-        try:
-            data = await request.json()
-            method = data.get("method")
-            params = data.get("params", {})
-            request_id = data.get("id")
-            
-            if method == "initialize":
-                response = {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "result": {
-                        "protocolVersion": "2024-11-05",
-                        "capabilities": {
-                            "tools": {"listChanged": True}
-                        },
-                        "serverInfo": {
-                            "name": "vdi-heat-pump-server",
-                            "version": "1.0.0"
-                        }
-                    }
-                }
-            elif method == "tools/list":
-                response = {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "result": {
-                        "tools": MCP_TOOLS
-                    }
-                }
-            elif method == "tools/call":
-                tool_name = params.get("name")
-                arguments = params.get("arguments", {})
-                result = route_mcp_tool(tool_name, arguments)
-                
-                response = {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "result": {
-                        "content": [
-                            {
-                                "type": "text",
-                                "text": result
-                            }
-                        ]
-                    }
-                }
-            else:
-                response = {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "error": {
-                        "code": -32601,
-                        "message": f"Method not found: {method}"
-                    }
+        # Tab 6: MCP Info
+        with gr.TabItem("🔌 MCP Info"):
+            gr.Markdown("## MCP Server Information")
+            gr.Markdown("This application exposes the following tools for Claude Desktop:")
+            
+            gr.Markdown("""
+            ### Available MCP Tools:
+            
+            - **`download_vdi_files`** - Download VDI files for a specific part number
+            - **`download_and_parse_part`** - Download and parse VDI files automatically
+            - **`parse_vdi_file`** - Parse a local VDI ZIP file
+            - **`search_heatpump`** - Search heat pumps by manufacturer, power, type, etc.
+            - **`get_heatpump_details`** - Get detailed specifications for a specific heat pump
+            - **`list_manufacturers`** - List all available manufacturers
+            - **`check_storage`** - Check storage locations and permissions
+            
+            ### Claude Desktop Configuration:
+            
+            ```json
+            {
+              "mcpServers": {
+                "heat-pump": {
+                  "command": "npx",
+                  "args": [
+                    "mcp-remote",
+                    "YOUR_SERVER_URL/gradio_api/mcp/sse"
+                  ]
                 }
+              }
+            }
+            ```
             
-            return JSONResponse(response)
+            ### Local Testing:
+            Replace `YOUR_SERVER_URL` with `http://localhost:7860` for local testing.
             
-        except Exception as e:
-            logger.error(f"MCP RPC error: {e}")
-            return JSONResponse({
-                "jsonrpc": "2.0",
-                "id": data.get("id") if 'data' in locals() else None,
-                "error": {
-                    "code": -32603,
-                    "message": f"Internal error: {str(e)}"
-                }
-            })
+            ### Production (Hugging Face):
+            Replace `YOUR_SERVER_URL` with your Hugging Face Space URL.
+            """)
 
-# Launch the app with MCP server support
+# Launch the application with MCP server enabled
 if __name__ == "__main__":
+    print("=" * 60)
+    print("🔥 VDI Heat Pump Parser - MCP Server")
+    print("=" * 60)
+    print("🌐 Starting Gradio interface with MCP server support...")
+    print("🔌 MCP tools will be automatically exposed for Claude Desktop")
+    print("=" * 60)
+    
+    # Launch with MCP server enabled - this is the key line!
     demo.launch(
+        mcp_server=True,  # This enables MCP server functionality
         share=False,
         server_name="0.0.0.0",
         server_port=7860,

requirements.txt

@@ -1,7 +1,4 @@
-gradio>=4.0.0
+gradio[mcp]>=4.0.0
 pandas>=2.0.0
 numpy>=1.24.0
 requests>=2.28.0
-fastapi>=0.68.0
-uvicorn>=0.15.0
-pathlib2>=2.3.7