AutoSAM: an Agentic Framework for Automating Input File Generation for the SAM Code with Multi-Modal Retrieval-Augmented Generation

AutoSAM is an agentic framework that automates the generation of System Analysis Module (SAM) input files for advanced reactor design by integrating multi-modal retrieval-augmented generation to extract and synthesize simulation parameters from heterogeneous engineering documents, achieving high accuracy across diverse thermal-hydraulic case studies.

The Gist

Imagine you are a master chef trying to recreate a complex, famous dish from a recipe book. But here's the catch: the recipe isn't written in a single, clear cookbook. Instead, the ingredients are scattered across:

• A blurry photo of the finished dish on a napkin.
• A handwritten note on a sticky pad.
• A spreadsheet with numbers that don't quite match the photo.
• A technical manual written in a language you only half-understand.

To cook the dish, you have to manually read all these different sources, figure out what the chef actually meant, write down a perfect, step-by-step list of instructions, and then translate that into the specific language your oven understands. If you make a tiny mistake in the translation, the oven might explode, or the food might be inedible.

This is exactly the problem nuclear engineers face.

They need to build computer simulations of nuclear reactors to ensure they are safe. But to do this, they have to manually dig through piles of messy engineering documents (PDFs, diagrams, spreadsheets) and type out thousands of lines of code for a specific computer program called SAM. It's slow, boring, and prone to human error.

Enter AutoSAM: The "Super Sous-Chef"

The paper introduces AutoSAM, an AI agent (a smart computer assistant) designed to be the ultimate "sous-chef" for these engineers. Instead of the engineer doing all the digging and typing, AutoSAM does the heavy lifting.

Here is how it works, using simple metaphors:

1. The "Multilingual Librarian" (Multi-Modal Retrieval)

Usually, AI is like a student who only reads text. If you show it a picture of a pipe, it might be confused. AutoSAM is different. It has eyes and a brain.

• It can read a PDF report (text).
• It can look at a diagram (image) and understand that a circle represents a pump and a line represents a pipe.
• It can open an Excel sheet and see the numbers.
• It acts like a librarian who can instantly find the right page in a book, look at a picture on that page, and tell you exactly what the numbers mean, all at the same time.

2. The "Rulebook Expert" (Retrieval-Augmented Generation)

AI often "hallucinates" (makes things up) because it doesn't know the specific rules of nuclear physics. AutoSAM doesn't guess.

• It has a digital copy of the SAM User Manual right next to it.
• Before it writes a single line of code, it asks the manual: "How do I tell the computer to set the temperature?"
• It uses Retrieval-Augmented Generation (RAG), which is like having a cheat sheet that it constantly checks to ensure it's following the exact rules of the game.

3. The "Safety Inspector" (The Human-in-the-Loop)

This is the most important part. AutoSAM is smart, but it's not allowed to just hit "Run" on a nuclear simulation by itself.

• Step 1: AutoSAM reads the messy documents and creates a clean, organized "shopping list" (an intermediate file).
• Step 2: A human engineer looks at this list. They say, "Yes, that pipe looks right, but you missed the pressure valve. Let me fix that."
• Step 3: Once the human approves the list, AutoSAM translates it into the final, complex code the computer needs.

This ensures that a human is always the final boss, checking the work before anything dangerous happens.

The "Test Drive" Results

The authors tested AutoSAM on four different "recipes," getting harder each time:

1. The Simple Pipe: Just a straight pipe. AutoSAM got it right 100% of the time using a spreadsheet.
2. The Hot Fuel Rod: A pipe with a fuel rod inside that gets hot. AutoSAM handled the complex physics correctly.
3. The Reactor Core (ABTR): A complex system with five parallel pipes. AutoSAM had to read a diagram and a PDF to figure out how they connected. It did this perfectly, even inferring missing details.
4. The Full Loop (MSRE): A giant, circulating loop with pumps and heat exchangers. AutoSAM reconstructed the entire system from a messy drawing and a report, creating a working simulation.

Why This Matters

Before AutoSAM, building a reactor simulation was like building a house by hand, brick by brick, while reading a blueprint written in a foreign language. It took weeks.

With AutoSAM, it's like having a robot that can read the blueprint, understand the foreign language, gather the bricks, and lay them out for you. You just have to walk through and say, "That wall looks good, but move the door here."

The Bottom Line:
AutoSAM doesn't replace the nuclear engineer. Instead, it frees them from the boring, error-prone task of typing data. It lets them focus on the thinking and the safety, while the AI handles the typing and the searching. It turns "modeling" into "prompting"—you tell the AI what you want, and it builds the foundation for you.

Technical Summary

1. Problem Statement

In the design and safety analysis of advanced nuclear reactors (e.g., Sodium-cooled Fast Reactors, Molten Salt Reactors), constructing input files for system-level thermal-hydraulics codes like SAM (System Analysis Module) is a major bottleneck.

• Labor Intensity: Analysts must manually extract data from heterogeneous engineering documents (PDF reports, system diagrams, spreadsheets, images) and transcribe them into solver-specific syntax.
• Error Prone: This manual process is iterative, requiring the reconciliation of inconsistent data across text, tables, and figures. Errors in input files can lead to non-conservative safety margins.
• Limitations of Existing Automation: Current automation relies on Optical Character Recognition (OCR) or rule-based extraction, which fail to interpret complex visual data (diagrams, schematics) or handle fragmented information across multiple document types. Furthermore, Large Language Models (LLMs) lack specific training data for closed-source codes like SAM, leading to hallucinations when prompted without external context.

