Add Foam-Agent MCP service with conda environment support

.env

@@ -0,0 +1,16 @@
+# OpenAI API Configuration
+OPENAI_API_KEY=sk-jQe76a54b309e6635aa04de6b1135c2cdcacfe15bbb4pB4N
+OPENAI_BASE_URL=https://api.gptsapi.net/v1
+# Alternative API providers (uncomment to use)
+# OPENAI_BASE_URL=https://api.gptsapi.net/v1
+# OPENAI_BASE_URL=https://your-custom-api-endpoint.com/v1
+
+# Foam-Agent Configuration
+WM_PROJECT_DIR=/opt/openfoam10
+MODEL_PROVIDER=openai
+MODEL_VERSION=gpt-4o
+TEMPERATURE=0.6
+
+# MCP Service Configuration
+MCP_TRANSPORT=http
+MCP_PORT=7860

Dockerfile

@@ -0,0 +1,25 @@
+FROM continuumio/miniconda3:latest
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+WORKDIR /app
+
+# Copy environment.yml and install dependencies
+COPY --chown=user ./environment.yml environment.yml
+RUN conda env create -f environment.yml && \
+    conda clean -afy
+
+# Copy application files
+COPY --chown=user . /app
+ENV PYTHONPATH=/app/Foam-Agent/source:$PYTHONPATH
+
+# Install additional MCP dependencies
+RUN /opt/conda/envs/openfoamAgent/bin/pip install fastapi uvicorn[standard] fastmcp
+
+EXPOSE 7860
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+# Activate conda environment and run
+CMD ["/opt/conda/envs/openfoamAgent/bin/python", "Foam-Agent/mcp_output/start_mcp.py"]

Foam-Agent/mcp_output/README_MCP.md

