Upload 32 files

.dockerignore

@@ -0,0 +1,9 @@
+.git
+__pycache__
+*.pyc
+.env
+.venv
+*.log
+prepare_deploy.sh
+prepare_deploy.ps1
+mcp_client_config.json

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# 安装系统依赖
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# 复制依赖文件
+COPY requirements.txt .
+
+# 安装 Python 依赖
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 复制应用代码
+COPY server.py .
+COPY models/ ./models/
+
+# 设置环境变量
+ENV MODEL_DIR=/app/models
+ENV MCP_TRANSPORT=sse
+ENV HOST=0.0.0.0
+ENV PORT=7860
+
+# 暴露端口
+EXPOSE 7860
+
+# 启动服务
+CMD ["python", "server.py"]

README.md

@@ -1,12 +1,118 @@
----
-title: Psc Predict
-emoji: 🐢
-colorFrom: pink
-colorTo: blue
-sdk: gradio
-sdk_version: 6.3.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Psc Predict MCP Server
+emoji: ☀️
+colorFrom: yellow
+colorTo: yellow
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+---
+
+# Psc_Predict MCP Server
+
+Perovskite Solar Cell Performance Prediction MCP Service
+
+## Features
+
+Predict 8 performance metrics from CIF crystal structure files:
+
+| Metric | Description | Unit |
+|--------|-------------|------|
+| PCE | Power Conversion Efficiency | % |
+| DFT Band Gap | DFT calculated band gap | eV |
+| Energy Above Hull | Thermodynamic stability | eV/atom |
+| Stability Retention | Stability retention percentage | % |
+| Stability T80 | T80 lifetime | hours |
+| Voc | Open-circuit voltage | V |
+| Jsc | Short-circuit current density | mA/cm² |
+| FF | Fill factor | - |
+
+## Available Model Types
+
+| Model | Description | Recommendation |
+|-------|-------------|----------------|
+| **XGBoost** | Gradient boosting ensemble | ⭐ Default & Recommended |
+| **Random Forest** | Ensemble of decision trees | Good interpretability |
+| **Neural Network** | 3-layer MLP (128-64-32) | Deep learning approach |
+
+## MCP Connection
+
+### SSE Connection Configuration
+
+```json
+{
+  "mcpServers": {
+    "psc-predict": {
+      "url": "https://your-space.hf.space/sse"
+    }
+  }
+}
+```
+
+### Available Tools (Simplified)
+
+| Tool | Description | Parameters |
+|------|-------------|------------|
+| `predict_ensemble` | **Predict using ALL 3 models with ensemble statistics** | cif, targets |
+| `parse_cif_features` | Parse CIF and extract features | cif |
+| `get_model_info` | Get model information | - |
+| `list_available_models` | List all available models | - |
+
+### Ensemble Prediction (Autonomous Multi-Model)
+
+The `predict_ensemble` tool automatically calls all three models and provides:
+- Individual predictions from XGBoost, Random Forest, and Neural Network
+- Ensemble statistics: mean, std, min, max, range
+- Recommendation based on model performance benchmarks
+
+Example response:
+```json
+{
+  "results": {
+    "pce": {
+      "predictions": {"xgboost": 18.5, "random_forest": 17.8, "neural_network": 19.1},
+      "ensemble": {"mean": 18.47, "std": 0.53, "range": 1.3},
+      "recommendation": {"model": "xgboost", "value": 18.5}
+    }
+  }
+}
+```
+
+## Input Example
+
+```cif
+data_CsPbI3
+_cell_length_a   6.2894
+_cell_length_b   6.2894
+_cell_length_c   6.2894
+_cell_angle_alpha   90.0
+_cell_angle_beta   90.0
+_cell_angle_gamma   90.0
+_cell_volume   248.89
+_chemical_formula_sum   'Cs1 Pb1 I3'
+```
+
+## Model Information
+
+- **Model Types**: XGBoost (recommended), Random Forest, Neural Network
+- **Input Features**: 93-dimensional (7 lattice parameters + 86 element fractions)
+- **Training Data**: Perovskite solar cell database
+
+## Local Development
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run server
+python server.py
+
+# Or with Docker
+docker build -t psc-predict .
+docker run -p 7860:7860 psc-predict
+```
+
+## License
+
+MIT

mcp_client_config.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "psc-predict": {
+      "url": "https://YOUR_USERNAME-psc-predict.hf.space/sse",
+      "description": "钙钛矿太阳能电池性能预测服务"
+    }
+  }
+}

models/neural_network_dft_band_gap_layers-128-64-32_seed-42_batch-32.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f478babc7d56f62a411f0598cf7b34beb6266527a00b77d570a11cce23ed6ea
+size 102275

models/neural_network_energy_above_hull_layers-128-64-32_seed-42_batch-32.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef4a292af2b075729071d487ed70a01d853d265eca01437c6971b0df3c617643
+size 102666

models/neural_network_ff_layers-128-64-32_seed-42_batch-32.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:060b02ee1f4b3d62d3a6f26d110ed5c9de696976e059c20a3d5ba562f74d8e33
+size 101941

models/neural_network_jsc_layers-128-64-32_seed-42_batch-32.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10f4e65abb8134b3771dec100e7e3249a78cbc183aeac481f23c32adc2576142
+size 101968

models/neural_network_pce_layers-128-64-32_seed-42_batch-32.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60abaddc2c19ab9bc6ad1fc716ff35973b11648085070a922c81d34f1a3744f1
+size 101968

models/neural_network_stability_retention_layers-128-64-32_seed-42_batch-32.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7237f1d0c204d04bab1db3993b9bd7afdd5bd6aaf06c9b487dd4831182e61782
+size 102784

models/neural_network_stability_t80_layers-128-64-32_seed-42_batch-32.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf10f974da99fa1a918024adfb144d1ff14f26e596675c0fda5ab2aca94948f2
+size 102302

models/neural_network_voc_layers-128-64-32_seed-42_batch-32.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b61326b22bcadcda1597dc6727b03859046351fb4c59bdf056a8d535685e21ce
+size 101968

models/random_forest_dft_band_gap_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:454a66719e5eeffff2bdc9b1c539cb184a1ec1165a5f859367b6dde2e7b33be9
+size 78465

models/random_forest_energy_above_hull_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54898c9f2964e812a89ec11431a0f3d842cf22c2aff2eb20e5fc46af1331987a
+size 408945

models/random_forest_ff_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6855a7a821ed30f410faa928d76e1bab616b0abea2a50394a189411b07167cc7
+size 837633

models/random_forest_jsc_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cad18bc4c396811c73141e1531a8b9aca2ba70d863efa0f6c0456b625d3dd462
+size 493185

models/random_forest_pce_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:543123bf0091ef5891e839f344320d3fa5f056cc6f4ec810940fb757afda6105
+size 930081

models/random_forest_stability_retention_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:885d1f08f1d0408ecf31e56175e37e631594ad70ed22a5a24b97826460501ad9
+size 206481

models/random_forest_stability_t80_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5153ef576c9f328022e00f4930c0008a8865245c22dd0dfcf0406a6d35b66c7
+size 246513

models/random_forest_voc_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e10b19fa6d3d411bb8d0153984d9040581308306bf624a5095d88f5457dbc2b6
+size 641937

models/xgboost_dft_band_gap_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8eee2e7754c1e53858fbdf6b9b8005af12a5ac3833f65a11fc29213ea2877b83
+size 144513

models/xgboost_energy_above_hull_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61f32e26d376e085bf2957597a1ecb28ed6c63b7b62e26486fbdd617a9a96712
+size 179733

models/xgboost_ff_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d0ebd9de2ad79e2b4a91d080d73be30a81fc8c70b87e6ef3b9a0e67b23ce4d1
+size 236807

models/xgboost_jsc_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1d812b2d0ce4290360bd19dddd9283ef0081382a4474b38ada248ff03db798f
+size 251791

models/xgboost_pce_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd56cf3600c8ee298be757665f1951e3186da94c7a8ebf49f07867e15e2a1e4c
+size 344777

models/xgboost_stability_retention_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2443fcb970bc15a32facb23f69d050858a6badffdfd4bf81bfaffb9c98ff241a
+size 188915

models/xgboost_stability_t80_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:196c918ffc90fa2cb39ed20734b03c85754c06d130aa5947f16c75c3289f776e
+size 202134

models/xgboost_voc_layers-NA_seed-42_batch-32.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3b046d876ea815280e942691364db7fbd98851133bca2b540e04999f5f257c4
+size 232382

prepare_deploy.ps1

@@ -0,0 +1,44 @@
+# 准备 HuggingFace Docker 部署文件 (Windows PowerShell)
+
+Write-Host "==========================================" -ForegroundColor Cyan
+Write-Host "Preparing Psc_Predict for HuggingFace" -ForegroundColor Cyan
+Write-Host "==========================================" -ForegroundColor Cyan
+
+# 创建 models 目录
+if (-not (Test-Path "models")) {
+    New-Item -ItemType Directory -Path "models" | Out-Null
+}
+
+# 从 Psc_Predict 复制模型文件
+Write-Host "`nCopying XGBoost models..." -ForegroundColor Yellow
+Copy-Item "..\Psc_Predict\Psc_Predict\output\xgboost\*.pkl" -Destination "models\" -Force
+
+# 检查模型文件
+Write-Host "`nModels copied:" -ForegroundColor Green
+Get-ChildItem models\
+
+# 显示文件结构
+Write-Host "`nDirectory structure:" -ForegroundColor Green
+Write-Host "Psc_Predict_server/"
+Write-Host "├── Dockerfile"
+Write-Host "├── README.md"
+Write-Host "├── requirements.txt"
+Write-Host "├── server.py"
+Write-Host "└── models/"
+Get-ChildItem models\ | ForEach-Object { Write-Host "    ├── $($_.Name)" }
+
+Write-Host "`n==========================================" -ForegroundColor Cyan
+Write-Host "Ready to deploy!" -ForegroundColor Green
+Write-Host ""
+Write-Host "Next steps:" -ForegroundColor Yellow
+Write-Host "1. Create a new HuggingFace Space (Docker SDK)"
+Write-Host "2. Upload all files to the Space"
+Write-Host "3. Wait for build and deployment"
+Write-Host ""
+Write-Host "Or use git:" -ForegroundColor Yellow
+Write-Host "  git init"
+Write-Host "  git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/psc-predict"
+Write-Host "  git add ."
+Write-Host "  git commit -m 'Initial commit'"
+Write-Host "  git push -u origin main"
+Write-Host "==========================================" -ForegroundColor Cyan

