Metadata-Version: 2.4
Name: chemgraph
Version: 0.6.0
Summary: A computational chemistry agent for molecular simulation tasks.
Author-email: Thang Pham <tpham@anl.gov>, Murat Keçeli <keceli@anl.gov>, Aditya Tanikanti <atanikanti@anl.gov>
Project-URL: Homepage, https://github.com/argonne-lcf/ChemGraph
Project-URL: Repository, https://github.com/argonne-lcf/ChemGraph
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: langgraph==0.4.7
Requires-Dist: langgraph-checkpoint==2.1.0
Requires-Dist: langgraph-prebuilt==0.5.2
Requires-Dist: langgraph-sdk==0.1.72
Requires-Dist: langchain
Requires-Dist: langchain-openai
Requires-Dist: langchain-ollama
Requires-Dist: langchain-anthropic
Requires-Dist: langchain-google-genai
Requires-Dist: langchain-groq
Requires-Dist: langchain-experimental
Requires-Dist: langchain-mcp-adapters
Requires-Dist: pydantic
Requires-Dist: pandas==2.2.3
Requires-Dist: pubchempy==1.0.5
Requires-Dist: pyppeteer==2.0.0
Requires-Dist: numpy==2.2.6
Requires-Dist: numexpr==2.11.0
Requires-Dist: pytest==8.4.1
Requires-Dist: deepdiff==8.5.0
Requires-Dist: ase
Requires-Dist: rdkit
Requires-Dist: pymatgen
Requires-Dist: mace-torch
Requires-Dist: globus_sdk
Requires-Dist: streamlit==1.48.1
Requires-Dist: stmol==0.0.9
Requires-Dist: ipython-genutils==0.2.0
Requires-Dist: langsmith==0.3.45
Requires-Dist: rich==14.1.0
Requires-Dist: toml==0.10.2
Requires-Dist: mcp
Requires-Dist: fastmcp
Requires-Dist: pytest-asyncio
Requires-Dist: grandalf==0.8
Provides-Extra: calculators
Requires-Dist: tblite==0.4.0; (python_version < "3.13" or platform_system != "Darwin") and extra == "calculators"
Provides-Extra: uma
Requires-Dist: fairchem-core==2.3.0; extra == "uma"
Requires-Dist: e3nn>=0.5; extra == "uma"
Provides-Extra: ui
Requires-Dist: streamlit; extra == "ui"
Requires-Dist: stmol; extra == "ui"
Requires-Dist: ipython-genutils; extra == "ui"
Provides-Extra: parsl
Requires-Dist: parsl; extra == "parsl"
Provides-Extra: ensemble-launcher
Requires-Dist: ensemble-launcher; extra == "ensemble-launcher"
Provides-Extra: globus-compute
Requires-Dist: globus-compute-sdk; extra == "globus-compute"
Provides-Extra: academy
Requires-Dist: academy-py; extra == "academy"
Requires-Dist: httpx; extra == "academy"
Requires-Dist: redis; extra == "academy"
Provides-Extra: xanes
Requires-Dist: mp-api; python_version >= "3.11" and extra == "xanes"
Requires-Dist: parsl; extra == "xanes"
Provides-Extra: rag
Requires-Dist: faiss-cpu>=1.7.4; extra == "rag"
Requires-Dist: langchain-text-splitters; extra == "rag"
Requires-Dist: langchain-huggingface; extra == "rag"
Requires-Dist: sentence-transformers>=2.2.2; extra == "rag"
Requires-Dist: pymupdf>=1.24.0; extra == "rag"
Dynamic: license-file

<p align="left">
  <img src="logo/chemgraph-color-dark__rgb-hires.jpg" alt="ChemGraph logo" width="240">
</p>