@@ -0,0 +1,205 @@
+# Foam-Agent
+
+Foam-Agent is a multi-agent system designed to handle complex tasks through collaborative approaches. This project integrates various tools and technology stacks, supporting task automation, data processing, visualization, and integration with GPT models. Foam-Agent's target users include researchers, engineers, and developers, particularly suitable for complex scenarios requiring multi-step collaboration.
+
+---
+
+## Project Overview
+
+### Features and Characteristics
+- **Multi-Agent Collaboration**: The system consists of multiple specialized agents (such as Architect Agent, Meshing Agent, Reviewer Agent, etc.), each responsible for specific subtasks.
+- **Knowledge Base System**: Provides a knowledge base for storing and retrieving task-related data.
+- **Data Processing and Visualization**: Supports data extraction, processing, and visualization, helping users understand and analyze complex datasets.
+- **Automated Workflows**: Achieves automated task processing through multi-agent collaboration, reducing manual intervention.
+- **FoamGPT Data Pipeline**: Utilizes GPT models for data processing and generation, supporting natural language processing (NLP) tasks.
+
+### Core Modules
+- **Architect Agent**: Responsible for overall task planning and allocation.
+- **Meshing Agent**: Handles mesh generation or data structure-related tasks.
+- **Input Writer Agent**: Responsible for input data preparation and formatting.
+- **Local Runner Agent**: Executes local tasks.
+- **Reviewer Agent**: Checks the quality of task results.
+- **Visualization Agent**: Generates visualization outputs for task results.
+- **FoamGPT Integration**: Supports OpenAI and Hugging Face GPT models for data generation and processing.
+
+---
+
+## Installation Instructions
+
+### System Requirements
+- **Operating System**: Linux, macOS, or Windows
+- **Python Version**: 3.8 or higher
+- **Dependencies**:
+  - Required: `numpy`, `pandas`, `matplotlib`, `faiss`, `openai`, `transformers`, `pyyaml`
+  - Optional: `plotly`, `seaborn`, `docker`
+
+### Installation Steps
+1. **Clone Repository**
+   ```bash
+   git clone https://github.com/csml-rpi/Foam-Agent.git
+   cd Foam-Agent
+   ```
+
+2. **Create Virtual Environment**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # Linux/macOS
+   venv\Scripts\activate     # Windows
+   ```
+
+3. **Install Dependencies**
+   If using `conda`:
+   ```bash
+   conda env create -f environment.yml
+   conda activate foam-agent
+   ```
+   If using `pip`:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Verify Installation**
+   ```bash
+   python foambench_main.py --help
+   ```
+
+---
+
+## Usage Instructions
+
+### Starting the Main Program
+Run the following command to start the Foam-Agent system:
+```bash
+python foambench_main.py
+```
+
+### Example Use Cases
+1. **Run Single Task**
+   ```bash
+   python foambench_main.py --task single --config config.yaml
+   ```
+2. **Run Batch Tasks**
+   ```bash
+   python foambench_main.py --task batch --config batch_config.yaml
+   ```
+
+### Configuration Files
+Foam-Agent uses YAML files for configuration. Here is an example configuration file:
+```yaml
+task:
+  name: "example_task"
+  agents:
+    - architect
+    - meshing
+    - reviewer
+output:
+  directory: "./results"
+  format: "json"
+```
+
+Save the configuration file as `config.yaml` and specify it via the `--config` parameter during runtime.
+
+---
+
+## Available Tool Endpoints
+
+The following are the main tool endpoints provided by Foam-Agent:
+
+### Core Modules
+- **Architect Agent**: Responsible for overall task planning and allocation.
+- **Meshing Agent**: Handles mesh generation or data structure-related tasks.
+- **Input Writer Agent**: Responsible for input data preparation and formatting.
+- **Local Runner Agent**: Executes local tasks.
+- **Reviewer Agent**: Checks the quality of task results.
+- **Visualization Agent**: Generates visualization outputs for task results.
+
+### Data Processing Modules
+- **FoamGPT Data Pipeline**:
+  - `foamgpt_data`: Manages data loading and saving related to FoamGPT.
+  - `foamgpt_gen`: Uses GPT models to generate Foam-related outputs.
+  - `foamgpt_huggingface`: Integrates Hugging Face models.
+  - `foamgpt_openai`: Integrates OpenAI GPT models.
+  - `foamgpt_parser`: Parses the output generated by FoamGPT.
+
+### FAISS Tools
+- `faiss_allrun_scripts`: Runs scripts related to FAISS indexing.
+- `faiss_command_help`: Provides help information for FAISS commands.
+- `faiss_tutorials_details`: Gets detailed information about FAISS tutorials.
+- `faiss_tutorials_structure`: Gets structural information about FAISS tutorials.
+- `tutorial_parser`: Parses tutorial content.
+
+---
+
+## Notes
+
+1. **Environment Configuration**:
+   - Ensure that all required dependencies are installed in the Python environment.
+   - If using GPU, ensure that CUDA and related drivers are installed correctly.
+
+2. **Configuration Files**:
+   - Paths in configuration files should be absolute or relative to the project root directory.
+   - Ensure that the configuration file format is correct, otherwise it may cause parsing errors.
+
+3. **Network Connection**:
+   - If using OpenAI or Hugging Face GPT models, ensure that the network connection is normal and the API key is configured.
+
+---
+
+## Troubleshooting
+
+### Common Issues and Solutions
+
+#### 1. **Dependency Installation Failed**
+- **Issue**: Error occurred during dependency installation.
+- **Solution**:
+  - Ensure that the Python version is 3.8 or higher.
+  - Use `pip install --upgrade pip` to update pip.
+  - If the problem persists, try using `conda` to install dependencies.
+
+#### 2. **Foam-Agent Cannot Start**
+- **Issue**: Error occurred when running `foambench_main.py`.
+- **Solution**:
+  - Check if the configuration file is correct.
+  - Use the `--help` parameter to view available options.
+  - Ensure that all dependencies are installed correctly.
+
+#### 3. **Task Execution Failed**
+- **Issue**: Task execution interrupted or results are incorrect.
+- **Solution**:
+  - Check if the input data format is correct.
+  - View the log file for detailed error information.
+  - Ensure that the agent module configuration is correct.
+
+#### 4. **FoamGPT Model Loading Failed**
+- **Issue**: Cannot load GPT model.
+- **Solution**:
+  - Check if the network connection is normal.
+  - Ensure that OpenAI or Hugging Face API keys are configured.
+  - Ensure that `transformers` and `openai` libraries are installed.
+
+---
+
+## Contributing
+
+Welcome to contribute to the Foam-Agent project! You can participate in the following ways:
+- Submit issue reports or feature requests.
+- Submit code improvements or new features.
+- Submit documentation improvements.
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for more contribution guidelines.
+
+---
+
+## License
+
+Foam-Agent follows the [MIT License](LICENSE). You are free to use, modify, and distribute this project, but you must retain the original license statement.
+
+---
+
+## Contact
+
+If you have any questions or suggestions, please contact us via the following methods:
+- **GitHub Issues**: [Submit Issues](https://github.com/csml-rpi/Foam-Agent/issues)
+- **Email**: [email protected]
+
+Thank you for using Foam-Agent!

Foam-Agent/mcp_output/analysis.json

@@ -0,0 +1,153 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/csml-rpi/Foam-Agent",
+    "summary_text": "Repository: csml-rpi/Foam-Agent\nCommit: main\nFiles analyzed: 50+\n\nEstimated tokens: 150k+",
+    "file_tree": "...",
+    "content": {},
+    "processed_by": "gitingest",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.src",
+      "source.src.nodes",
+      "source.database.foamgpt",
+      "source.database.script"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": true,
+    "has_requirements_txt": false,
+    "pyproject": false,
+    "setup_cfg": false,
+    "setup_py": false
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [
+      {
+        "command": "foambench_main.py",
+        "description": "Main entry point for starting the Foam-Agent system."
+      }
+    ],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "source.src.nodes",
+        "module": "architect_node",
+        "functions": [
+          "save_file"
+        ],
+        "description": "Defines a placeholder for a file-saving function."
+      },
+      {
+        "package": "source.src.nodes",
+        "module": "meshing_node",
+        "functions": [
+          "handle_custom_mesh",
+          "handle_gmsh_mesh",
+          "meshing_node"
+        ],
+        "description": "Handles different mesh generation scenarios based on user requirements, including custom meshes and GMSH-based generation."
+      },
+      {
+        "package": "source.src.nodes",
+        "module": "input_writer_node",
+        "functions": [
+          "input_writer_node"
+        ],
+        "description": "Generates and rewrites OpenFOAM input files based on the specified mode (initial write or rewrite)."
+      },
+      {
+        "package": "source.src.nodes",
+        "module": "local_runner_node",
+        "functions": [
+          "local_runner_node"
+        ],
+        "description": "Executes the Allrun script for the simulation case and checks for errors."
+      },
+      {
+        "package": "source.src.nodes",
+        "module": "reviewer_node",
+        "functions": [
+          "reviewer_node"
+        ],
+        "description": "Reviews error logs from simulation runs and provides analysis and suggestions for fixes."
+      },
+      {
+        "package": "source.src.nodes",
+        "module": "visualization_node",
+        "functions": [
+          "visualization_node"
+        ],
+        "description": "Generates PyVista visualizations from successfully completed OpenFOAM cases."
+      },
+      {
+        "package": "source.src",
+        "module": "utils",
+        "classes": [
+          "LLMService",
+          "GraphState"
+        ],
+        "functions": [
+          "retrieve_faiss",
+          "run_command",
+          "check_foam_errors"
+        ],
+        "description": "Provides core utility functions and classes for the system, including the LLM service wrapper, state management, and file/command operations."
+      }
+    ],
+    "cli_commands": [
+      {
+        "command": "foambench_main.py",
+        "description": "Main entry point for starting the Foam-Agent system."
+      }
+    ],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "cli",
+      "confidence": 0.8
+    },
+    "dependencies": {
+      "required": [
+        "langchain",
+        "faiss-cpu",
+        "langchain-openai",
+        "langchain-aws",
+        "langchain-anthropic",
+        "pydantic",
+        "boto3",
+        "requests",
+        "pyyaml",
+        "numpy",
+        "matplotlib",
+        "pyvista"
+      ],
+      "optional": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "low",
+      "complexity": "high"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/csml-rpi/Foam-Agent",
+    "repo_name": "Foam-Agent",
+    "analysis": "### Analysis Report: Foam-Agent GitHub Repository\n\n#### 1. What are the main functions and purposes of this repository?\n\nFoam-Agent is an automated system designed to generate and run OpenFOAM simulations based on user requirements. It operates as a stateful pipeline, where a series of functional nodes process data sequentially to set up, execute, and visualize a simulation case. Its main functions are:\n\n- **Automated Case Generation**: Takes a natural language description of a simulation and generates the complete directory structure and input files for OpenFOAM.\n- **Mesh Generation**: Includes logic for generating meshes using GMSH based on user requirements.\n- **Simulation Execution**: Runs the generated OpenFOAM case using an `Allrun` script.\n- **Error Correction Loop**: If a simulation fails, it reviews the error logs, uses an LLM to propose corrections, rewrites the input files, and re-runs the simulation.\n- **Data Retrieval**: Utilizes a FAISS vector database to retrieve information about similar tutorials, command help, and existing scripts to inform the generation process.\n- **Visualization**: Automatically generates visualizations of the simulation results using PyVista.\n\nThe target users are engineers and researchers who need to run OpenFOAM simulations but want to automate the process of case setup and execution.\n\n---\n\n#### 2. What are the core modules and entry points of this repository?\n\nThe system is not a multi-agent system in the traditional sense but rather a graph-based pipeline orchestrated by a main script. The core components are:\n\n- **Core Modules (Functional Nodes)**:\n  - `meshing_node`: Generates the computational mesh.\n  - `input_writer_node`: Creates and modifies the OpenFOAM input dictionaries.\n  - `local_runner_node`: Executes the simulation script.\n  - `reviewer_node`: Analyzes errors if the simulation fails.\n  - `visualization_node`: Creates plots and images from the results.\n\n- **Core Utilities (`utils.py`)**:\n  - `LLMService`: A wrapper for interacting with various large language models (OpenAI, Bedrock, Anthropic).\n  - `GraphState`: A TypedDict that defines the shared state passed between nodes in the pipeline.\n  - `retrieve_faiss`: A function to query the FAISS vector database for relevant information.\n\n- **Main Entry Points**:\n  - `foambench_main.py`: The primary script that initializes the configuration, sets up the graph, and starts the simulation generation process.\n  - `source/src/main.py`: Contains the logic for defining the graph structure and the flow between the different nodes.\n\n---\n\n#### 3. What are the main technology stacks and dependencies used by this repository?\n\n- **Language**: Python\n- **Orchestration**: LangChain (specifically for its graph/state machine capabilities and LLM integrations).\n- **AI/ML**: OpenAI, Anthropic, or AWS Bedrock models for generation and analysis.\n- **Vector Database**: FAISS for similarity search on tutorials and commands.\n- **Core Libraries**: Pydantic (for data validation), PyYAML (for configuration), Boto3 (for AWS). \n- **Visualization**: PyVista.\n\n#### 4. Is this project suitable for conversion to an MCP (Model Context Protocol) service? Why?\n\n**Suitability Analysis:**\nFoam-Agent is highly suitable for conversion to an MCP service. The reasons are:\n\n- **Clear Entry Point**: The entire workflow is triggered by a single entry point (`foambench_main.py`) that takes a user requirement, making it easy to expose as a single service endpoint.\n- **Stateful, Long-Running Task**: The process is a long-running, stateful task, which aligns well with the MCP model of managing complex, multi-step jobs.\n- **Modular Logic**: The graph-based node structure means the internal logic is already modular. While the entire pipeline would likely be a single MCP tool, the underlying design is robust.\n- **High Value, Complex Task**: Automating OpenFOAM simulations is a complex and valuable task. Encapsulating it as a service makes it accessible to a wider range of users without requiring them to manage the complex environment and dependencies.\n\n**Recommendations:**\n- **Service Endpoint**: Expose the functionality of `foambench_main.py` as a single tool endpoint that accepts the user requirement as input.\n- **State Management**: The existing `GraphState` can be used internally to manage the state of the task.\n- **Output**: The service should return the path to the final case directory and any generated visualizations as its output.",
+    "model": "gpt-4o",
+    "source": "llm_direct_analysis",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o"
+  },
+  "risk": {
+    "import_feasibility": 0.8,
+    "intrusiveness_risk": "low",
+    "complexity": "high"
+  }
+}

Foam-Agent/mcp_output/env_info.json

@@ -0,0 +1,15 @@
+{
+  "environment": {
+    "type": "conda",
+    "name": "Foam-Agent_847955_env",
+    "files": {},
+    "python": "3.10",
+    "exec_prefix": []
+  },
+  "original_tests": {
+    "passed": true,
+    "report_path": null
+  },
+  "timestamp": 1755848930.0114202,
+  "conda_available": true
+}

Foam-Agent/mcp_output/mcp_logs/llm_statistics.json

@@ -0,0 +1,11 @@
+{
+  "total_calls": 4,
+  "failed_calls": 0,
+  "retry_count": 0,
+  "total_prompt_tokens": 13683,
+  "total_completion_tokens": 8017,
+  "total_tokens": 21700,
+  "average_prompt_tokens": 3420.75,
+  "average_completion_tokens": 2004.25,
+  "average_tokens": 5425.0
+}

Foam-Agent/mcp_output/mcp_logs/run_log.json

@@ -0,0 +1,79 @@
+{
+  "timestamp": 1755849059.289963,
+  "node": "RunNode",
+  "test_result": {
+    "passed": false,
+    "report_path": null,
+    "stdout": "",
+    "stderr": "Traceback (most recent call last):\n\n  File \"E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\start_mcp.py\", line 17, in <module>\n\n    from mcp_service import create_app\n\n  File \"E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\mcp_plugin\\mcp_service.py\", line 8, in <module>\n\n    from src.config import load_config, save_config\n\nImportError: cannot import name 'load_config' from 'src.config' (E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\source\\src\\config.py)\n\n\nERROR conda.cli.main_run:execute(49): `conda run python mcp_output\\start_mcp.py` failed. (See above for error)\n"
+  },
+  "run_result": {
+    "success": false,
+    "test_passed": false,
+    "exit_code": 1,
+    "stdout": "",
+    "stderr": "Traceback (most recent call last):\n\n  File \"E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\start_mcp.py\", line 17, in <module>\n\n    from mcp_service import create_app\n\n  File \"E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\mcp_plugin\\mcp_service.py\", line 8, in <module>\n\n    from src.config import load_config, save_config\n\nImportError: cannot import name 'load_config' from 'src.config' (E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\source\\src\\config.py)\n\n\nERROR conda.cli.main_run:execute(49): `conda run python mcp_output\\start_mcp.py` failed. (See above for error)\n",
+    "timestamp": 1755849059.289963,
+    "details": {
+      "command": "D:\\download\\Anaconda\\Scripts\\conda.exe run -n Foam-Agent_847955_env --cwd E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent python mcp_output\\start_mcp.py",
+      "working_directory": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent",
+      "environment_type": "conda"
+    }
+  },
+  "environment": {
+    "type": "conda",
+    "name": "Foam-Agent_847955_env",
+    "files": {},
+    "python": "3.10",
+    "exec_prefix": []
+  },
+  "plugin_info": {
+    "files": {
+      "mcp_output/start_mcp.py": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\mcp_plugin\\__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\mcp_plugin\\mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\mcp_plugin\\adapter.py",
+      "mcp_output/mcp_plugin/main.py": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\mcp_plugin\\main.py",
+      "mcp_output/requirements.txt": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\requirements.txt",
+      "mcp_output/README_MCP.md": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\README_MCP.md",
+      "mcp_output/tests_mcp/test_mcp_basic.py": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\tests_mcp\\test_mcp_basic.py"
+    },
+    "adapter_mode": "import",
+    "endpoints": [
+      "health",
+      "version",
+      "architectnode*",
+      "meshingnode*",
+      "inputwriternode*",
+      "localrunnernode*",
+      "reviewernode*",
+      "visualizationnode*",
+      "load_config",
+      "save_config",
+      "route_task",
+      "track_aws_event",
+      "parse_data",
+      "validate_input",
+      "load_foam_data",
+      "save_foam_data",
+      "generate_foam_output",
+      "huggingface_integration",
+      "openai_integration",
+      "parse_foam_output",
+      "run_faiss_index",
+      "get_faiss_help",
+      "get_tutorial_details",
+      "get_tutorial_structure",
+      "parse_tutorial"
+    ],
+    "mcp_dir": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\mcp_plugin",
+    "tests_dir": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\tests_mcp",
+    "main_entry": "start_mcp.py",
+    "readme_path": "E:\\code\\fastMCP\\fastMCP\\mcp-repo-output\\workspace\\Foam-Agent\\mcp_output\\README_MCP.md",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ]
+  },
+  "fastmcp_installed": false
+}

Foam-Agent/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry function"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

Foam-Agent/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,180 @@
+import os
+import sys
+import tempfile
+import subprocess
+from typing import Dict, Any
+
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+
+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]:
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+            f.write(requirements)
+            prompt_path = f.name
+        
+        cmd = [
+            "python", "src/main.py",
+            "--prompt_path", prompt_path,
+            "--output_dir", output_dir
+        ]
+        if custom_mesh:
+            cmd.extend(["--custom_mesh_path", custom_mesh])
+        
+        result = subprocess.run(cmd, cwd=source_path, capture_output=True, text=True, timeout=3600)
+        os.unlink(prompt_path)
+        
+        if result.returncode == 0:
+            return {"status": "success", "output": result.stdout, "case_dir": output_dir}
+        else:
+            return {"status": "error", "message": result.stderr}
+    except subprocess.TimeoutExpired:
+        return {"status": "error", "message": "Foam-Agent execution timed out after 1 hour"}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@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]:
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+            f.write(requirements)
+            prompt_path = f.name
+        
+        cmd = [
+            "python", "foambench_main.py",
+            "--openfoam_path", openfoam_path,
+            "--output", output_dir,
+            "--prompt_path", prompt_path
+        ]
+        if custom_mesh:
+            cmd.extend(["--custom_mesh_path", custom_mesh])
+        
+        result = subprocess.run(cmd, cwd=source_path, capture_output=True, text=True, timeout=7200)
+        os.unlink(prompt_path)
+        
+        if result.returncode == 0:
+            return {"status": "success", "output": result.stdout, "case_dir": output_dir}
+        else:
+            return {"status": "error", "message": result.stderr}
+    except subprocess.TimeoutExpired:
+        return {"status": "error", "message": "Foam-Agent benchmark execution timed out after 2 hours"}
+    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
+    
+    # Check API URL
+    api_url = os.environ.get('OPENAI_BASE_URL')
+    if api_url:
+        status["api_url_configured"] = True
+    
+    # Check dependencies
+    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"
+        }
+    }
+
+@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

Foam-Agent/mcp_output/requirements.txt

@@ -0,0 +1,7 @@
+fastmcp>=0.1.0
+pydantic>=2.0.0
+faiss-cpu
+PyYAML
+requests
+boto3
+

Foam-Agent/mcp_output/start_mcp.py

@@ -0,0 +1,55 @@
+
+"""
+MCP Service Startup Entry Point
+"""
+import sys
+import os
+from pathlib import Path
+
+# Load environment variables from .env file if it exists
+def load_env_file():
+    env_file = Path(__file__).parent.parent.parent.parent / '.env'
+    if env_file.exists():
+        with open(env_file, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#') and '=' in line:
+                    key, value = line.split('=', 1)
+                    os.environ[key] = value
+
+# Load environment variables
+load_env_file()
+
+# Set default values if not provided
+if not os.environ.get('OPENAI_API_KEY'):
+    print("Warning: OPENAI_API_KEY not set. Please set it in .env file or environment variables.")
+if not os.environ.get('OPENAI_BASE_URL'):
+    os.environ['OPENAI_BASE_URL'] = 'https://api.openai.com/v1'
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+# Set path to point to source directory
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP Service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Select transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

Foam-Agent/mcp_output/tests_mcp/test_mcp_basic.py

@@ -0,0 +1,49 @@
+"""
+MCP Service Basic Tests
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+def test_import_mcp_service():
+    """Test that the MCP service can be imported correctly"""
+    try:
+        from mcp_service import create_app
+        app = create_app()
+        assert app is not None
+        print("MCP service imported successfully")
+        return True
+    except Exception as e:
+        print(f"Failed to import MCP service: {e}")
+        return False
+
+def test_adapter_init():
+    """Test that the adapter can be initialized correctly"""
+    try:
+        from adapter import Adapter
+        adapter = Adapter()
+        assert adapter is not None
+        print("Adapter initialized successfully")
+        return True
+    except Exception as e:
+        print(f"Failed to initialize adapter: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("Running MCP service basic tests...")
+    test1 = test_import_mcp_service()
+    test2 = test_adapter_init()
+    
+    if test1 and test2:
+        print("All basic tests passed")
+        sys.exit(0)
+    else:
+        print("Some tests failed")
+        sys.exit(1)

Foam-Agent/mcp_output/tests_smoke/test_smoke.py

@@ -0,0 +1,29 @@
+import importlib, sys
+import os
+
+# Add current directory to Python path
+sys.path.insert(0, os.getcwd())
+
+source_dir = os.path.join(os.getcwd(), "source")
+if os.path.exists(source_dir):
+    sys.path.insert(0, source_dir)
+
+
+try:
+    importlib.import_module("src.nodes")
+    print("OK - Successfully imported src.nodes")
+except ImportError as e:
+    print(f"Failed to import src.nodes: {e}")
+    fallback_packages = []
+
+    fallback_packages = ['nodes']
+
+    for pkg in fallback_packages:
+        try:
+            importlib.import_module(pkg)
+            print(f"OK - Successfully imported {pkg}")
+            break
+        except ImportError:
+            continue
+    else:
+        print("All import attempts failed")

Foam-Agent/source/.gitignore

@@ -0,0 +1,181 @@
+# Project
+*.pkl
+*.txt
+runs/
+database/faiss
+database/raw
+output/
+benchmark/
+database/foamgpt/data
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

Foam-Agent/source/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ling Yue
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Foam-Agent/source/README.md

@@ -0,0 +1,151 @@
+# Foam-Agent
+
+<p align="center">
+  <img src="overview.png" alt="Foam-Agent System Architecture" width="600">
+</p>
+
+You can visit https://deepwiki.com/csml-rpi/Foam-Agent for a comprehensive introduction and to ask any questions interactively.
+
+## Introduction
+**Foam-Agent** is a multi-agent framework that automates complex OpenFOAM-based CFD simulation workflows from natural language inputs. By leveraging advanced AI techniques, Foam-Agent significantly lowers the expertise barrier for Computational Fluid Dynamics while maintaining modeling accuracy.
+
+Our framework offers three key innovations:
+- **Hierarchical multi-index retrieval system** with specialized indices for different simulation aspects
+- **Dependency-aware file generation system** ensuring consistency across configuration files
+- **Iterative error correction mechanism** that diagnoses and resolves simulation failures without human intervention
+
+## Features
+### 🔍 **Enhanced Retrieval System**
+- **Hierarchical retrieval** covering case files, directory structures, and dependencies
+- **Specialized vector index architecture** for improved information retrieval
+- **Context-specific knowledge retrieval** at different simulation stages
+
+### 🤖 **Multi-Agent Workflow Optimization**
+- **Architect Agent** interprets requirements and plans file structures
+- **Input Writer Agent** generates configuration files with consistency management
+- **Runner Agent** executes simulations and captures outputs
+- **Reviewer Agent** analyzes errors and proposes corrections
+
+### 🛠️ **Intelligent Error Correction**
+- **Error pattern recognition** for common simulation failures
+- **Automatic diagnosis and resolution** of configuration issues
+- **Iterative refinement process** that progressively improves simulation configurations
+
+### 📐 **External Mesh File Support**
+- **Custom mesh integration** with GMSH `.msh` files
+- **Boundary condition specification** through natural language requirements
+- **Currently supports** GMSH ASCII 2.2 format mesh files
+- **Seamless workflow** from mesh import to simulation execution
+
+**Example Usage:**
+```bash
+python foambench_main.py --openfoam_path $WM_PROJECT_DIR --output ./output --prompt_path ./user_requirement.txt --custom_mesh_path ./tandem_wing.msh
+```
+
+**Example Mesh File:** The `geometry.msh` file in this repository is taken from the [tandem wing tutorial](https://github.com/openfoamtutorials/tandem_wing) and demonstrates a 3D tandem wing simulation with NACA 0012 airfoils.
+
+**Requirements Format:** In your `user_req_tandem_wing.txt`, describe the boundary conditions and physical parameters for your custom mesh. The agent will automatically detect the mesh type and generate appropriate OpenFOAM configuration files.
+
+## Getting Started
+
+### 1. Clone the repository and install dependencies
+
+```bash
+git clone https://github.com/csml-rpi/Foam-Agent.git
+cd Foam-Agent
+git checkout v1.0.0
+conda env create -f environment.yml
+conda activate openfoamAgent
+```
+
+### 2. Install and configure OpenFOAM v10
+
+Foam-Agent requires OpenFOAM v10. Please follow the official installation guide for your operating system:
+
+- Official installation: [https://openfoam.org/version/10/](https://openfoam.org/version/10/)
+
+Verify your installation with:
+
+```bash
+echo $WM_PROJECT_DIR
+```
+and the result should be
+```
+/opt/openfoam10
+```
+or something similar.
+
+`WM_PROJECT_DIR` is an environment variable that comes with your OpenFOAM installation, indicating the location of OpenFOAM on your computer.
+
+### 3. Database preprocessing (first-time setup)
+
+Before running any workflow, you must preprocess the OpenFOAM tutorial and command database. This can be done automatically or manually.
+
+#### Recommended: Automatic preprocessing
+
+```bash
+python foambench_main.py --openfoam_path $WM_PROJECT_DIR --output ./output --prompt_path ./user_requirement.txt
+```
+
+This script will automatically run all necessary preprocessing scripts in `database/script/` and then launch the main workflow.
+
+#### Manual preprocessing (advanced)
+
+If you prefer to run preprocessing scripts manually, execute the following:
+
+```bash
+python database/script/tutorial_parser.py --output_dir=./database/raw --wm_project_dir=$WM_PROJECT_DIR
+python database/script/faiss_command_help.py --database_path=./database
+python database/script/faiss_allrun_scripts.py --database_path=./database
+python database/script/faiss_tutorials_structure.py --database_path=./database
+python database/script/faiss_tutorials_details.py --database_path=./database
+```
+
+### 4. Run a demo workflow
+
+#### Option 1: Automated benchmark (recommended)
+
+```bash
+python foambench_main.py --openfoam_path $WM_PROJECT_DIR --output ./output --prompt_path ./user_requirement.txt
+```
+
+#### Option 2: Directly run the main agent
+
+```bash
+python src/main.py --prompt_path ./user_requirement.txt --output_dir ./output
+```
+
+- You can also specify a custom mesh:
+
+```bash
+python src/main.py --prompt_path ./user_requirement.txt --output_dir ./output --custom_mesh_path ./my_mesh.msh
+```
+
+#### Example user_requirement.txt
+
+```
+do a Reynolds-Averaged Simulation (RAS) pitzdaily simulation. Use PIMPLE algorithm. The domain is a 2D millimeter-scale channel geometry. Boundary conditions specify a fixed velocity of 10m/s at the inlet (left), zero gradient pressure at the outlet (right), and no-slip conditions for walls. Use timestep of 0.0001 and output every 0.01. Finaltime is 0.3. use nu value of 1e-5.
+```
+
+### 5. Configuration and environment variables
+
+- Default configuration is in `src/config.py`. You can modify model provider, database path, and other parameters there.
+- You must set the `OPENAI_API_KEY` environment variable if using OpenAI/Bedrock models.
+
+### 6. Troubleshooting
+
+- **OpenFOAM environment not found**: Ensure you have sourced the OpenFOAM bashrc and restarted your terminal.
+- **Database not initialized**: Make sure you have run `foambench_main.py` or all scripts in `database/script/`.
+- **Missing dependencies**: After activating the environment, run `pip install -r requirements.txt` if needed.
+- **API key errors**: Ensure `OPENAI_API_KEY` is set in your environment.
+
+## Citation
+If you use Foam-Agent in your research, please cite our paper:
+```bibtex
+@article{yue2025foam,
+  title={Foam-Agent: Towards Automated Intelligent CFD Workflows},
+  author={Yue, Ling and Somasekharan, Nithin and Cao, Yadi and Pan, Shaowu},
+  journal={arXiv preprint arXiv:2505.04997},
+  year={2025}
+}
+```

Foam-Agent/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+Foam-Agent 项目包初始化文件
+"""

Foam-Agent/source/database/foamgpt/foamgpt_data.py

@@ -0,0 +1,80 @@
+import argparse
+import json
+from pathlib import Path
+from typing import Dict, List
+from collections import defaultdict
+from tqdm import tqdm
+
+
+def load_jsonl_data(file_path: Path) -> List[Dict]:
+    """Load data from JSONL file"""
+    print(f"Loading jsonl data from {file_path}")
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            if line.strip():
+                data.append(json.loads(line))
+    return data
+
+
+def main():
+    user_req_jsonl = load_jsonl_data(Path(__file__).parent / 'data' / 'foamgpt_user_requirements.jsonl')
+    user_req_dict = {req['case_name']: req['user_requirement'] for req in user_req_jsonl}
+    print(f"Loaded {len(user_req_jsonl)} user requirements")
+
+    foamgpt_input_data = load_jsonl_data(Path(__file__).parent / 'data' / 'parsed_openfoam_cases.jsonl')
+    print(f"Loaded {len(foamgpt_input_data)} input data")
+    print(f"{foamgpt_input_data[0].keys()}")
+
+    output_data = []
+
+    for case_file_data in foamgpt_input_data:
+        case_name = case_file_data['case_name']
+        file_name = case_file_data['file_name']
+        folder_name = case_file_data['folder_name']
+        case_solver = case_file_data['case_solver']
+        case_domain = case_file_data['case_domain']
+        case_category = case_file_data['case_category']
+
+        case_user_requirement = user_req_dict[case_name]
+
+
+        system_prompt = (
+            "You are an expert in OpenFOAM simulation and numerical modeling."
+            f"Your task is to generate a complete and functional file named: <file_name>{file_name}</file_name> within the <folder_name>{folder_name}</folder_name> directory. "
+            "Before finalizing the output, ensure:\n"
+            "- Ensure units and dimensions are correct** for all physical variables.\n"
+            f"- Ensure case solver settings are consistent with the user's requirements. Available solvers are: {case_solver}.\n"
+            "Provide only the code—no explanations, comments, or additional text."
+        )
+
+        user_prompt = (
+            f"User requirement: {case_user_requirement}\n"
+            "Please ensure that the generated file is complete, functional, and logically sound."
+            "Additionally, apply your domain expertise to verify that all numerical values are consistent with the user's requirements, maintaining accuracy and coherence."
+            "When generating controlDict, do not include anything to preform post processing. Just include the necessary settings to run the simulation."
+        )
+
+        output_data.append({
+            "case_name": case_name,
+            "file_name": file_name,
+            "folder_name": folder_name,
+            "case_solver": case_solver,
+            "case_domain": case_domain,
+            "case_category": case_category,
+            "system_prompt": system_prompt,
+            "user_prompt": user_prompt,
+            "file_content": case_file_data['file_content'],
+            "user_requirement": case_user_requirement
+        })
+
+    with open(Path(__file__).parent / 'data' / 'foamgpt_all.jsonl', 'w', encoding='utf-8') as f:
+        for data in output_data:
+            json.dump(data, f, ensure_ascii=False)
+            f.write('\n')
+        
+        print(f"Saved {len(output_data)} data to {Path(__file__).parent / 'data' / 'foamgpt_all.jsonl'}")
+
+if __name__ == "__main__":
+    main()
+    

Foam-Agent/source/database/foamgpt/foamgpt_gen.py

@@ -0,0 +1,211 @@
+import argparse
+import json
+from pathlib import Path
+from typing import Dict, List
+from collections import defaultdict
+from tqdm import tqdm
+
+import sys
+sys.path.append(str(Path(__file__).parent.parent.parent / "src"))
+
+from utils import LLMService
+from config import Config
+
+
+def load_jsonl_data(file_path: Path) -> List[Dict]:
+    """Load data from JSONL file"""
+    print(f"Loading jsonl data from {file_path}")
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            if line.strip():
+                data.append(json.loads(line))
+    return data
+
+
+def group_by_case_name(data: List[Dict]) -> Dict[str, List[Dict]]:
+    """Group records by case_name"""
+    grouped = defaultdict(list)
+    for record in data:
+        case_name = record.get('case_name', 'unknown')
+        grouped[case_name].append(record)
+    return dict(grouped)
+
+
+def create_system_prompt() -> str:
+    """Create the system prompt for generating user requirements"""
+    return """You are an expert OpenFOAM simulation engineer. Your task is to analyze OpenFOAM case files and generate a realistic user requirement that a simulation engineer would specify when requesting such a simulation.
+
+Based on the provided OpenFOAM case files, generate a user_requirement that follows these patterns:
+
+STRUCTURE REQUIREMENTS:
+1. Start with "do a [simulation type]" or "Perform a [simulation type]" or "Conduct a [simulation type]"
+2. Include solver specification: "using [solver name] solver" or "Use [solver name] solver"
+3. Specify geometric details with precise dimensions.
+4. When reporting dimensions, report values as is in the geometry file without scaling using convertToMeters parameter. Further report the convertToMeters value seperatly. 
+5. Define all boundary conditions for different patches/surfaces
+6. Include time parameters (start time, end time, timestep, output frequency)
+7. Specify physical properties (viscosity, density, temperature, pressure, etc.)
+8. Mention grid/mesh details when relevant
+9. Include algorithm details (PIMPLE, SIMPLE, etc.) when applicable
+10. When reporting intial location of fluid, report their location in x,y,z coordinates. For example water occupies the region 0<=x<=1, 0<=y<=1, 0<=z<=1.
+11. Detail the geometry of the domain as much as possible in a concise manner.
+
+TECHNICAL ACCURACY:
+- Use correct OpenFOAM terminology and solver names
+- Include realistic engineering values with proper units
+- Specify boundary condition types accurately (fixedValue, zeroGradient, noSlip, etc.)
+- Include material properties relevant to the simulation type
+- Mention turbulence models when applicable (k-epsilon, RAS, etc.)
+
+FORMAT REQUIREMENTS:
+- Generate a single, comprehensive sentence or paragraph
+- Use technical language appropriate for CFD engineers
+- Include specific numerical values extracted from the case files
+- Maintain consistency with OpenFOAM naming conventions
+
+EXAMPLES OF GOOD PATTERNS:
+- "do a Reynolds-Averaged Simulation (RAS) pitzdaily simulation. Use PIMPLE algorithm. The domain is a 2D millimeter-scale channel geometry. Boundary conditions specify a fixed velocity of 10m/s at the inlet (left), zero gradient pressure at the outlet (right), and no-slip conditions for walls. Use timestep of 0.0001 and output every 0.01. Finaltime is 0.3. use nu value of 1e-5."
+
+- "do an incompressible lid driven cavity flow. The cavity is a square with dimensions normalized to 1 unit on both the x and y axes and very thin in the z-direction (0.1 unit scaled down by a factor of 0.1, making it effectively 2D). Use a grid of 20X20 in x and y direction and 1 cell in z-direction(due to the expected 2D flow characteristics). The top wall ('movingWall') moves in the x-direction with a uniform velocity of 1 m/s. The 'fixedWalls' have a no-slip boundary condition (velocity equal to zero at the wall). The front and back faces are designated as 'empty'. The simulation runs from time 0 to 10 with a time step of 0.005 units, and results are output every 100 time steps. The viscosity (nu) is set as constant with a value of 1e-05 m^2/s."
+
+Generate ONLY the user_requirement text as a single comprehensive statement, with no additional explanation, formatting, or metadata."""
+
+
+def create_user_prompt(case_data: List[Dict]) -> str:
+    """Create the user prompt with case file information"""
+    case_info = case_data[0]  # Get case metadata from first record
+    
+    prompt = f"""Analyze this OpenFOAM case and generate a realistic user requirement:
+
+CASE METADATA:
+- Case Name: {case_info['case_name']}
+- Domain: {case_info['case_domain']}
+- Category: {case_info['case_category']}
+- Solver: {case_info['case_solver']}
+
+CASE FILES ANALYSIS:
+"""
+    
+    # Group files by folder for better organization
+    files_by_folder = defaultdict(list)
+    for record in case_data:
+        files_by_folder[record['folder_name']].append(record)
+    
+    # Add file contents organized by folder
+    for folder_name, files in files_by_folder.items():
+        prompt += f"\n=== {folder_name}/ ===\n"
+        for record in files:
+            file_name = record['file_name']
+            file_content = record['file_content']
+            prompt += f"\n--- {file_name} ---\n{file_content}\n"
+    
+    prompt += """
+
+TASK:
+Based on the case files above, extract the key simulation parameters and generate a realistic user_requirement that an engineer would specify when requesting this simulation. Focus on:
+
+1. Simulation type and solver
+2. Domain geometry and dimensions
+3. Boundary conditions for all patches
+4. Time settings (timestep, end time, output frequency)
+5. Physical properties (viscosity, density, temperature, etc.)
+6. Grid/mesh specifications
+7. Algorithm settings (PIMPLE, SIMPLE, turbulence models, etc.)
+
+Generate a single, comprehensive user_requirement statement that captures all essential simulation parameters."""
+    
+    return prompt
+
+
+def process_cases(grouped_data: Dict[str, List[Dict]], llm_service: LLMService, output_path: Path):
+    """Process each case and generate user requirements"""
+    results = []
+    total_cases = len(grouped_data)
+    
+    print(f"Processing {total_cases} cases...")
+    
+    for i, (case_name, case_data) in tqdm(enumerate(grouped_data.items(), 1)):
+        print(f"Processing case {i}/{total_cases}: {case_name}")
+        
+        try:
+            # Create prompts
+            system_prompt = create_system_prompt()
+            user_prompt = create_user_prompt(case_data)
+            
+            # Invoke LLM
+            user_requirement = llm_service.invoke(
+                user_prompt=user_prompt,
+                system_prompt=system_prompt
+            )
+            
+            # Create result record
+            case_info = case_data[0]  # Get metadata from first record
+            result = {
+                'case_name': case_name,
+                'case_domain': case_info['case_domain'],
+                'case_category': case_info['case_category'],
+                'case_solver': case_info['case_solver'],
+                'user_requirement': str(user_requirement).strip(),
+                'file_count': len(case_data),
+                'files': [{'folder_name': r['folder_name'], 'file_name': r['file_name']} for r in case_data]
+            }
+            
+            results.append(result)
+            
+            # Save progress after each case
+            with open(output_path, 'w', encoding='utf-8') as f:
+                for result_record in results:
+                    json.dump(result_record, f, ensure_ascii=False)
+                    f.write('\n')
+            
+            print(f"  ✓ Generated user requirement for {case_name}")
+
+        except Exception as e:
+            print(f"  ❌ Error processing {case_name}: {str(e)}")
+            continue
+    
+    return results
+
+
+def main():
+
+    input_path = Path(__file__).parent / 'data' / 'parsed_openfoam_cases.jsonl'
+    output_path = Path(__file__).parent / 'data' / 'foamgpt_user_requirements.jsonl'
+    
+    print(f"📂 Input: {input_path}")
+    print(f"💾 Output: {output_path}")
+    print()
+    
+    print("Initializing LLM service...")
+
+    config = Config()
+    print(f"Config: {config}")
+    llm_service = LLMService(config)
+    
+    # Load and process data
+    print("Loading data...")
+    data = load_jsonl_data(input_path)
+    print(f"Loaded {len(data)} records")
+    
+    print("Grouping by case name...")
+    grouped_data = group_by_case_name(data)
+    print(f"Found {len(grouped_data)} unique cases")
+    
+    # Process cases
+    results = process_cases(grouped_data, llm_service, output_path)
+    
+    # Print statistics
+    stats = llm_service.get_stats()
+    print(f"\n📊 Processing Summary:")
+    print(f"   Total cases processed: {len(results)}")
+    print(f"   LLM calls made: {stats['total_calls']}")
+    print(f"   Failed calls: {stats['failed_calls']}")
+    print(f"   Total tokens used: {stats['total_tokens']}")
+    print(f"   Prompt tokens: {stats['total_prompt_tokens']}")
+    print(f"   Completion tokens: {stats['total_completion_tokens']}")
+    
+    print(f"\n✅ Done! User requirements saved to: {output_path}")
+
+if __name__ == "__main__":
+    main()

Foam-Agent/source/database/foamgpt/foamgpt_huggingface.py

@@ -0,0 +1,72 @@
+import json
+import random
+from huggingface_hub import upload_file
+from pathlib import Path
+
+# Data splitting configuration
+input_file = Path(__file__).parent / 'data' / 'foamgpt_all.jsonl'
+train_file = Path(__file__).parent / 'data' / 'foamgpt_train.jsonl'
+test_file = Path(__file__).parent / 'data' / 'foamgpt_test.jsonl'
+test_ratio = 0.1
+
+# Hugging Face configuration
+repo_id = "LeoYML/FoamGPT"
+
+def split_data():
+    """Split data into training and test sets"""
+    print("Starting data splitting...")
+    
+    # Set random seed for reproducibility
+    random.seed(0)
+    
+    with open(input_file, "r", encoding="utf-8") as f:
+        lines = [json.loads(line) for line in f]
+
+    random.shuffle(lines)
+    split_idx = int(len(lines) * (1 - test_ratio))
+    train_data = lines[:split_idx]
+    test_data = lines[split_idx:]
+
+    # Write files
+    with open(train_file, "w", encoding="utf-8") as f:
+        for item in train_data:
+            f.write(json.dumps(item) + "\n")
+
+    with open(test_file, "w", encoding="utf-8") as f:
+        for item in test_data:
+            f.write(json.dumps(item) + "\n")
+
+    print(f"Data splitting completed: Train {len(train_data)} samples, Test {len(test_data)} samples")
+    return train_file, test_file
+
+def upload_to_huggingface(train_file, test_file):
+    """Upload files to Hugging Face"""
+    print("Starting upload to Hugging Face...")
+    
+    upload_file(
+        path_or_fileobj=train_file,
+        path_in_repo=train_file.name,
+        repo_id=repo_id,
+        repo_type="dataset"
+    )
+    print(f"Uploaded training file: {train_file}")
+
+    upload_file(
+        path_or_fileobj=test_file,
+        path_in_repo=test_file.name,
+        repo_id=repo_id,
+        repo_type="dataset"
+    )
+    print(f"Uploaded test file: {test_file}")
+    
+    print("All files uploaded successfully!")
+
+if __name__ == "__main__":
+    # Execute data splitting
+    print("Splitting data...")
+    train_file, test_file = split_data()
+    
+    # Upload to Hugging Face
+    print("Uploading to Hugging Face...")
+    upload_to_huggingface(train_file, test_file)
+

Foam-Agent/source/database/foamgpt/foamgpt_openai.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+Convert FoamGPT fine-tune data to OpenAI format for supervised fine-tuning.
+"""
+
+import json
+import os
+from pathlib import Path
+
+def convert_to_openai_format(input_file, output_file):
+    """
+    Convert FoamGPT fine-tune data to OpenAI format.
+    
+    Args:
+        input_file (str): Path to input JSONL file
+        output_file (str): Path to output JSONL file
+    """
+    
+    # Create output directory if it doesn't exist
+    output_path = Path(output_file)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    converted_count = 0
+    error_count = 0
+    
+    with open(input_file, 'r', encoding='utf-8') as infile, \
+         open(output_file, 'w', encoding='utf-8') as outfile:
+        
+        for line_num, line in enumerate(infile, 1):
+            try:
+                # Parse the original data
+                data = json.loads(line.strip())
+                
+                # Create OpenAI format
+                openai_format = {
+                    "messages": [
+                        {
+                            "role": "system",
+                            "content": data['system_prompt']
+                        },
+                        {
+                            "role": "user", 
+                            "content": data['user_prompt']
+                        },
+                        {
+                            "role": "assistant",
+                            "content": data['file_content']
+                        }
+                    ]
+                }
+                
+                # Write to output file
+                outfile.write(json.dumps(openai_format, ensure_ascii=False) + '\n')
+                converted_count += 1
+                
+                # Progress indicator
+                if converted_count % 100 == 0:
+                    print(f"Converted {converted_count} records...")
+                    
+            except json.JSONDecodeError as e:
+                print(f"Error parsing line {line_num}: {e}")
+                error_count += 1
+                continue
+            except Exception as e:
+                print(f"Unexpected error on line {line_num}: {e}")
+                error_count += 1
+                continue
+    
+    print(f"\nConversion completed!")
+    print(f"Successfully converted: {converted_count} records")
+    print(f"Errors encountered: {error_count} records")
+    print(f"Output saved to: {output_file}")
+
+def main():
+    """Main function to run the conversion."""
+    
+    # Define input and output paths
+    input_file = f"{Path(__file__).parent}/data/foamgpt_train.jsonl"
+    output_file = f"{Path(__file__).parent}/data/foamgpt_openai_train.jsonl"
+    
+    # Check if input file exists
+    if not os.path.exists(input_file):
+        print(f"Error: Input file '{input_file}' not found!")
+        return
+    
+    print(f"Converting {input_file} to OpenAI format...")
+    print(f"Output will be saved to: {output_file}")
+    
+    # Perform conversion
+    convert_to_openai_format(input_file, output_file)
+
+        # Define input and output paths
+    input_file = f"{Path(__file__).parent}/data/foamgpt_test.jsonl"
+    output_file = f"{Path(__file__).parent}/data/foamgpt_openai_test.jsonl"
+    
+    # Check if input file exists
+    if not os.path.exists(input_file):
+        print(f"Error: Input file '{input_file}' not found!")
+        return
+    
+    print(f"Converting {input_file} to OpenAI format...")
+    print(f"Output will be saved to: {output_file}")
+    
+    # Perform conversion
+    convert_to_openai_format(input_file, output_file)
+
+if __name__ == "__main__":
+    main()

Foam-Agent/source/database/foamgpt/foamgpt_parser.py

@@ -0,0 +1,174 @@
+import argparse
+import json
+import re
+from pathlib import Path
+from typing import Dict, List
+
+
+def parse_case_content(case_content: str) -> Dict:
+    """Parse a single case from the content."""
+    case_data = {}
+    
+    # Extract index information
+    index_match = re.search(r'<index>(.*?)</index>', case_content, re.DOTALL)
+    if index_match:
+        index_content = index_match.group(1)
+        case_data['case_name'] = re.search(r'case name:\s*(.+)', index_content).group(1).strip()
+        case_data['case_domain'] = re.search(r'case domain:\s*(.+)', index_content).group(1).strip()
+        case_data['case_category'] = re.search(r'case category:\s*(.+)', index_content).group(1).strip()
+        case_data['case_solver'] = re.search(r'case solver:\s*(.+)', index_content).group(1).strip()
+    
+    # Extract tutorials section
+    tutorials_match = re.search(r'<tutorials>(.*?)</tutorials>', case_content, re.DOTALL)
+    if tutorials_match:
+        case_data['files'] = parse_tutorials(tutorials_match.group(1))
+    
+    return case_data
+
+
+def parse_tutorials(tutorials_content: str) -> List[Dict]:
+    """Parse the tutorials section to extract file information."""
+    files = []
+    
+    # Find all directories
+    dir_pattern = r'<directory_begin>directory name:\s*(.+?)\n(.*?)</directory_end>'
+    for dir_match in re.finditer(dir_pattern, tutorials_content, re.DOTALL):
+        folder_name = dir_match.group(1).strip()
+        dir_content = dir_match.group(2)
+        
+        # Find all files in this directory
+        file_pattern = r'<file_begin>file name:\s*(.+?)\n<file_content>(.*?)</file_content>'
+        for file_match in re.finditer(file_pattern, dir_content, re.DOTALL):
+            file_name = file_match.group(1).strip()
+            file_content = file_match.group(2)
+            
+            files.append({
+                'file_name': file_name,
+                'folder_name': folder_name,
+                'file_content': file_content
+            })
+    
+    return files
+
+
+def process_file(input_path: Path, output_path: Path, char_limit: int):
+    """Process the OpenFOAM tutorials file and convert to JSONL format."""
+    
+    with open(input_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    # Split content by cases
+    case_pattern = r'<case_begin>(.*?)</case_end>'
+    cases = re.findall(case_pattern, content, re.DOTALL)
+    
+    skipped_files = []
+    processed_records = []
+    
+    print(f"Found {len(cases)} cases to process")
+    
+    for i, case_content in enumerate(cases):
+        if (i + 1) % 10 == 0:
+            print(f"Processing case {i + 1}/{len(cases)}")
+        
+        case_data = parse_case_content(case_content)
+        
+        if 'files' not in case_data:
+            continue
+        
+        for file_info in case_data['files']:
+            file_name = file_info['file_name'].strip()
+            folder_name = file_info['folder_name'].strip()
+            case_name = case_data['case_name'].strip()
+            case_domain = case_data['case_domain'].strip()
+            case_category = case_data['case_category'].strip()
+            case_solver = case_data['case_solver'].strip()
+            file_content = file_info['file_content'].strip()
+
+            # Check file content length
+            if len(file_content) > char_limit:
+                full_path = f"{case_name}/{folder_name}/{file_name}"
+                print(f"\n⚠️  WARNING: Skipping file due to length > {char_limit} characters")
+                print(f"   Length: {len(file_content)} characters")
+                print(f"   Content preview (first 500 chars):")
+                print("   " + "-" * 60)
+                print(file_content[:500] + "...")
+                print("   " + "-" * 60 + "\n")
+                
+                if full_path == "pitzDaily/system/blockMeshDict":
+                    pass
+
+                skipped_files.append({
+                    'path': full_path,
+                    'length': len(file_content)
+                })
+                continue
+        
+            # Check if the file content is not beginning with "FoamFile"
+            if not file_content.startswith("FoamFile"):
+                print(f"\n⚠️  WARNING: Skipping file due to missing 'FoamFile' header")
+                print(f"   Content preview (first 500 chars):")
+                print("   " + "-" * 60)
+                print(file_content[:500] + "...")
+                print("   " + "-" * 60 + "\n")
+                
+                continue
+
+        
+            
+            record = {
+                'file_name': file_name,
+                'folder_name': folder_name,
+                'case_name': case_name,
+                'case_domain': case_domain,
+                'case_category': case_category,
+                'case_solver': case_solver,
+                'file_content': file_content
+
+            }
+            processed_records.append(record)
+    
+    # Write output
+    print(f"\nWriting {len(processed_records)} records to {output_path}")
+    
+    with open(output_path, 'w', encoding='utf-8') as f:
+        for record in processed_records:
+            json.dump(record, f, ensure_ascii=False)
+            f.write('\n')
+    
+    # Summary
+    print(f"\n📊 Processing Summary:")
+    print(f"   Total cases processed: {len(cases)}")
+    print(f"   Total files written: {len(processed_records)}")
+    print(f"   Files skipped (too long): {len(skipped_files)}")
+    
+    if skipped_files:
+        skipped_files = sorted(skipped_files, key=lambda x: x['length'])
+        print(f"\n📋 Skipped files summary:")
+        for skip in skipped_files[:10]:  # Show first 10
+            print(f"   - {skip['path']} ({skip['length']} chars)")
+        if len(skipped_files) > 10:
+            print(f"   ... and {len(skipped_files) - 10} more")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert OpenFOAM tutorials to JSONL format for HuggingFace')
+    parser.add_argument('--char-limit', type=int, default=1500,
+                        help='Character limit for file content (default: 1500)')
+    
+    args = parser.parse_args()
+
+    input_openfoam_file_path = Path(__file__).parent.parent / 'raw' / 'openfoam_tutorials_details.txt'
+    output_parsed_file_path = Path(__file__).parent / 'data' / 'parsed_openfoam_cases.jsonl'
+
+    print(f"📂 Input: {input_openfoam_file_path}")      
+    print(f"📂 Output: {output_parsed_file_path}")
+    print(f"📏 Character limit: {args.char_limit}")
+    print()
+    
+    process_file(input_openfoam_file_path, output_parsed_file_path, args.char_limit)
+    
+    print(f"\n✅ Done! Output saved to: {output_parsed_file_path}")
+
+
+if __name__ == "__main__":
+    main()

Foam-Agent/source/database/script/__test_faiss.py

@@ -0,0 +1,36 @@
+from langchain_community.vectorstores import FAISS
+import argparse
+from pathlib import Path
+from langchain_community.embeddings.openai import OpenAIEmbeddings
+
+# Step 1: Parse command-line arguments
+parser = argparse.ArgumentParser(description="Process OpenFOAM case data and store embeddings in FAISS.")
+parser.add_argument("--db_name", type=str, required=True, help="Name of the FAISS database to retrieve from")
+parser.add_argument("--db_path", type=str, default=str(Path(__file__).resolve().parent.parent),
+                    help="Path to the database directory (default: '../database')")
+
+args = parser.parse_args()
+
+database_path = args.db_path  # Get the database path from arguments
+
+
+# Step 1: Define the path to the FAISS database
+persist_directory = f"{database_path}/faiss/{args.db_name}"
+
+# Step 2: Load the FAISS database
+embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
+vectordb = FAISS.load_local(persist_directory, embedding_model, allow_dangerous_deserialization=True)
+
+# Step 3: Retrieve all stored documents
+documents = vectordb.docstore._dict.values()  # Extract stored documents
+
+# Step 4: Print the contents
+print(f"📂 Loaded {len(documents)} documents from the FAISS database.\n")
+
+for i, doc in enumerate(documents):
+    if i > 10:
+        break
+    print(f"Document {i + 1}:")
+    print(f"Page Content: {doc.page_content}")
+    print(f"Metadata: {doc.metadata}")
+    print("-" * 80)

Foam-Agent/source/database/script/faiss_allrun_scripts.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+import os
+import re
+import argparse
+from pathlib import Path
+
+from langchain_community.vectorstores import FAISS
+from langchain_openai.embeddings import OpenAIEmbeddings
+from langchain_core.documents import Document
+
+
+def extract_field(field_name: str, text: str) -> str:
+    """Extract the specified field from the given text."""
+    match = re.search(fr"{field_name}:\s*(.*)", text)
+    return match.group(1).strip() if match else "Unknown"
+
+def tokenize(text: str) -> str:
+    # Replace underscores with spaces
+    text = text.replace('_', ' ')
+    # Insert a space between a lowercase letter and an uppercase letter (global match)
+    text = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', text)
+    return text.lower()
+
+def main():
+    # Step 1: Parse command-line arguments
+    parser = argparse.ArgumentParser(
+        description="Process OpenFOAM case data and store embeddings in FAISS."
+    )
+    parser.add_argument(
+        "--database_path",
+        type=str,
+        default=Path(__file__).resolve().parent.parent,
+        help="Path to the database directory (default: '../../')",
+    )
+        
+    args = parser.parse_args()
+    database_path = args.database_path
+    print(f"Database path: {database_path}")
+
+    # Step 2: Read the input file
+    database_allrun_path = os.path.join(database_path, "raw/openfoam_allrun_scripts.txt")
+    if not os.path.exists(database_allrun_path):
+        raise FileNotFoundError(f"File not found: {database_allrun_path}")
+
+    with open(database_allrun_path, "r", encoding="utf-8") as file:
+        file_content = file.read()
+
+    # Step 3: Extract segments using regex
+    pattern = re.compile(r"<case_begin>(.*?)</case_end>", re.DOTALL)
+    matches = pattern.findall(file_content)
+    if not matches:
+        raise ValueError("No cases found in the input file. Please check the file content.")
+
+    documents = []
+    for match in matches:
+        # Extract <index> content
+        index_match = re.search(r"<index>(.*?)</index>", match, re.DOTALL)
+        if not index_match:
+            continue
+        index_content = index_match.group(0).strip()
+        full_content = match.strip()
+
+        # Extract directory structure
+        dir_match = re.search(r"<directory_structure>(.*?)</directory_structure>", match, re.DOTALL)
+        dir_structure = dir_match.group(0).strip() if dir_match else "Unknown"
+
+        # Extract metadata fields from index_content
+        case_name = extract_field("case name", index_content)
+        case_domain = extract_field("case domain", index_content)
+        case_category = extract_field("case category", index_content)
+        case_solver = extract_field("case solver", index_content)
+        
+        # allrun script content is not sensitive to case domain and category
+        index_content = f"<index>\ncase name: {case_name}\ncase solver: {case_solver}</index>"
+
+        # Extract allrun script content from full_content
+        script_match = re.search(r"<allrun_script>([\s\S]*?)</allrun_script>", full_content)
+        case_allrun_script = script_match.group(1).strip() if script_match else "Unknown"
+
+        doc = Document(
+            page_content=tokenize(index_content + dir_structure),
+            metadata={
+                "full_content": full_content,
+                "case_name": case_name,
+                "case_domain": case_domain,
+                "case_category": case_category,
+                "case_solver": case_solver,
+                "dir_structure": dir_structure,
+                "allrun_script": case_allrun_script,
+            },
+        )
+        documents.append(doc)
+
+    # Step 4: Compute embeddings and store in FAISS
+    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+    vectordb = FAISS.from_documents(documents, embeddings)
+
+    # Step 5: Save the FAISS index locally
+    persist_directory = os.path.join(database_path, "faiss/openfoam_allrun_scripts")
+    vectordb.save_local(persist_directory)
+
+    print(f"{len(documents)} cases indexed successfully with metadata! Saved at: {persist_directory}")
+
+
+if __name__ == "__main__":
+    main()

Foam-Agent/source/database/script/faiss_command_help.py

@@ -0,0 +1,77 @@
+import os
+import re
+import argparse
+from pathlib import Path
+
+from langchain_community.vectorstores import FAISS
+from langchain_openai.embeddings import OpenAIEmbeddings
+from langchain_core.documents import Document
+
+def tokenize(text: str) -> str:
+    # Replace underscores with spaces
+    text = text.replace('_', ' ')
+    # Insert a space between a lowercase letter and an uppercase letter (global match)
+    text = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', text)
+    return text.lower()
+
+def main():
+    # Step 1: Parse command-line arguments
+    parser = argparse.ArgumentParser(
+        description="Process OpenFOAM case data and store embeddings in FAISS."
+    )
+    parser.add_argument(
+        "--database_path",
+        type=str,
+        default=Path(__file__).resolve().parent.parent,
+        help="Path to the database directory (default: '../../')",
+    )
+        
+    args = parser.parse_args()
+    database_path = args.database_path
+    print(f"Database path: {database_path}")
+        
+    # Step 2: Read the input file
+    database_allrun_path = os.path.join(database_path, "raw/openfoam_command_help.txt")
+    if not os.path.exists(database_allrun_path):
+        raise FileNotFoundError(f"File not found: {database_allrun_path}")
+
+    with open(database_allrun_path, "r", encoding="utf-8") as file:
+        file_content = file.read()
+
+    # Step 3: Extract `<command_begin> ... </command_end>` segments using regex
+    pattern = re.compile(r"<command_begin>(.*?)</command_end>", re.DOTALL)
+    matches = pattern.findall(file_content)
+
+    if not matches:
+        raise ValueError("No cases found in the input file. Please check the file content.")
+
+    documents = []
+
+    for match in matches:
+        command = re.search(r"<command>(.*?)</command>", match, re.DOTALL).group(1).strip()
+        help_text = re.search(r"<help_text>(.*?)</help_text>", match, re.DOTALL).group(1).strip()
+        full_content = match.strip()  # Store the complete case
+        
+        # Create a Document instance
+        documents.append(Document(
+            page_content=tokenize(command), 
+            metadata={
+                "full_content": full_content,
+                "command": command,
+                "help_text": help_text
+            }
+        ))
+
+    # Step 4: Compute embeddings and store them in FAISS
+    embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
+    vectordb = FAISS.from_documents(documents, embedding_model)
+
+    # Step 5: Save FAISS index locally
+    persist_directory = os.path.join(database_path, "faiss/openfoam_command_help")
+    vectordb.save_local(persist_directory)
+
+    print(f"{len(documents)} cases indexed successfully with metadata! Saved at: {persist_directory}")
+
+if __name__ == "__main__":
+    main()
+    

Foam-Agent/source/database/script/faiss_tutorials_details.py

@@ -0,0 +1,96 @@
+import os
+import re
+import argparse
+from pathlib import Path
+
+from langchain_community.vectorstores import FAISS
+from langchain_openai.embeddings import OpenAIEmbeddings
+from langchain_core.documents import Document
+
+# Function to extract specific fields from text
+def extract_field(field_name: str, text: str) -> str:
+    """Extracts the specified field from the given text."""
+    match = re.search(fr"{field_name}:\s*(.*)", text)
+    return match.group(1).strip() if match else "Unknown"
+
+def tokenize(text: str) -> str:
+    # Replace underscores with spaces
+    text = text.replace('_', ' ')
+    # Insert a space between a lowercase letter and an uppercase letter (global match)
+    text = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', text)
+    return text.lower()
+
+def main():
+   # Step 1: Parse command-line arguments
+    parser = argparse.ArgumentParser(
+        description="Process OpenFOAM case data and store embeddings in FAISS."
+    )
+    parser.add_argument(
+        "--database_path",
+        type=str,
+        default=Path(__file__).resolve().parent.parent,
+        help="Path to the database directory (default: '../../')",
+    )
+        
+    args = parser.parse_args()
+    database_path = args.database_path
+    print(f"Database path: {database_path}")
+        
+    # Step 2: Read the input file
+    database_allrun_path = os.path.join(database_path, "raw/openfoam_tutorials_details.txt")
+    if not os.path.exists(database_allrun_path):
+        raise FileNotFoundError(f"File not found: {database_allrun_path}")
+
+    with open(database_allrun_path, "r", encoding="utf-8") as file:
+        file_content = file.read()
+
+    # Step 3: Extract `<case_begin> ... </case_end>` segments using regex
+    pattern = re.compile(r"<case_begin>(.*?)</case_end>", re.DOTALL)
+    matches = pattern.findall(file_content)
+
+    if not matches:
+        raise ValueError("No cases found in the input file. Please check the file content.")
+
+    documents = []
+
+    for match in matches:
+        full_content = match.strip()  # Store the complete case
+        
+        index_match = re.search(r"<index>(.*?)</index>", match, re.DOTALL)
+        index_content = index_match.group(1).strip()  # Extract `<index>` content
+        
+        # Extract metadata fields
+        case_name = extract_field("case name", index_content)
+        case_domain = extract_field("case domain", index_content)
+        case_category = extract_field("case category", index_content)
+        case_solver = extract_field("case solver", index_content)
+        case_directory_structure = re.search(r"<directory_structure>([\s\S]*?)</directory_structure>", full_content).group(1)
+        detailed_tutorial = re.search(r"<tutorials>([\s\S]*?)</tutorials>", full_content).group(1)
+
+        # Create a Document instance
+        documents.append(Document(
+            page_content=tokenize(index_content+case_directory_structure),
+            metadata={
+                "full_content": full_content,  # Store full `<case_begin> ... </case_end>`
+                "case_name": case_name,
+                "case_domain": case_domain,
+                "case_category": case_category,
+                "case_solver": case_solver,
+                'dir_structure': case_directory_structure,
+                'tutorials': detailed_tutorial
+            }
+        ))
+
+    # Step 4: Compute embeddings and store them in FAISS
+    embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
+    vectordb = FAISS.from_documents(documents, embedding_model)
+
+    # Step 5: Save FAISS index locally
+    persist_directory = os.path.join(database_path, "faiss/openfoam_tutorials_details")
+    vectordb.save_local(persist_directory)
+
+    print(f"{len(documents)} cases indexed successfully with metadata! Saved at: {persist_directory}")
+
+if __name__ == "__main__":
+    main()
+    

Foam-Agent/source/database/script/faiss_tutorials_structure.py

@@ -0,0 +1,95 @@
+import os
+import re
+import argparse
+from pathlib import Path
+
+from langchain_community.vectorstores import FAISS
+from langchain_openai.embeddings import OpenAIEmbeddings
+from langchain_core.documents import Document
+
+# Function to extract specific fields from text
+def extract_field(field_name: str, text: str) -> str:
+    """Extracts the specified field from the given text."""
+    match = re.search(fr"{field_name}:\s*(.*)", text)
+    return match.group(1).strip() if match else "Unknown"
+
+def tokenize(text: str) -> str:
+    # Replace underscores with spaces
+    text = text.replace('_', ' ')
+    # Insert a space between a lowercase letter and an uppercase letter (global match)
+    text = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', text)
+    return text.lower()
+
+def main():
+   # Step 1: Parse command-line arguments
+    parser = argparse.ArgumentParser(
+        description="Process OpenFOAM case data and store embeddings in FAISS."
+    )
+    parser.add_argument(
+        "--database_path",
+        type=str,
+        default=Path(__file__).resolve().parent.parent,
+        help="Path to the database directory (default: '../../')",
+    )
+        
+    args = parser.parse_args()
+    database_path = args.database_path
+    print(f"Database path: {database_path}")
+
+    # Step 2: Read the input file
+    database_allrun_path = os.path.join(database_path, "raw/openfoam_tutorials_structure.txt")
+    if not os.path.exists(database_allrun_path):
+        raise FileNotFoundError(f"File not found: {database_allrun_path}")
+
+    with open(database_allrun_path, "r", encoding="utf-8") as file:
+        file_content = file.read()
+
+    # Step 3: Extract `<case_begin> ... </case_end>` segments using regex
+    pattern = re.compile(r"<case_begin>(.*?)</case_end>", re.DOTALL)
+    matches = pattern.findall(file_content)
+
+    if not matches:
+        raise ValueError("No cases found in the input file. Please check the file content.")
+
+    documents = []
+
+
+    for match in matches:
+        full_content = match.strip()  # Store the complete case
+        
+        index_match = re.search(r"<index>(.*?)</index>", match, re.DOTALL)
+        index_content = index_match.group(1).strip()  # Extract `<index>` content
+        
+        # Extract metadata fields
+        case_name = extract_field("case name", index_content)
+        case_domain = extract_field("case domain", index_content)
+        case_category = extract_field("case category", index_content)
+        case_solver = extract_field("case solver", index_content)
+        case_directory_structure = re.search(r"<directory_structure>([\s\S]*?)</directory_structure>", full_content).group(1)
+
+        # Create a Document instance
+        documents.append(Document(
+            page_content=tokenize(index_content),  # Use `<index>` content for embedding
+            metadata={
+                "full_content": full_content,  # Store full `<case_begin> ... </case_end>`
+                "case_name": case_name,
+                "case_domain": case_domain,
+                "case_category": case_category,
+                "case_solver": case_solver,
+                'dir_structure': case_directory_structure
+            }
+        ))
+
+    # Step 4: Compute embeddings and store them in FAISS
+    embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
+    vectordb = FAISS.from_documents(documents, embedding_model)
+
+    # Step 5: Save FAISS index locally
+    persist_directory = os.path.join(database_path, "faiss/openfoam_tutorials_structure")
+    vectordb.save_local(persist_directory)
+
+    print(f"{len(documents)} cases indexed successfully with metadata! Saved at: {persist_directory}")
+
+if __name__ == "__main__":
+    main()
+    

Foam-Agent/source/database/script/tutorial_parser.py

@@ -0,0 +1,376 @@
+import os
+import subprocess
+import argparse
+import concurrent.futures
+from pathlib import Path
+import re
+import json
+
+def read_files_into_dict(base_path, stats=None):
+    """
+    Reads files from the given base_path directory and stores their content in a dictionary.
+    """
+    if stats is None:
+        stats = {
+            "files_total_scanned": 0,
+            "files_skipped_encoding": 0,
+            "files_skipped_large": 0,
+            "files_read_success": 0,
+            "allrun_read_success": 0,
+            "allrun_read_fail": 0
+        }
+
+    file_contents, file_names, folder_names = {}, [], {}
+    base_depth = base_path.rstrip(os.sep).count(os.sep)
+
+    # Read 'Allrun' file
+    allrun_path = os.path.join(base_path, "Allrun")
+    allrun_content = "None"
+    
+    # Check if "Allrun" exists and attempt to read it
+    if os.path.isfile(allrun_path):
+        stats["files_total_scanned"] += 1  # We are scanning the Allrun file
+        
+        try:
+            with open(allrun_path, "r") as file_handle:
+                allrun_content = file_handle.read()
+            stats["allrun_read_success"] += 1
+        except UnicodeDecodeError:
+            print(f"Skipping file due to encoding error: {allrun_path}")
+            stats["files_skipped_encoding"] += 1
+            stats["allrun_read_fail"] += 1
+        except Exception as e:
+            print(f"Error reading file {allrun_path}: {e}")
+            stats["allrun_read_fail"] += 1
+
+    # Traverse the base_path directory to read files
+    for root, _, files in os.walk(base_path):
+        # Only read files one level below the base_path
+        if root.rstrip(os.sep).count(os.sep) == base_depth + 1:
+            for file in files:
+                file_path = os.path.join(root, file)
+                
+                stats["files_total_scanned"] += 1  # We are scanning this file
+                
+                try:
+                    with open(file_path, "r") as file_handle:
+                        lines = file_handle.readlines()
+
+                        file_contents[file] = "".join(lines)
+                        stats["files_read_success"] += 1
+
+                        folder_names[file] = os.path.relpath(root, base_path)
+                        file_names.append(file)
+                except UnicodeDecodeError:
+                    print(f"Skipping file due to encoding error: {file_path}")
+                    stats["files_skipped_encoding"] += 1
+                except Exception as e:
+                    print(f"Error reading file {file_path}: {e}")
+    
+    return allrun_content, file_contents, file_names, folder_names, stats
+
+
+def find_cases(root_dir):
+    """
+    Traverse the directory tree under 'root_dir' and look for cases containing a 'system' folder.
+    For each case found, extract metadata such as case name, solver, category, and domain.
+    
+    Additionally, collect statistics in a "funnel-like" manner to see how many directories 
+    and files are processed, skipped due to encoding issues, skipped due to large size, etc.
+    """
+    cases = []
+    
+    # Initialize statistics dictionary
+    stats = {
+        "directories_scanned": 0,
+        "directories_with_system": 0,
+        "files_total_scanned": 0,
+        "files_skipped_encoding": 0,
+        "files_skipped_large": 0,
+        "files_read_success": 0,
+        "allrun_read_success": 0,
+        "allrun_read_fail": 0
+    }
+
+    # Get FOAM_TUTORIALS from environment or fallback
+    FOAM_TUTORIALS = os.environ.get("FOAM_TUTORIALS", "/home/somasn/Documents/LLM/OpenFOAM-10/tutorials")
+    blockmesh_resource_dir = os.path.join(FOAM_TUTORIALS, "resources", "blockMesh")
+
+    for root, dirs, files in os.walk(root_dir):
+        stats["directories_scanned"] += 1  # Scanning this directory
+
+        # Check if the current directory contains a 'system' folder
+        if "system" in dirs:
+            stats["directories_with_system"] += 1
+
+            # Read files in the current directory (root)
+            allrun_content, file_contents, file_names, folder_names, file_stats = read_files_into_dict(root, stats={
+                "files_total_scanned": 0,
+                "files_skipped_encoding": 0,
+                "files_skipped_large": 0,
+                "files_read_success": 0,
+                "allrun_read_success": 0,
+                "allrun_read_fail": 0
+            })
+            
+            # Merge file_stats into the global stats
+            stats["files_total_scanned"] += file_stats["files_total_scanned"]
+            stats["files_skipped_encoding"] += file_stats["files_skipped_encoding"]
+            stats["files_skipped_large"] += file_stats["files_skipped_large"]
+            stats["files_read_success"] += file_stats["files_read_success"]
+            stats["allrun_read_success"] += file_stats["allrun_read_success"]
+            stats["allrun_read_fail"] += file_stats["allrun_read_fail"]
+
+            # The case name is the name of the current directory
+            case_name = os.path.basename(root)
+            
+            # Initialize solver, category, and domain
+            solver, category, domain = None, None, None
+            
+            # Move up to the parent directory and search up to 3 levels
+            current_path = os.path.dirname(root)
+            found_foam = False
+
+            for level in range(3):
+                # Stop if the path is empty or if we have reached the root_dir
+                if (not current_path) or (os.path.basename(current_path) == os.path.basename(root_dir)):
+                    break
+                
+                dir_name = os.path.basename(current_path)
+                
+                # If the directory name ends with 'Foam', treat it as the solver
+                if dir_name.endswith("Foam"):
+                    solver = dir_name
+                    # The parent of the solver directory is considered the domain
+                    domain = os.path.basename(os.path.dirname(current_path))
+                    found_foam = True
+                    break
+                elif level == 0:
+                    category = dir_name
+                
+                # Move one level up
+                current_path = os.path.dirname(current_path)
+            
+            # If no solver directory ending with 'Foam' was found, use the relative path logic
+            if not found_foam:
+                category = None  # Reset category in case it was partially set above
+                relative_path = os.path.relpath(root, root_dir)
+                path_components = relative_path.split(os.sep)
+                
+                # If the relative path has exactly 3 components: domain/solver/caseName
+                if len(path_components) == 3:
+                    domain, solver = path_components[0], path_components[1]
+                # If the relative path has exactly 4 components: domain/solver/category/caseName
+                elif len(path_components) == 4:
+                    domain, solver, category = path_components[0], path_components[1], path_components[2]
+
+            # --- NEW LOGIC: Check for missing blockMeshDict and copy if referenced in Allrun ---
+            system_dir = os.path.join(root, "system")
+            blockmeshdict_path = os.path.join(system_dir, "blockMeshDict")
+            if not os.path.isfile(blockmeshdict_path):
+                # Only try if Allrun exists and was read
+                if allrun_content != "None":
+                    # Look for blockMesh -dict $FOAM_TUTORIALS/resources/blockMesh/<name>
+                    pattern = r"blockMesh\s+-dict\s+\$FOAM_TUTORIALS/resources/blockMesh/([\w\d_]+)"
+                    match = re.search(pattern, allrun_content)
+                    if match:
+                        referenced_file = match.group(1)
+                        src_blockmeshdict = os.path.join(blockmesh_resource_dir, referenced_file)
+                        if os.path.isfile(src_blockmeshdict):
+                            # Copy to system/blockMeshDict
+                            try:
+                                with open(src_blockmeshdict, "r") as src_f:
+                                    blockmesh_content = src_f.read()
+                                # Save to the case's system dir
+                                os.makedirs(system_dir, exist_ok=True)
+                                with open(blockmeshdict_path, "w") as dst_f:
+                                    dst_f.write(blockmesh_content)
+                                # Add to in-memory structures for output
+                                file_contents["blockMeshDict"] = blockmesh_content
+                                file_names.append("blockMeshDict")
+                                folder_names["blockMeshDict"] = "system"
+                                print(f"[INFO] Copied {src_blockmeshdict} to {blockmeshdict_path} for case {case_name}")
+                            except Exception as e:
+                                print(f"[WARNING] Failed to copy {src_blockmeshdict} to {blockmeshdict_path}: {e}")
+                        else:
+                            print(f"[WARNING] Referenced blockMeshDict {src_blockmeshdict} not found for case {case_name}")
+                    else:
+                        print(f"[INFO] No blockMesh -dict reference found in Allrun for case {case_name}")
+                else:
+                    print(f"[INFO] No Allrun file to check for blockMeshDict reference in case {case_name}")
+            # --- END NEW LOGIC ---
+
+            # Append the extracted metadata to the 'cases' list
+            cases.append({
+                "case_name": case_name,
+                "solver": solver,
+                "category": category,
+                "domain": domain,
+                "folder_names": folder_names,
+                "file_names": file_names,
+                "file_contents": file_contents,
+                "allrun": allrun_content
+            })
+    
+    return cases, stats
+
+
+
+def save_cases_to_file(cases, output_dir):
+    """
+    Saves case details, summary, or Allrun content to a file.
+    """
+    
+    allrun_filepath = f"{output_dir}/openfoam_allrun_scripts.txt"
+    tutorials_summary_filepath = f"{output_dir}/openfoam_tutorials_structure.txt"
+    tutorial_filepath = f"{output_dir}/openfoam_tutorials_details.txt"
+    case_stats_filepath = f"{output_dir}/openfoam_case_stats.json"
+    
+    allrun_text = ''
+    tutorials_summary_text = ''
+    tutorials_text = ''
+    
+    case_stats = {
+        'case_domain': set(),
+        'case_category': set(),
+        'case_solver': set()
+    }
+    
+    for case in cases:
+        case_name, case_domain, case_category, case_solver = (
+            case["case_name"], case["domain"], case["category"], case["solver"]
+        )
+        
+        if case_domain:
+            case_stats['case_domain'].add(case_domain)
+        if case_category:
+            case_stats['case_category'].add(case_category)
+        if case_solver:
+            case_stats['case_solver'].add(case_solver)
+        
+        # Save the case index
+        case_index_text = "<index>\n"
+        case_index_text += f"case name: {case_name}\n"
+        case_index_text += f"case domain: {case_domain}\n"
+        case_index_text += f"case category: {case_category}\n"
+        case_index_text += f"case solver: {case_solver}\n"
+        case_index_text += "</index>\n\n"
+        
+        # Save the directory structure
+        folder_file_dict = {}
+        for file_name, folder_name in case["folder_names"].items():
+            if folder_name not in folder_file_dict:
+                folder_file_dict[folder_name] = []
+            folder_file_dict[folder_name].append(file_name)
+        
+        dir_structure_text = "<directory_structure>\n"
+        for folder_name, file_names in folder_file_dict.items():
+            dir_structure_text += f"<dir>directory name: {folder_name}. "
+            dir_structure_text += f"File names in this directory: [{', '.join(file_names)}]</dir>\n"
+        dir_structure_text += "</directory_structure>\n\n"
+        
+        
+        if case["allrun"] != "None":
+            # Save the Allrun content
+            allrun_text += f'''
+<case_begin>
+{case_index_text}
+{dir_structure_text}
+<allrun_script>
+{case["allrun"]}
+</allrun_script>
+</case_end>\n\n\n
+'''
+
+        # Save the tutorials summary
+        tutorials_summary_text += f"<case_begin>\n{case_index_text}\n{dir_structure_text}\n</case_end>\n\n"
+
+        # Save the detailed tutorials
+        tutorials_text += f"<case_begin>\n{case_index_text}\n{dir_structure_text}\n<tutorials>\n"
+        
+        for folder_name, file_names in folder_file_dict.items():
+            tutorials_text += f"<directory_begin>directory name: {folder_name}\n"
+            for file_name in file_names:
+                tutorials_text += f"<file_begin>file name: {file_name}\n"
+                
+                # Delete comments, such as license information, from the file contents
+                cleaned_text = re.sub(r'/\*.*?\*/', '', case['file_contents'][file_name], flags=re.DOTALL)
+                cleaned_text = re.sub(r'//.*', '', cleaned_text)
+
+                tutorials_text += f"<file_content>{cleaned_text}</file_content>\n"
+                tutorials_text += f"</file_end>\n\n"
+            
+            tutorials_text += f"</directory_end>\n\n"            
+
+        tutorials_text += "</tutorials>\n</case_end>\n\n\n"
+
+    with open(allrun_filepath, "w", encoding="utf-8") as file:
+        file.write(allrun_text)
+    
+    with open(tutorials_summary_filepath, "w", encoding="utf-8") as file:
+        file.write(tutorials_summary_text)
+            
+    with open(tutorial_filepath, "w", encoding="utf-8") as file:
+        file.write(tutorials_text)
+    
+    case_stats['case_category'].add("None")
+    case_stats['case_category'] = list(case_stats['case_category'])
+    case_stats['case_domain'] = list(case_stats['case_domain'])
+    case_stats['case_solver'] = list(case_stats['case_solver'])
+    
+    with open(case_stats_filepath, "w", encoding="utf-8") as file:
+        json.dump(case_stats, file, ensure_ascii=False, indent=4)
+            
+
+def get_commands_from_directory(directory_path):
+    """Retrieves all command file names from a specified directory using os.scandir."""
+    if not os.path.exists(directory_path):
+        raise FileNotFoundError(f"The directory {directory_path} does not exist.")
+    return [entry.name for entry in os.scandir(directory_path) if entry.is_file()]
+
+def get_command_help(command, directory_path):
+    """Retrieves the help message for a given command."""
+    try:
+        result = subprocess.run(
+            f"{os.path.join(directory_path, command)} -help", shell=True, capture_output=True, text=True
+        )
+        return result.stdout if result.returncode == 0 else result.stderr
+    except Exception as e:
+        return str(e)
+
+def fetch_command_helps(commands, directory_path):
+    """Fetch help messages in parallel."""
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        return dict(zip(commands, executor.map(lambda cmd: get_command_help(cmd, directory_path), commands)))
+
+if __name__ == "__main__":
+    # python ./database/script/tutorial_parser.py --output_dir=./database/raw --wm_project_dir=$WM_PROJECT_DIR
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--wm_project_dir", required=True, help="Path to WM_PROJECT_DIR")
+    parser.add_argument("--output_dir", default='./database', help="Directory to save output files")
+    args = parser.parse_args()
+    
+    print(args)
+
+    tutorial_path = os.path.join(args.wm_project_dir, "tutorials")
+    cases_info, case_stats = find_cases(tutorial_path)
+    print(f"Statistics: {case_stats}")
+    print(f"Found {len(cases_info)} cases in {tutorial_path}")
+    
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    save_cases_to_file(cases_info, output_dir)
+
+    commands_path = Path(args.wm_project_dir) / "platforms/linux64GccDPInt32Opt/bin"
+    commands = get_commands_from_directory(commands_path)
+    command_help_data = fetch_command_helps(commands, commands_path)
+
+    with open(output_dir / "openfoam_commands.txt", "w", encoding="utf-8") as f:
+        f.write("\n".join(commands) + "\n")
+
+    with open(output_dir / "openfoam_command_help.txt", "w", encoding="utf-8") as f:
+        for cmd, help_text in command_help_data.items():
+            f.write(f"<command_begin><command>{cmd}</command><help_text>{help_text}</help_text></command_end>\n\n")

Foam-Agent/source/environment.yml

@@ -0,0 +1,104 @@
+name: openfoamAgent
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1
+  - _openmp_mutex=4.5
+  - bzip2=1.0.8
+  - ca-certificates=2025.1.31
+  - expat=2.6.4
+  - ld_impl_linux-64=2.43
+  - libexpat=2.6.4
+  - libffi=3.4.6
+  - libgcc=14.2.0
+  - libgcc-ng=14.2.0
+  - libgomp=14.2.0
+  - liblzma=5.6.4
+  - liblzma-devel=5.6.4
+  - libnsl=2.0.1
+  - libsqlite=3.46.0
+  - libuuid=1.41.5
+  - libzlib=1.2.13
+  - ncurses=6.5
+  - openssl=3.4.1
+  - pip=25.0.1
+  - python=3.12.9
+  - readline=8.2
+  - setuptools=75.8.0
+  - sqlite=3.46.0
+  - tk=8.6.14
+  - tzdata=2025a
+  - wheel=0.45.1
+  - xz=5.6.4
+  - xz-gpl-tools=5.6.4
+  - xz-tools=5.6.4
+  - zlib=1.2.13
+  - pip:
+      - aiohappyeyeballs==2.4.6
+      - aiohttp==3.11.12
+      - aiosignal==1.3.2
+      - annotated-types==0.7.0
+      - anthropic==0.45.2
+      - anyio==4.8.0
+      - attrs==25.1.0
+      - certifi==2025.1.31
+      - charset-normalizer==3.4.1
+      - click==8.1.8
+      - dataclasses-json==0.6.7
+      - defusedxml==0.7.1
+      - distro==1.9.0
+      - faiss-cpu==1.10.0
+      - frozenlist==1.5.0
+      - gitingest==0.1.2
+      - greenlet==3.1.1
+      - h11==0.14.0
+      - httpcore==1.0.7
+      - httpx==0.28.1
+      - httpx-sse==0.4.0
+      - idna==3.10
+      - jiter==0.8.2
+      - jsonpatch==1.33
+      - jsonpointer==3.0.0
+      - langchain==0.3.18
+      - langchain-anthropic==0.2.4
+      - langchain-community==0.3.17
+      - langchain-core==0.3.34
+      - langchain-experimental==0.3.4
+      - langchain-openai==0.2.14
+      - langchain-text-splitters==0.3.6
+      - langchain-ollama==0.1.1
+      - langgraph==0.2.71
+      - langgraph-checkpoint==2.0.12
+      - langgraph-sdk==0.1.51
+      - langserve==0.3.1
+      - langsmith==0.3.8
+      - marshmallow==3.26.1
+      - msgpack==1.1.0
+      - multidict==6.1.0
+      - mypy-extensions==1.0.0
+      - numpy==2.2.2
+      - openai==1.61.1
+      - orjson==3.10.15
+      - packaging==24.2
+      - propcache==0.2.1
+      - pydantic==2.10.6
+      - pydantic-core==2.27.2
+      - pydantic-settings==2.7.1
+      - python-dotenv==1.0.1
+      - pyyaml==6.0.2
+      - regex==2024.11.6
+      - requests==2.32.3
+      - requests-toolbelt==1.0.0
+      - sniffio==1.3.1
+      - sqlalchemy==2.0.38
+      - tenacity==9.0.0
+      - tiktoken==0.8.0
+      - tqdm==4.67.1
+      - typing-extensions==4.12.2
+      - typing-inspect==0.9.0
+      - urllib3==2.3.0
+      - yarl==1.18.3
+      - zstandard==0.23.0
+      - boto3==1.36.26
+      - langchain_aws==0.2.13

Foam-Agent/source/foambench_main.py

@@ -0,0 +1,119 @@
+import os
+import subprocess
+import sys
+import argparse
+import shlex
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Benchmark Workflow Interface")
+    parser.add_argument(
+        '--openfoam_path',
+        type=str,
+        required=True,
+        help="Path to OpenFOAM installation (WM_PROJECT_DIR)"
+    )
+    parser.add_argument(
+        '--output',
+        type=str,
+        required=True,
+        help="Base output directory for benchmark results"
+    )
+    parser.add_argument(
+        '--prompt_path',
+        type=str,
+        required=True,
+        help="User requirement file path for the benchmark"
+    )
+    parser.add_argument(
+        '--custom_mesh_path',
+        type=str,
+        default=None,
+        help="Path to custom mesh file (e.g., .msh, .stl, .obj). If not provided, no custom mesh will be used."
+    )
+    return parser.parse_args()
+
+def run_command(command_str):
+    """
+    Execute a command string using the current terminal's input/output,
+    with the working directory set to the directory of the current file.
+    
+    Parameters:
+        command_str (str): The command to execute, e.g. "python main.py --output_dir xxxx" 
+                           or "bash xxxxx.sh".
+    """
+    # Split the command string into a list of arguments
+    args = shlex.split(command_str)
+    # Set the working directory to the directory of the current file
+    cwd = os.path.dirname(os.path.abspath(__file__))
+    
+    try:
+        result = subprocess.run(
+            args,
+            cwd=cwd,
+            check=True,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+            stdin=sys.stdin
+        )
+        print(f"Finished command: Return Code {result.returncode}")
+    except subprocess.CalledProcessError as e:
+        print(f"Error running command: {e}")
+        sys.exit(e.returncode)
+
+def main():
+    args = parse_args()
+    print(args)
+
+    # Set environment variables
+    WM_PROJECT_DIR = args.openfoam_path
+    # Check if OPENAI_API_KEY is available in the environment
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        print("Error: OPENAI_API_KEY is not set in the environment.")
+        sys.exit(1)
+
+    # Create the output folder
+    os.makedirs(args.output, exist_ok=True)
+
+    # Define the list of scripts to be executed.
+    # Each tuple consists of (script_path, list_of_arguments).
+    # Scripts can be Python or shell scripts.
+    
+    # Get the directory where this script is located
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    print(f"script_dir: {script_dir}")
+
+    SCRIPTS = []
+    
+    # Preprocess the OpenFOAM tutorials    
+    if not os.path.exists(f"{script_dir}/database/raw/openfoam_tutorials_details.txt"):
+        SCRIPTS.append(f"python database/script/tutorial_parser.py --output_dir=./database/raw --wm_project_dir={WM_PROJECT_DIR}")
+    if not os.path.exists(f"{script_dir}/database/faiss/openfoam_command_help"):
+        SCRIPTS.append(f"python database/script/faiss_command_help.py --database_path=./database")
+    if not os.path.exists(f"{script_dir}/database/faiss/openfoam_allrun_scripts"):
+        SCRIPTS.append(f"python database/script/faiss_allrun_scripts.py --database_path=./database")
+    if not os.path.exists(f"{script_dir}/database/faiss/openfoam_tutorials_structure"):
+        SCRIPTS.append(f"python database/script/faiss_tutorials_structure.py --database_path=./database")
+    if not os.path.exists(f"{script_dir}/database/faiss/openfoam_tutorials_details"):
+        SCRIPTS.append(f"python database/script/faiss_tutorials_details.py --database_path=./database")
+    
+    # Build main workflow command with optional custom mesh path
+    main_cmd = f"python src/main.py --prompt_path='{args.prompt_path}' --output_dir='{args.output}'"
+    if args.custom_mesh_path:
+        main_cmd += f" --custom_mesh_path='{args.custom_mesh_path}'"
+    
+    print(f"Main workflow command: {main_cmd}")
+    # Main workflow
+    SCRIPTS.extend([
+        main_cmd
+    ])
+
+    print("Starting workflow...")
+    for script in SCRIPTS:
+        run_command(script)
+    print("Workflow completed successfully.")
+
+if __name__ == "__main__":
+    ## python foambench_main.py --openfoam_path $WM_PROJECT_DIR --output ./output --prompt_path "./user_requirement.txt"
+    ## python foambench_main.py --openfoam_path $WM_PROJECT_DIR --output ./output --prompt_path "./user_requirement.txt" --custom_mesh_path "./my_mesh.msh"
+    main()

Foam-Agent/source/src/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+src 包初始化文件
+"""

Foam-Agent/source/src/config.py

@@ -0,0 +1,20 @@
+# config.py
+from dataclasses import dataclass
+from pathlib import Path
+
+@dataclass
+class Config:
+    max_loop: int = 10
+    
+    batchsize: int = 10
+    searchdocs: int = 2
+    run_times: int = 1  # current run number (for directory naming)
+    database_path: str = Path(__file__).resolve().parent.parent / "database"
+    run_directory: str = Path(__file__).resolve().parent.parent / "runs"
+    case_dir: str = ""
+    max_time_limit = 36000 # Max time limit after which the openfoam run will be terminated
+    model_provider: str = "openai"# [openai, ollama, bedrock]
+    # model_version should be in ["gpt-4o", "deepseek-r1:32b-qwen-distill-fp16", "qwen2.5:32b-instruct"]
+    model_version: str = "gpt-4o"
+    temperature: float = 0.6
+    

Foam-Agent/source/src/main.py

@@ -0,0 +1,160 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, TypedDict, Literal
+from langgraph.graph import StateGraph, START, END
+from langgraph.types import Command
+import argparse
+from pathlib import Path
+from utils import LLMService, GraphState
+
+from config import Config
+from nodes.architect_node import architect_node
+from nodes.meshing_node import meshing_node
+from nodes.input_writer_node import input_writer_node
+from nodes.local_runner_node import local_runner_node
+from nodes.reviewer_node import reviewer_node
+from nodes.visualization_node import visualization_node
+from nodes.hpc_runner_node import hpc_runner_node
+from router_func import (
+    route_after_architect, 
+    route_after_input_writer, 
+    route_after_runner, 
+    route_after_reviewer
+)
+import json
+
+def create_foam_agent_graph() -> StateGraph:
+    """Create the OpenFOAM agent workflow graph."""
+    
+    # Create the graph
+    workflow = StateGraph(GraphState)
+    
+    # Add nodes
+    workflow.add_node("architect", architect_node)
+    workflow.add_node("meshing", meshing_node)
+    workflow.add_node("input_writer", input_writer_node)
+    workflow.add_node("local_runner", local_runner_node)
+    workflow.add_node("hpc_runner", hpc_runner_node)
+    workflow.add_node("reviewer", reviewer_node)
+    workflow.add_node("visualization", visualization_node)
+    
+    # Add edges
+    workflow.add_edge(START, "architect")
+    workflow.add_conditional_edges("architect", route_after_architect)
+    workflow.add_edge("meshing", "input_writer")
+    workflow.add_conditional_edges("input_writer", route_after_input_writer)
+    workflow.add_conditional_edges("hpc_runner", route_after_runner)
+    workflow.add_conditional_edges("local_runner", route_after_runner)
+    workflow.add_conditional_edges("reviewer", route_after_reviewer)
+    workflow.add_edge("visualization", END)
+    
+    return workflow
+
+def initialize_state(user_requirement: str, config: Config, custom_mesh_path: Optional[str] = None) -> GraphState:
+    case_stats = json.load(open(f"{config.database_path}/raw/openfoam_case_stats.json", "r"))
+    # mesh_type = "custom_mesh" if custom_mesh_path else "standard_mesh"
+    state = GraphState(
+        user_requirement=user_requirement,
+        config=config,
+        case_dir="",
+        tutorial="",
+        case_name="",
+        subtasks=[],
+        current_subtask_index=0,
+        error_command=None,
+        error_content=None,
+        loop_count=0,
+        llm_service=LLMService(config),
+        case_stats=case_stats,
+        tutorial_reference=None,
+        case_path_reference=None,
+        dir_structure_reference=None,
+        case_info=None,
+        allrun_reference=None,
+        dir_structure=None,
+        commands=None,
+        foamfiles=None,
+        error_logs=None,
+        history_text=None,
+        case_domain=None,
+        case_category=None,
+        case_solver=None,
+        mesh_info=None,
+        mesh_commands=None,
+        custom_mesh_used=None,
+        mesh_type=None,
+        custom_mesh_path=custom_mesh_path,
+        review_analysis=None,
+        input_writer_mode="initial",
+        job_id=None,
+        cluster_info=None,
+        slurm_script_path=None
+    )
+    if custom_mesh_path:
+        print(f"Custom mesh path: {custom_mesh_path}")
+    else:
+        print("No custom mesh path provided.")
+    return state
+
+def main(user_requirement: str, config: Config, custom_mesh_path: Optional[str] = None):
+    """Main function to run the OpenFOAM workflow."""
+    
+    # Create and compile the graph
+    workflow = create_foam_agent_graph()
+    app = workflow.compile()
+    
+    # Initialize the state
+    initial_state = initialize_state(user_requirement, config, custom_mesh_path)
+    
+    print("Starting Foam-Agent...")
+    
+    # Invoke the graph
+    try:
+        result = app.invoke(initial_state)
+        print("Workflow completed successfully!")
+        
+        # Print final statistics
+        if result.get("llm_service"):
+            result["llm_service"].print_statistics()
+        
+        # print(f"Final state: {result}")
+        
+    except Exception as e:
+        print(f"Workflow failed with error: {e}")
+        raise
+
+if __name__ == "__main__":
+    # python main.py
+    parser = argparse.ArgumentParser(
+        description="Run the OpenFOAM workflow"
+    )
+    parser.add_argument(
+        "--prompt_path",
+        type=str,
+        default=f"{Path(__file__).parent.parent}/user_requirement.txt",
+        help="User requirement file path for the workflow.",
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="",
+        help="Output directory for the workflow.",
+    )
+    parser.add_argument(
+        "--custom_mesh_path",
+        type=str,
+        default=None,
+        help="Path to custom mesh file (e.g., .msh, .stl, .obj). If not provided, no custom mesh will be used.",
+    )
+    
+    args = parser.parse_args()
+    print(args)
+    
+    # Initialize configuration.
+    config = Config()
+    if args.output_dir != "":
+        config.case_dir = args.output_dir
+    
+    with open(args.prompt_path, 'r') as f:
+        user_requirement = f.read()
+    
+    main(user_requirement, config, args.custom_mesh_path)

Foam-Agent/source/src/nodes/__init__.py

@@ -0,0 +1 @@
+# nodes package 

Foam-Agent/source/src/nodes/architect_node.py

@@ -0,0 +1,4 @@
+from src.utils import retrieve_faiss, parse_directory_structure
+
+def save_file(*args, **kwargs):
+    raise NotImplementedError("save_file function is not implemented yet.")

Foam-Agent/source/src/nodes/hpc_runner_node.py

@@ -0,0 +1,463 @@
+# hpc_runner_node.py
+from typing import List
+import os
+import subprocess
+import json
+from pydantic import BaseModel, Field
+import re
+from utils import (
+    save_file, remove_files, remove_file,
+    run_command, check_foam_errors, retrieve_faiss, remove_numeric_folders
+)
+
+
+def extract_cluster_info(state) -> dict:
+    """
+    Extract cluster information from user requirement using LLM.
+    
+    Args:
+        state: Current graph state containing user requirement and LLM service
+        
+    Returns:
+        dict: Dictionary containing cluster_name, account_number, and other cluster details
+    """
+    user_requirement = state["user_requirement"]
+    case_dir = state["case_dir"]
+    
+    # Check if decomposeParDict exists and read its content
+    decompose_par_dict_content = ""
+    decompose_par_dict_path = os.path.join(case_dir, "system", "decomposeParDict")
+    if os.path.exists(decompose_par_dict_path):
+        try:
+            with open(decompose_par_dict_path, 'r') as f:
+                decompose_par_dict_content = f.read()
+        except Exception as e:
+            print(f"Warning: Could not read decomposeParDict: {e}")
+    
+    system_prompt = (
+        "You are an expert in HPC cluster analysis. "
+        "Analyze the user requirement to extract cluster information. "
+        "Look for keywords like: cluster name, account number, partition, queue, "
+        "specific cluster names (e.g., Stampede2, Frontera, Summit, etc.), "
+        "account numbers, project codes, or any mention of specific HPC systems. "
+        ""
+        "IMPORTANT: If a decomposeParDict file is provided, analyze it to determine "
+        "the appropriate number of tasks per node (ntasks_per_node) based on the "
+        "decomposition settings. The number of tasks should match the total number "
+        "of subdomains or processes specified in the decomposeParDict."
+        ""
+        "Return a JSON object with the following structure: "
+        "{"
+        "  'cluster_name': 'name of the cluster or HPC system', "
+        "  'account_number': 'account number or project code', "
+        "  'partition': 'partition name (e.g., normal, debug, gpu)', "
+        "  'nodes': 'number of nodes (default: 1)', "
+        "  'ntasks_per_node': 'number of tasks per node (determine from decomposeParDict if available)', "
+        "  'time_limit': 'time limit in hours (default: 24)', "
+        "  'memory': 'memory per node in GB (default: 64)'"
+        "}"
+        "If any information is not specified, use reasonable defaults based on your expertise. "
+        "Only return valid JSON. Don't include any other text."
+    )
+    
+    user_prompt = (
+        f"User requirement: {user_requirement}\n\n"
+    )
+    
+    if decompose_par_dict_content:
+        user_prompt += (
+            f"decomposeParDict content:\n{decompose_par_dict_content}\n\n"
+            "Analyze the decomposeParDict to determine the appropriate number of tasks per node "
+            "based on the decomposition settings. "
+        )
+    
+    user_prompt += "Extract cluster information and return as JSON object."
+    
+    response = state["llm_service"].invoke(user_prompt, system_prompt)
+    
+    # Try to parse the JSON response
+    try:
+        # Clean up the response to extract JSON
+        response = response.strip()
+        if response.startswith('```json'):
+            response = response[7:]
+        if response.endswith('```'):
+            response = response[:-3]
+        response = response.strip()
+        
+        cluster_info = json.loads(response)
+        
+        # Set defaults for missing values
+        defaults = {
+            'cluster_name': 'default_cluster',
+            'account_number': 'default_account',
+            'partition': 'normal',
+            'nodes': 1,
+            'ntasks_per_node': 1,
+            'time_limit': 24,
+            'memory': 64
+        }
+        
+        for key, default_value in defaults.items():
+            if key not in cluster_info or cluster_info[key] is None:
+                cluster_info[key] = default_value
+                
+        return cluster_info
+        
+    except (json.JSONDecodeError, KeyError) as e:
+        print(f"Error parsing cluster info from LLM response: {e}")
+        print(f"LLM response: {response}")
+        # Return default values if parsing fails
+        return {
+            'cluster_name': 'default_cluster',
+            'account_number': 'default_account',
+            'partition': 'normal',
+            'nodes': 1,
+            'ntasks_per_node': 1,
+            'time_limit': 24,
+            'memory': 64
+        }
+
+
+def create_slurm_script(case_dir: str, cluster_info: dict, state) -> str:
+    """
+    Create a SLURM script for OpenFOAM simulation using LLM.
+    
+    Args:
+        case_dir: Directory containing the OpenFOAM case
+        cluster_info: Dictionary containing cluster configuration
+        state: Current graph state containing LLM service
+        
+    Returns:
+        str: Path to the created SLURM script
+    """
+    system_prompt = (
+        "You are an expert in HPC cluster job submission and SLURM scripting. "
+        "Create a complete SLURM script for running OpenFOAM simulations. "
+        "The script should include:"
+        "1. Proper SLURM directives (#SBATCH) based on the cluster information provided"
+        "2. Do not load openfoam"
+        "3. Load libaraies for openfoam for run in parallel"
+        "4. Directory navigation and execution of the Allrun script"
+        "5. Error handling and status reporting"
+        "6. Any cluster-specific optimizations or requirements"
+        "7. Use your understanding of the documentation of the cluster and figure out the syntax of their jobscript."
+        ""
+        "Return ONLY the complete SLURM script content. Do not include any explanations or markdown formatting."
+        "Make sure the script is executable and follows best practices for the specified cluster."
+    )
+    
+    user_prompt = (
+        f"Create a SLURM script for OpenFOAM simulation with the following parameters:\n"
+        f"Cluster: {cluster_info['cluster_name']}\n"
+        f"Account: {cluster_info['account_number']}\n"
+        f"Partition: {cluster_info['partition']}\n"
+        f"Nodes: {cluster_info['nodes']}\n"
+        f"Tasks per node: {cluster_info['ntasks_per_node']}\n"
+        f"Time limit: {cluster_info['time_limit']} hours\n"
+        f"Memory: {cluster_info['memory']} GB per node\n"
+        f"Case directory: {case_dir}\n"
+        f""
+        f"Generate a complete SLURM script that will run the OpenFOAM simulation using the Allrun script."
+    )
+    
+    response = state["llm_service"].invoke(user_prompt, system_prompt)
+    
+    # Clean up the response to extract just the script content
+    script_content = response.strip()
+    if script_content.startswith('```bash'):
+        script_content = script_content[7:]
+    elif script_content.startswith('```'):
+        script_content = script_content[3:]
+    if script_content.endswith('```'):
+        script_content = script_content[:-3]
+    script_content = script_content.strip()
+    
+    # Ensure the script starts with shebang
+    if not script_content.startswith('#!/bin/bash'):
+        script_content = '#!/bin/bash\n' + script_content
+    
+    script_path = os.path.join(case_dir, "submit_job.slurm")
+    save_file(script_path, script_content)
+    return script_path
+
+
+def create_slurm_script_with_error_context(case_dir: str, cluster_info: dict, state, error_message: str = "", previous_script_content: str = "") -> str:
+    """
+    Create a SLURM script for OpenFOAM simulation using LLM, with error context for retries.
+    
+    Args:
+        case_dir: Directory containing the OpenFOAM case
+        cluster_info: Dictionary containing cluster configuration
+        state: Current graph state containing LLM service
+        error_message: Error message from previous submission attempt
+        previous_script_content: Content of the previous failed SLURM script
+        
+    Returns:
+        str: Path to the created SLURM script
+    """
+    system_prompt = (
+        "You are an expert in HPC cluster job submission and SLURM scripting. "
+        "Create a complete SLURM script for running OpenFOAM simulations. "
+        "The script should include:"
+        "1. Proper SLURM directives (#SBATCH) based on the cluster information provided"
+        "2. Do not load OpenFOAM"
+        "3. Load libaraies for openfoam for run in parallel"
+        "4. Directory navigation and execution of the Allrun script"
+        "5. Error handling and status reporting"
+        "6. Any cluster-specific optimizations or requirements"
+        "7. Use your understanding of the documentation of the cluster and figure out the syntax of their jobscript."
+        ""
+        "If a previous script and error message are provided, analyze the error and the script "
+        "to identify what went wrong and fix it. Common issues to consider:"
+        "- Invalid account numbers or partitions"
+        "- Insufficient resources (memory, time, nodes)"
+        "- Missing modules or environment variables"
+        "- Incorrect file paths or permissions"
+        "- Cluster-specific requirements or restrictions"
+        "- Syntax errors in SLURM directives"
+        "- Incorrect module names or versions"
+        ""
+        "Compare the previous script with the error message to identify the specific issue "
+        "and create a corrected version."
+        ""
+        "Return ONLY the complete SLURM script content. Do not include any explanations or markdown formatting."
+        "Make sure the script is executable and follows best practices for the specified cluster."
+    )
+    
+    user_prompt = (
+        f"Create a SLURM script for OpenFOAM simulation with the following parameters:\n"
+        f"Cluster: {cluster_info['cluster_name']}\n"
+        f"Account: {cluster_info['account_number']}\n"
+        f"Partition: {cluster_info['partition']}\n"
+        f"Nodes: {cluster_info['nodes']}\n"
+        f"Tasks per node: {cluster_info['ntasks_per_node']}\n"
+        f"Time limit: {cluster_info['time_limit']} hours\n"
+        f"Memory: {cluster_info['memory']} GB per node\n"
+        f"Case directory: {case_dir}\n"
+    )
+    
+    if error_message and previous_script_content:
+        user_prompt += f"\nPrevious submission failed with error: {error_message}\n"
+        user_prompt += f"Previous SLURM script that failed:\n```bash\n{previous_script_content}\n```\n"
+        user_prompt += "Please analyze this error and the previous script to identify the issue and create a corrected version."
+    
+    user_prompt += f"\nGenerate a complete SLURM script that will run the OpenFOAM simulation using the Allrun script. Return ONLY the complete SLURM script content. Do not include any explanations or markdown formatting."
+    
+    response = state["llm_service"].invoke(user_prompt, system_prompt)
+    
+    # Clean up the response to extract just the script content
+    script_content = response.strip()
+    if script_content.startswith('```bash'):
+        script_content = script_content[7:]
+    elif script_content.startswith('```'):
+        script_content = script_content[3:]
+    if script_content.endswith('```'):
+        script_content = script_content[:-3]
+    script_content = script_content.strip()
+    
+    # Ensure the script starts with shebang
+    if not script_content.startswith('#!/bin/bash'):
+        script_content = '#!/bin/bash\n' + script_content
+    
+    script_path = os.path.join(case_dir, "submit_job.slurm")
+    save_file(script_path, script_content)
+    return script_path
+
+
+def submit_slurm_job(script_path: str) -> tuple:
+    """
+    Submit a SLURM job and return job ID.
+    
+    Args:
+        script_path: Path to the SLURM script
+        
+    Returns:
+        tuple: (job_id, success, error_message)
+    """
+    try:
+        # Submit the job
+        result = subprocess.run(
+            ["sbatch", script_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        # Extract job ID from output
+        output = result.stdout.strip()
+        job_id_match = re.search(r'Submitted batch job (\d+)', output)
+        
+        if job_id_match:
+            job_id = job_id_match.group(1)
+            return job_id, True, ""
+        else:
+            return None, False, f"Could not extract job ID from output: {output}"
+            
+    except subprocess.CalledProcessError as e:
+        return None, False, f"Failed to submit job: {e.stderr}"
+    except Exception as e:
+        return None, False, f"Unexpected error: {str(e)}"
+
+
+def check_job_status(job_id: str) -> tuple:
+    """
+    Check the status of a SLURM job.
+    
+    Args:
+        job_id: SLURM job ID
+        
+    Returns:
+        tuple: (status, success, error_message)
+    """
+    try:
+        result = subprocess.run(
+            ["squeue", "-j", job_id, "--noheader", "-o", "%T"],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        status = result.stdout.strip()
+        if status:
+            return status, True, ""
+        else:
+            return "COMPLETED", True, ""  # Job not in queue, likely completed
+            
+    except subprocess.CalledProcessError as e:
+        return None, False, f"Failed to check job status: {e.stderr}"
+    except Exception as e:
+        return None, False, f"Unexpected error: {str(e)}"
+
+
+def hpc_runner_node(state):
+    """
+    HPC Runner node: Extract cluster info from user requirement, create SLURM script,
+    submit job to cluster, wait for completion, and check for errors.
+    Retries submission on failure up to max_loop times, regenerating script based on errors.
+    """
+    config = state["config"]
+    case_dir = state["case_dir"]
+    allrun_file_path = os.path.join(case_dir, "Allrun")
+    max_loop = config.max_loop
+    current_attempt = 0
+    
+    print(f"============================== HPC Runner ==============================")
+    
+    # Clean up any previous log and error files.
+    out_file = os.path.join(case_dir, "Allrun.out")
+    err_file = os.path.join(case_dir, "Allrun.err")
+    remove_files(case_dir, prefix="log")
+    remove_file(err_file)
+    remove_file(out_file)
+    remove_numeric_folders(case_dir)
+    
+    # Extract cluster information from user requirement
+    print("Extracting cluster information from user requirement...")
+    cluster_info = extract_cluster_info(state)
+    print(f"Cluster info extracted: {cluster_info}")
+    
+    # Submit the job with retry logic
+    while current_attempt < max_loop:
+        current_attempt += 1
+        print(f"Attempt {current_attempt}/{max_loop}: Creating and submitting SLURM job...")
+        
+        # Create SLURM script (regenerate on retry with error context)
+        if current_attempt == 1:
+            print("Creating initial SLURM script...")
+            script_path = create_slurm_script(case_dir, cluster_info, state)
+        else:
+            print(f"Regenerating SLURM script based on previous error...")
+            # Read the previous failed script content
+            previous_script_content = ""
+            try:
+                with open(script_path, 'r') as f:
+                    previous_script_content = f.read()
+            except Exception as e:
+                print(f"Warning: Could not read previous script: {e}")
+            
+            script_path = create_slurm_script_with_error_context(case_dir, cluster_info, state, last_error_msg, previous_script_content)
+        
+        print(f"SLURM script created at: {script_path}")
+        
+        job_id, success, error_msg = submit_slurm_job(script_path)
+        
+        if success:
+            print(f"Job submitted successfully with ID: {job_id}")
+            break
+        else:
+            print(f"Attempt {current_attempt} failed: {error_msg}")
+            last_error_msg = error_msg  # Store error for next iteration
+            if current_attempt < max_loop:
+                print(f"Retrying in 5 seconds...")
+                import time
+                time.sleep(5)
+            else:
+                print(f"Maximum attempts ({max_loop}) reached. Job submission failed.")
+                error_logs = [f"Job submission failed after {max_loop} attempts. Last error: {error_msg}"]
+                return {
+                    **state,
+                    "error_logs": error_logs,
+                    "job_id": None,
+                    "cluster_info": cluster_info,
+                    "slurm_script_path": script_path
+                }
+    
+    # Wait for job completion
+    print("Waiting for job completion...")
+    import time
+    max_wait_time = 3600  # 1 hour timeout
+    wait_interval = 30    # Check every 30 seconds
+    elapsed_time = 0
+    
+    while elapsed_time < max_wait_time:
+        status, status_success, status_error = check_job_status(job_id)
+        
+        if not status_success:
+            print(f"Failed to check job status: {status_error}")
+            error_logs = [f"Status check failed: {status_error}"]
+            return {
+                **state,
+                "error_logs": error_logs,
+                "job_id": job_id,
+                "cluster_info": cluster_info,
+                "slurm_script_path": script_path
+            }
+        
+        print(f"Job status: {status}")
+        
+        # Check if job is completed (either successfully or with error)
+        if status in ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"]:
+            print(f"Job finished with status: {status}")
+            break
+        
+        # Wait before checking again
+        time.sleep(wait_interval)
+        elapsed_time += wait_interval
+        
+        if elapsed_time % 300 == 0:  # Print progress every 5 minutes
+            print(f"Still waiting... ({elapsed_time//60} minutes elapsed)")
+    
+    if elapsed_time >= max_wait_time:
+        print("Job timeout reached. Assuming job completed.")
+    
+    # Check for errors in log files (similar to local_runner)
+    print("Checking for errors in log files...")
+    error_logs = check_foam_errors(case_dir)
+    
+    if len(error_logs) > 0:
+        print("Errors detected in the HPC Allrun execution.")
+        print(error_logs)
+    else:
+        print("HPC Allrun executed successfully without errors.")
+    
+    state['loop_count'] += 1
+    
+    # Return updated state
+    return {
+        **state,
+        "error_logs": error_logs,
+        "job_id": job_id,
+        "cluster_info": cluster_info,
+        "slurm_script_path": script_path
+    }

Foam-Agent/source/src/nodes/input_writer_node.py

@@ -0,0 +1,272 @@
+# input_writer_node.py
+import os
+from utils import save_file, parse_context, retrieve_faiss, FoamPydantic, FoamfilePydantic
+import re
+from typing import List
+from pydantic import BaseModel, Field
+
+# System prompts for different modes
+INITIAL_WRITE_SYSTEM_PROMPT = (
+    "You are an expert in OpenFOAM simulation and numerical modeling."
+    f"Your task is to generate a complete and functional file named: <file_name>{{file_name}}</file_name> within the <folder_name>{{folder_name}}</folder_name> directory. "
+    "Ensure all required values are present and match with the files content already generated."
+    "Before finalizing the output, ensure:\n"
+    "- All necessary fields exist (e.g., if `nu` is defined in `constant/transportProperties`, it must be used correctly in `0/U`).\n"
+    "- Cross-check field names between different files to avoid mismatches.\n"
+    "- Ensure units and dimensions are correct** for all physical variables.\n"
+    f"- Ensure case solver settings are consistent with the user's requirements. Available solvers are: {{case_solver}}.\n"
+    "Provide only the code—no explanations, comments, or additional text."
+)
+
+REWRITE_SYSTEM_PROMPT = (
+    "You are an expert in OpenFOAM simulation and numerical modeling. "
+    "Your task is to modify and rewrite the necessary OpenFOAM files to fix the reported error. "
+    "Please do not propose solutions that require modifying any parameters declared in the user requirement, try other approaches instead."
+    "The user will provide the error content, error command, reviewer's suggestions, and all relevant foam files. "
+    "Only return files that require rewriting, modification, or addition; do not include files that remain unchanged. "
+    "Return the complete, corrected file contents in the following JSON format: "
+    "list of foamfile: [{file_name: 'file_name', folder_name: 'folder_name', content: 'content'}]. "
+    "Ensure your response includes only the modified file content with no extra text, as it will be parsed using Pydantic."
+)
+
+def compute_priority(subtask):
+    if subtask["folder_name"] == "system":
+        return 0
+    elif subtask["folder_name"] == "constant":
+        return 1
+    elif subtask["folder_name"] == "0":
+        return 2
+    else:
+        return 3
+        
+
+def parse_allrun(text: str) -> str:
+    match = re.search(r'```(.*?)```', text, re.DOTALL)
+    
+    return match.group(1).strip() 
+
+def retrieve_commands(command_path) -> str:
+    with open(command_path, 'r') as file:
+        commands = file.readlines()
+    
+    return f"[{', '.join([command.strip() for command in commands])}]"
+    
+class CommandsPydantic(BaseModel):
+    commands: List[str] = Field(description="List of commands")
+
+def input_writer_node(state):
+    """
+    InputWriter node: Generate the complete OpenFOAM foamfile.
+    
+    Args:
+        state: The current state containing all necessary information
+    """
+
+    mode = state["input_writer_mode"]
+    
+    if mode == "rewrite":
+        return _rewrite_mode(state)
+    else:
+        return _initial_write_mode(state)
+
+def _rewrite_mode(state):
+    """
+    Rewrite mode: Fix errors based on reviewer analysis
+    """
+    print(f"============================== Rewrite Mode ==============================")
+
+    config = state["config"]
+    
+    if not state.get("review_analysis"):
+        print("No review analysis available for rewrite mode.")
+        return state
+    
+    rewrite_user_prompt = (
+        f"<foamfiles>{str(state['foamfiles'])}</foamfiles>\n"
+        f"<error_logs>{state['error_logs']}</error_logs>\n"
+        f"<reviewer_analysis>{state['review_analysis']}</reviewer_analysis>\n\n"
+        f"<user_requirement>{state['user_requirement']}</user_requirement>\n\n"
+        "Please update the relevant OpenFOAM files to resolve the reported errors, ensuring that all modifications strictly adhere to the specified formats. Ensure all modifications adhere to user requirement."
+    )
+    rewrite_response = state["llm_service"].invoke(rewrite_user_prompt, REWRITE_SYSTEM_PROMPT, pydantic_obj=FoamPydantic)
+
+    print(f"============================== Rewrite ==============================")
+    # Prepare updated dir_structure and foamfiles without mutating state
+    dir_structure = dict(state["dir_structure"]) if state.get("dir_structure") else {}
+    foamfiles_list = list(state["foamfiles"].list_foamfile) if state.get("foamfiles") and hasattr(state["foamfiles"], "list_foamfile") else []
+
+    for foamfile in rewrite_response.list_foamfile:
+        print(f"Modified the file: {foamfile.file_name} in folder: {foamfile.folder_name}")
+        file_path = os.path.join(state["case_dir"], foamfile.folder_name, foamfile.file_name)
+        save_file(file_path, foamfile.content)
+        
+        if foamfile.folder_name not in dir_structure:
+            dir_structure[foamfile.folder_name] = []
+        if foamfile.file_name not in dir_structure[foamfile.folder_name]:
+            dir_structure[foamfile.folder_name].append(foamfile.file_name)
+        
+        foamfiles_list = [f for f in foamfiles_list if not (f.folder_name == foamfile.folder_name and f.file_name == foamfile.file_name)]
+        foamfiles_list.append(foamfile)
+
+    foamfiles = FoamPydantic(list_foamfile=foamfiles_list)
+    return {
+        "dir_structure": dir_structure,
+        "foamfiles": foamfiles,
+        "error_logs": []
+    }
+
+def _initial_write_mode(state):
+    """
+    Initial write mode: Generate files from scratch
+    """
+    print(f"============================== Initial Write Mode ==============================")
+    
+    config = state["config"]
+    subtasks = state["subtasks"]
+    subtasks = sorted(subtasks, key=compute_priority)
+    
+    writed_files = []
+    dir_structure = {}
+    
+    for subtask in subtasks:
+        file_name = subtask["file_name"]
+        folder_name = subtask["folder_name"]
+        
+        if folder_name not in dir_structure:
+            dir_structure[folder_name] = []
+        dir_structure[folder_name].append(file_name)
+        
+        print(f"Generating file: {file_name} in folder: {folder_name}")
+        
+        if not file_name or not folder_name:
+            raise ValueError(f"Invalid subtask format: {subtask}")
+
+        file_path = os.path.join(state["case_dir"], folder_name, file_name)
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        # Retrieve a similar reference foamfile from the tutorial.
+        similar_file_text = state["tutorial_reference"]
+        
+        # Generate the complete foamfile.
+        code_system_prompt = INITIAL_WRITE_SYSTEM_PROMPT.format(
+            file_name=file_name,
+            folder_name=folder_name,
+            case_solver=state['case_stats']['case_solver']
+        )
+
+        code_user_prompt = (
+            f"User requirement: {state['user_requirement']}\n"
+            f"Refer to the following similar case file content to ensure the generated file aligns with the user requirement:\n<similar_case_reference>{similar_file_text}</similar_case_reference>\n"
+            f"Similar case reference is always correct. If you find the user requirement is very consistent with the similar case reference, you should use the similar case reference as the template to generate the file."
+            f"Just modify the necessary parts to make the file complete and functional."
+            "Please ensure that the generated file is complete, functional, and logically sound."
+            "Additionally, apply your domain expertise to verify that all numerical values are consistent with the user's requirements, maintaining accuracy and coherence."
+            "When generating controlDict, do not include anything to preform post processing. Just include the necessary settings to run the simulation."
+        )
+        if len(writed_files) > 0:
+            code_user_prompt += f"The following are files content already generated: {str(writed_files)}\n\n\nYou should ensure that the new file is consistent with the previous files. Such as boundary conditions, mesh settings, etc."
+
+        generation_response = state["llm_service"].invoke(code_user_prompt, code_system_prompt)
+        
+        code_context = parse_context(generation_response)
+        save_file(file_path, code_context)
+        
+        writed_files.append(FoamfilePydantic(file_name=file_name, folder_name=folder_name, content=code_context))
+    
+    # Write the Allrun script.
+    case_dir = state["case_dir"]
+    allrun_file_path = os.path.join(case_dir, "Allrun")
+    if os.path.exists(allrun_file_path):
+        print("Warning: Allrun file exists. Overwriting.")
+    
+    # Retrieve available commands from the FAISS "Commands" database.
+    commands = retrieve_commands(f"{config.database_path}/raw/openfoam_commands.txt")
+    
+    # Include mesh commands if custom mesh is used
+    mesh_commands_info = ""
+    if state.get("custom_mesh_used") and state.get("mesh_commands"):
+        mesh_commands_info = f"\nCustom mesh commands to include: {state['mesh_commands']}"
+        print(f"Including custom mesh commands: {state['mesh_commands']}")
+    
+    command_system_prompt = (
+        "You are an expert in OpenFOAM. The user will provide a list of available commands. "
+        "Your task is to generate only the necessary OpenFOAM commands required to create an Allrun script for the given user case, based on the provided directory structure. "
+        "Return only the list of commands—no explanations, comments, or additional text."
+    )
+
+    if state.get("mesh_type") == "custom_mesh":
+        command_system_prompt += "If custom mesh commands are provided, include them in the appropriate order (typically after blockMesh or instead of blockMesh if custom mesh is used). "
+    
+    command_user_prompt = (
+        f"Available OpenFOAM commands for the Allrun script: {commands}\n"
+        f"Case directory structure: {dir_structure}\n"
+        f"User case information: {state['case_info']}\n"
+        f"Reference Allrun scripts from similar cases: {state['allrun_reference']}\n"
+        "Generate only the required OpenFOAM command list—no extra text."
+    )
+
+    if state.get("mesh_type") == "custom_mesh":
+        command_user_prompt += f"{mesh_commands_info}\n"
+    
+    command_response = state["llm_service"].invoke(command_user_prompt, command_system_prompt, pydantic_obj=CommandsPydantic)
+
+    if len(command_response.commands) == 0:
+        print("Failed to generate subtasks.")
+        raise ValueError("Failed to generate subtasks.")
+
+    print(f"Need {len(command_response.commands)} commands.")
+    
+    commands_help = []
+    for command in command_response.commands:
+        command_help = retrieve_faiss("openfoam_command_help", command, topk=config.searchdocs)
+        commands_help.append(command_help[0]['full_content'])
+    commands_help = "\n".join(commands_help)
+
+
+    allrun_system_prompt = (
+        "You are an expert in OpenFOAM. Generate an Allrun script based on the provided details."
+        f"Available commands with descriptions: {commands_help}\n\n"
+        f"Reference Allrun scripts from similar cases: {state['allrun_reference']}\n\n"
+        "If custom mesh commands are provided, make sure to include them in the appropriate order in the Allrun script. "
+        "CRITICAL: Do not include any post processing commands in the Allrun script."
+        "CRITICAL: Do not include any commands to convert mesh to foam format like gmshToFoam or others."
+    )
+
+    if state.get("mesh_mode") == "custom":
+        allrun_system_prompt += "CRITICAL: Do not include any other mesh commands other than the custom mesh commands.\n"
+        allrun_system_prompt += "CRITICAL: Do not include any gmshToFoam commands in the Allrun script."
+    
+    allrun_user_prompt = (
+        f"User requirement: {state['user_requirement']}\n"
+        f"Case directory structure: {dir_structure}\n"
+        f"User case infomation: {state['case_info']}\n"
+        f"{mesh_commands_info}\n"
+        "All run scripts for these similar cases are for reference only and may not be correct, as you might be a different case solver or have a different directory structure. " 
+        "You need to rely on your OpenFOAM and physics knowledge to discern this, and pay more attention to user requirements, " 
+        "as your ultimate goal is to fulfill the user's requirements and generate an allrun script that meets those requirements."
+        "CRITICAL: Do not include any post processing commands in the Allrun script."
+        "CRITICAL: Do not include any commands to convert mesh to foam format like gmshToFoam or others."
+        "CRITICAL: Do not include any commands that run gmsh to create the mesh."
+        "Generate the Allrun script strictly based on the above information. Do not include explanations, comments, or additional text. Put the code in ``` tags."
+    )
+
+    if state.get("mesh_mode") == "custom":
+        allrun_user_prompt += "CRITICAL: Do not include any other mesh commands other than the custom mesh commands.\n"
+        allrun_user_prompt += "CRITICAL: Do not include any gmshToFoam commands in the Allrun script."
+
+
+    
+    allrun_response = state["llm_service"].invoke(allrun_user_prompt, allrun_system_prompt)
+    
+    allrun_script = parse_allrun(allrun_response)
+    save_file(allrun_file_path, allrun_script)
+    
+    writed_files.append(FoamfilePydantic(file_name="Allrun", folder_name="./", content=allrun_script))
+    foamfiles = FoamPydantic(list_foamfile=writed_files)
+    
+    # Return updated state
+    return {
+        "dir_structure": dir_structure,
+        "commands": command_response.commands,
+        "foamfiles": foamfiles
+    }

Foam-Agent/source/src/nodes/local_runner_node.py

@@ -0,0 +1,49 @@
+# runner_node.py
+from typing import List
+import os
+from pydantic import BaseModel, Field
+import re
+from utils import (
+    save_file, remove_files, remove_file,
+    run_command, check_foam_errors, retrieve_faiss, remove_numeric_folders
+)
+
+
+def local_runner_node(state):
+    """
+    Runner node: Execute an Allrun script, and check for errors.
+    On error, update state.error_command and state.error_content.
+    """
+    config = state["config"]
+    case_dir = state["case_dir"]
+    allrun_file_path = os.path.join(case_dir, "Allrun")
+    
+    print(f"============================== Runner ==============================")
+    
+    # Clean up any previous log and error files.
+    out_file = os.path.join(case_dir, "Allrun.out")
+    err_file = os.path.join(case_dir, "Allrun.err")
+    remove_files(case_dir, prefix="log")
+    remove_file(err_file)
+    remove_file(out_file)
+    remove_numeric_folders(case_dir)
+    
+    # Execute the Allrun script.
+    run_command(allrun_file_path, out_file, err_file, case_dir, config)
+    
+    # Check for errors.
+    error_logs = check_foam_errors(case_dir)
+
+    if len(error_logs) > 0:
+        print("Errors detected in the Allrun execution.")
+        print(error_logs)
+    else:
+        print("Allrun executed successfully without errors.")
+    
+    state['loop_count'] += 1
+    # Return updated state
+    return {
+        **state,
+        "error_logs": error_logs
+    }
+        

Foam-Agent/source/src/nodes/meshing_node.py

@@ -0,0 +1,926 @@
+import os
+import shutil
+import subprocess
+import re
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from utils import save_file, remove_file
+
+# System prompts for LLM interactions
+BOUNDARY_SYSTEM_PROMPT = (
+    "You are an expert in OpenFOAM mesh processing and simulations. "
+    "Your role is to analyze and modify boundary conditions in OpenFOAM polyMesh boundary file. "
+    "You understand both 2D and 3D simulations and know how to properly set boundary conditions. "
+    "For 2D simulations, you know which boundaries should be set to 'empty' type and 'empty' physicalType. "
+    "You are precise and only return the exact boundary file content without any additional text or explanations. "
+    "IMPORTANT: Only change the specified boundary to 'empty' type and leave all other boundaries exactly as they are."
+)
+
+CONTROLDICT_SYSTEM_PROMPT = (
+    "You are an expert in OpenFOAM simulation setup. "
+    "Your role is to create a basic controlDict file for mesh conversion. "
+    "You understand the minimal requirements needed for gmshToFoam to work. "
+    "You are precise and only return the exact controlDict file content without any additional text or explanations."
+)
+
+GMSH_PYTHON_SYSTEM_PROMPT = (
+    "You are an expert in GMSH Python API and OpenFOAM mesh generation. "
+    "Your role is to create Python code that uses the GMSH library to generate meshes based on user requirements. "
+    "You understand: "
+    "- GMSH Python API for geometry creation "
+    "- How to create points, lines, surfaces, and volumes programmatically "
+    "- How to assign physical groups for OpenFOAM compatibility "
+    "- How to control mesh sizing and refinement "
+    "- How to handle 2D and 3D geometries "
+    "You can: "
+    "- Create complex geometries using GMSH Python API "
+    "- Set up proper boundary conditions for OpenFOAM "
+    "- Implement mesh refinement strategies "
+    "- Generate 3D meshes with correct boundary assignments "
+    "CRITICAL REQUIREMENTS: "
+    "- Always generate 3D meshes for OpenFOAM simulations "
+    "- Set mesh sizes and generate 3D mesh: gmsh.model.mesh.generate(3) "
+    "- AFTER 3D mesh generation, identify surfaces using gmsh.model.getEntities(2) "
+    "- Use gmsh.model.getBoundingBox(dim, tag) to analyze surface positions and categorize them "
+    "- Do not use gmsh.model.getCenterOfMass(dim, tag) function to analyze surface positions "
+    "- Create 2D physical groups based on spatial analysis, not during geometry creation "
+    "- Use user-specified boundary names "
+    "- Create physical groups for all surfaces and the volume domain "
+    "- Set gmsh.option.setNumber('Mesh.MshFileVersion', 2.2) for OpenFOAM compatibility "
+    "- Save as 'geometry.msh' and finalize GMSH "
+    "- Use proper coordinate system - define z_min and z_max variables and use them consistently for boundary detection "
+    "- Use bounding box coordinates (x_min, y_min, z_min, x_max, y_max, z_max) directly for boundary detection, NOT center points "
+    "- Ensure all boundary types (example: inlet, outlet, top, bottom, cylinder, frontAndBack) are properly detected and created "
+    "CRITICAL ORDER: Create geometry then Extrude then Synchronize then Generate mesh then create physical groups "
+    "CRITICAL: Use bounding box coordinates consistently for ALL boundaries - do not mix center points and bounding box coordinates in the same boundary detection logic "
+    "MOST CRITICAL: NEVER create physical groups before mesh generation. Always create them AFTER gmsh.model.mesh.generate(3) "
+    "MOST CRITICAL: Physical groups created before mesh generation will reference wrong surface tags after extrusion and meshing "
+    "CRITICAL FACE DETECTION: "
+    "- For thin boundary surfaces: use abs(zmin - zmax) < tol AND (abs(zmin - z_min) < tol OR abs(zmin - z_max) < tol) "
+    "- Thin surfaces at z_min and z_max are boundary surfaces that need physical groups "
+    "- Use tolerance tol = 1e-6 for floating point comparisons "
+    "- Ensure ALL user-specified boundaries are detected and assigned to physical groups "
+    "IMPORTANT: Use your expertise to create robust, adaptable code that can handle various geometry types and boundary conditions."
+)
+
+BOUNDARY_EXTRACTION_SYSTEM_PROMPT = (
+    "You are an expert in OpenFOAM mesh generation and boundary condition analysis. "
+    "Your role is to extract boundary names from user requirements for mesh generation. "
+    "You understand: "
+    "- Common OpenFOAM boundary types (inlet, outlet, wall, cylinder, etc.) "
+    "- How to identify boundary names from natural language descriptions "
+    "- The importance of accurate boundary identification for mesh generation "
+    "You can: "
+    "- Parse user requirements to identify all mentioned boundaries "
+    "- Distinguish between boundary names and other geometric terms "
+    "- Handle variations in boundary naming conventions "
+    "- Return a clean list of boundary names "
+    "IMPORTANT: Return ONLY a comma-separated list of boundary names without any additional text, explanations, or formatting. "
+    "Example: inlet,outlet,wall,cylinder "
+    "If no boundaries are mentioned, return an empty string."
+)
+
+GMSH_PYTHON_ERROR_CORRECTION_SYSTEM_PROMPT = (
+    "You are an expert in debugging GMSH Python API code. "
+    "Your role is to analyze GMSH Python errors and fix the corresponding code. "
+    "You understand common GMSH Python API errors including: "
+    "- Geometry definition errors (invalid points, lines, surfaces, volumes) "
+    "- Physical group assignment issues "
+    "- Mesh generation problems "
+    "- API usage errors "
+    "- Missing boundary definitions that cause OpenFOAM conversion failures "
+    "- Mesh quality issues detected by checkMesh (skewness, aspect ratio, etc.) "
+    "You can identify the root cause of errors and provide corrected Python code. "
+    "CRITICAL REQUIREMENTS: "
+    "- Ensure 3D mesh generation for OpenFOAM compatibility "
+    "- Use proper spatial analysis for boundary identification "
+    "- Create complete physical group definitions for surfaces and volumes "
+    "- Handle various geometry types and boundary conditions "
+    "- When missing boundaries are mentioned, ensure they are properly defined "
+    "- Do not use gmsh.model.getCenterOfMass(dim, tag) function to analyze surface positions "
+    "- Address mesh quality issues by adjusting mesh sizing and refinement strategies "
+    "CRITICAL CORRECTIONS: "
+    "- Use proper coordinate system variables (z_min, z_max) for boundary detection "
+    "- Use bounding box coordinates directly for boundary detection, NOT center points "
+    "- Ensure all boundary types are detected: (example: inlet, outlet, top, bottom, cylinder, frontAndBack) "
+    "- Check boundary detection logic for coordinate system consistency "
+    "- Verify that extrusion creates proper 3D geometry with all expected surfaces "
+    "- For mesh quality issues: adjust mesh sizes, add refinement zones, improve geometry definition "
+    "CRITICAL ORDER: Create geometry then Extrude then Synchronize then Generate mesh then create physical groups "
+    "CRITICAL: Use bounding box coordinates consistently for ALL boundary types - do not mix center points and bounding box coordinates in the same boundary detection logic "
+    "MOST CRITICAL FIX: If boundaries are missing after gmshToFoam, move ALL physical group creation to AFTER gmsh.model.mesh.generate(3) "
+    "MOST CRITICAL FIX: Physical groups created before mesh generation will have wrong surface tag references "
+    "CRITICAL FACE DETECTION FIXES: "
+    "- Fix thin boundary detection: use abs(zmin - zmax) < tol AND (abs(zmin - z_min) < tol OR abs(zmin - z_max) < tol) "
+    "- Use tolerance tol = 1e-6 for all floating point comparisons "
+    "- Ensure thin surfaces at z_min and z_max are properly classified as boundary surfaces "
+    "- Check that ALL user-specified boundaries are detected and assigned to physical groups "
+    "MESH QUALITY FIXES: "
+    "- For high skewness: refine mesh in problematic areas, adjust element sizes "
+    "- For poor aspect ratio: use smaller mesh sizes, add refinement zones "
+    "- For non-orthogonality: improve geometry definition, use structured meshing where possible "
+    "- For negative volume elements: check geometry validity, ensure proper surface orientation "
+    "IMPORTANT: Use your expertise to diagnose and fix issues while maintaining code adaptability for different problems."
+)
+
+class MeshInfoPydantic(BaseModel):
+    mesh_file_path: str = Field(description="Path to the custom mesh file (e.g., .msh, .stl, .obj)")
+    mesh_file_type: str = Field(description="Type of mesh file (gmsh, stl, obj, etc.)")
+    mesh_description: str = Field(description="Description of the mesh and any specific requirements")
+    requires_blockmesh_removal: bool = Field(description="Whether to remove blockMeshDict file", default=True)
+
+class MeshCommandsPydantic(BaseModel):
+    mesh_commands: List[str] = Field(description="List of OpenFOAM commands needed to process the custom mesh")
+    mesh_file_destination: str = Field(description="Destination path for the mesh file in the case directory")
+
+class GMSHPythonCode(BaseModel):
+    python_code: str = Field(description="Complete Python code using GMSH library")
+    mesh_type: str = Field(description="Type of mesh (2D or 3D)")
+    geometry_type: str = Field(description="Type of geometry being created")
+
+class GMSHPythonCorrection(BaseModel):
+    corrected_code: str = Field(description="Corrected GMSH Python code")
+    error_analysis: str = Field(description="Analysis of the error and what was fixed")
+
+def _correct_gmsh_python_code(state, current_code, error_output):
+    """
+    Attempt to correct GMSH Python code based on error output or missing boundary info.
+    
+    Args:
+        state: State object containing LLM service
+        current_code: Current Python code content
+        error_output: GMSH Python error output or missing boundary error message
+    
+    Returns:
+        Corrected Python code content or None if correction failed
+    """
+    try:
+        # Detect if this is a boundary mismatch error
+        is_boundary_mismatch = (
+            isinstance(error_output, str) and "Boundary mismatch after gmshToFoam" in error_output
+        )
+        found_boundaries = state['found_boundaries']
+        expected_boundaries = state['expected_boundaries']
+        boundary_info = ""
+        if is_boundary_mismatch and found_boundaries is not None and expected_boundaries is not None:
+            boundary_info = (
+                f"\n<boundary_mismatch>Found boundaries in OpenFOAM: {found_boundaries}. "
+                f"Expected boundaries: {expected_boundaries}. "
+                "Please correct the mesh code so that the boundaries in the OpenFOAM boundary file match the expected boundaries exactly."
+                "Note that these boundaries might be present in the msh file, but not in the boundary file after running gmshToFoam to convert the msh file to OpenFOAM format."
+                "MOST LIKELY CAUSES: "
+                "1. Physical groups were created before mesh generation. Move ALL physical group creation to AFTER gmsh.model.mesh.generate(3). "
+                "2. Points created at z=0 instead of z=z_min. Create ALL points at z=z_min for proper boundary detection. "
+                "3. Incorrect surface detection logic - surfaces not properly classified by position. "
+                "4. If 'defaultFaces' appears, it means some surfaces weren't assigned to any physical group. "
+                "5. Check that ALL surfaces are being classified and assigned to the correct user-specified boundary names."
+                "</boundary_mismatch>"
+            )
+        if is_boundary_mismatch:
+            correction_prompt = (
+                f"<user_requirements>{state['user_requirement']}</user_requirements>{boundary_info}\n"
+                f"<current_python_code>{current_code}</current_python_code>\n"
+                "Please analyze the current Python code and the boundary mismatch information. "
+                "The mesh generation was successful, but the boundaries in the OpenFOAM conversion do not match the expected boundaries. "
+                "Note that these boundaries might be present in the msh file, but not in the boundary file after running gmshToFoam to convert the msh file to OpenFOAM format."
+                "MOST LIKELY SOLUTIONS: "
+                "1. Move ALL physical group creation to AFTER gmsh.model.mesh.generate(3). "
+                "2. Use correct thin boundary detection: abs(zmin - zmax) < tol AND (abs(zmin - z_min) < tol OR abs(zmin - z_max) < tol). "
+                "3. Use tolerance tol = 1e-6 for all floating point comparisons. "
+                "4. Use exact boundary names from user requirements, do not hardcode specific names. "
+                "Physical groups created before mesh generation will reference wrong surface tags after extrusion and meshing."
+                "Provide a corrected Python code that ensures the boundaries in the OpenFOAM boundary file match the expected boundaries exactly. "
+                "IMPORTANT: Return ONLY the complete corrected Python code without any additional text."
+            )
+        else:
+            # Fallback to previous logic for other errors
+            missing_boundary_info = ""
+            if 'missing_boundaries' in state and state['missing_boundaries']:
+                missing_boundary_info = (
+                    f"\n<missing_boundaries>Previous attempts were missing these boundaries: {state['missing_boundaries']}. "
+                    "Ensure these boundaries are properly defined in the GMSH physical groups.</missing_boundaries>"
+                )
+            correction_prompt = (
+                f"<user_requirements>{state['user_requirement']}</user_requirements>{missing_boundary_info}\n"
+                f"<current_python_code>{current_code}</current_python_code>\n"
+                f"<gmsh_python_error_output>{error_output}</gmsh_python_error_output>\n"
+                "Please analyze the GMSH Python error output and the current Python code. "
+                "Identify the specific error and provide a corrected Python code that fixes the issue. "
+                "IMPORTANT: Return ONLY the complete corrected Python code without any additional text."
+            )
+        correction_response = state["llm_service"].invoke(
+            correction_prompt, 
+            GMSH_PYTHON_ERROR_CORRECTION_SYSTEM_PROMPT, 
+            pydantic_obj=GMSHPythonCorrection
+        )
+        if correction_response.corrected_code:
+            print(f"Error analysis: {correction_response.error_analysis}")
+            return correction_response.corrected_code
+    except Exception as e:
+        print(f"Error in Python code correction: {str(e)}")
+    return None
+
+def extract_boundary_names_from_requirements(state, user_requirement):
+    """Extract boundary names mentioned in user requirements using LLM."""
+    try:
+        extraction_prompt = (
+            f"<user_requirements>{user_requirement}</user_requirements>\n"
+            "Please extract all boundary names mentioned in the user requirements. "
+            "Look for terms like inlet, outlet, wall, cylinder, top, bottom, front, back, side, etc. "
+            "Focus on boundaries that would need to be defined in the mesh for OpenFOAM simulation. "
+            "Return ONLY a comma-separated list of boundary names without any additional text."
+        )
+        
+        boundary_response = state["llm_service"].invoke(extraction_prompt, BOUNDARY_EXTRACTION_SYSTEM_PROMPT).strip()
+        
+        if boundary_response:
+            boundary_names = [name.strip() for name in boundary_response.split(',') if name.strip()]
+            print(f"LLM extracted boundary names: {boundary_names}")
+            return boundary_names
+        else:
+            print("No boundary names extracted by LLM")
+            return []
+            
+    except Exception as e:
+        print(f"Error in LLM boundary extraction: {e}")
+        # Fallback to simple keyword matching
+        boundary_keywords = ['inlet', 'outlet', 'wall', 'cylinder', 'top', 'bottom', 'front', 'back', 'side']
+        found_boundaries = []
+        
+        requirement_lower = user_requirement.lower()
+        for keyword in boundary_keywords:
+            if keyword in requirement_lower:
+                found_boundaries.append(keyword)
+        
+        print(f"Fallback boundary extraction: {found_boundaries}")
+        return found_boundaries
+
+def check_boundary_file_for_missing_boundaries(boundary_file_path, expected_boundaries):
+    """Check if all expected boundaries are present in the boundary file."""
+    if not os.path.exists(boundary_file_path):
+        return False, expected_boundaries, []
+    
+    try:
+        with open(boundary_file_path, 'r') as f:
+            content = f.read()
+        
+        boundary_pattern = r'(\w+)\s*\{'
+        found_boundaries = re.findall(boundary_pattern, content)
+        
+        boundary_keywords = ['type', 'physicalType', 'nFaces', 'startFace', 'FoamFile']
+        found_boundaries = [b for b in found_boundaries if b not in boundary_keywords]
+        
+        missing_boundaries = [b for b in expected_boundaries if b not in found_boundaries]
+        all_present = len(missing_boundaries) == 0
+        
+        return all_present, missing_boundaries, found_boundaries
+        
+    except Exception as e:
+        print(f"Error reading boundary file: {e}")
+        return False, expected_boundaries, []
+
+def handle_custom_mesh(state, case_dir):
+    print("============================== Custom Mesh Processing ==============================")
+    custom_mesh_path = state.get("custom_mesh_path")
+    error_logs = []
+    if not custom_mesh_path:
+        error_logs.append("No custom mesh path provided in state")
+        print("Error: No custom mesh path provided")
+        return {
+            "mesh_info": None,
+            "mesh_commands": [],
+            "error_logs": error_logs
+        }
+    if not os.path.exists(custom_mesh_path):
+        error_logs.append(f"Custom mesh file does not exist: {custom_mesh_path}")
+        print(f"Error: Custom mesh file not found at {custom_mesh_path}")
+        return {
+            "mesh_info": None,
+            "mesh_commands": [],
+            "error_logs": error_logs
+        }
+    mesh_in_case_dir = os.path.join(case_dir, "geometry.msh")
+    try:
+        shutil.copy2(custom_mesh_path, mesh_in_case_dir)
+        print(f"Copied custom mesh from {custom_mesh_path} to {mesh_in_case_dir}")
+    except Exception as e:
+        error_logs.append(f"Failed to copy custom mesh file: {str(e)}")
+        print(f"Error: Failed to copy custom mesh file: {str(e)}")
+        return {
+            "mesh_info": None,
+            "mesh_commands": [],
+            "error_logs": error_logs
+        }
+    print(f"Using mesh file: {mesh_in_case_dir}")
+    try:
+        constant_dir = os.path.join(case_dir, "constant")
+        os.makedirs(constant_dir, exist_ok=True)
+        system_dir = os.path.join(case_dir, "system")
+        os.makedirs(system_dir, exist_ok=True)
+        controldict_prompt = (
+            f"<user_requirements>{state['user_requirement']}</user_requirements>\n"
+            "Please create a basic controlDict file for mesh conversion. "
+            "The file should include only the essential settings needed for gmshToFoam to work. "
+            "Use the application name as mentioned in the user requirements. "
+            "IMPORTANT: Return ONLY the complete controlDict file content without any additional text."
+        )
+        controldict_content = state["llm_service"].invoke(controldict_prompt, CONTROLDICT_SYSTEM_PROMPT).strip()
+        if controldict_content:
+            controldict_file = os.path.join(system_dir, "controlDict")
+            save_file(controldict_file, controldict_content)
+            print("Created basic controlDict file for mesh conversion")
+        result = subprocess.run(
+            ["gmshToFoam", "geometry.msh"],
+            cwd=case_dir,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        print(f"gmshToFoam command output: {result.stdout}")
+        polyMesh_dir = os.path.join(constant_dir, "polyMesh")
+        if not os.path.exists(polyMesh_dir):
+            error_logs.append("Mesh conversion failed: polyMesh directory not created")
+            return {
+                "mesh_info": None,
+                "mesh_commands": [],
+                "error_logs": error_logs
+            }
+        boundary_file = os.path.join(polyMesh_dir, "boundary")
+        if os.path.exists(boundary_file):
+            with open(boundary_file, 'r') as f:
+                boundary_content = f.read()
+            boundary_prompt = (
+                f"<user_requirements>{state['user_requirement']}</user_requirements>\n"
+                f"<boundary_file_content>{boundary_content}</boundary_file_content>\n"
+                "Please analyze the user requirements and boundary file content. "
+                "Identify which boundary is to be modified based on the boundaries mentioned in the user requirements."
+                "If this is a 2D simulation, modify ONLY the appropriate boundary to 'empty' type and 'empty' physicalType. "
+                "Based on the no slip boundaries mentioned in the user requirements, modify the appropriate boundary/boundaries to type 'wall' and physicalType 'wall'. "
+                "If this is a 3D simulation, only modify the appropriate boundary/boundaries to type 'wall' and physicalType 'wall'."
+                "IMPORTANT: Do not change any other boundaries - leave them exactly as they are. "
+                "Return ONLY the complete boundary file content with any necessary modifications. No additional text."
+            )
+            updated_boundary_content = state["llm_service"].invoke(boundary_prompt, BOUNDARY_SYSTEM_PROMPT).strip()
+            if updated_boundary_content:
+                save_file(boundary_file, updated_boundary_content)
+                print("Boundary file updated based on simulation requirements")
+        foam_file = os.path.join(case_dir, f"{os.path.basename(case_dir)}.foam")
+        with open(foam_file, 'w') as f:
+            pass
+        mesh_commands = [
+            "checkMesh",
+        ]
+        return {
+            "mesh_info": {
+                "mesh_file_path": mesh_in_case_dir,
+                "mesh_file_type": "gmsh",
+                "mesh_description": "Custom mesh processed by preprocessor",
+                "requires_blockmesh_removal": True
+            },
+            "mesh_commands": mesh_commands,
+            "custom_mesh_used": True,
+            "error_logs": error_logs
+        }
+    except subprocess.CalledProcessError as e:
+        error_message = f"Error in mesh conversion: {str(e)}"
+        if e.stdout:
+            error_message += f"\nSTDOUT:\n{e.stdout}"
+        if e.stderr:
+            error_message += f"\nSTDERR:\n{e.stderr}"
+        error_logs.append(error_message)
+        return {
+            "mesh_info": None,
+            "mesh_commands": [],
+            "error_logs": error_logs
+        }
+
+def run_checkmesh_and_correct(state, case_dir, python_file, max_loop, current_loop, corrected_code, error_logs):
+    """
+    Run checkMesh command and handle mesh quality issues.
+    
+    Args:
+        state: State object containing LLM service and configuration
+        case_dir: Case directory path
+        python_file: Path to the Python mesh generation file
+        max_loop: Maximum number of retry attempts
+    
+    Returns:
+        tuple: (success: bool, should_continue: bool)
+    """
+    print("Running checkMesh to verify mesh quality...")
+    
+    try:
+        # Run checkMesh command
+        result = subprocess.run(
+            ["checkMesh"],
+            cwd=case_dir,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        checkmesh_output = result.stdout
+        print("checkMesh completed successfully")
+        print(f"checkMesh output:\n{checkmesh_output}")
+        
+        # Check if checkMesh reported any failures
+        if "Failed" in checkmesh_output and "mesh checks" in checkmesh_output:
+            # Extract the number of failed checks
+            failed_match = re.search(r"Failed (\d+) mesh checks", checkmesh_output)
+            if failed_match:
+                failed_count = int(failed_match.group(1))
+                print(f"checkMesh detected {failed_count} mesh quality issues")
+                
+                if current_loop < max_loop:
+                    print("Attempting to correct mesh generation based on checkMesh results...")
+                    
+                    # Read current Python code
+                    with open(python_file, 'r') as f:
+                        current_code = f.read()
+                    
+                    # Create error message for correction
+                    checkmesh_error = (
+                        f"checkMesh output:\n{checkmesh_output}\n"
+                        "Please analyze the checkMesh output and correct the mesh generation code. "
+                        "Common issues include: "
+                        "- Poor mesh quality (skewness, aspect ratio, etc.) "
+                        "- Geometry issues affecting mesh generation "
+                        "- Boundary layer problems "
+                        "- Boundary naming overlap or mismatch "
+                        "Provide corrected Python code that addresses the specific mesh quality issues identified by checkMesh."
+                    )
+                    
+                    # Use the existing correction function
+                    corrected_code = _correct_gmsh_python_code(
+                        state,
+                        current_code,
+                        checkmesh_error
+                    )
+                    
+                    if corrected_code:
+                        state['corrected_python_code'] = corrected_code
+                        print("Generated corrected Python code for next attempt (checkMesh issues)")
+                        return False, True  # Not successful, but should continue
+                    else:
+                        print("Failed to generate corrected code for checkMesh issues")
+                        return False, False  # Not successful, should not continue
+                else:
+                    print(f"Failed to resolve checkMesh issues after {max_loop} attempts")
+                    return False, False  # Not successful, should not continue
+            else:
+                print("checkMesh output contains 'Failed' but couldn't parse failure count")
+                return False, False
+        else:
+            print("checkMesh passed - no mesh quality issues detected")
+            return True, False  # Successful, no need to continue
+            
+    except subprocess.CalledProcessError as e:
+        error_message = f"Error running checkMesh: {str(e)}"
+        if e.stdout:
+            error_message += f"\nSTDOUT:\n{e.stdout}"
+        if e.stderr:
+            error_message += f"\nSTDERR:\n{e.stderr}"
+        print(error_message)
+        state["error_logs"].append(error_message)
+        
+        if current_loop < max_loop:
+            print("Retrying mesh generation due to checkMesh error...")
+            return False, True  # Not successful, but should continue
+        else:
+            print(f"Failed to run checkMesh after {max_loop} attempts")
+            return False, False  # Not successful, should not continue
+    
+    except Exception as e:
+        print(f"Unexpected error in checkMesh: {str(e)}")
+        state["error_logs"].append(f"Unexpected error in checkMesh: {str(e)}")
+        return False, False
+
+def handle_gmsh_mesh(state, case_dir):
+    """Handle GMSH mesh generation using gmsh python logic."""
+    print("============================== GMSH Mesh Generation ==============================")
+    
+    # Ensure case_dir exists
+    case_dir = os.path.abspath(case_dir)
+    error_logs = []
+    if os.path.exists(case_dir):
+        print(f"Warning: Case directory {case_dir} already exists. Overwriting.")
+        shutil.rmtree(case_dir)
+    os.makedirs(case_dir)
+    print(f"Created case directory: {case_dir}")
+    
+    # Define file paths
+    python_file = os.path.join(case_dir, "generate_mesh.py")
+    msh_file = os.path.join(case_dir, "geometry.msh")
+    
+    # Extract expected boundary names from user requirements
+    expected_boundaries = extract_boundary_names_from_requirements(state, state["user_requirement"])
+    print(f"Expected boundaries from user requirements: {expected_boundaries}")
+    
+    # Initialize loop counter if not present
+    gmsh_python_current_loop = 0
+    
+    # Initialize missing boundaries tracking
+    missing_boundaries = []
+    
+    # Initialize corrected code flag
+    corrected_python_code = None
+    
+    max_loop = state['config'].max_loop
+    while gmsh_python_current_loop < max_loop:
+        gmsh_python_current_loop += 1
+        print(f"GMSH Python attempt {gmsh_python_current_loop} of {max_loop}")
+        
+        # Determine if we should generate new code or use corrected code
+        should_generate_new_code = True
+        if corrected_python_code:
+            should_generate_new_code = False
+            python_code_to_use = corrected_python_code
+            print("Using corrected Python code from previous attempt")
+        
+        try:
+            if should_generate_new_code:
+                # Generate Python code based on user requirements
+                missing_boundary_info = ""
+                if missing_boundaries:
+                    missing_boundary_info = f"\n<missing_boundaries>Previous attempts were missing these boundaries: {missing_boundaries} in boundary file after performing gmshToFoam. Ensure these boundaries are properly defined in the GMSH physical groups.</missing_boundaries>"
+                
+                python_prompt = (
+                    f"<user_requirements>{state['user_requirement']}</user_requirements>{missing_boundary_info}\n"
+                    "Please create Python code using the GMSH library to generate a mesh based on the user requirements. "
+                    "Use boundary names specified in user requirements (e.g., 'inlet', 'outlet', 'wall', 'cylinder', etc.). "
+                    "Return ONLY the complete Python code without any additional text."
+                )
+                
+                # Generate Python code using LLM
+                python_response = state["llm_service"].invoke(python_prompt, GMSH_PYTHON_SYSTEM_PROMPT, pydantic_obj=GMSHPythonCode)
+                
+                if not python_response.python_code:
+                    print("Failed to generate GMSH Python code")
+                    if gmsh_python_current_loop >= max_loop:
+                        return {
+                            "mesh_info": None,
+                            "mesh_commands": [],
+                            "mesh_file_destination": None,
+                            "error_logs": error_logs
+                        }
+                    continue
+                
+                python_code_to_use = python_response.python_code
+                mesh_type = python_response.mesh_type
+                geometry_type = python_response.geometry_type
+            else:
+                # Use corrected code from previous attempt
+                mesh_type = "3D"  # Default for corrected code
+                geometry_type = "corrected"  # Indicate this is corrected code
+            
+            # Save the Python file
+            save_file(python_file, python_code_to_use)
+            print(f"Created GMSH Python file: {python_file}")
+            
+            # Clear the corrected code flag since we're using it
+            corrected_python_code = None
+            
+            # Run the Python code to generate the mesh
+            print("Running GMSH Python code to generate mesh...")
+            
+            # Use Popen to get real-time output while still capturing stderr for error correction
+            process = subprocess.Popen(
+                ["python", python_file],
+                cwd=case_dir,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            # Stream stdout in real-time
+            while True:
+                output = process.stdout.readline()
+                if output == '' and process.poll() is not None:
+                    break
+                if output:
+                    print(output.strip())
+            
+            # Wait for process to complete and get return code
+            return_code = process.wait()
+            
+            # Get stderr for potential error correction
+            stderr_output = process.stderr.read()
+            
+            if return_code != 0:
+                raise subprocess.CalledProcessError(return_code, process.args, stderr=stderr_output)
+            
+            print("GMSH Python mesh generation completed successfully")
+            
+            # Verify the mesh file was created
+            if not os.path.exists(msh_file):
+                print("Error: Mesh file was not created by GMSH Python")
+                if stderr_output:
+                    print(f"GMSH Python error output: {stderr_output}")
+                    # Try to correct the Python code based on the error
+                    if gmsh_python_current_loop < max_loop:
+                        print("Attempting to correct Python code based on error...")
+                        corrected_code = _correct_gmsh_python_code(
+                            state, 
+                            python_code_to_use, 
+                            stderr_output
+                        )
+                        if corrected_code:
+                            corrected_python_code = corrected_code
+                            print("Generated corrected Python code for next attempt")
+                            continue
+                if gmsh_python_current_loop >= max_loop:
+                    return {
+                        "mesh_info": None,
+                        "mesh_commands": [],
+                        "mesh_file_destination": None,
+                        "error_logs": error_logs
+                    }
+                continue
+            
+            print(f"Successfully created mesh file: {msh_file}")
+            
+            # ========== INTEGRATED PREPROCESSOR OPERATIONS ==========
+            print("Starting OpenFOAM conversion and boundary checking...")
+            
+            try:
+                # Create constant and system directories
+                constant_dir = os.path.join(case_dir, "constant")
+                system_dir = os.path.join(case_dir, "system")
+                os.makedirs(constant_dir, exist_ok=True)
+                os.makedirs(system_dir, exist_ok=True)
+                
+                # Create basic controlDict file
+                controldict_prompt = (
+                    f"<user_requirements>{state['user_requirement']}</user_requirements>\n"
+                    "Please create a basic controlDict file for mesh conversion. "
+                    "The file should include only the essential settings needed for gmshToFoam to work. "
+                    "IMPORTANT: Return ONLY the complete controlDict file content without any additional text."
+                )
+                
+                controldict_content = state["llm_service"].invoke(controldict_prompt, CONTROLDICT_SYSTEM_PROMPT).strip()
+                
+                if controldict_content:
+                    controldict_file = os.path.join(system_dir, "controlDict")
+                    save_file(controldict_file, controldict_content)
+                    print("Created basic controlDict file for mesh conversion")
+                
+                # Run gmshToFoam command
+                print("Running gmshToFoam conversion...")
+                result = subprocess.run(
+                    ["gmshToFoam", "geometry.msh"],
+                    cwd=case_dir,
+                    check=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True
+                )
+                print(f"gmshToFoam command output: {result.stdout}")
+                
+                # Check if the mesh was converted successfully
+                polyMesh_dir = os.path.join(constant_dir, "polyMesh")
+                if not os.path.exists(polyMesh_dir):
+                    raise subprocess.CalledProcessError(1, "gmshToFoam", "polyMesh directory not created")
+                
+                # Check boundary file for boundaries
+                boundary_file = os.path.join(polyMesh_dir, "boundary")
+                if os.path.exists(boundary_file):
+                    all_present, missing_boundaries, found_boundaries = check_boundary_file_for_missing_boundaries(
+                        boundary_file, expected_boundaries
+                    )
+                    
+                    print(f"Found boundaries in OpenFOAM: {found_boundaries}")
+                    print(f"Expected boundaries: {expected_boundaries}")
+                    
+                    # Simple: If sets don't match, ask LLM to fix
+                    if set(found_boundaries) != set(expected_boundaries):
+                        print(f"Boundary mismatch detected. Found: {found_boundaries}, Expected: {expected_boundaries}")
+                        # Store for LLM context
+                        state['found_boundaries'] = found_boundaries
+                        state['expected_boundaries'] = expected_boundaries
+                        # Read current generate_mesh.py code
+                        with open(python_file, 'r') as f:
+                            current_code = f.read()
+                        if gmsh_python_current_loop < max_loop:
+                            print("Retrying mesh generation due to boundary mismatch...")
+                            boundary_error = (
+                                f"Boundary mismatch after gmshToFoam. "
+                                f"Found boundaries: {found_boundaries}. "
+                                f"Expected boundaries: {expected_boundaries}. "
+                                "Please correct the mesh code so that the boundaries in the OpenFOAM boundary file match the expected boundaries exactly."
+                            )
+                            error_logs.append(boundary_error)
+                            corrected_code = _correct_gmsh_python_code(
+                                state,
+                                current_code,
+                                boundary_error
+                            )
+                            if corrected_code:
+                                corrected_python_code = corrected_code
+                                print("Generated corrected Python code for next attempt (boundary mismatch)")
+                                continue
+                        else:
+                            print(f"Failed to generate correct boundaries after {max_loop} attempts")
+                            return {
+                                "mesh_info": None,
+                                "mesh_commands": [],
+                                "mesh_file_destination": None,
+                                "error_logs": error_logs
+                            }
+                    else:
+                        print("All boundaries match expected in OpenFOAM boundary file")
+                        # Clear any previous boundary issues
+                        if 'found_boundaries' in state:
+                            del state['found_boundaries']
+                        if 'expected_boundaries' in state:
+                            del state['expected_boundaries']
+                        missing_boundaries = []
+                        
+                        # Run checkMesh to verify mesh quality BEFORE boundary file update
+                        checkmesh_success, should_continue = run_checkmesh_and_correct(
+                            state, case_dir, python_file, max_loop, gmsh_python_current_loop, corrected_python_code, error_logs
+                        )
+                        
+                        if not checkmesh_success:
+                            if should_continue:
+                                continue  # Continue to next iteration with corrected code
+                            else:
+                                print(f"Failed to resolve checkMesh issues after {max_loop} attempts")
+                                return {
+                                    "mesh_info": None,
+                                    "mesh_commands": [],
+                                    "mesh_file_destination": None,
+                                    "error_logs": error_logs
+                                }
+                        
+                        # Handle boundary conditions based on user requirements
+                        with open(boundary_file, 'r') as f:
+                            boundary_content = f.read()
+                        
+                        boundary_prompt = (
+                            f"<user_requirements>{state['user_requirement']}</user_requirements>\n"
+                            f"<boundary_file_content>{boundary_content}</boundary_file_content>\n"
+                            "Please analyze the user requirements and boundary file content. "
+                            "Identify which boundary is to be modified based on the boundaries mentioned in the user requirements."
+                            "If this is a 2D simulation, modify ONLY the appropriate boundary to 'empty' type and 'empty' physicalType. "
+                            "Based on the no slip boundaries mentioned in the user requirements, modify the appropriate boundary/boundaries to type 'wall' and physicalType 'wall'. "
+                            "If this is a 3D simulation, only modify the appropriate boundary/boundaries to type 'wall' and physicalType 'wall'."
+                            "IMPORTANT: Do not change any other boundaries - leave them exactly as they are. "
+                            "Return ONLY the complete boundary file content with any necessary modifications. No additional text."
+                        )
+                        
+                        updated_boundary_content = state["llm_service"].invoke(boundary_prompt, BOUNDARY_SYSTEM_PROMPT).strip()
+                        
+                        if updated_boundary_content:
+                            save_file(boundary_file, updated_boundary_content)
+                            print("Boundary file updated based on simulation requirements")
+                
+                # Create .foam file
+                foam_file = os.path.join(case_dir, f"{os.path.basename(case_dir)}.foam")
+                with open(foam_file, 'w') as f:
+                    pass
+                
+                print("OpenFOAM conversion, boundary setup, and mesh quality check completed successfully")
+                
+                # Generate mesh commands for the InputWriter node
+                mesh_commands = [   # Check mesh quality  # Renumber mesh for better performance
+                ]
+                
+                # Update state with mesh information
+                return {
+                    "mesh_info": {
+                        "mesh_file_path": msh_file,
+                        "mesh_file_type": "gmsh",
+                        "mesh_description": f"GMSH generated {geometry_type} mesh",
+                        "requires_blockmesh_removal": True
+                    },
+                    "mesh_commands": mesh_commands,
+                    "mesh_file_destination": msh_file,
+                    "custom_mesh_used": True,
+                    "error_logs": error_logs
+                }
+                
+            except subprocess.CalledProcessError as e:
+                error_message = f"Error in OpenFOAM conversion: {str(e)}"
+                if e.stdout:
+                    error_message += f"\nSTDOUT:\n{e.stdout}"
+                if e.stderr:
+                    error_message += f"\nSTDERR:\n{e.stderr}"
+                print(error_message)
+                error_logs.append(error_message)
+                
+                # Retry mesh generation
+                if gmsh_python_current_loop < max_loop:
+                    print("Retrying mesh generation due to OpenFOAM conversion error...")
+                    continue
+                else:
+                    print(f"Failed to convert mesh to OpenFOAM format after {max_loop} attempts")
+                    return {
+                        "mesh_info": None,
+                        "mesh_commands": [],
+                        "mesh_file_destination": None,
+                        "error_logs": error_logs
+                    }
+            
+        except subprocess.CalledProcessError as e:
+            error_message = f"Error in GMSH Python mesh generation (attempt {gmsh_python_current_loop}): {str(e)}"
+            if e.stdout:
+                error_message += f"\nSTDOUT:\n{e.stdout}"
+            if e.stderr:
+                error_message += f"\nSTDERR:\n{e.stderr}"
+            print(error_message)
+            error_logs.append(error_message)
+            
+            # Try to correct the Python code based on the error
+            if gmsh_python_current_loop < max_loop:
+                print("Attempting to correct Python code based on error...")
+                try:
+                    # Read the current Python file
+                    with open(python_file, 'r') as f:
+                        current_code = f.read()
+                    
+                    corrected_code = _correct_gmsh_python_code(
+                        state, 
+                        current_code, 
+                        e.stderr
+                    )
+                    if corrected_code:
+                        corrected_python_code = corrected_code
+                        print("Generated corrected Python code for next attempt")
+                        continue
+                except Exception as correction_error:
+                    print(f"Error during Python code correction: {correction_error}")
+            
+            if gmsh_python_current_loop >= max_loop:
+                print(f"Failed to generate mesh after {max_loop} attempts")
+                return {
+                    "mesh_info": None,
+                    "mesh_commands": [],
+                    "mesh_file_destination": None,
+                    "error_logs": error_logs
+                }
+            
+        except Exception as e:
+            print(f"Error in GMSH Python node: {str(e)}")
+            if gmsh_python_current_loop >= max_loop:
+                return {
+                    "mesh_info": None,
+                    "mesh_commands": [],
+                    "mesh_file_destination": None,
+                    "error_logs": error_logs
+                }
+            continue
+    
+    return {
+        "mesh_info": None,
+        "mesh_commands": [],
+        "mesh_file_destination": None,
+        "error_logs": error_logs
+    }
+
+def handle_standard_mesh(state, case_dir):
+    """Handle standard OpenFOAM mesh generation."""
+    print("============================== Standard Mesh Generation ==============================")
+    print("Using standard OpenFOAM mesh generation (blockMesh, snappyHexMesh, etc.)")
+    return {
+        "mesh_info": None,
+        "mesh_commands": [],
+        "mesh_file_destination": None,
+        "custom_mesh_used": False,
+        "error_logs": []
+    }
+
+def meshing_node(state):
+    """
+    Meshing node: Handle different mesh scenarios based on user requirements.
+    
+    Three scenarios:
+    1. Custom mesh: User provides existing mesh file (uses preprocessor logic)
+    2. GMSH mesh: User wants mesh generated using GMSH (uses gmsh python logic)
+    3. Standard mesh: User wants standard OpenFOAM mesh generation (returns None)
+    
+    Updates state with:
+      - mesh_info: Information about the custom mesh
+      - mesh_commands: Commands needed for mesh processing
+      - mesh_file_destination: Where the mesh file should be placed
+    """
+    config = state["config"]
+    user_requirement = state["user_requirement"]
+    case_dir = state["case_dir"]
+    
+    # Get mesh type from state (determined by router)
+    mesh_type = state.get("mesh_type", "standard_mesh")
+    
+    # Handle mesh based on type determined by router
+    if mesh_type == "custom_mesh":
+        print("Router determined: Custom mesh requested.")
+        return handle_custom_mesh(state, case_dir)
+    elif mesh_type == "gmsh_mesh":
+        print("Router determined: GMSH mesh requested.")
+        return handle_gmsh_mesh(state, case_dir)
+    else:
+        print("Router determined: Standard mesh generation.")
+        return handle_standard_mesh(state, case_dir)

Foam-Agent/source/src/nodes/reviewer_node.py

@@ -0,0 +1,75 @@
+# reviewer_node.py
+from pydantic import BaseModel, Field
+from typing import List
+
+REVIEWER_SYSTEM_PROMPT = (
+    "You are an expert in OpenFOAM simulation and numerical modeling. "
+    "Your task is to review the provided error logs and diagnose the underlying issues. "
+    "You will be provided with a similar case reference, which is a list of similar cases that are ordered by similarity. You can use this reference to help you understand the user requirement and the error."
+    "When an error indicates that a specific keyword is undefined (for example, 'div(phi,(p|rho)) is undefined'), your response must propose a solution that simply defines that exact keyword as shown in the error log. "
+    "Do not reinterpret or modify the keyword (e.g., do not treat '|' as 'or'); instead, assume it is meant to be taken literally. "
+    "Propose ideas on how to resolve the errors, but do not modify any files directly. "
+    "Please do not propose solutions that require modifying any parameters declared in the user requirement, try other approaches instead. Do not ask the user any questions."
+    "The user will supply all relevant foam files along with the error logs, and within the logs, you will find both the error content and the corresponding error command indicated by the log file name."
+)
+
+def reviewer_node(state):
+    """
+    Reviewer node: Reviews the error logs and provides analysis and suggestions
+    for fixing the errors. This node only focuses on analysis, not file modification.
+    """
+    print(f"============================== Reviewer Analysis ==============================")
+    if len(state["error_logs"]) == 0:
+        print("No error to review.")
+        return state
+    
+    # Analysis the reason and give the method to fix the error.
+    if state.get("history_text") and state["history_text"]:
+        reviewer_user_prompt = (
+            f"<similar_case_reference>{state['tutorial_reference']}</similar_case_reference>\n"
+            f"<foamfiles>{str(state['foamfiles'])}</foamfiles>\n"
+            f"<current_error_logs>{state['error_logs']}</current_error_logs>\n"
+            f"<history>\n"
+            f"{chr(10).join(state['history_text'])}\n"
+            f"</history>\n\n"
+            f"<user_requirement>{state['user_requirement']}</user_requirement>\n\n"
+            f"I have modified the files according to your previous suggestions. If the error persists, please provide further guidance. Make sure your suggestions adhere to user requirements and do not contradict it. Also, please consider the previous attempts and try a different approach."
+        )
+    else:
+        reviewer_user_prompt = (
+            f"<similar_case_reference>{state['tutorial_reference']}</similar_case_reference>\n"
+            f"<foamfiles>{str(state['foamfiles'])}</foamfiles>\n"
+            f"<error_logs>{state['error_logs']}</error_logs>\n"
+            f"<user_requirement>{state['user_requirement']}</user_requirement>\n"
+            "Please review the error logs and provide guidance on how to resolve the reported errors. Make sure your suggestions adhere to user requirements and do not contradict it."
+        ) 
+    
+    review_response = state["llm_service"].invoke(reviewer_user_prompt, REVIEWER_SYSTEM_PROMPT)
+    review_content = review_response
+    
+    # Initialize history_text if it doesn't exist
+    if not state.get("history_text"):
+        history_text = []
+    else:
+        history_text = state["history_text"]
+        
+    # Add current attempt to history
+    current_attempt = [
+        f"<Attempt {len(history_text)//4 + 1}>\n"
+        f"<Error_Logs>\n{state['error_logs']}\n</Error_Logs>",
+        f"<Review_Analysis>\n{review_content}\n</Review_Analysis>",
+        f"</Attempt>\n"  # Closing tag for Attempt with empty line
+    ]
+    history_text.extend(current_attempt)
+    
+    print(review_content)
+
+
+
+    # Return updated state with review analysis
+    return {
+        "history_text": history_text,
+        "review_analysis": review_content,
+        "loop_count": state.get("loop_count", 0) + 1,
+        "input_writer_mode": "rewrite",
+    }

Foam-Agent/source/src/nodes/visualization_node.py

@@ -0,0 +1,300 @@
+# visualization_node.py
+import os
+import subprocess
+import sys
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from utils import save_file
+import glob
+
+# Helper to get the .foam file name
+def get_foam_file(case_dir):
+    case_dir_name = os.path.basename(os.path.normpath(case_dir))
+    return f"{case_dir_name}.foam"
+
+VISUALIZATION_SYSTEM_PROMPT = (
+    "You are an expert in OpenFOAM post-processing and PyVista Python scripting. "
+    "Your task is to generate a PyVista Python script that visualizes the specified data from the OpenFOAM case. "
+    "The script should load the OpenFOAM case data by reading the .foam file (e.g., 'runs.foam') in the case directory using PyVista, display the geometry, and color the surface by the specified field (e.g., 'U' for velocity). "
+    "Ensure the script shows the geometry, sets up the colorbar, and saves the visualization as a PNG file. "
+    "Use coolwarm colormap by default."
+    "The script must save the visualization as a PNG file, and the output image must contain the geometry and the colorbar, not just the colorbar. "
+    "IMPORTANT: Return ONLY the Python code without any markdown formatting, code block markers, or explanatory text. "
+    "The script should start with the necessary imports, read the .foam file using PyVista, and end with the screenshot saving."
+)
+
+ERROR_FIX_SYSTEM_PROMPT = (
+    "You are an expert in PyVista Python scripting and OpenFOAM visualization. "
+    "Your task is to fix the provided PyVista Python script that encountered an error. "
+    "Ensure the script loads the OpenFOAM case data by reading the .foam file (e.g., 'runs.foam') in the case directory using PyVista, displays the geometry, and colors the surface by the specified field. "
+    "Make sure the script shows the geometry, sets up the colorbar, and saves the visualization as a PNG file. "
+    "Use coolwarm colormap by default."
+    "The script must save the visualization as a PNG file, and the output image must contain the geometry and the colorbar, not just the colorbar. "
+    "IMPORTANT: Return ONLY the Python code without any markdown formatting, code block markers, or explanatory text. "
+    "The script should start with the necessary imports, read the .foam file using PyVista, and end with the screenshot saving."
+)
+
+class PlotConfigPydantic(BaseModel):
+    """Configuration for plotting parameters"""
+    plot_type: str = Field(description="Type of plot (e.g., 'contour', 'vector', 'streamline', 'time_series')")
+    field_name: str = Field(description="Field to plot (e.g., 'U', 'p', 'T', 'rho')")
+    time_step: Optional[str] = Field(default=None, description="Time step to plot (if None, use latest)")
+    output_format: str = Field(default="png", description="Output format for plots")
+    output_path: str = Field(description="Path to save the plot")
+
+class VisualizationPlanPydantic(BaseModel):
+    """Plan for visualization tasks"""
+    plots: List[PlotConfigPydantic] = Field(description="List of plots to generate")
+
+class VisualizationAnalysisPydantic(BaseModel):
+    """Analysis of user requirements for visualization needs"""
+    primary_field: str = Field(description="Primary field to visualize (e.g., 'U', 'p', 'T', 'rho')")
+    plot_type: str = Field(description="Type of plot requested (e.g., 'contour', 'vector', 'streamline', 'time_series')")
+    time_step: Optional[str] = Field(default=None, description="Specific time step to plot (if mentioned)")
+    plane_info: Optional[str] = Field(default=None, description="Plane information if 2D slice is requested (e.g., 'Z plane', 'X=0.5')")
+    additional_fields: List[str] = Field(default=[], description="Additional fields that might be useful to visualize")
+    visualization_priority: str = Field(description="Priority of visualization (e.g., 'high', 'medium', 'low')")
+
+def visualization_node(state):
+    """
+    Visualization node: Creates PyVista visualizations from the successfully generated OpenFOAM case.
+    This node uses the successfully generated code and user_requirement to create PyVista visualizations.
+    
+    Updates state with:
+      - plot_configs: List of plot configurations
+      - plot_outputs: List of generated plot file paths
+      - visualization_summary: Summary of generated visualizations
+      - pyvista_visualization: PyVista visualization results
+    """
+    config = state["config"]
+    user_requirement = state["user_requirement"]
+    case_dir = state["case_dir"]
+    
+    print(f"============================== Visualization (PyVista) ==============================")
+    
+    # Ensure case_dir is absolute
+    case_dir = os.path.abspath(case_dir)
+    if not os.path.exists(case_dir):
+        print(f"Case directory does not exist: {case_dir}")
+        return {
+            **state,
+            "plot_configs": [],
+            "plot_outputs": [],
+            "visualization_summary": {"error": f"Case directory does not exist: {case_dir}"},
+            "pyvista_visualization": {"success": False, "error": f"Case directory does not exist: {case_dir}"}
+        }
+    
+    # Touch the .foam file before generating the visualization script
+    foam_file = get_foam_file(case_dir)
+    foam_file_path = os.path.join(case_dir, foam_file)
+    with open(foam_file_path, 'a'):
+        os.utime(foam_file_path, None)
+    
+    # Initialize loop counter
+    current_loop = 0
+    error_logs = []
+    max_loop = state['config'].max_loop
+    
+    while current_loop < max_loop:
+        current_loop += 1
+        print(f"Attempt {current_loop} of {max_loop}")
+        
+        # Create visualization script
+        viz_prompt = (
+            f"<case_directory>{case_dir}</case_directory>\n"
+            f"<foam_file>{foam_file}</foam_file>\n"
+            f"<visualization_requirements>{state['user_requirement']}</visualization_requirements>\n"
+            f"<previous_errors>{error_logs}</previous_errors>\n"
+            f"Please create a PyVista Python script that visualizes the specified data by reading the .foam file ('{foam_file}')."
+            "Save the visualization as PNG file named visualization.png if not specified otherwise in the user requirement."
+        )
+        
+        viz_script = state["llm_service"].invoke(viz_prompt, VISUALIZATION_SYSTEM_PROMPT)
+        
+        # Save the visualization script
+        script_path = os.path.join(case_dir, "visualization.py")
+        save_file(script_path, viz_script)
+        
+        # Execute the script using Python
+        try:
+            result = subprocess.run(
+                [sys.executable, script_path],
+                cwd=case_dir,
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            print(f"Finished command: Return Code {result.returncode}")
+            error_logs = []
+            
+            # Check if any PNG output image was created
+            png_files = glob.glob(os.path.join(case_dir, "*.png"))
+            if png_files:
+                output_image = png_files[0]  # Use the first PNG file found
+                print(f"PyVista visualization created successfully: {output_image}")
+                
+                # Create plot configs and outputs in the expected format
+                plot_configs = [
+                    {
+                        "plot_type": "pyvista_2d",
+                        "field_name": "U",  # Default field, could be enhanced to detect from script
+                        "time_step": "latest",
+                        "output_format": "png",
+                        "output_path": output_image
+                    }
+                ]
+                
+                plot_outputs = [output_image]
+                
+                visualization_summary = {
+                    "total_plots_generated": len(plot_outputs),
+                    "plot_types": ["pyvista_2d"],
+                    "fields_visualized": ["U"],
+                    "output_directory": case_dir,
+                    "pyvista_success": True
+                }
+                
+                pyvista_result = {
+                    "success": True,
+                    "output_image": output_image,
+                    "script": viz_script
+                }
+                
+                print(f"Generated {len(plot_outputs)} plots")
+                print(f"PyVista visualization saved to: {output_image}")
+                print("============================== Visualization Complete ==============================")
+                
+                return {
+                    **state,
+                    "plot_configs": plot_configs,
+                    "plot_outputs": plot_outputs,
+                    "visualization_summary": visualization_summary,
+                    "pyvista_visualization": pyvista_result
+                }
+            else:
+                error_logs.append("Visualization script executed but no PNG output image was created")
+                
+        except subprocess.CalledProcessError as e:
+            error_message = f"Error executing visualization script: {str(e)}"
+            if e.stdout:
+                error_message += f"\nSTDOUT:\n{e.stdout.decode() if isinstance(e.stdout, bytes) else e.stdout}"
+            if e.stderr:
+                error_message += f"\nSTDERR:\n{e.stderr.decode() if isinstance(e.stderr, bytes) else e.stderr}"
+            error_logs.append(error_message)
+        
+        # If we have errors and haven't reached max loops, try to fix them
+        if error_logs and current_loop < max_loop:
+            error_fix_prompt = (
+                f"<error_logs>{error_logs}</error_logs>\n"
+                f"<foam_file>{foam_file}</foam_file>\n"
+                f"<original_script>{viz_script}</original_script>\n"
+                f"<attempt_number>{current_loop}</attempt_number>\n"
+                f"Please fix the PyVista Python script based on the error messages. The script should read the .foam file ('{foam_file}') in the case directory."
+            )
+            
+            fixed_script = state["llm_service"].invoke(error_fix_prompt, ERROR_FIX_SYSTEM_PROMPT)
+            
+            # Save the fixed script
+            save_file(script_path, fixed_script)
+            
+            # Try executing the fixed script
+            try:
+                result = subprocess.run(
+                    [sys.executable, script_path],
+                    cwd=case_dir,
+                    check=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                print(f"Finished command: Return Code {result.returncode}")
+                error_logs = []
+                
+                # Check if any PNG output image was created
+                png_files = glob.glob(os.path.join(case_dir, "*.png"))
+                if png_files:
+                    output_image = png_files[0]  # Use the first PNG file found
+                    print(f"PyVista visualization created successfully: {output_image}")
+                    
+                    # Create plot configs and outputs in the expected format
+                    plot_configs = [
+                        {
+                            "plot_type": "pyvista_3d",
+                            "field_name": "U",  # Default field, could be enhanced to detect from script
+                            "time_step": "latest",
+                            "output_format": "png",
+                            "output_path": output_image
+                        }
+                    ]
+                    
+                    plot_outputs = [output_image]
+                    
+                    visualization_summary = {
+                        "total_plots_generated": len(plot_outputs),
+                        "plot_types": ["pyvista_3d"],
+                        "fields_visualized": ["U"],
+                        "output_directory": case_dir,
+                        "pyvista_success": True
+                    }
+                    
+                    pyvista_result = {
+                        "success": True,
+                        "output_image": output_image,
+                        "script": fixed_script
+                    }
+                    
+                    print(f"Generated {len(plot_outputs)} plots")
+                    print(f"PyVista visualization saved to: {output_image}")
+                    print("============================== Visualization Complete ==============================")
+                    
+                    return {
+                        **state,
+                        "plot_configs": plot_configs,
+                        "plot_outputs": plot_outputs,
+                        "visualization_summary": visualization_summary,
+                        "pyvista_visualization": pyvista_result
+                    }
+                else:
+                    error_logs.append("Fixed visualization script executed but no PNG output image was created")
+                    
+            except subprocess.CalledProcessError as e:
+                error_message = f"Error executing fixed visualization script: {str(e)}"
+                if e.stdout:
+                    error_message += f"\nSTDOUT:\n{e.stdout.decode() if isinstance(e.stdout, bytes) else e.stdout}"
+                if e.stderr:
+                    error_message += f"\nSTDERR:\n{e.stderr.decode() if isinstance(e.stderr, bytes) else e.stderr}"
+                error_logs.append(error_message)
+    
+    # If we've exhausted all attempts
+    if current_loop >= max_loop:
+        print(f"Failed to create visualization after {max_loop} attempts")
+        error_message = f"Maximum number of attempts ({max_loop}) reached without success"
+        error_logs.append(error_message)
+    
+    # Return failure state in the expected format
+    plot_configs = []
+    plot_outputs = []
+    
+    visualization_summary = {
+        "total_plots_generated": 0,
+        "plot_types": [],
+        "fields_visualized": [],
+        "output_directory": case_dir,
+        "pyvista_success": False,
+        "error": error_message if 'error_message' in locals() else "Unknown error"
+    }
+    
+    pyvista_result = {
+        "success": False,
+        "error": error_message if 'error_message' in locals() else "Unknown error",
+        "error_logs": error_logs
+    }
+    
+    print("============================== Visualization Failed ==============================")
+    
+    return {
+        **state,
+        "plot_configs": plot_configs,
+        "plot_outputs": plot_outputs,
+        "visualization_summary": visualization_summary,
+        "pyvista_visualization": pyvista_result
+    }

Foam-Agent/source/src/router_func.py

@@ -0,0 +1,158 @@
+from typing import TypedDict, List, Optional
+from config import Config
+from utils import LLMService, GraphState
+from langgraph.graph import StateGraph, START, END
+from langgraph.types import Command
+
+
+def llm_requires_custom_mesh(state: GraphState) -> int:
+    """
+    Use LLM to determine if user requires custom mesh based on their requirement.
+    
+    Args:
+        state: Current graph state containing user requirement and LLM service
+        
+    Returns:
+        int: 1 if custom mesh is required, 2 if gmsh mesh is required, 0 otherwise
+    """
+    user_requirement = state["user_requirement"]
+    
+    system_prompt = (
+        "You are an expert in OpenFOAM workflow analysis. "
+        "Analyze the user requirement to determine if they want to use a custom mesh file. "
+        "Look for keywords like: custom mesh, mesh file, .msh, .stl, .obj, gmsh, snappyHexMesh, "
+        "or any mention of importing/using external mesh files. "
+        "If the user explicitly mentions or implies they want to use a custom mesh file, return 'custom_mesh'. "
+        "If they want to use standard OpenFOAM mesh generation (blockMesh, snappyHexMesh with STL, etc.), return 'standard_mesh'. "
+        "Look for keywords like gmsh and determine if they want to create mesh using gmsh. If they want to create mesh using gmsh, return 'gmsh_mesh'. "
+        "Be conservative - if unsure, assume 'standard_mesh' unless clearly specified otherwise."
+        "Only return 'custom_mesh' or 'standard_mesh' or 'gmsh_mesh'. Don't return anything else."
+    )
+    
+    user_prompt = (
+        f"User requirement: {user_requirement}\n\n"
+        "Determine if the user wants to use a custom mesh file. "
+        "Return exactly 'custom_mesh' if they want to use a custom mesh file, "
+        "'standard_mesh' if they want standard OpenFOAM mesh generation or 'gmsh_mesh' if they want to create mesh using gmsh."
+    )
+    
+    response = state["llm_service"].invoke(user_prompt, system_prompt)
+    if "custom_mesh" in response.lower():
+        return 1
+    elif "gmsh_mesh" in response.lower():
+        return 2
+    else:
+        return 0
+
+
+def llm_requires_hpc(state: GraphState) -> bool:
+    """
+    Use LLM to determine if user requires HPC/cluster execution based on their requirement.
+    
+    Args:
+        state: Current graph state containing user requirement and LLM service
+        
+    Returns:
+        bool: True if HPC execution is required, False otherwise
+    """
+    user_requirement = state["user_requirement"]
+    
+    system_prompt = (
+        "You are an expert in OpenFOAM workflow analysis. "
+        "Analyze the user requirement to determine if they want to run the simulation on HPC (High Performance Computing) or locally. "
+        "Look for keywords like: HPC, cluster, supercomputer, SLURM, PBS, job queue, "
+        "parallel computing, distributed computing, or any mention of running on remote systems. "
+        "If the user explicitly mentions or implies they want to run on HPC/cluster, return 'hpc_run'. "
+        "If they want to run locally or don't specify, return 'local_run'. "
+        "Be conservative - if unsure, assume local run unless clearly specified otherwise."
+        "Only return 'hpc_run' or 'local_run'. Don't return anything else."
+    )
+    
+    user_prompt = (
+        f"User requirement: {user_requirement}\n\n"
+        "return 'hpc_run' or 'local_run'"
+    )
+    
+    response = state["llm_service"].invoke(user_prompt, system_prompt)
+    return "hpc_run" in response.lower()
+
+
+def llm_requires_visualization(state: GraphState) -> bool:
+    """
+    Use LLM to determine if user requires visualization based on their requirement.
+    
+    Args:
+        state: Current graph state containing user requirement and LLM service
+        
+    Returns:
+        bool: True if visualization is required, False otherwise
+    """
+    user_requirement = state["user_requirement"]
+    
+    system_prompt = (
+        "You are an expert in OpenFOAM workflow analysis. "
+        "Analyze the user requirement to determine if they want visualization of results. "
+        "Look for keywords like: plot, visualize, graph, chart, contour, streamlines, paraview, post-processing."
+        "Only if the user explicitly mentions they want visualization, return 'yes_visualization'. "
+        "If they don't mention visualization or only want to run the simulation, return 'no_visualization'. "
+        "Be conservative - if unsure, assume visualization is wanted unless clearly specified otherwise."
+        "Only return 'yes_visualization' or 'no_visualization'. Don't return anything else."
+    )
+    
+    user_prompt = (
+        f"User requirement: {user_requirement}\n\n"
+        "return 'yes_visualization' or 'no_visualization'"
+    )
+    
+    response = state["llm_service"].invoke(user_prompt, system_prompt)
+    return "yes_visualization" in response.lower()
+
+
+def route_after_architect(state: GraphState):
+    """
+    Route after architect node based on whether user wants custom mesh.
+    For current version, if user wants custom mesh, user should be able to provide a path to the mesh file.
+    """
+    mesh_type = state.get("mesh_type", "standard_mesh")
+    if mesh_type == "custom_mesh":
+        print("Router: Custom mesh requested. Routing to meshing node.")
+        return "meshing"
+    elif mesh_type == "gmsh_mesh":
+        print("Router: GMSH mesh requested. Routing to meshing node.")
+        return "meshing"
+    else:
+        print("Router: Standard mesh generation. Routing to input_writer node.")
+        return "input_writer"
+
+
+def route_after_input_writer(state: GraphState):
+    """
+    Route after input_writer node based on whether user wants to run on HPC.
+    """
+    if llm_requires_hpc(state):
+        print("LLM determined: HPC run requested. Routing to hpc_runner node.")
+        return "hpc_runner"
+    else:
+        print("LLM determined: Local run requested. Routing to local_runner node.")
+        return "local_runner"
+
+def route_after_runner(state: GraphState):
+    if state.get("error_logs") and len(state["error_logs"]) > 0:
+        return "reviewer"
+    elif llm_requires_visualization(state):
+        return "visualization"
+    else:
+        return END
+
+def route_after_reviewer(state: GraphState):
+    loop_count = state.get("loop_count", 0)
+    max_loop = state["config"].max_loop
+    if loop_count >= max_loop:
+        print(f"Maximum loop count ({max_loop}) reached. Ending workflow.")
+        if llm_requires_visualization(state):
+            return "visualization"
+        else:
+            return END
+    print(f"Loop {loop_count}: Continuing to fix errors.")
+
+    return "input_writer"

Foam-Agent/source/src/tracking_aws.py

@@ -0,0 +1,152 @@
+"""
+# Usage
+
+Initialize your client as follows:
+
+```python
+
+import tracking_aws
+
+bedrock_runtime = tracking_aws.new_default_client()
+```
+
+Your usage will be tracked in a local file called `usage_nrel_aws.json`.
+"""
+from __future__ import annotations
+from math import nan
+import itertools
+import os
+import io
+import json
+import pathlib
+from typing import Union, Dict
+import pathlib
+from typing import Any
+from contextlib import contextmanager
+
+import boto3
+
+Usage = Dict[str, Union[int, float]]  # TODO: could have used Counter class
+default_usage_file = pathlib.Path("usage_nrel_aws.json")
+
+CLAUDE_3_5_HAIKU = 'arn:aws:bedrock:us-west-2:991404956194:application-inference-profile/g47vfd2xvs5w'
+CLAUDE_3_5_SONNET = 'arn:aws:bedrock:us-west-2:991404956194:application-inference-profile/56i8iq1vib3e'
+
+# prices match https://aws.amazon.com/bedrock/pricing/ as of January 2025.
+# but they don't consider discounts for caching or batching.
+# Not all models are listed in this file, nor is the fine-tuning API.
+pricing = {  # $ per 1,000 tokens
+    CLAUDE_3_5_HAIKU: {'input': 0.0008, 'output': 0.004},
+    CLAUDE_3_5_SONNET: {'input': 0.003, 'output': 0.015},
+}
+
+# Default models.  These variables can be imported from this module.
+# Even if the system that is being evaluated uses a cheap default_model.
+# one might want to evaluate it carefully using a more expensive default_eval_model.
+default_model = CLAUDE_3_5_HAIKU
+default_eval_model = CLAUDE_3_5_HAIKU
+
+
+# A context manager that lets you temporarily change the default models
+# during a block of code.  You can write things like
+#     with use_model('arn:aws:bedrock:us-west-2:991404956194:application-inference-profile/g47vfd2xvs5w'):
+#        ...
+#
+#     with use_model(eval_model='arn:aws:bedrock:us-west-2:991404956194:application-inference-profile/g47vfd2xvs5w'):
+#        ...
+@contextmanager
+def use_model(model: str = default_model, eval_model: str = default_eval_model):
+    global default_model, default_eval_model
+    save_model, save_eval_model = default_model, default_eval_model
+    default_model, default_eval_model = model, eval_model
+    try:
+        yield
+    finally:
+        default_model, default_eval_model = save_model, save_eval_model
+
+
+def track_usage(client: boto3.client, path: pathlib.Path = default_usage_file) -> boto3.client:
+    """
+    This method modifies (and returns) `client` so that its API calls
+    will log token counts to `path`. If the file does not exist it
+    will be created after the first API call. If the file exists the new
+    counts will be added to it.
+
+    The `read_usage()` function gets a Usage object from the file, e.g.:
+    {
+        "cost": 0.0022136,
+        "input_tokens": 16,
+        "output_tokens": 272
+    }
+
+    >>> client = boto3.client('bedrock')
+    >>> track_usage(client, "example_usage_file.json")
+    >>> type(client)
+    <class 'botocore.client.BaseClient'>
+
+    """
+    old_invoke_model = client.invoke_model
+
+    def tracked_invoke_model(*args, **kwargs) -> Any:
+        response = old_invoke_model(*args, **kwargs)
+        old: Usage = read_usage(path)
+        new, response_body = get_usage(response, model=kwargs.get('modelId', None))
+        _write_usage(_merge_usage(old, new), path)
+        return response_body
+
+    client.invoke_model = tracked_invoke_model  # type:ignore
+    return client
+
+
+def get_usage(response, model=None) -> Usage:
+    """Extract usage info from an AWS Bedrock response."""
+    response_body = json.loads(response['body'].read().decode())
+    usage: Usage = {'input_tokens': response_body['usage']['input_tokens'],
+                    'output_tokens': response_body['usage']['output_tokens']}
+
+    # add a cost field
+    try:
+        costs = pricing[model]  # model name passed in request (may be alias)
+    except KeyError:
+        raise ValueError(f"Don't know prices for model {model} or {response.model}")
+
+    cost = (usage.get('input_tokens', 0) * costs['input']
+            + usage.get('output_tokens', 0) * costs['output']) / 1_000
+    usage['cost'] = cost
+    return usage, response_body
+
+
+def read_usage(path: pathlib.Path = default_usage_file) -> Usage:
+    """Retrieve total usage logged in a file."""
+    if os.path.exists(path):
+        with open(path, "rt") as f:
+            return json.load(f)
+    else:
+        return {}
+
+
+def _write_usage(u: Usage, path: pathlib.Path):
+    with open(path, "wt") as f:
+        json.dump(u, f, indent=4)
+
+
+def _merge_usage(u1: Usage, u2: Usage) -> Usage:
+    return {k: u1.get(k, 0) + u2.get(k, 0) for k in itertools.chain(u1, u2)}
+
+
+def new_default_client(default='boto3') -> boto3.client:
+    """Set the `default_client` to a new tracked client, based on the current
+    aws credentials. If your credentials change you should call this method again."""
+    global default_client
+    default_client = track_usage(
+        boto3.client('bedrock-runtime', region_name='us-west-2'))  # create a client with default args, and modify it
+    # so that it will store its usage in a local file
+    return default_client
+
+
+# new_default_client()       # set `default_client` right away when importing this module
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Foam-Agent/source/src/utils.py

@@ -0,0 +1,535 @@
+# utils.py
+import re
+import subprocess
+import os
+from typing import Optional, Any, Type, TypedDict, List
+from pydantic import BaseModel, Field
+from langchain.chat_models import init_chat_model
+from langchain_community.vectorstores import FAISS
+from langchain_openai.embeddings import OpenAIEmbeddings
+from langchain_aws import ChatBedrock, ChatBedrockConverse
+from langchain_anthropic import ChatAnthropic
+from pathlib import Path
+import tracking_aws
+import requests
+import time
+import random
+from botocore.exceptions import ClientError
+import shutil
+from config import Config
+from langchain_ollama import ChatOllama
+
+# Global dictionary to store loaded FAISS databases
+FAISS_DB_CACHE = {}
+DATABASE_DIR = f"{Path(__file__).resolve().parent.parent}/database/faiss"
+
+FAISS_DB_CACHE = {
+    "openfoam_allrun_scripts": FAISS.load_local(f"{DATABASE_DIR}/openfoam_allrun_scripts", OpenAIEmbeddings(model="text-embedding-3-small"), allow_dangerous_deserialization=True),
+    "openfoam_tutorials_structure": FAISS.load_local(f"{DATABASE_DIR}/openfoam_tutorials_structure", OpenAIEmbeddings(model="text-embedding-3-small"), allow_dangerous_deserialization=True),
+    "openfoam_tutorials_details": FAISS.load_local(f"{DATABASE_DIR}/openfoam_tutorials_details", OpenAIEmbeddings(model="text-embedding-3-small"), allow_dangerous_deserialization=True),
+    "openfoam_command_help": FAISS.load_local(f"{DATABASE_DIR}/openfoam_command_help", OpenAIEmbeddings(model="text-embedding-3-small"), allow_dangerous_deserialization=True)
+}
+
+class FoamfilePydantic(BaseModel):
+    file_name: str = Field(description="Name of the OpenFOAM input file")
+    folder_name: str = Field(description="Folder where the foamfile should be stored")
+    content: str = Field(description="Content of the OpenFOAM file, written in OpenFOAM dictionary format")
+
+class FoamPydantic(BaseModel):
+    list_foamfile: List[FoamfilePydantic] = Field(description="List of OpenFOAM configuration files")
+
+class ResponseWithThinkPydantic(BaseModel):
+    think: str = Field(description="Thought process of the LLM")
+    response: str = Field(description="Response of the LLM")
+    
+class LLMService:
+    def __init__(self, config: object):
+        self.model_version = getattr(config, "model_version", "gpt-4o")
+        self.temperature = getattr(config, "temperature", 0)
+        self.model_provider = getattr(config, "model_provider", "openai")
+        
+        # Initialize statistics
+        self.total_calls = 0
+        self.total_prompt_tokens = 0
+        self.total_completion_tokens = 0
+        self.total_tokens = 0
+        self.failed_calls = 0
+        self.retry_count = 0
+        
+        # Initialize the LLM
+        if self.model_provider.lower() == "bedrock":
+            bedrock_runtime = tracking_aws.new_default_client()
+            self.llm = ChatBedrockConverse(
+                client=bedrock_runtime, 
+                model_id=self.model_version, 
+                temperature=self.temperature, 
+                max_tokens=8192
+            )
+        elif self.model_provider.lower() == "anthropic":
+            self.llm = ChatAnthropic(
+                model=self.model_version, 
+                temperature=self.temperature
+            )
+        elif self.model_provider.lower() == "openai":
+            self.llm = init_chat_model(
+                self.model_version, 
+                model_provider=self.model_provider, 
+                temperature=self.temperature
+            )
+        elif self.model_provider.lower() == "ollama":
+            try:
+                response = requests.get("http://localhost:11434/api/version", timeout=2)
+                # If request successful, service is running
+            except requests.exceptions.RequestException:
+                print("Ollama is not running, starting it...")
+                subprocess.Popen(["ollama", "serve"], 
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE)
+                # Wait for service to start
+                time.sleep(5)  # Give it 3 seconds to initialize
+
+            self.llm = ChatOllama(
+                model=self.model_version, 
+                temperature=self.temperature,
+                num_predict=-1,
+                num_ctx=131072,
+                base_url="http://localhost:11434"
+            )
+        else:
+            raise ValueError(f"{self.model_provider} is not a supported model_provider")
+    
+    def invoke(self, 
+              user_prompt: str, 
+              system_prompt: Optional[str] = None, 
+              pydantic_obj: Optional[Type[BaseModel]] = None,
+              max_retries: int = 10) -> Any:
+        """
+        Invoke the LLM with the given prompts and return the response.
+        
+        Args:
+            user_prompt: The user's prompt
+            system_prompt: Optional system prompt
+            pydantic_obj: Optional Pydantic model for structured output
+            max_retries: Maximum number of retries for throttling errors
+            
+        Returns:
+            The LLM response with token usage statistics
+        """
+        self.total_calls += 1
+        
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": user_prompt})
+        
+        # Calculate prompt tokens
+        prompt_tokens = 0
+        for message in messages:
+            prompt_tokens += self.llm.get_num_tokens(message["content"])
+        
+        retry_count = 0
+        while True:
+            try:
+                if pydantic_obj:
+                    structured_llm = self.llm.with_structured_output(pydantic_obj)
+                    response = structured_llm.invoke(messages)
+                else:
+                    if self.model_version.startswith("deepseek"):
+                        structured_llm = self.llm.with_structured_output(ResponseWithThinkPydantic)
+                        response = structured_llm.invoke(messages)
+
+                        # Extract the resposne without the think
+                        response = response.response
+                    else:
+                        response = self.llm.invoke(messages)
+                        response = response.content
+
+                # Calculate completion tokens
+                response_content = str(response)
+                completion_tokens = self.llm.get_num_tokens(response_content)
+                total_tokens = prompt_tokens + completion_tokens
+                
+                # Update statistics
+                self.total_prompt_tokens += prompt_tokens
+                self.total_completion_tokens += completion_tokens
+                self.total_tokens += total_tokens
+                
+                return response
+                
+            except ClientError as e:
+                if e.response['Error']['Code'] == 'Throttling' or e.response['Error']['Code'] == 'TooManyRequestsException':
+                    retry_count += 1
+                    self.retry_count += 1
+                    
+                    if retry_count > max_retries:
+                        self.failed_calls += 1
+                        raise Exception(f"Maximum retries ({max_retries}) exceeded: {str(e)}")
+                    
+                    base_delay = 1.0
+                    max_delay = 60.0
+                    delay = min(max_delay, base_delay * (2 ** (retry_count - 1)))
+                    jitter = random.uniform(0, 0.1 * delay)
+                    sleep_time = delay + jitter
+                    
+                    print(f"ThrottlingException occurred: {str(e)}. Retrying in {sleep_time:.2f} seconds (attempt {retry_count}/{max_retries})")
+                    time.sleep(sleep_time)
+                else:
+                    self.failed_calls += 1
+                    raise e
+            except Exception as e:
+                self.failed_calls += 1
+                raise e
+    
+    def get_statistics(self) -> dict:
+        """
+        Get the current statistics of the LLM service.
+        
+        Returns:
+            Dictionary containing various statistics
+        """
+        return {
+            "total_calls": self.total_calls,
+            "failed_calls": self.failed_calls,
+            "retry_count": self.retry_count,
+            "total_prompt_tokens": self.total_prompt_tokens,
+            "total_completion_tokens": self.total_completion_tokens,
+            "total_tokens": self.total_tokens,
+            "average_prompt_tokens": self.total_prompt_tokens / self.total_calls if self.total_calls > 0 else 0,
+            "average_completion_tokens": self.total_completion_tokens / self.total_calls if self.total_calls > 0 else 0,
+            "average_tokens": self.total_tokens / self.total_calls if self.total_calls > 0 else 0
+        }
+    
+    def print_statistics(self) -> None:
+        """
+        Print the current statistics of the LLM service.
+        """
+        stats = self.get_statistics()
+        print("\n<LLM Service Statistics>")
+        print(f"Total calls: {stats['total_calls']}")
+        print(f"Failed calls: {stats['failed_calls']}")
+        print(f"Total retries: {stats['retry_count']}")
+        print(f"Total prompt tokens: {stats['total_prompt_tokens']}")
+        print(f"Total completion tokens: {stats['total_completion_tokens']}")
+        print(f"Total tokens: {stats['total_tokens']}")
+        print(f"Average prompt tokens per call: {stats['average_prompt_tokens']:.2f}")
+        print(f"Average completion tokens per call: {stats['average_completion_tokens']:.2f}")
+        print(f"Average tokens per call: {stats['average_tokens']:.2f}\n")
+        print("</LLM Service Statistics>")
+
+class GraphState(TypedDict):
+    user_requirement: str
+    config: Config
+    case_dir: str
+    tutorial: str
+    case_name: str
+    subtasks: List[dict]
+    current_subtask_index: int
+    error_command: Optional[str]
+    error_content: Optional[str]
+    loop_count: int
+    # Additional state fields that will be added during execution
+    llm_service: Optional['LLMService']
+    case_stats: Optional[dict]
+    tutorial_reference: Optional[str]
+    case_path_reference: Optional[str]
+    dir_structure_reference: Optional[str]
+    case_info: Optional[str]
+    allrun_reference: Optional[str]
+    dir_structure: Optional[dict]
+    commands: Optional[List[str]]
+    foamfiles: Optional[dict]
+    error_logs: Optional[List[str]]
+    history_text: Optional[List[str]]
+    case_domain: Optional[str]
+    case_category: Optional[str]
+    case_solver: Optional[str]
+    # Mesh-related state fields
+    mesh_info: Optional[dict]
+    mesh_commands: Optional[List[str]]
+    custom_mesh_used: Optional[bool]
+    mesh_type: Optional[str]
+    custom_mesh_path: Optional[str]
+    # Review and rewrite related fields
+    review_analysis: Optional[str]
+    input_writer_mode: Optional[str]
+    # HPC-related fields
+    job_id: Optional[str]
+    cluster_info: Optional[dict]
+    slurm_script_path: Optional[str]
+
+def tokenize(text: str) -> str:
+    # Replace underscores with spaces
+    text = text.replace('_', ' ')
+    # Insert a space between a lowercase letter and an uppercase letter (global match)
+    text = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', text)
+    return text.lower()
+
+def save_file(path: str, content: str) -> None:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, 'w') as f:
+        f.write(content)
+    print(f"Saved file at {path}")
+
+def read_file(path: str) -> str:
+    if os.path.exists(path):
+        with open(path, 'r') as f:
+            return f.read()
+    return ""
+
+def list_case_files(case_dir: str) -> str:
+    files = [f for f in os.listdir(case_dir) if os.path.isfile(os.path.join(case_dir, f))]
+    return ", ".join(files)
+
+def remove_files(directory: str, prefix: str) -> None:
+    for file in os.listdir(directory):
+        if file.startswith(prefix):
+            os.remove(os.path.join(directory, file))
+    print(f"Removed files with prefix '{prefix}' in {directory}")
+
+def remove_file(path: str) -> None:
+    if os.path.exists(path):
+        os.remove(path)
+        print(f"Removed file {path}")
+
+def remove_numeric_folders(case_dir: str) -> None:
+    """
+    Remove all folders in case_dir that represent numeric values, including those with decimal points,
+    except for the "0" folder.
+    
+    Args:
+        case_dir (str): The directory path to process
+    """
+    for item in os.listdir(case_dir):
+        item_path = os.path.join(case_dir, item)
+        if os.path.isdir(item_path) and item != "0":
+            try:
+                # Try to convert to float to check if it's a numeric value
+                float(item)
+                # If conversion succeeds, it's a numeric folder
+                try:
+                    shutil.rmtree(item_path)
+                    print(f"Removed numeric folder: {item_path}")
+                except Exception as e:
+                    print(f"Error removing folder {item_path}: {str(e)}")
+            except ValueError:
+                # Not a numeric value, so we keep this folder
+                pass
+
+def run_command(script_path: str, out_file: str, err_file: str, working_dir: str, config : Config) -> None:
+    print(f"Executing script {script_path} in {working_dir}")
+    os.chmod(script_path, 0o777)
+    openfoam_dir = os.getenv("WM_PROJECT_DIR")
+    command = f"source {openfoam_dir}/etc/bashrc && bash {os.path.abspath(script_path)}"
+    timeout_seconds = config.max_time_limit
+
+    with open(out_file, 'w') as out, open(err_file, 'w') as err:
+        process = subprocess.Popen(
+            ['bash', "-c", command],
+            cwd=working_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            stdin=subprocess.DEVNULL,
+            text=True
+        )
+        # stdout, stderr = process.communicate()
+        # out.write(stdout)
+        # err.write(stderr)
+
+        try:
+            stdout, stderr = process.communicate(timeout=timeout_seconds)
+            out.write(stdout)
+            err.write(stderr)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            stdout, stderr = process.communicate()
+            timeout_message = (
+                "OpenFOAM execution took too long. "
+                "This case, if set up right, does not require such large execution times.\n"
+            )
+            out.write(timeout_message + stdout)
+            err.write(timeout_message + stderr)
+            print(f"Execution timed out: {script_path}")
+
+    
+
+    print(f"Executed script {script_path}")
+
+def check_foam_errors(directory: str) -> list:
+    error_logs = []
+    # DOTALL mode allows '.' to match newline characters
+    pattern = re.compile(r"ERROR:(.*)", re.DOTALL)
+    
+    for file in os.listdir(directory):
+        if file.startswith("log"):
+            filepath = os.path.join(directory, file)
+            with open(filepath, 'r') as f:
+                content = f.read()
+            
+            match = pattern.search(content)
+            if match:
+                error_content = match.group(0).strip()
+                error_logs.append({"file": file, "error_content": error_content})
+            elif "error" in content.lower():
+                print(f"Warning: file {file} contains 'error' but does not match expected format.")
+    return error_logs
+
+def extract_commands_from_allrun_out(out_file: str) -> list:
+    commands = []
+    if not os.path.exists(out_file):
+        return commands
+    with open(out_file, 'r') as f:
+        for line in f:
+            if line.startswith("Running "):
+                parts = line.split(" ")
+                if len(parts) > 1:
+                    commands.append(parts[1].strip())
+    return commands
+
+def parse_case_name(text: str) -> str:
+    match = re.search(r'case name:\s*(.+)', text, re.IGNORECASE)
+    return match.group(1).strip() if match else "default_case"
+
+def split_subtasks(text: str) -> list:
+    header_match = re.search(r'splits into (\d+) subtasks:', text, re.IGNORECASE)
+    if not header_match:
+        print("Warning: No subtasks header found in the response.")
+        return []
+    num_subtasks = int(header_match.group(1))
+    subtasks = re.findall(r'subtask\d+:\s*(.*)', text, re.IGNORECASE)
+    if len(subtasks) != num_subtasks:
+        print(f"Warning: Expected {num_subtasks} subtasks but found {len(subtasks)}.")
+    return subtasks
+
+def parse_context(text: str) -> str:
+    match = re.search(r'FoamFile\s*\{.*?(?=```|$)', text, re.DOTALL | re.IGNORECASE)
+    if match:
+        return match.group(0).strip()
+    
+    print("Warning: Could not parse context; returning original text.")
+    return text
+
+
+def parse_file_name(subtask: str) -> str:
+    match = re.search(r'openfoam\s+(.*?)\s+foamfile', subtask, re.IGNORECASE)
+    return match.group(1).strip() if match else ""
+
+def parse_folder_name(subtask: str) -> str:
+    match = re.search(r'foamfile in\s+(.*?)\s+folder', subtask, re.IGNORECASE)
+    return match.group(1).strip() if match else ""
+
+def find_similar_file(description: str, tutorial: str) -> str:
+    start_pos = tutorial.find(description)
+    if start_pos == -1:
+        return "None"
+    end_marker = "input_file_end."
+    end_pos = tutorial.find(end_marker, start_pos)
+    if end_pos == -1:
+        return "None"
+    return tutorial[start_pos:end_pos + len(end_marker)]
+
+def read_commands(file_path: str) -> str:
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Commands file not found: {file_path}")
+    with open(file_path, 'r') as f:
+        # join non-empty lines with a comma
+        return ", ".join(line.strip() for line in f if line.strip())
+
+def find_input_file(case_dir: str, command: str) -> str:
+    for root, _, files in os.walk(case_dir):
+        for file in files:
+            if command in file:
+                return os.path.join(root, file)
+    return ""
+
+def retrieve_faiss(database_name: str, query: str, topk: int = 1) -> dict:
+    """
+    Retrieve a similar case from a FAISS database.
+    """
+    
+    if database_name not in FAISS_DB_CACHE:
+        raise ValueError(f"Database '{database_name}' is not loaded.")
+    
+    # Tokenize the query
+    query = tokenize(query)
+    
+    vectordb = FAISS_DB_CACHE[database_name]
+    docs = vectordb.similarity_search(query, k=topk)
+    if not docs:
+        raise ValueError(f"No documents found for query: {query}")
+    
+    formatted_results = []
+    for doc in docs:
+        metadata = doc.metadata or {}
+        
+        if database_name == "openfoam_allrun_scripts":
+            formatted_results.append({
+                "index": doc.page_content,
+                "full_content": metadata.get("full_content", "unknown"),
+                "case_name": metadata.get("case_name", "unknown"),
+                "case_domain": metadata.get("case_domain", "unknown"),
+                "case_category": metadata.get("case_category", "unknown"),
+                "case_solver": metadata.get("case_solver", "unknown"),
+                "dir_structure": metadata.get("dir_structure", "unknown"),
+                "allrun_script": metadata.get("allrun_script", "N/A")
+            })
+        elif database_name == "openfoam_command_help":
+            formatted_results.append({
+                "index": doc.page_content,
+                "full_content": metadata.get("full_content", "unknown"),
+                "command": metadata.get("command", "unknown"),
+                "help_text": metadata.get("help_text", "unknown")
+            })
+        elif database_name == "openfoam_tutorials_structure":
+            formatted_results.append({
+                "index": doc.page_content,
+                "full_content": metadata.get("full_content", "unknown"),
+                "case_name": metadata.get("case_name", "unknown"),
+                "case_domain": metadata.get("case_domain", "unknown"),
+                "case_category": metadata.get("case_category", "unknown"),
+                "case_solver": metadata.get("case_solver", "unknown"),
+                "dir_structure": metadata.get("dir_structure", "unknown")
+            })
+        elif database_name == "openfoam_tutorials_details":
+            formatted_results.append({
+                "index": doc.page_content,
+                "full_content": metadata.get("full_content", "unknown"),
+                "case_name": metadata.get("case_name", "unknown"),
+                "case_domain": metadata.get("case_domain", "unknown"),
+                "case_category": metadata.get("case_category", "unknown"),
+                "case_solver": metadata.get("case_solver", "unknown"),
+                "dir_structure": metadata.get("dir_structure", "unknown"),
+                "tutorials": metadata.get("tutorials", "N/A")
+            })
+        else:
+            raise ValueError(f"Unknown database name: {database_name}")
+    
+    
+
+    return formatted_results
+        
+
+def parse_directory_structure(data: str) -> dict:
+    """
+    Parses the directory structure string and returns a dictionary where:
+      - Keys: directory names
+      - Values: count of files in that directory.
+    """
+    directory_file_counts = {}
+
+    # Find all <dir>...</dir> blocks in the input string.
+    dir_blocks = re.findall(r'<dir>(.*?)</dir>', data, re.DOTALL)
+
+    for block in dir_blocks:
+        # Extract the directory name (everything after "directory name:" until the first period)
+        dir_name_match = re.search(r'directory name:\s*(.*?)\.', block)
+        # Extract the list of file names within square brackets
+        files_match = re.search(r'File names in this directory:\s*\[(.*?)\]', block)
+        
+        if dir_name_match and files_match:
+            dir_name = dir_name_match.group(1).strip()
+            files_str = files_match.group(1)
+            # Split the file names by comma, removing any surrounding whitespace
+            file_list = [filename.strip() for filename in files_str.split(',')]
+            directory_file_counts[dir_name] = len(file_list)
+
+    return directory_file_counts

README.md

@@ -1,10 +1,146 @@
----
-title: Code2MCP FoamAgent
-emoji: 🐨
-colorFrom: red
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Code2MCP-FoamAgent
+
+Foam-Agent 的 MCP (Model Context Protocol) 服务包装器，提供基于自然语言的 OpenFOAM CFD 仿真工作流。
+
+## 功能特性
+
+- 🧪 基于自然语言的 CFD 仿真需求
+- 🤖 多智能体工作流自动化
+- 📊 自动错误检测和修正
+- 🔧 自定义网格支持 (GMSH .msh 文件)
+- 🌐 多种 LLM 提供商支持
+
+## 快速开始
+
+### 1. 环境配置
+
+复制环境变量模板并配置：
+
+```bash
+cp env.example .env
+```
+
+编辑 `.env` 文件，设置您的 API 密钥：
+
+```env
+# OpenAI API Configuration
+OPENAI_API_KEY=your_openai_api_key_here
+OPENAI_BASE_URL=https://api.openai.com/v1
+
+# 或者使用自定义 API 端点
+# OPENAI_BASE_URL=https://api.gptsapi.net/v1
+```
+
+### 2. 安装依赖
+
+#### 使用 conda（推荐）
+
+```bash
+# 创建 conda 环境
+conda env create -f environment.yml
+
+# 激活环境
+conda activate openfoamAgent
+
+# 安装额外的 MCP 依赖
+pip install fastapi uvicorn[standard] fastmcp
+```
+
+### 3. 运行 MCP 服务
+
+```bash
+python Foam-Agent/mcp_output/start_mcp.py
+```
+
+### 4. Docker 部署
+
+#### 方法一：使用 .env 文件（推荐）
+
+```bash
+# 1. 创建 .env 文件
+cp env.example .env
+# 编辑 .env 文件，填入您的 API 密钥
+
+# 2. 使用 docker-compose（推荐）
+docker-compose up -d
+
+# 3. 或者使用 docker run
+docker run -p 7860:7860 --env-file .env code2mcp-foamagent
+```
+
+#### 方法二：直接设置环境变量
+
+```bash
+# 构建镜像
+docker build -t code2mcp-foamagent .
+
+# 运行容器（设置环境变量）
+docker run -p 7860:7860 \
+  -e OPENAI_API_KEY=your_api_key_here \
+  -e OPENAI_BASE_URL=https://api.openai.com/v1 \
+  code2mcp-foamagent
+```
+
+## 使用方法
+
+### 基本 CFD 仿真
+
+```python
+# 运行简单的 CFD 仿真
+result = run_foam_agent(
+    requirements="Do an incompressible lid driven cavity flow...",
+    output_dir="./output"
+)
+```
+
+### 使用自定义网格
+
+```python
+# 使用自定义 GMSH 网格文件
+result = run_foam_agent(
+    requirements="Simulate flow over a tandem wing...",
+    output_dir="./output",
+    custom_mesh="./tandem_wing.msh"
+)
+```
+
+### 完整基准测试
+
+```python
+# 运行完整的 Foam-Agent 基准测试
+result = run_foam_benchmark(
+    openfoam_path="/opt/openfoam10",
+    requirements="Your CFD requirements...",
+    output_dir="./output"
+)
+```
+
+## 环境变量
+
+| 变量名 | 描述 | 默认值 |
+|--------|------|--------|
+| `OPENAI_API_KEY` | OpenAI API 密钥 | 必需 |
+| `OPENAI_BASE_URL` | OpenAI API 基础 URL | `https://api.openai.com/v1` |
+| `WM_PROJECT_DIR` | OpenFOAM 安装路径 | `/opt/openfoam10` |
+| `MODEL_PROVIDER` | LLM 提供商 | `openai` |
+| `MODEL_VERSION` | 模型版本 | `gpt-4o` |
+| `MCP_TRANSPORT` | MCP 传输模式 | `http` |
+| `MCP_PORT` | MCP 服务端口 | `7860` |
+
+## 系统要求
+
+- Python 3.11+
+- OpenFOAM v10
+- OpenAI API 密钥或其他 LLM 提供商
+- 预处理的 OpenFOAM 数据库
+
+## 故障排除
+
+1. **检查系统状态**：使用 `check_foam_agent_status` 工具
+2. **验证 API 配置**：确保 API 密钥和 URL 正确设置
+3. **检查依赖**：确保所有 Python 包已正确安装
+4. **OpenFOAM 环境**：确保 OpenFOAM 已正确安装并配置
+
+## 许可证
+
+MIT License

app.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+import os
+
+app = FastAPI()
+
+
+@app.get("/")
+async def root():
+    return {
+        "status": "ok",
+        "service": "Code2MCP-FoamAgent",
+        "transport": os.environ.get("MCP_TRANSPORT", "stdio"),
+    }

docker-compose.yml

@@ -0,0 +1,16 @@
+version: '3.8'
+
+services:
+  foam-agent-mcp:
+    build: .
+    ports:
+      - "7860:7860"
+    env_file:
+      - .env
+    environment:
+      - MCP_TRANSPORT=http
+      - MCP_PORT=7860
+      - CONDA_DEFAULT_ENV=openfoamAgent
+    volumes:
+      - ./output:/app/output
+    restart: unless-stopped