2. Methodology: The AutoSAM Framework

The authors propose AutoSAM, an agentic framework that automates input file generation by combining a ReAct-based LLM agent with Retrieval-Augmented Generation (RAG) and specialized tools. The framework operates on a "human-in-the-loop" philosophy, ensuring safety and traceability.

Core Architecture

The framework utilizes three complementary strategies to specialize the LLM:

1. System Instructions: Persistent, engineered instructions derived from the SAM user guide and theory manual define the agent's role, input file structure, and modeling conventions.
2. Retrieval-Augmented Generation (RAG): The agent accesses a vector store containing the SAM theory manual and user guide. It retrieves relevant technical context based on the user's query rather than relying solely on pre-trained weights.
3. Specialized Tool Suite: The agent is equipped with seven tools to handle multi-modal data and execution:
   • Content Parsing Tools: Readers for Excel and text files to extract tabulated data.
   • Retrieval Tools:
     • PDF Analysis Tool: Uses the Nougat model (vision-to-text for scientific papers) to extract text, equations, and tables. It also employs Vision-Language Models (VLMs) to interpret figures, generate descriptions, and create semantic embeddings for retrieval.
     • Image Analysis Tool: Scans image folders, generates natural language descriptions of schematics/diagrams using VLMs, and embeds them for similarity-based retrieval.
   • Instruction Passing Tools:
     • Input File Creator: Transforms intermediate structured data into the final SAM input syntax.
     • Input File Validator: Performs deterministic syntax checks and physics verification (units, connectivity, boundary conditions).
   • Python Execution Tool: Allows the agent to run code for calculations.

Workflow

1. Ingestion: The agent ingests unstructured documents (PDFs, images, spreadsheets).
2. Extraction & Reasoning: Using the tool suite, the agent extracts parameters, interprets diagrams, and reconciles data.
3. Intermediate Representation: The agent generates a human-auditable intermediate structured file (YAML). This is a critical checkpoint where domain experts can verify, edit, and augment the extracted data before final generation.
4. Synthesis: The agent converts the validated intermediate file into a solver-compatible SAM input deck.
5. Validation: The input file is checked for completeness and consistency.

3. Key Contributions

• Multi-Modal Document Processing: Unlike previous text-only approaches, AutoSAM successfully integrates the interpretation of engineering diagrams, schematics, and tables alongside narrative text to reconstruct system topology and parameters.
• Agentic RAG for Closed-Source Codes: The framework demonstrates how to adapt general-purpose LLMs to specialized, closed-source engineering codes (SAM) by combining system instructions with a domain-specific RAG pipeline.
• Human-in-the-Loop Safety Mechanism: The introduction of the intermediate structured file ensures that human experts retain control over critical modeling decisions, addressing safety and regulatory concerns inherent in nuclear engineering.
• End-to-End Automation Pipeline: The system moves from raw heterogeneous documents to a validated, executable simulation model, explicitly flagging missing data and assumptions.

4. Results and Evaluation

The framework was evaluated on four case studies of increasing complexity:

1. Single-Pipe Steady-State Model: Validated the agent's ability to translate structured spreadsheet data into a valid 1-D flow model.
   • Result: 100% utilization of structured inputs; results matched expected physical behavior (constant temperature profile).
2. Solid-Fuel Channel with Reactivity Feedback: Tested multi-physics coupling (fluid flow + heat transfer + kinetics).
   • Result: Successfully generated transient models with temperature-dependent reactivity feedback, correctly simulating the stabilizing effect of negative feedback.
3. Advanced Burner Test Reactor (ABTR) Core: Required extracting topology from an image and parameters from a PDF.
   • Result: The agent reconstructed a 5-channel parallel flow model. It achieved 100% completeness in vision-based geometric extraction and ~88% recall in PDF text extraction.
4. Molten Salt Reactor Experiment (MSRE) Primary Loop: A complex circulating loop with multiple components (core, pump, heat exchanger).
   • Result: The agent successfully reconstructed the loop connectivity from a 2-D schematic and generated a model exhibiting correct hot-leg/cold-leg temperature distributions.

Quantitative Metrics:

• Structured Data Usage: 100% (all Excel parameters utilized).
• PDF Text Extraction: ~88% (45/51 items retrieved).
• Vision-Based Geometric Extraction: 100% (37/37 attributes recovered, including inferred dimensions).

5. Significance and Impact

• Paradigm Shift: The paper proposes a shift toward "Prompt-Driven Reactor Modeling," where analysts provide system descriptions and documentation, and the agent translates this intent into executable simulations.
• Productivity: It significantly reduces the time analysts spend on data transcription and manual model assembly, allowing them to focus on model fidelity and scenario analysis.
• Traceability: By explicitly labeling assumed values and missing data, the framework enhances the transparency and reproducibility of safety analyses.
• Future Applicability: While demonstrated on SAM, the modular architecture (solver-agnostic tools + solver-specific instructions) suggests the framework can be adapted to other system codes (e.g., RELAP5, TRACE) and broader engineering domains.

The study concludes that while LLMs have limitations (e.g., potential hallucinations), a tool-augmented, human-supervised agentic framework offers a practical and safe path to automating complex engineering modeling workflows.