![Tests](https://github.com/argonne-lcf/ChemGraph/actions/workflows/tests.yml/badge.svg)
![Conda Tests](https://github.com/argonne-lcf/ChemGraph/actions/workflows/conda-tests.yml/badge.svg)
![Test PyPI Package](https://github.com/argonne-lcf/ChemGraph/actions/workflows/test-pypi-package.yml/badge.svg)
[![GHCR](https://img.shields.io/badge/Docker-GHCR-2496ED?logo=docker&logoColor=white)](https://github.com/argonne-lcf/ChemGraph/pkgs/container/chemgraph)

<details open>
  <summary><strong>Overview</strong></summary>

**ChemGraph** is an agentic framework that can automate molecular simulation workflows using large language models (LLMs). Built on top of `LangGraph` and `ASE`, ChemGraph allows users to perform complex computational chemistry tasks, from structure generation to thermochemistry calculations, with a natural language interface. 
ChemGraph supports diverse simulation backends, including ab initio quantum chemistry methods (e.g. coupled-cluster, DFT via NWChem, ORCA), semi-empirical methods (e.g., XTB via TBLite), and machine learning potentials (e.g, MACE, UMA) through a modular integration with `ASE`. 

</details>

<details open>
  <summary><strong>Installation Instructions</strong></summary>

Ensure you have **Python 3.10 or higher** installed on your system. 

**Install-Free Method (Docker from GHCR)**

Run ChemGraph without local Python/package installation:

For complete Docker usage (GHCR, compose modes, environment variables, and publishing), see [`docs/docker_support.md`](docs/docker_support.md).

Then launch one of:

```bash
# JupyterLab
docker run --rm -it -p 8888:8888 ghcr.io/argonne-lcf/chemgraph:latest \
  jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root --LabApp.token=

# Streamlit
docker run --rm -it -p 8501:8501 ghcr.io/argonne-lcf/chemgraph:latest \
  streamlit run src/ui/app.py --server.address=0.0.0.0 --server.port=8501

# MCP server (HTTP)
docker run --rm -it -p 9003:9003 ghcr.io/argonne-lcf/chemgraph:latest \
  python -m chemgraph.mcp.mcp_tools --transport streamable_http --host 0.0.0.0 --port 9003

# Interactive CLI shell
docker run --rm -it --entrypoint /bin/bash -v "$PWD:/work" -w /work \
  ghcr.io/argonne-lcf/chemgraph:latest
# then run: chemgraph --config config.toml -q "your query"
```

**Pass API keys securely when running containers**

Required keys depend on provider/model:

- `OPENAI_API_KEY`
- `ANTHROPIC_API_KEY`
- `GEMINI_API_KEY`
- `GROQ_API_KEY`
- `ALCF_ACCESS_TOKEN` (ALCF inference endpoints, via Globus OAuth)
- Optional: `ARGO_USER` (Argo setups)

Best practice for `docker run` is host variable pass-through:

```bash
export OPENAI_API_KEY="..."
docker run --rm -it -e OPENAI_API_KEY -p 8501:8501 ghcr.io/argonne-lcf/chemgraph:latest \
  streamlit run src/ui/app.py --server.address=0.0.0.0 --server.port=8501
```

For multiple keys, use an env file:

```bash
docker run --rm -it --env-file .env.chemgraph -p 8501:8501 ghcr.io/argonne-lcf/chemgraph:latest \
  streamlit run src/ui/app.py --server.address=0.0.0.0 --server.port=8501
```

Do not commit `.env.chemgraph` and avoid storing API keys in `config.toml`.

For `config.toml` options and provider/base URL settings, see [`docs/configuration_with_toml.md`](docs/configuration_with_toml.md).

**Install from PyPI (Recommended)**

The easiest way to install ChemGraph is from PyPI:

```bash
pip install chemgraph
```

> Default installation does **not** require `tblite`.
> `tblite` is only installed when using the optional `calculators` extra.

To install with calculator extras (includes `tblite`):
```bash
pip install chemgraph[calculators]
```

> Note: On some platforms/Python combinations (especially where no prebuilt `tblite`
> wheel is available), installing the `calculators` extra may require a local
> Fortran toolchain.

**Install from Source (Alternative Methods)**

If you need to install from source for the latest version:

**Using pip from source**

1. Clone the repository:
   ```bash
   git clone https://github.com/argonne-lcf/ChemGraph
   cd ChemGraph
    ```
2. Create and activate a virtual environment:
   ```bash
   # Using venv (built into Python)
   python -m venv chemgraph-env
   source chemgraph-env/bin/activate  # On Unix/macOS
   # OR
   .\chemgraph-env\Scripts\activate  # On Windows
   ```

3. Install ChemGraph:
   ```bash
   pip install -e .
   ```

**Using Conda from source**

> ⚠️ **Note on Compatibility**  
> ChemGraph supports both MACE and UMA (Meta's machine learning potential). However, due to the current dependency conflicts, particularly with `e3nn`—**you cannot install both in the same environment**.  
> To use both libraries, create **separate Conda environments**, one for each.

1. Clone the repository:
   ```bash
   git clone --depth 1 https://github.com/argonne-lcf/ChemGraph
   cd ChemGraph
   ```

2. Create and activate the conda environment from the provided environment.yml:
   ```bash
   conda env create -f environment.yml
   conda activate chemgraph
   ```

   The `environment.yml` file automatically installs all required dependencies including:
   - Python 3.10
   - Core packages (numpy, pandas, pytest, rich, toml)
   - Computational chemistry packages (nwchem, tblite)
   - All ChemGraph dependencies via pip
   

**Using uv from source**

1. Clone the repository:
   ```bash
   git clone https://github.com/argonne-lcf/ChemGraph
   cd ChemGraph
   ```

2. Create and activate a virtual environment using uv:
    ```bash
    uv venv --python 3.11 chemgraph-env

    source chemgraph-env/bin/activate # Unix/macos
    # OR
    .\chemgraph-env\Scripts\activate  # On Windows
   ```

3. Install ChemGraph using uv:
    ```bash
    uv pip install -e .
    ```

**Optional: Install with UMA support**

> ⚠️ **Note on e3nn Conflict for UMA Installation:** The `uma` extras (requiring `e3nn>=0.5`) conflict with the base `mace-torch` dependency (which pins `e3nn==0.4.4`). 
> 
> **For PyPI installations**, you can try:
> ```bash
> pip install chemgraph[uma]
> ```
> However, this may fail due to the e3nn version conflict. If it does, you'll need to install from source using the workaround below.
>
> **For source installations**, if you need to install UMA support in an environment where `mace-torch` might cause this conflict, you can try the following workaround:
> 1. **Temporarily modify `pyproject.toml`**: Open the `pyproject.toml` file in the root of the ChemGraph project.
> 2. Find the line containing `"mace-torch",` in the `dependencies` list.
> 3. Comment out this line by adding a `#` at the beginning (e.g., `#    "mace-torch",`).
> 4. **Install UMA extras**: Run `pip install -e ".[uma]"`.
> 5. **(Optional) Restore `pyproject.toml`**: After installation, you can uncomment the `mace-torch` line if you still need it for other purposes in the same environment. Be aware that `mace-torch` might not function correctly due to the `e3nn` version mismatch (`e3nn>=0.5` will be present for UMA).
>
> **The most robust solution for using both MACE and UMA with their correct dependencies is to create separate Conda environments, as highlighted in the "Note on Compatibility" above.**

> **Important for UMA Model Access:** The `facebook/UMA` model is a gated model on Hugging Face. To use it, you must:
> 1. Visit the [facebook/UMA model page](https://huggingface.co/facebook/UMA) on Hugging Face.
> 2. Log in with your Hugging Face account.
> 3. Accept the model's terms and conditions if prompted.
> Your environment (local or CI) must also be authenticated with Hugging Face, typically by logging in via `huggingface-cli login` or ensuring `HF_TOKEN` is set and recognized.
</details>

<details open>
  <summary><strong>Example Usage</strong></summary>

1. Before exploring example usage in the `notebooks/` directory, ensure you have specified the necessary API tokens in your environment. For example, you can set the OpenAI API token and Anthropic API token using the following commands:

   ```bash
   # Set OpenAI API token
   export OPENAI_API_KEY="your_openai_api_key_here"

   # Set Anthropic API token
   export ANTHROPIC_API_KEY="your_anthropic_api_key_here"
   
   # Set Google API token
   export GEMINI_API_KEY="your_google_api_key_here"
   ```

2. **Explore Example Notebooks**: Navigate to the `notebooks/` directory to explore various example notebooks demonstrating different capabilities of ChemGraph.

   - **[Single-Agent System with MACE](notebooks/1_Demo_single_agent.ipynb)**: This notebook demonstrates how a single agent can utilize multiple tools with MACE/xTB support.

   - **[Single-Agent System with UMA](notebooks/Demo_single_agent_UMA.ipynb)**: This notebook demonstrates how a single agent can utilize multiple tools with UMA support.

   - **[Multi-Agent System](notebooks/2_Demo-multi_agent.ipynb)**: This notebook demonstrates a multi-agent setup where planner and executor agents decompose and run computational chemistry tasks.

   - **[Model Context Protocol (MCP) Server](notebooks/3_Demo_using_MCP.ipynb)**: This notebook demonstrates how to run an MCP server and connect to ChemGraph.
   - **[Single-Agent System with gRASPA](notebooks/Demo_graspa_agent.ipynb)**: This notebook provides a sample guide on executing a gRASPA simulation using a single agent. For gRASPA-related installation instructions, visit the [gRASPA GitHub repository](https://github.com/snurr-group/gRASPA). The notebook's functionality has been validated on a single compute node at ALCF Polaris.

   - **[Infrared absorption spectrum prediction](notebooks/Demo_infrared_spectrum.ipynb)**: This notebook demonstrates how to calculate an infrared absorption spectrum.


</details>

<details>
  <summary><strong>Streamlit Web Interface</strong></summary>

ChemGraph includes a **Streamlit web interface** for chat-driven computational chemistry workflows. The UI auto-initializes the selected agent, streams tool-call progress while a query runs, shows generated structures and reports, and stores conversations in the same local session database used by the CLI.

### Features

- **🧪 Interactive Chat Interface**: Natural language queries for computational chemistry tasks
- **🧬 3D Molecular Visualization**: Interactive molecular structure display using `stmol` and `py3Dmol`
- **📊 Report Integration**: Embedded and downloadable HTML reports from computational calculations
- **💾 Data Export**: Download molecular structures as XYZ or JSON files
- **🧮 Math Rendering**: Display LaTeX-style equations and reaction arrows in assistant responses
- **🔧 Multiple Workflows**: Support for single-agent, multi-agent, Python REPL, and gRASPA workflows
- **💬 Session Memory**: Browse, load, and delete saved conversations from `~/.chemgraph/sessions.db`
- **👤 Human Supervision**: Optional follow-up prompts when the agent needs confirmation or missing inputs

### Installation Requirements

The Streamlit UI dependencies are included by default when you install ChemGraph:

```bash
# Install ChemGraph (includes UI dependencies)
pip install -e .
```

**Alternative Installation Options:**
```bash
# Install only UI dependencies separately (if needed)
pip install -e ".[ui]"

# Install with UMA support (separate environment recommended)
pip install -e ".[uma]"
```

### Running the Streamlit Interface

1. **Set up your API keys** (same as for notebooks):
   ```bash
   export OPENAI_API_KEY="your_openai_api_key_here"
   export ANTHROPIC_API_KEY="your_anthropic_api_key_here"
   ```

2. **Launch the Streamlit app**:
   ```bash
   streamlit run src/ui/app.py
   ```

3. **Access the interface**: Open your browser to `http://localhost:8501`

### Using the Interface

#### Configuration
- Use the **Configuration** page to edit `config.toml`, provider base URLs, API timeouts, workflow, recursion limit, report generation, and human supervision.
- API keys entered in the UI are applied only to the current Streamlit process and are not written to `config.toml`.
- The main sidebar shows calculators detected during ChemGraph initialization and marks the default calculator used when a query does not specify one.
- To change model, workflow, thread, or report settings, edit them on the **Configuration** page, save, then use **Reload Config** or **Refresh Agents**.


#### Interaction
1. **Open the main page**: The agent initializes automatically from the active configuration.
2. **Ask Questions**: Use the chat input to enter computational chemistry queries.
3. **Monitor Tools**: Tool calls and completions stream in the assistant response while the workflow runs.
4. **Respond to Prompts**: If human supervision is enabled and the agent pauses, answer in the same chat input.
5. **View and Export Results**: Structures, IR artifacts, HTML reports, and download controls appear with the response when available.

#### Example Queries
- "What is the SMILES string for caffeine?"
- "Optimize the geometry of water molecule using DFT"
- "Calculate the single point energy of methane and show the structure"
- "Generate the structure of aspirin and calculate its vibrational frequencies"

#### Molecular Visualization
The interface automatically detects molecular structure data in agent responses and provides:
- **Interactive 3D Models**: Multiple visualization styles (ball & stick, sphere, stick, wireframe)
- **Structure Information**: Chemical formula, composition, mass, center of mass
- **Export Options**: Download as XYZ files or JSON data
- **Fallback Display**: Table view when 3D visualization is unavailable

#### Conversation Management
- **History Display**: All queries and responses are preserved in conversation bubbles
- **Saved Sessions**: Recent sessions can be loaded or deleted from the sidebar
- **Structure Detection**: Molecular structures are automatically extracted and visualized
- **Report Integration**: HTML reports and run artifacts are embedded directly in the interface
- **Debug Information**: Expandable sections show detailed message processing information

### Troubleshooting

**3D Visualization Issues:**
- Ensure `stmol` is installed: `pip install stmol`
- If 3D display fails, the interface falls back to table/text display
- Check browser compatibility for WebGL support

**Agent Initialization:**
- Verify API keys are set correctly
- Verify provider base URLs and local model endpoints on the Configuration page
- Check that ChemGraph package is installed: `pip install -e .`
- Ensure all dependencies are available in your environment

**Performance:**
- For large molecular systems, visualization may take longer to load
- Start a new chat or load a smaller saved session if rendering many prior structures becomes slow
- Use **Refresh Agents** after changing credentials or external model services

</details>

<details>
  <summary><strong>Configuration with TOML</strong></summary>

ChemGraph supports comprehensive configuration through TOML files, allowing you to customize model settings, API configurations, chemistry parameters, and more.

### Configuration File Structure

Create a `config.toml` file in your project directory to configure ChemGraph behavior:

```toml
# ChemGraph Configuration File
# This file contains all configuration settings for ChemGraph CLI and agents

[general]
# Default model to use for queries
model = "gpt-4o-mini"
# Workflow type: single_agent, multi_agent, python_relp, graspa, mock_agent
# Alias accepted by CLI/UI: python_repl -> python_relp
workflow = "single_agent"
# Output format: state, last_message
output = "state"
# Enable structured output
structured = false
# Generate detailed reports
report = true
# Default LangGraph thread ID
thread = 1

# Recursion limit for agent workflows
recursion_limit = 20
# Allow the agent to pause and ask for human input
human_supervised = false
# Enable verbose output
verbose = false

[llm]
# Temperature for LLM responses (0.0 to 1.0)
temperature = 0.1
# Maximum tokens for responses
max_tokens = 4000
# Top-p sampling parameter
top_p = 0.95
# Frequency penalty (-2.0 to 2.0)
frequency_penalty = 0.0
# Presence penalty (-2.0 to 2.0)
presence_penalty = 0.0

[api]
# Custom base URLs for different providers
[api.openai]
base_url = "https://api.openai.com/v1"
timeout = 30
argo_user = ""

[api.anthropic]
base_url = "https://api.anthropic.com"
timeout = 30

[api.google]
base_url = "https://generativelanguage.googleapis.com/v1beta"
timeout = 30

[api.alcf]
base_url = "https://inference-api.alcf.anl.gov/resource_server/sophia/vllm/v1"
timeout = 30

[api.local]
# For local models like Ollama
base_url = "http://localhost:11434"
timeout = 60

[chemistry]
# Default calculation settings
[chemistry.optimization]
# Optimization method: BFGS, L-BFGS-B, CG, etc.
method = "BFGS"
# Force tolerance for convergence
fmax = 0.05
# Maximum optimization steps
steps = 200

[chemistry.frequencies]
# Displacement for finite difference
displacement = 0.01
# Number of processes for parallel calculation
nprocs = 1

[chemistry.calculators]
# Default calculator for different tasks
default = "mace_mp"
# Available calculators: mace_mp, emt, nwchem, orca, psi4, tblite
fallback = "emt"

[output]
# Output file settings
[output.files]
# Default output directory
directory = "./chemgraph_output"
# File naming pattern
pattern = "{timestamp}_{query_hash}"
# Supported formats: xyz, json, html, png
formats = ["xyz", "json", "html"]

[output.visualization]
# 3D visualization settings
enable_3d = true
# Molecular viewer: py3dmol, ase_gui
viewer = "py3dmol"
# Image resolution for saved figures
dpi = 300

[logging]
# Logging level: DEBUG, INFO, WARNING, ERROR, CRITICAL
level = "INFO"
# Log file location
file = "./chemgraph.log"
# Enable console logging
console = true

[features]
# Enable experimental features
enable_experimental = false
# Enable caching of results
enable_cache = true
# Cache directory
cache_dir = "./cache"
# Cache expiration time in hours
cache_expiry = 24

[security]
# Enable API key validation
validate_keys = true
# Enable request rate limiting
rate_limit = true
# Max requests per minute
max_requests_per_minute = 60
```

The core CLI and UI currently consume `[general]`, `[api]`, `[chemistry]`, and
`[output]` directly. The agent uses deterministic LLM defaults internally
(`temperature=0.0`, fixed token limits); `[llm]` entries are kept for
documentation/forward compatibility rather than active runtime tuning.

### Using Configuration Files

#### With the Command Line Interface

```bash
# Use configuration file
chemgraph --config config.toml -q "What is the SMILES string for water?"

# Override specific settings
chemgraph --config config.toml -q "Optimize methane" -m gpt-4o --verbose
```

#### Using Argo (Argonne Internal)

ChemGraph supports Argo through its OpenAI-compatible endpoint.

1. Set your Argo/OpenAI base URL in `config.toml`:

```toml
[api.openai]
base_url = "https://apps-dev.inside.anl.gov/argoapi/v1"
timeout = 30
argo_user = "<your_anl_domain_username>"
```

2. Set environment variables:

```bash
# Required by OpenAI-compatible clients in ChemGraph; for Argo use your ANL username
export OPENAI_API_KEY="<your_anl_domain_username>"

# Optional fallback only: used when api.openai.argo_user is not set in config.toml
export ARGO_USER="<your_anl_domain_username>"
```

3. Use an Argo model ID with the `argo:` prefix (from `supported_argo_models` in `src/chemgraph/models/supported_models.py`), for example:

```text
argo:gpt-4o, argo:gpt-4o-latest, argo:gpt-5, argo:gpt-5-mini,
argo:gemini-2.5-flash, argo:claude-sonnet-4.5
```

4. Run with config:

```bash
chemgraph --config config.toml -m argo:gpt-4o-latest -q "calculate the energy for water molecule using mace_mp"
```

Notes:
- Argo endpoints are available on Argonne internal network (or VPN on an Argonne-managed machine).
- For current Argo endpoint guidance and policy updates, refer to your internal Argo documentation.

#### Using ALCF Inference Endpoints

ChemGraph supports [ALCF Inference Endpoints](https://docs.alcf.anl.gov/services/inference-endpoints/), which provide API access to open-source models running on dedicated ALCF hardware (Sophia cluster with vLLM).

1. Configure the endpoint in `config.toml` (already set by default):

```toml
[api.alcf]
base_url = "https://inference-api.alcf.anl.gov/resource_server/sophia/vllm/v1"
timeout = 30
```

2. Authenticate via Globus OAuth:

```bash
pip install globus_sdk
wget https://raw.githubusercontent.com/argonne-lcf/inference-endpoints/refs/heads/main/inference_auth_token.py
python inference_auth_token.py authenticate
```

3. Set the access token (valid for ~48 hours):

```bash
export ALCF_ACCESS_TOKEN=$(python inference_auth_token.py get_access_token)
```

4. Run with an ALCF model (use the model name directly, no prefix needed):

```bash
chemgraph --config config.toml -m meta-llama/Meta-Llama-3.1-70B-Instruct \
  -q "Calculate the energy of water using MACE"
```

See the [ALCF docs](https://docs.alcf.anl.gov/services/inference-endpoints/#available-models) for the full list of available models.

Notes:
- Access tokens expire after 48 hours. Re-run `get_access_token` to refresh.
- An internal policy requires Globus re-authentication every 30 days.
- ALCF models are available to users with an active ALCF account.

#### Using Groq

ChemGraph supports [Groq](https://groq.com/) for fast LLM inference. Use the `groq:` prefix to route any model through Groq:

1. Set your Groq API key:

```bash
export GROQ_API_KEY="your_groq_api_key_here"
```

2. Run with a Groq model (prefix the model name with `groq:`):

```bash
chemgraph -q "What is the SMILES for water?" -m groq:llama-3.3-70b-versatile
chemgraph -q "Optimize methane" -m groq:openai/gpt-oss-120b
```

No curated model list is maintained -- any model available on Groq can be used by prefixing it with `groq:`. See the [Groq docs](https://console.groq.com/docs/models) for current models.

#### LLM Provider Prefixes

For third-party providers that share model names with other services, ChemGraph uses a prefix convention to route models unambiguously:

| Prefix  | Provider                    | Auth Env Var     | Example                               |
| ------- | --------------------------- | ---------------- | ------------------------------------- |
| `argo:` | Argo API (Argonne internal) | `OPENAI_API_KEY` | `argo:gpt-4o`, `argo:claude-sonnet-4` |
| `groq:` | Groq Cloud                  | `GROQ_API_KEY`   | `groq:llama-3.3-70b-versatile`        |

Direct model names (no prefix) are used for:

| Provider       | Auth Env Var        | Example                                  |
| -------------- | ------------------- | ---------------------------------------- |
| OpenAI         | `OPENAI_API_KEY`    | `gpt-4o`, `gpt-4o-mini`                  |
| Anthropic      | `ANTHROPIC_API_KEY` | `claude-3-5-sonnet-20241022`             |
| Google         | `GEMINI_API_KEY`    | `gemini-2.5-pro`                         |
| ALCF           | `ALCF_ACCESS_TOKEN` | `meta-llama/Meta-Llama-3.1-70B-Instruct` |
| Ollama (local) | Not required        | `llama3.2`                               |

For Argo, model names are mapped to Argo-specific wire names when using the default Argo endpoint. See `supported_argo_models` in `src/chemgraph/models/supported_models.py` for the full list.

For Groq, the `groq:` prefix is stripped before sending to the Groq API. Any model available on the [Groq console](https://console.groq.com/docs/models) can be used.

### Configuration Sections

| Section       | Description                                             |
| ------------- | ------------------------------------------------------- |
| `[general]`   | Basic settings like model, workflow, and output format  |
| `[llm]`       | Reserved/legacy LLM parameter documentation             |
| `[api]`       | API endpoints and timeouts for different providers      |
| `[chemistry]` | Chemistry-specific calculation settings                 |
| `[output]`    | Output file formats and visualization settings          |
| `[logging]`   | Logging configuration and verbosity levels              |
| `[features]`  | Feature flags and experimental settings                 |
| `[security]`  | Security settings and rate limiting                     |

### Command Line Interface

ChemGraph includes a powerful command-line interface (CLI) that provides all the functionality of the web interface through the terminal. The CLI features rich formatting, interactive mode, and comprehensive configuration options.

#### Installation & Setup

The CLI is included by default when you install ChemGraph:

```bash
pip install -e .
```

#### Basic Usage

##### Quick Start

```bash
# Basic query
chemgraph -q "What is the SMILES string for water?"

# With model selection
chemgraph -q "Optimize methane geometry using MACE" -m gpt-4o

# With report generation
chemgraph -q "Calculate CO2 vibrational frequencies using DFT with NWChem" -r

# Using configuration file
chemgraph --config config.toml -q "Your query here"
```

##### Command Syntax

```bash
chemgraph [OPTIONS] -q "YOUR_QUERY"
```

#### Command Line Options

**Core Arguments:**

| Option             | Short | Description                                          | Default        |
| ------------------ | ----- | ---------------------------------------------------- | -------------- |
| `--query`          | `-q`  | The computational chemistry query to execute         | Required       |
| `--model`          | `-m`  | LLM model to use                                     | `gpt-4o-mini`  |
| `--workflow`       | `-w`  | Workflow type                                        | `single_agent` |
| `--output`         | `-o`  | Output format (`state`, `last_message`)              | `state`        |
| `--structured`     | `-s`  | Use structured output format                         | `False`        |
| `--report`         | `-r`  | Generate detailed report                             | `False`        |
| `--resume`         |       | Resume from a previous session ID (prefix supported) |                |
| `--list-sessions`  |       | List recent sessions from the memory database        |                |
| `--show-session`   |       | Show conversation for a session (prefix supported)   |                |
| `--delete-session` |       | Delete a session from the memory database            |                |

**Model Selection:**

```bash
# OpenAI models
chemgraph -q "Your query" -m gpt-4o
chemgraph -q "Your query" -m gpt-4o-mini

# Anthropic models
chemgraph -q "Your query" -m claude-3-5-sonnet-20241022

# Google models
chemgraph -q "Your query" -m gemini-2.5-pro

# Argo models (Argonne internal, argo: prefix)
chemgraph -q "Your query" -m argo:gpt-4o
chemgraph -q "Your query" -m argo:claude-sonnet-4

# ALCF models (Globus auth required, no prefix)
chemgraph -q "Your query" -m meta-llama/Meta-Llama-3.1-70B-Instruct

# Groq models (groq: prefix, any Groq model)
chemgraph -q "Your query" -m groq:llama-3.3-70b-versatile

# Local models (Ollama)
chemgraph -q "Your query" -m llama3.2
```

**Workflow Types:**

```bash
# Single agent (default) - best for most tasks
chemgraph -q "Optimize water molecule" -w single_agent

# Multi-agent - complex tasks with planning
chemgraph -q "Complex analysis" -w multi_agent

# Python REPL - interactive coding
chemgraph -q "Write analysis code" -w python_repl

# gRASPA - molecular simulation
chemgraph -q "Run adsorption simulation" -w graspa
```

**Output Formats:**

```bash
# Full state output (default)
chemgraph -q "Your query" -o state

# Last message only
chemgraph -q "Your query" -o last_message

# Structured output
chemgraph -q "Your query" -s

# Generate detailed report
chemgraph -q "Your query" -r
```

#### Interactive Mode

Start an interactive session for continuous conversations:

```bash
chemgraph --interactive
```

**Interactive Features:**
- **Persistent conversation**: Maintain context across queries
- **Session memory**: Conversations are automatically saved to a local SQLite database (`~/.chemgraph/sessions.db`) and can be resumed later
- **Model switching**: Change models mid-conversation
- **Workflow switching**: Switch between different agent types
- **Built-in commands**: Help, clear, config, session management, etc.

**Interactive Commands:**
```bash
# In interactive mode, type:
help                    # Show available commands
clear                   # Clear screen
config                  # Show current configuration and session ID
quit                    # Exit interactive mode
model gpt-4o           # Change model
workflow multi_agent   # Change workflow

# Session management:
history                 # List recent sessions
show <session_id>       # Show a session's conversation
resume <session_id>     # Resume from a previous session
```

#### Utility Commands

**List Available Models:**
```bash
chemgraph --list-models
```

**Check API Keys:**
```bash
chemgraph --check-keys
```

**Get Help:**
```bash
chemgraph --help
```

#### Session Memory

ChemGraph automatically saves every conversation to a local SQLite database at `~/.chemgraph/sessions.db`. This allows you to browse past sessions, review tool calls and results, and resume previous conversations with full context.

**List Recent Sessions:**
```bash
chemgraph --list-sessions
```

**View a Session's Conversation:**
```bash
# Full session ID or prefix (first few characters)
chemgraph --show-session a3b2
```

**Resume From a Previous Session:**
```bash
# Injects previous conversation context into the new query
chemgraph -q "Now optimize the geometry at 500K" --resume a3b2
```

**Delete a Session:**
```bash
chemgraph --delete-session a3b2c1d4
```

Session IDs support prefix matching -- you only need to type enough characters to uniquely identify the session.

#### Configuration File Support

Use TOML configuration files for consistent settings:

```bash
chemgraph --config config.toml -q "Your query"
```

#### Advanced Options

**Timeout and Error Handling:**
```bash
# Set recursion limit
chemgraph -q "Complex query" --recursion-limit 30

# Verbose output for debugging
chemgraph -q "Your query" -v

# Save output to file
chemgraph -q "Your query" --output-file results.txt
```



#### Example Workflows

**Basic Molecular Analysis:**
```bash
# Get molecular structure
chemgraph -q "What is the SMILES string for caffeine?"

# Optimize geometry
chemgraph -q "Optimize the geometry of caffeine using DFT" -m gpt-4o -r

# Calculate properties
chemgraph -q "Calculate the vibrational frequencies of optimized caffeine" -r
```

**Interactive Research Session:**
```bash
# Start interactive mode
chemgraph --interactive

# Select model and workflow
> model gpt-4o
> workflow single_agent

# Conduct analysis
> What is the structure of aspirin?
> Optimize its geometry using DFT
> Calculate its electronic properties
> Compare with ibuprofen
```

**Batch Processing:**
```bash
# Process multiple queries
chemgraph -q "Analyze water molecule" --output-file water_analysis.txt
chemgraph -q "Analyze methane molecule" --output-file methane_analysis.txt
chemgraph -q "Analyze ammonia molecule" --output-file ammonia_analysis.txt
```

#### API Key Setup

**Required API Keys:**
```bash
# OpenAI (for GPT models)
export OPENAI_API_KEY="your_openai_key_here"

# Anthropic (for Claude models)
export ANTHROPIC_API_KEY="your_anthropic_key_here"

# Google (for Gemini models)
export GEMINI_API_KEY="your_gemini_key_here"

# Groq (for groq: prefixed models)
export GROQ_API_KEY="your_groq_key_here"

# ALCF (Globus OAuth access token)
export ALCF_ACCESS_TOKEN=$(python inference_auth_token.py get_access_token)
```

**Getting API Keys:**
- **OpenAI**: Visit [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
- **Anthropic**: Visit [console.anthropic.com](https://console.anthropic.com/)
- **Google**: Visit [aistudio.google.com/apikey](https://aistudio.google.com/apikey)
- **Groq**: Visit [console.groq.com/keys](https://console.groq.com/keys)
- **ALCF**: See [ALCF Inference Endpoints docs](https://docs.alcf.anl.gov/services/inference-endpoints/#api-access)

#### Performance Tips

- Use `gpt-4o-mini` for faster, cost-effective queries
- Use `gpt-4o` for complex analysis requiring higher reasoning
- Enable `--report` for detailed documentation
- Use `--structured` output for programmatic parsing
- Leverage configuration files for consistent settings

#### Troubleshooting

**Common Issues:**
```bash
# Check API key status
chemgraph --check-keys

# Verify model availability
chemgraph --list-models

# Test with verbose output
chemgraph -q "test query" -v

# Check configuration
chemgraph --config config.toml -q "test" --verbose
```

**Error Messages:**
- **"Invalid model"**: Use `--list-models` to see available options
- **"API key not found"**: Use `--check-keys` to verify setup
- **"Query required"**: Use `-q` to specify your query
- **"Timeout"**: Increase `--recursion-limit` or simplify query

The CLI provides:
- **Beautiful terminal output** with colors and formatting powered by Rich
- **API key validation** before agent initialization
- **Timeout protection** to prevent hanging processes
- **Interactive mode** for continuous conversations
- **Configuration file support** with TOML format
- **Environment-specific settings** for development/production
- **Comprehensive help** and examples for all features

</details>

<details>
  <summary><strong>Project Structure</strong></summary>

```
chemgraph/
│
├── src/                       # Source code
│   ├── chemgraph/             # Top-level package
│   │   ├── agent/             # Agent-based task management
│   │   ├── eval/              # Evaluation & benchmarking (LLM-as-judge)
│   │   ├── graphs/            # Workflow graph utilities
│   │   ├── mcp/               # MCP servers (stdio/streamable HTTP)
│   │   ├── memory/            # Session memory (SQLite-backed persistence)
│   │   ├── models/            # LLM provider integrations
│   │   ├── prompt/            # Agent prompt templates
│   │   ├── schemas/           # Pydantic data models
│   │   ├── state/             # Agent state definitions
│   │   ├── tools/             # Tools for molecular simulations
│   │   ├── utils/             # Other utility functions
│   ├── ui/                    # CLI and Streamlit UI
│
├── pyproject.toml             # Project configuration
└── README.md                  # Project documentation
```

</details>

<details>
  <summary><strong>Evaluation & Benchmarking</strong></summary>

ChemGraph includes a built-in evaluation module (`chemgraph.eval`) for benchmarking LLM tool-calling accuracy across models and workflows. It uses an **LLM-as-judge** strategy: a separate judge LLM grades the agent's tool-call sequence and final answer against ground-truth results using binary scoring (1 = correct, 0 = wrong).

### Bundled Dataset

A default dataset of **14 queries** across 4 categories is shipped with the package:

| Category                     | Description                                   | Example                                                                       |
| ---------------------------- | --------------------------------------------- | ----------------------------------------------------------------------------- |
| **A** Single tool calls      | Name-to-SMILES, SMILES-to-coordinates         | "Provide the SMILES string for sulfur dioxide"                                |
| **B** Multi-step from name   | Name → SMILES → coordinates → ASE simulation  | "Calculate the geometry optimization of sulfur dioxide using mace_mp"         |
| **C** Multi-step from SMILES | SMILES → coordinates → ASE simulation         | "Calculate the single-point energy using mace_mp for SMILES: N#N"             |
| **D** Reaction Gibbs energy  | Multi-species thermochemistry + stoichiometry | "Calculate the Gibbs free energy of reaction for Methane Combustion at 300 K" |

### Running Evaluations

**CLI (recommended):**

```bash
# Minimal invocation (uses bundled 14-query dataset)
chemgraph-eval --models gpt-4o-mini --judge-model gpt-4o

# Multiple models
chemgraph-eval --models gpt-4o-mini gemini-2.5-flash claude-3-5-haiku-20241022 \
    --judge-model gpt-4o

# With TOML config (resolves base_url, argo_user, profiles)
chemgraph-eval --models gpt-4o-mini --judge-model gpt-4o --config config.toml

# Profile-based (reads [eval.profiles.*] from config.toml)
chemgraph-eval --profile quick --models gpt-4o-mini --judge-model gpt-4o --config config.toml

# Custom dataset, limit queries, specific workflow
chemgraph-eval --models gpt-4o-mini \
    --judge-model gpt-4o \
    --dataset path/to/custom_ground_truth.json \
    --workflows single_agent \
    --max-queries 5 \
    --output-dir eval_results
```

**Python API:**

```python
import asyncio
from chemgraph.eval import ModelBenchmarkRunner, BenchmarkConfig

config = BenchmarkConfig(
    models=["gpt-4o-mini", "gemini-2.5-flash"],
    judge_model="gpt-4o",
    # dataset defaults to bundled 14-query dataset
    # workflow_types defaults to ["single_agent"]
)
runner = ModelBenchmarkRunner(config)
results = asyncio.run(runner.run_all())
runner.report()  # generates JSON + Markdown + console output
```

### CLI Options

| Option                   | Description                                            | Default         |
| ------------------------ | ------------------------------------------------------ | --------------- |
| `--models`               | LLM model names to evaluate (required)                 | —               |
| `--judge-model`          | LLM model name for the judge (required)                | —               |
| `--profile`              | Eval profile name from config.toml `[eval.profiles.*]` | None            |
| `--dataset`              | Path to ground-truth JSON file                         | Bundled dataset |
| `--workflows`            | Workflow types to test                                 | `single_agent`  |
| `--output-dir`           | Output directory for results                           | `eval_results`  |
| `--max-queries`          | Max queries to evaluate (0 = all)                      | 0               |
| `--recursion-limit`      | Max LangGraph recursion steps per query                | 50              |
| `--config`               | Path to TOML config file                               | None            |
| `--tags`                 | Free-form tags for run metadata                        | —               |
| `--no-structured-output` | Disable structured output on the agent                 | —               |
| `--report`               | Report format: `json`, `markdown`, `console`, `all`    | `all`           |

### TOML Profile Configuration

Define reusable evaluation profiles in your `config.toml`:

```toml
[eval]
default_profile = "quick"

[eval.profiles.quick]
judge_model = "gpt-4o-mini"
workflow_types = ["single_agent"]
recursion_limit = 20
max_queries = 5

[eval.profiles.standard]
judge_model = "gpt-4o"
workflow_types = ["single_agent", "multi_agent"]
recursion_limit = 50
```

### Generating Custom Ground Truth

To generate a new ground-truth dataset from custom molecules and reactions:

```bash
cd scripts/evaluations

# Full execution (runs tool chains, captures actual results)
python generate_ground_truth.py --input_file input_data.json

# Skip execution (empty results, faster)
python generate_ground_truth.py --input_file input_data.json --skip_execution

# Custom output path
python generate_ground_truth.py --input_file input_data.json -o my_gt.json
```

### Output

Evaluation runs produce:
- **JSON report** (`eval_results/benchmark_<timestamp>.json`) -- machine-readable results with per-query scores
- **Markdown report** (`eval_results/benchmark_<timestamp>.md`) -- human-readable summary with accuracy tables
- **Per-model detail files** (`eval_results/<model>_<workflow>_detail.json`) -- individual query results
- **Console summary** -- printed accuracy table during the run

For full documentation, see [`docs/evaluation.md`](docs/evaluation.md).

</details>

<details>
  <summary><strong>Running With External LLM Endpoints</strong></summary>

ChemGraph no longer provides an in-repo vLLM Docker stack. For local or hosted model inference, run your preferred OpenAI-compatible endpoint separately and configure ChemGraph with:

- model name
- API key environment variable
- optional base URL (for non-default endpoints)

For hosted providers:

```bash
export OPENAI_API_KEY="your_openai_api_key_here"
export ANTHROPIC_API_KEY="your_anthropic_api_key_here"
export GEMINI_API_KEY="your_gemini_api_key_here"
```

Then run CLI, Streamlit, or notebooks normally.
</details>

<details>
  <summary><strong>Docker Support (Jupyter, Streamlit, MCP, CLI)</strong></summary>

The Docker setup is now a single ChemGraph image with profile-based runtime modes:

- `jupyter` (JupyterLab)
- `streamlit` (web UI)
- `mcp` (MCP server over streamable HTTP)
- `cli` (interactive shell with `chemgraph` command)

See full guide: [`docs/docker_support.md`](docs/docker_support.md)

**Quick start**

Run JupyterLab (install-free):

```bash
docker run --rm -it -p 8888:8888 ghcr.io/argonne-lcf/chemgraph:latest \
  jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root --LabApp.token=
```

Run Streamlit (install-free):

```bash
docker run --rm -it -p 8501:8501 ghcr.io/argonne-lcf/chemgraph:latest \
  streamlit run src/ui/app.py --server.address=0.0.0.0 --server.port=8501
```

Run MCP server (install-free):

```bash
docker run --rm -it -p 9003:9003 ghcr.io/argonne-lcf/chemgraph:latest \
  python -m chemgraph.mcp.mcp_tools --transport streamable_http --host 0.0.0.0 --port 9003
```

Run interactive CLI shell (install-free):

```bash
docker run --rm -it --entrypoint /bin/bash -v "$PWD:/work" -w /work \
  ghcr.io/argonne-lcf/chemgraph:latest
# then run: chemgraph --config config.toml -q "your query"
```

If you want source-mounted development mode with Docker Compose, use:

```bash
docker compose build
docker compose --profile jupyter up
# or --profile streamlit / --profile mcp
```

**Ports**

- JupyterLab: `8888`
- Streamlit: `8501`
- MCP (HTTP): `9003`

### Running With Colmena

If you use [Colmena](https://github.com/exalearn/colmena), run ChemGraph services in containers and let Colmena orchestrate tasks:

1. Start one of the Docker modes above (`jupyter`, `streamlit`, or `mcp`).
2. In your Colmena workflow, choose one integration pattern:
   - call the ChemGraph CLI inside a worker task (e.g., `chemgraph -q ...`)
   - connect to the MCP server (`docker compose --profile mcp up`) from your worker/client
3. Mount the same project/output volume if Colmena workers and Docker run on the same host.

Use this as an orchestration layer: Colmena schedules tasks; ChemGraph handles chemistry execution.

### Kubernetes Deployment

ChemGraph Streamlit can also be deployed on Kubernetes clusters. See the [`k8s/`](k8s/) directory for deployment manifests and instructions.

**Quick deployment:**

```bash
cd k8s
./deploy.sh deploy
```

For detailed instructions, see [`k8s/README.md`](k8s/README.md).
</details>

<details>
  <summary><strong>Model Context Protocol (MCP) Servers</strong></summary>

ChemGraph provides several **MCP servers** that expose its capabilities as standardized tools conforming to the [Model Context Protocol](https://modelcontextprotocol.io/). These can be connected to MCP-compliant clients or other agentic frameworks.

### Available Servers

The servers are located in `src/chemgraph/mcp/`:

*   **`mcp_tools.py`**: General-purpose chemistry tools powered by ASE. Supports:
    *   Geometry optimization (GetStructure, RunASE)
    *   Energy/Thermochemistry calculations
    *   File I/O (handling XYZ, JSON, etc.)
*   **`mace_mcp_parsl.py`**: Tools for running **MACE** (Machine Learning Potential) simulations.
    *   Supports single-structure calculations.
    *   Supports **ensemble** calculations (directories of structures) using **Parsl** for parallel execution on HPC systems (e.g., Polaris, Aurora).
*   **`graspa_mcp_parsl.py`**: Tools for **gRASPA** simulations (Gas Adsorption in MOFs).
    *   Supports single and ensemble runs via Parsl.
*   **`xanes_mcp_parsl.py`**: Tools for running XANES/FDMNES ensembles with Parsl.
*   **`data_analysis_mcp.py`**: Tools for analyzing simulation results.
    *   Aggregating JSONL logs from ensemble runs into CSV/DataFrames.
    *   Plotting isotherms and other data.

### Running a Server

You can run the servers using Python. They support both `stdio` (default) and `streamable_http` transports.

**Basic Usage (stdio)**
Connect this directly to your MCP client (e.g., Claude Desktop config):

```bash
python -m chemgraph.mcp.mcp_tools
```

**Using streamable HTTP**
To run a server that listens for HTTP connections (useful for remote deployment or debugging):

```bash
python -m chemgraph.mcp.mcp_tools --transport streamable_http --host 0.0.0.0 --port 8000
```

**Configuration via Arguments**
All servers in `src/chemgraph/mcp/` support the following arguments:
*   `--transport`: `stdio` (default) or `streamable_http`.
*   `--port`: Port number (for HTTP transport).
*   `--host`: Host address (default: 127.0.0.1).

**Note on HPC Servers:**
For `graspa_mcp_parsl.py` and `xanes_mcp_parsl.py`, set `COMPUTE_SYSTEM=polaris` or `COMPUTE_SYSTEM=aurora` before launch so the server loads the matching Parsl configuration from `chemgraph.hpc_configs`. `mace_mcp_parsl.py` currently contains site-specific `worker_init` settings; review and edit those paths/modules before production use.

</details>

<details>
  <summary><strong>Code Formatting & Linting</strong></summary>

This project uses [Ruff](https://github.com/astral-sh/ruff) for **both formatting and linting**. To ensure all code follows our style guidelines, install the pre-commit hook:

```sh
pip install pre-commit
pre-commit install
```
</details>

<details>
  <summary><strong>Citation</strong></summary>
    
  If you use ChemGraph in your research, please cite [our paper](https://doi.org/10.1038/s42004-025-01776-9):
    
  ```bibtex
    @article{pham_chemgraph_2026,
    title = {{ChemGraph} as an agentic framework for computational chemistry workflows},
    url = {https://doi.org/10.1038/s42004-025-01776-9},
    doi = {10.1038/s42004-025-01776-9},
    author = {Pham, Thang D. and Tanikanti, Aditya and Ke\c{c}eli, Murat},
    date = {2026-01-08},
    author={Pham, Thang D and Tanikanti, Aditya and Ke{\c{c}}eli, Murat},
    journal={Communications Chemistry},
    year={2026},
    publisher={Nature Publishing Group UK London}
    }
  ```
  If you use the HPC integration features,  please also cite [our preprint](https://arxiv.org/abs/2604.07681):
  
  ```bibtex
    @misc{pham2026multiagent,
    title         = {Multi-Agent Orchestration for High-Throughput Materials Screening on a Leadership-Class System},
    author        = {Pham, Thang Duc and Tummalapalli, Harikrishna and Bhuiyan, Fakhrul Hasan and V{\'a}zquez Mayagoitia, {\'A}lvaro and Simpson, Christine and Balin, Riccardo and Vishwanath, Venkatram and Ke{\c{c}}eli, Murat},
    year          = {2026},
    eprint        = {2604.07681},
    archivePrefix = {arXiv},
    primaryClass  = {cs.AI},
    doi           = {10.48550/arXiv.2604.07681},
    url           = {https://arxiv.org/abs/2604.07681}
}
  ```
 </details>
<details>
  <summary><strong>Acknowledgments</strong></summary>
This research used resources of the Argonne Leadership Computing Facility, a U.S.
Department of Energy (DOE) Office of Science user facility at Argonne National
Laboratory and is based on research supported by the U.S. DOE Office of Science-
Advanced Scientific Computing Research Program, under Contract No. DE-AC02-
06CH11357. Our work leverages ALCF Inference Endpoints, which provide a robust API
for LLM inference on ALCF HPC clusters via Globus Compute. We are thankful to Serkan
Altuntaş for his contributions to the user interface of ChemGraph and for insightful
discussions on AIOps.
</details>

<details>
  <summary><strong>License</strong></summary>
This project is licensed under the Apache 2.0 License.
</details>
