Update MCP service with core Foam-Agent functionality based on official repository

Foam-Agent/mcp_output/mcp_plugin/mcp_service.py

@@ -2,7 +2,8 @@ import os
 import sys
 import tempfile
 import subprocess
-from typing import Dict, Any
+import json
+from typing import Dict, Any, List, Optional
 
 project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
@@ -19,6 +20,17 @@ mcp = FastMCP("FoamAgentService")
 
 @mcp.tool(name="run_foam_agent", description="Run Foam-Agent workflow with natural language requirements")
 def run_foam_agent(requirements: str, output_dir: str = "./output", custom_mesh: str = None) -> Dict[str, Any]:
+    """
+    Run Foam-Agent workflow with natural language requirements.
+    
+    Args:
+        requirements: Natural language description of the CFD simulation
+        output_dir: Output directory for simulation results
+        custom_mesh: Optional path to custom GMSH .msh file
+    
+    Returns:
+        Dict containing status, output, and case directory
+    """
     try:
         with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
             f.write(requirements)
@@ -46,6 +58,19 @@ def run_foam_agent(requirements: str, output_dir: str = "./output", custom_mesh:
 
 @mcp.tool(name="run_foam_benchmark", description="Run complete Foam-Agent benchmark with OpenFOAM preprocessing")
 def run_foam_benchmark(openfoam_path: str, requirements: str, output_dir: str = "./output", custom_mesh: str = None) -> Dict[str, Any]:
+    """
+    Run complete Foam-Agent benchmark with OpenFOAM preprocessing.
+    This includes database initialization and full workflow execution.
+    
+    Args:
+        openfoam_path: Path to OpenFOAM installation (WM_PROJECT_DIR)
+        requirements: Natural language description of the CFD simulation
+        output_dir: Output directory for simulation results
+        custom_mesh: Optional path to custom GMSH .msh file
+    
+    Returns:
+        Dict containing status, output, and case directory
+    """
     try:
         with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
             f.write(requirements)
@@ -72,109 +97,56 @@ def run_foam_benchmark(openfoam_path: str, requirements: str, output_dir: str =
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
-@mcp.tool(name="check_foam_agent_status", description="Check if Foam-Agent is properly configured")
-def check_foam_agent_status() -> Dict[str, Any]:
-    status = {
-        "openfoam_installed": False,
-        "database_initialized": False,
-        "api_key_configured": False,
-        "api_url_configured": False,
-        "dependencies_installed": False
-    }
-    
-    # Check OpenFOAM
-    openfoam_dir = os.environ.get('WM_PROJECT_DIR')
-    if openfoam_dir and os.path.exists(openfoam_dir):
-        status["openfoam_installed"] = True
-    
-    # Check database
-    database_path = os.path.join(source_path, "database", "faiss")
-    if os.path.exists(database_path):
-        required_dbs = [
-            "openfoam_allrun_scripts",
-            "openfoam_tutorials_structure", 
-            "openfoam_tutorials_details",
-            "openfoam_command_help"
-        ]
-        status["database_initialized"] = all(
-            os.path.exists(os.path.join(database_path, db)) for db in required_dbs
-        )
-    
-    # Check API key
-    api_key = os.environ.get('OPENAI_API_KEY')
-    if api_key:
-        status["api_key_configured"] = True
+@mcp.tool(name="preprocess_database", description="Preprocess OpenFOAM database for Foam-Agent")
+def preprocess_database(openfoam_path: str) -> Dict[str, Any]:
+    """
+    Preprocess OpenFOAM database for Foam-Agent.
+    This runs all necessary preprocessing scripts.
     
-    # Check API URL
-    api_url = os.environ.get('OPENAI_BASE_URL')
-    if api_url:
-        status["api_url_configured"] = True
+    Args:
+        openfoam_path: Path to OpenFOAM installation (WM_PROJECT_DIR)
     
-    # Check dependencies
+    Returns:
+        Dict containing status and preprocessing results
+    """
     try:
-        import langchain
-        import faiss
-        import openai
-        status["dependencies_installed"] = True
-    except ImportError:
-        status["dependencies_installed"] = False
-    
-    return {
-        "status": "success", 
-        "checks": status,
-        "api_info": {
-            "api_key": api_key[:10] + "..." if api_key else "Not set",
-            "api_url": api_url if api_url else "Not set"
-        }
-    }
+        scripts = [
+            "database/script/tutorial_parser.py",
+            "database/script/faiss_command_help.py", 
+            "database/script/faiss_allrun_scripts.py",
+            "database/script/faiss_tutorials_structure.py",
+            "database/script/faiss_tutorials_details.py"
+        ]
+        
+        results = []
+        for script in scripts:
+            script_path = os.path.join(source_path, script)
+            if os.path.exists(script_path):
+                if "tutorial_parser.py" in script:
+                    cmd = ["python", script_path, "--output_dir=./database/raw", f"--wm_project_dir={openfoam_path}"]
+                else:
+                    cmd = ["python", script_path, "--database_path=./database"]
+                
+                result = subprocess.run(cmd, cwd=source_path, capture_output=True, text=True, timeout=1800)
+                results.append({
+                    "script": script,
+                    "status": "success" if result.returncode == 0 else "error",
+                    "output": result.stdout,
+                    "error": result.stderr
+                })
+            else:
+                results.append({
+                    "script": script,
+                    "status": "error",
+                    "output": "",
+                    "error": f"Script not found: {script_path}"
+                })
+        
+        return {"status": "success", "results": results}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
 
-@mcp.tool(name="get_foam_agent_info", description="Get Foam-Agent system information")
-def get_foam_agent_info() -> Dict[str, Any]:
-    return {
-        "status": "success",
-        "info": {
-            "name": "Foam-Agent",
-            "description": "Multi-agent framework for OpenFOAM CFD simulations",
-            "version": "1.0.0",
-            "capabilities": [
-                "Natural language to OpenFOAM workflow",
-                "Multi-agent architecture with LangGraph",
-                "FAISS vector database for knowledge retrieval",
-                "Automatic error correction and iteration",
-                "Custom mesh support (GMSH .msh files)",
-                "Multiple LLM provider support"
-            ],
-            "requirements": [
-                "OpenFOAM v10 installation",
-                "OpenAI API key or other LLM provider",
-                "Preprocessed OpenFOAM database",
-                "Python dependencies (langchain, faiss, etc.)"
-            ]
-        }
-    }
 
-@mcp.tool(name="validate_requirements", description="Validate user requirements for CFD simulation")
-def validate_requirements(requirements: str) -> Dict[str, Any]:
-    required_keywords = ["flow", "velocity", "pressure", "boundary", "mesh"]
-    found_keywords = [kw for kw in required_keywords if kw in requirements.lower()]
-    
-    return {
-        "status": "success",
-        "validation": {
-            "has_flow_info": "flow" in requirements.lower(),
-            "has_boundary_conditions": "boundary" in requirements.lower(),
-            "has_geometry": "mesh" in requirements.lower() or "geometry" in requirements.lower(),
-            "found_keywords": found_keywords,
-            "completeness": len(found_keywords) / len(required_keywords),
-            "suggestions": [
-                "Include flow type (incompressible/compressible)",
-                "Specify boundary conditions clearly",
-                "Define geometry or mesh requirements",
-                "Set physical parameters (viscosity, density, etc.)",
-                "Specify solver preferences if any"
-            ]
-        }
-    }
 
 def create_app():
     return mcp