prepare_deploy.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# 准备 HuggingFace Docker 部署文件
+
+echo "=========================================="
+echo "Preparing Psc_Predict for HuggingFace"
+echo "=========================================="
+
+# 创建 models 目录
+mkdir -p models
+
+# 从 Psc_Predict 复制模型文件
+echo "Copying XGBoost models..."
+cp ../Psc_Predict/Psc_Predict/output/xgboost/*.pkl models/
+
+# 检查模型文件
+echo ""
+echo "Models copied:"
+ls -la models/
+
+# 检查文件结构
+echo ""
+echo "Directory structure:"
+echo "├── Dockerfile"
+echo "├── README.md"
+echo "├── requirements.txt"
+echo "├── server.py"
+echo "└── models/"
+ls models/ | sed 's/^/    ├── /'
+
+echo ""
+echo "=========================================="
+echo "Ready to deploy!"
+echo ""
+echo "Next steps:"
+echo "1. Create a new HuggingFace Space (Docker SDK)"
+echo "2. Upload all files to the Space"
+echo "3. Wait for build and deployment"
+echo ""
+echo "Or use git:"
+echo "  git init"
+echo "  git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/psc-predict"
+echo "  git add ."
+echo "  git commit -m 'Initial commit'"
+echo "  git push -u origin main"
+echo "=========================================="

requirements.txt

@@ -0,0 +1,7 @@
+mcp[cli]>=1.0.0
+fastmcp>=0.1.0
+numpy>=1.21.0
+scikit-learn>=1.0.0
+xgboost>=1.7.0
+uvicorn>=0.20.0
+starlette>=0.25.0

server.py

@@ -0,0 +1,566 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Psc_Predict MCP Server
+
+Perovskite Solar Cell Performance Prediction MCP Service
+Using FastMCP framework with SSE transport
+Designed for HuggingFace Docker deployment
+"""
+
+import os
+import re
+import pickle
+import logging
+from typing import Dict, List, Optional, Any
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mcp.server.fastmcp import FastMCP
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastMCP server
+mcp = FastMCP(
+    "Psc_Predict",
+    description="Perovskite Solar Cell Performance Prediction Service - Predict PCE, bandgap, stability and other properties from CIF crystal structures"
+)
+
+# ============ CIF Parser ============
+class CIFParser:
+    """Extract crystallographic features from CIF content (93 dimensions)"""
+    
+    def __init__(self):
+        self.elements = [
+            'H', 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Cl', 'K', 'Ca', 
+            'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Br', 'Rb', 
+            'Sr', 'Y', 'Zr', 'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn', 'Sb', 'Te', 
+            'I', 'Cs', 'Ba', 'La', 'Ce', 'Pr', 'Nd', 'Pm', 'Sm', 'Eu', 'Gd', 'Tb', 'Dy', 'Ho', 'Er', 
+            'Tm', 'Yb', 'Lu', 'Hf', 'Ta', 'W', 'Re', 'Os', 'Ir', 'Pt', 'Au', 'Hg', 'Tl', 'Pb', 'Bi', 
+            'Po', 'At', 'Rn', 'Fr', 'Ra', 'Ac', 'Th', 'Pa', 'U'
+        ]
+        self.elem_to_idx = {e: i for i, e in enumerate(self.elements)}
+
+    def parse(self, cif_text: str) -> np.ndarray:
+        """Parse CIF string and return 93-dimensional feature vector"""
+        # Handle escaped newlines
+        if "\\n" in cif_text:
+            cif_text = cif_text.replace("\\n", "\n")
+        
+        # A. Extract lattice parameters (7 dimensions)
+        patterns = {
+            'a': r"_cell_length_a\s+([\d\.]+)",
+            'b': r"_cell_length_b\s+([\d\.]+)",
+            'c': r"_cell_length_c\s+([\d\.]+)",
+            'alpha': r"_cell_angle_alpha\s+([\d\.]+)",
+            'beta': r"_cell_angle_beta\s+([\d\.]+)",
+            'gamma': r"_cell_angle_gamma\s+([\d\.]+)",
+            'vol': r"_cell_volume\s+([\d\.]+)"
+        }
+        
+        lattice_feats = []
+        for key, pat in patterns.items():
+            match = re.search(pat, cif_text)
+            val = float(match.group(1)) if match else 0.0
+            lattice_feats.append(val)
+            
+        # B. Extract element composition (86 dimensions)
+        chem_match = re.search(r"_chemical_formula_sum\s+'?([^'\n]+)'?", cif_text)
+        elem_vec = np.zeros(len(self.elements))
+        
+        if chem_match:
+            formula = chem_match.group(1)
+            parts = formula.replace("'", "").split()
+            for part in parts:
+                m = re.match(r"([A-Za-z]+)([\d\.]*)", part)
+                if m:
+                    el = m.group(1)
+                    num = float(m.group(2)) if m.group(2) else 1.0
+                    if el in self.elem_to_idx:
+                        elem_vec[self.elem_to_idx[el]] = num
+        
+        # Normalize element vector
+        total_atoms = np.sum(elem_vec)
+        if total_atoms > 0:
+            elem_vec = elem_vec / total_atoms
+            
+        return np.concatenate([lattice_feats, elem_vec])
+
+    def get_feature_names(self) -> List[str]:
+        return ['a', 'b', 'c', 'alpha', 'beta', 'gamma', 'vol'] + self.elements
+
+
+# ============ Neural Network Model ============
+class MaterialNN(nn.Module):
+    """Neural Network for material property prediction"""
+    def __init__(self, input_dim, hidden_dims=[128, 64, 32]):
+        super(MaterialNN, self).__init__()
+        layers = []
+        in_d = input_dim
+        for h_d in hidden_dims:
+            layers.append(nn.Linear(in_d, h_d))
+            layers.append(nn.ReLU())
+            layers.append(nn.BatchNorm1d(h_d))
+            in_d = h_d
+        layers.append(nn.Linear(in_d, 1))
+        self.net = nn.Sequential(*layers)
+        
+    def forward(self, x):
+        return self.net(x)
+
+
+# ============ Model Manager ============
+class ModelManager:
+    """Manage all pretrained models (XGBoost, Random Forest, Neural Network)"""
+    
+    TARGETS = ['pce', 'dft_band_gap', 'energy_above_hull', 'stability_retention', 
+               'stability_t80', 'voc', 'jsc', 'ff']
+    
+    MODEL_TYPES = ['xgboost', 'random_forest', 'neural_network']
+    
+    TARGET_INFO = {
+        'pce': {'name': 'Power Conversion Efficiency', 'unit': '%'},
+        'dft_band_gap': {'name': 'DFT Band Gap', 'unit': 'eV'},
+        'energy_above_hull': {'name': 'Energy Above Hull', 'unit': 'eV/atom'},
+        'stability_retention': {'name': 'Stability Retention', 'unit': '%'},
+        'stability_t80': {'name': 'T80 Lifetime', 'unit': 'hours'},
+        'voc': {'name': 'Open Circuit Voltage', 'unit': 'V'},
+        'jsc': {'name': 'Short Circuit Current Density', 'unit': 'mA/cm²'},
+        'ff': {'name': 'Fill Factor', 'unit': ''}
+    }
+    
+    def __init__(self, model_dir: str = "./models"):
+        self.model_dir = model_dir
+        self.models: Dict[str, Dict[str, Any]] = {
+            'xgboost': {},
+            'random_forest': {},
+            'neural_network': {}
+        }
+        self.cif_parser = CIFParser()
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self._load_all_models()
+    
+    def _load_all_models(self):
+        """Load all available models"""
+        # Load XGBoost models
+        for target in self.TARGETS:
+            model_path = os.path.join(
+                self.model_dir, 
+                f"xgboost_{target}_layers-NA_seed-42_batch-32.pkl"
+            )
+            if os.path.exists(model_path):
+                try:
+                    with open(model_path, 'rb') as f:
+                        self.models['xgboost'][target] = pickle.load(f)
+                    logger.info(f"Loaded XGBoost model for {target}")
+                except Exception as e:
+                    logger.warning(f"Failed to load XGBoost model for {target}: {e}")
+        
+        # Load Random Forest models
+        for target in self.TARGETS:
+            model_path = os.path.join(
+                self.model_dir, 
+                f"random_forest_{target}_layers-NA_seed-42_batch-32.pkl"
+            )
+            if os.path.exists(model_path):
+                try:
+                    with open(model_path, 'rb') as f:
+                        self.models['random_forest'][target] = pickle.load(f)
+                    logger.info(f"Loaded Random Forest model for {target}")
+                except Exception as e:
+                    logger.warning(f"Failed to load Random Forest model for {target}: {e}")
+        
+        # Load Neural Network models
+        for target in self.TARGETS:
+            model_path = os.path.join(
+                self.model_dir, 
+                f"neural_network_{target}_layers-128-64-32_seed-42_batch-32.pth"
+            )
+            if os.path.exists(model_path):
+                try:
+                    model = MaterialNN(input_dim=93, hidden_dims=[128, 64, 32])
+                    model.load_state_dict(torch.load(model_path, map_location=self.device))
+                    model.to(self.device)
+                    model.eval()
+                    self.models['neural_network'][target] = model
+                    logger.info(f"Loaded Neural Network model for {target}")
+                except Exception as e:
+                    logger.warning(f"Failed to load Neural Network model for {target}: {e}")
+    
+    def predict(self, cif_text: str, targets: Optional[List[str]] = None, 
+                model_type: str = 'xgboost') -> Dict[str, float]:
+        """Predict specified targets using selected model type"""
+        if model_type not in self.models:
+            raise ValueError(f"Unknown model type: {model_type}. Available: {self.MODEL_TYPES}")
+        
+        if targets is None:
+            targets = list(self.models[model_type].keys())
+        
+        # Parse CIF
+        features = self.cif_parser.parse(cif_text)
+        X = features.reshape(1, -1)
+        
+        # Predict
+        results = {}
+        for target in targets:
+            if target in self.models[model_type]:
+                model = self.models[model_type][target]
+                if model_type == 'neural_network':
+                    X_tensor = torch.tensor(X, dtype=torch.float32).to(self.device)
+                    with torch.no_grad():
+                        pred = model(X_tensor).cpu().numpy().flatten()[0]
+                else:
+                    pred = model.predict(X)[0]
+                results[target] = float(pred)
+            else:
+                results[target] = None
+        
+        return results
+    
+    def get_available_targets(self, model_type: str = 'xgboost') -> List[str]:
+        """Return available prediction targets for a model type"""
+        if model_type in self.models:
+            return list(self.models[model_type].keys())
+        return []
+    
+    def get_available_models(self) -> Dict[str, List[str]]:
+        """Return all available models and their targets"""
+        return {
+            model_type: list(targets.keys()) 
+            for model_type, targets in self.models.items()
+            if targets
+        }
+
+
+# Global model manager
+model_manager: Optional[ModelManager] = None
+
+
+def get_model_manager() -> ModelManager:
+    """Get or initialize model manager"""
+    global model_manager
+    if model_manager is None:
+        model_dir = os.environ.get("MODEL_DIR", "./models")
+        model_manager = ModelManager(model_dir)
+    return model_manager
+
+
+# ============ MCP Tools ============
+
+# Valid model types
+VALID_MODEL_TYPES = ['xgboost', 'random_forest', 'neural_network']
+DEFAULT_MODEL_TYPE = 'xgboost'
+
+
+@mcp.tool()
+def parse_cif_features(cif: str) -> Dict[str, Any]:
+    """
+    Parse a CIF file and extract features for model prediction.
+    
+    Extracts 93-dimensional features:
+    - 7 lattice parameters (a, b, c, alpha, beta, gamma, volume)
+    - 86 element composition fractions
+    
+    Args:
+        cif: Crystal structure text in CIF format
+        
+    Returns:
+        Dictionary containing lattice parameters and element composition
+    """
+    manager = get_model_manager()
+    features = manager.cif_parser.parse(cif)
+    feature_names = manager.cif_parser.get_feature_names()
+    
+    # Separate lattice parameters and element composition
+    lattice = dict(zip(feature_names[:7], features[:7].tolist()))
+    
+    # Only return non-zero elements
+    composition = {}
+    for i, elem in enumerate(feature_names[7:]):
+        if features[7 + i] > 0:
+            composition[elem] = float(features[7 + i])
+    
+    return {
+        "lattice_parameters": lattice,
+        "composition": composition,
+        "feature_dim": len(features),
+        "status": "success"
+    }
+
+
+@mcp.tool()
+def get_model_info() -> Dict[str, Any]:
+    """
+    Get model information and available prediction targets.
+    
+    Returns information about:
+    - Available model types (XGBoost, Random Forest, Neural Network)
+    - All 8 prediction targets and their availability
+    - Input feature dimensions
+    
+    Returns:
+        Dictionary containing model information
+    """
+    manager = get_model_manager()
+    
+    # Get available targets for each model type
+    model_availability = {}
+    for mt in VALID_MODEL_TYPES:
+        available = manager.get_available_targets(model_type=mt)
+        model_availability[mt] = {
+            "available_targets": available,
+            "count": len(available)
+        }
+    
+    targets_info = []
+    for target in ModelManager.TARGETS:
+        info = ModelManager.TARGET_INFO.get(target, {})
+        targets_info.append({
+            "id": target,
+            "name": info.get('name', target),
+            "unit": info.get('unit', ''),
+            "xgboost": target in model_availability['xgboost']['available_targets'],
+            "random_forest": target in model_availability['random_forest']['available_targets'],
+            "neural_network": target in model_availability['neural_network']['available_targets']
+        })
+    
+    return {
+        "available_model_types": VALID_MODEL_TYPES,
+        "default_model_type": DEFAULT_MODEL_TYPE,
+        "recommended_model_type": "xgboost",
+        "input_features": 93,
+        "targets": targets_info,
+        "model_availability": model_availability,
+        "total_targets": len(ModelManager.TARGETS)
+    }
+
+
+@mcp.tool()
+def list_available_models() -> Dict[str, Any]:
+    """
+    List all available models and their status.
+    
+    Returns detailed information about which models are loaded and ready for inference.
+    
+    Returns:
+        Dictionary containing model availability status for each target and model type
+    """
+    manager = get_model_manager()
+    
+    models_status = {}
+    for mt in VALID_MODEL_TYPES:
+        models_status[mt] = {}
+        for target in ModelManager.TARGETS:
+            key = f"{mt}_{target}"
+            is_loaded = key in manager.models
+            models_status[mt][target] = {
+                "loaded": is_loaded,
+                "status": "ready" if is_loaded else "not_available"
+            }
+    
+    return {
+        "models": models_status,
+        "model_types": VALID_MODEL_TYPES,
+        "targets": ModelManager.TARGETS,
+        "status": "success"
+    }
+
+
+@mcp.tool()
+def predict_ensemble(cif: str, targets: Optional[List[str]] = None) -> Dict[str, Any]:
+    """
+    Predict using all three model types and return ensemble results with comparison.
+    
+    Automatically calls XGBoost, Random Forest, and Neural Network models for the same input,
+    allowing comparison of predictions across different model architectures.
+    Also provides ensemble statistics (mean, std, min, max) for each target.
+    
+    Args:
+        cif: Crystal structure text in CIF format
+        targets: Optional list of specific targets to predict. If None, predicts all available targets.
+                 Valid targets: pce, dft_band_gap, energy_above_hull, stability_retention, 
+                               stability_t80, voc, jsc, ff
+        
+    Returns:
+        Dictionary containing predictions from all models and ensemble statistics
+    """
+    import numpy as np
+    
+    manager = get_model_manager()
+    
+    # Determine targets to predict
+    if targets is None:
+        targets = ModelManager.TARGETS
+    
+    # Collect predictions from all models
+    all_predictions = {}
+    for mt in VALID_MODEL_TYPES:
+        try:
+            result = manager.predict(cif, list(targets), model_type=mt)
+            all_predictions[mt] = result
+        except Exception as e:
+            all_predictions[mt] = {"error": str(e)}
+    
+    # Calculate ensemble statistics for each target
+    ensemble_results = {}
+    for target in targets:
+        values = []
+        model_values = {}
+        
+        for mt in VALID_MODEL_TYPES:
+            if mt in all_predictions and target in all_predictions[mt]:
+                val = all_predictions[mt][target]
+                if val is not None:
+                    values.append(val)
+                    model_values[mt] = val
+                else:
+                    model_values[mt] = None
+            else:
+                model_values[mt] = None
+        
+        info = ModelManager.TARGET_INFO.get(target, {})
+        
+        if values:
+            ensemble_results[target] = {
+                "name": info.get('name', target),
+                "unit": info.get('unit', ''),
+                "predictions": model_values,
+                "ensemble": {
+                    "mean": float(np.mean(values)),
+                    "std": float(np.std(values)),
+                    "min": float(np.min(values)),
+                    "max": float(np.max(values)),
+                    "range": float(np.max(values) - np.min(values)),
+                    "n_models": len(values)
+                },
+                "recommendation": _get_best_prediction(target, model_values)
+            }
+        else:
+            ensemble_results[target] = {
+                "name": info.get('name', target),
+                "unit": info.get('unit', ''),
+                "predictions": model_values,
+                "ensemble": None,
+                "recommendation": None
+            }
+    
+    return {
+        "targets_predicted": list(targets),
+        "models_used": VALID_MODEL_TYPES,
+        "results": ensemble_results,
+        "raw_predictions": all_predictions,
+        "status": "success"
+    }
+
+
+def _get_best_prediction(target: str, model_values: Dict[str, float]) -> Dict[str, Any]:
+    """
+    Provide recommendation based on model performance characteristics.
+    XGBoost is generally recommended as it has the best overall performance.
+    """
+    # XGBoost is the recommended model based on benchmark results
+    if model_values.get('xgboost') is not None:
+        return {
+            "model": "xgboost",
+            "value": model_values['xgboost'],
+            "reason": "XGBoost recommended - best overall performance in benchmarks"
+        }
+    elif model_values.get('random_forest') is not None:
+        return {
+            "model": "random_forest", 
+            "value": model_values['random_forest'],
+            "reason": "Random Forest - fallback when XGBoost unavailable"
+        }
+    elif model_values.get('neural_network') is not None:
+        return {
+            "model": "neural_network",
+            "value": model_values['neural_network'],
+            "reason": "Neural Network - fallback option"
+        }
+    return None
+
+
+# ============ MCP Resources ============
+
+@mcp.resource("psc://info")
+def get_service_info() -> str:
+    """Service information"""
+    return """
+# Psc_Predict MCP Service
+
+Perovskite Solar Cell Performance Prediction Service
+
+## Features
+- Predict 8 performance metrics from CIF crystal structures
+- Support for single-target and multi-target prediction
+- Multiple model types: XGBoost (recommended), Random Forest, Neural Network
+
+## Available Model Types
+1. **XGBoost** (default, recommended) - Best overall performance
+2. **Random Forest** - Good interpretability
+3. **Neural Network** - 3-layer MLP (128-64-32)
+
+## Prediction Targets
+1. PCE - Power Conversion Efficiency (%)
+2. DFT Band Gap - DFT calculated band gap (eV)
+3. Energy Above Hull - Thermodynamic stability (eV/atom)
+4. Stability Retention - Stability retention percentage (%)
+5. Stability T80 - T80 lifetime (hours)
+6. Voc - Open-circuit voltage (V)
+7. Jsc - Short-circuit current density (mA/cm²)
+8. FF - Fill factor
+
+## Input Format
+CIF (Crystallographic Information File) format crystal structure text
+
+## Usage Example
+Call predict_pce(cif, model_type="xgboost") to predict PCE using XGBoost model.
+"""
+
+
+@mcp.resource("psc://example-cif")
+def get_example_cif() -> str:
+    """Example CIF file for testing"""
+    return """data_CsPbI3
+_symmetry_space_group_name_H-M   'P m -3 m'
+_cell_length_a   6.2894
+_cell_length_b   6.2894
+_cell_length_c   6.2894
+_cell_angle_alpha   90.0
+_cell_angle_beta   90.0
+_cell_angle_gamma   90.0
+_cell_volume   248.89
+_chemical_formula_sum   'Cs1 Pb1 I3'
+
+loop_
+_atom_site_label
+_atom_site_type_symbol
+_atom_site_fract_x
+_atom_site_fract_y
+_atom_site_fract_z
+Cs1 Cs 0.0 0.0 0.0
+Pb1 Pb 0.5 0.5 0.5
+I1 I 0.5 0.5 0.0
+I2 I 0.5 0.0 0.5
+I3 I 0.0 0.5 0.5
+"""
+
+
+# ============ Main Entry Point ============
+
+if __name__ == "__main__":
+    import sys
+    
+    # Support command line arguments for transport selection
+    transport = os.environ.get("MCP_TRANSPORT", "sse")
+    
+    if transport == "stdio":
+        mcp.run(transport="stdio")
+    else:
+        # SSE mode (default, for HuggingFace)
+        host = os.environ.get("HOST", "0.0.0.0")
+        port = int(os.environ.get("PORT", 7860))
+        mcp.run(transport="sse", host=host, port=port)