Agent skill

Mat Raman Spectra

by learningmatter-mit in learningmatter-mit/AtomisticSkills

Calculate Raman-active phonon mode frequencies and simulate Raman spectra from MLIP phonon calculations; optionally compute full Raman intensities with DFT Born charges via atomate2.

MITAuto-check passed

Install Mat Raman Spectra

skills CLI
$ npx skills add learningmatter-mit/AtomisticSkills --skill mat-raman-spectra -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install learningmatter-mit/AtomisticSkills mat-raman-spectra --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/learningmatter-mit/AtomisticSkills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/mat-raman-spectra .claude/skills/mat-raman-spectra && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
mat-raman-spectra
GitHub stars
176
Token cost
~2.3k tokens
SKILL.md length
779 words
Files
7 (incl. scripts)
Skills in repo
129
Repo updated
First seen
Licence
MIT

At a glance

Calculate Raman-active phonon mode frequencies and simulate Raman spectra from MLIP phonon calculations; optionally compute full Raman intensities with DFT Born charges via atomate2.

  • Works in 5 steps: Relax Structure → Calculate Phonons (MLIP) → Analyse Raman-Active Modes and Simulate… → …
  • SKILL.md covers Goal, Prerequisites, Instructions and Examples, plus 2 more sections
  • Runs Python scripts from its folder

What it does

Mat Raman Spectra is an agent skill from learningmatter-mit/AtomisticSkills. Calculate Raman-active phonon mode frequencies and simulate Raman spectra from MLIP phonon calculations; optionally compute full Raman intensities with DFT Born charges via atomate2.

Its SKILL.md is about 2.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 9 other files, including scripts (for example `examples/tio2-rutile/README.md`, `examples/tio2-rutile/raman_modes.json` and `examples/tio2-rutile/replot.py`).

It works with Model Context Protocol. The repository describes itself as: Integrating AtomisticSkills into Agentic IDEs (Cursor, Claude Code, Codex, Google Antigravity, Hermes Agent, etc). The licence is MIT.

Example prompts

  • “/mat-raman-spectra”

Requirements

  • Python 3

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Relax Structure
  2. Calculate Phonons (MLIP)
  3. Analyse Raman-Active Modes and Simulate Spectrum (MLIP Tier)
  4. Compute Full Raman Intensities (DFT Tier — Optional)
  5. Compare with Experiment (Optional)

What it can do on your machine

Read from SKILL.md and the folder at commit 6257444. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • doi.org
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Mat Raman Spectra loads about 2.3k tokens when it runs. Until then it costs about 50 tokens; SKILL.md has 779 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~50
When it runs · the whole SKILL.md, loaded when a task matches
~2.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from learningmatter-mit/AtomisticSkills at commit 6257444, republished under its MIT licence (© learningmatter-mit). 779 words, ~2,274 tokens.

Download SKILL.mdSave it as .claude/skills/mat-raman-spectra/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
mat-raman-spectra
description
Calculate Raman-active phonon mode frequencies and simulate Raman spectra from MLIP phonon calculations; optionally compute full Raman intensities with DFT Born charges via atomate2.
metadata.category
materials
metadata.venv
cpu, mlip

Raman Spectra Calculation

<!-- mcp-tools-note -->

[!NOTE] Steps written server.tool are MCP tool calls: mace.load_model is the load_model tool of the mace server (mcp__mace__load_model, or mcp__plugin_atomistic-skills_mace__load_model when installed as a plugin). Without a connected server, run the same tools from the shell. Tools named in one command share a process, so a model loaded by load_model stays loaded:

bash
${CLAUDE_SKILL_DIR}/../../venv/run mlip python -m src.mcp_server.cli mace load_model key=value relax_structure key=value
${CLAUDE_SKILL_DIR}/../../venv/run cpu python -m src.mcp_server.cli atomate2 run_atomate2_vasp_calculation key=value get_atomate2_job_status key=value

Goal

To calculate the Raman spectrum of a crystalline material by:

  1. Identifying Raman-active phonon modes via group-theory symmetry analysis of Γ-point phonons (MLIP-only path)
  2. Optionally computing full Raman scattering intensities using DFT-level Born effective charges and dielectric tensors (DFT path)

Physical background: Raman scattering intensity of mode $\nu$ is proportional to $|(\hat{e}i \cdot \alpha\nu \cdot \hat{e}s)|^2$, where $\alpha\nu = d\boldsymbol{\alpha}/dQ_\nu$ is the Raman tensor (derivative of polarizability with respect to mode coordinate $Q_\nu$). Computing $\alpha_\nu$ requires DFT-level dielectric calculations; phonon frequencies alone can be obtained with MLIPs.

[!IMPORTANT] Two-tier approach:

  • MLIP tier (Step 1–3): Predicts Raman peak positions (frequencies). Intensities are set equal as a placeholder. Sufficient for peak assignment and comparison with experiment when known structure is available.
  • DFT tier (Step 4): Computes actual Raman intensities via Born charges and dielectric tensor from VASP DFPT. Required for quantitative intensity matching.

Prerequisites

  • Pymatgen, phonopy installed in cpu (for symmetry analysis and plotting)
  • MLIP environment (mlip for MACE or MatGL, or fairchem) for phonon calculation

Instructions

1. Relax Structure

Before computing phonons, ensure the structure is fully relaxed. Use the MCP tool for your chosen MLIP:

bash
mace.load_model(model_name="MACE-MH-1")
mace.relax_structure(
    structure_data="input_structure.cif",
    relax_cell=True,
    fmax=0.001,       # tight convergence for phonons
    output_dir="relaxation/"
)

[!IMPORTANT] Use a tight force convergence (fmax ≤ 0.001 eV/Å) for phonon calculations. Poorly relaxed structures produce imaginary frequencies that indicate a false structural instability.

2. Calculate Phonons (MLIP)

Use the mat-phonon skill to compute Γ-point phonons. The output phonon.yaml is the required input for this skill.

bash
${CLAUDE_SKILL_DIR}/../../venv/run mlip python ${CLAUDE_SKILL_DIR}/../mat-phonon/scripts/calculate_phonon.py \
    --structure relaxation/relaxed_structure.cif \
    --model_type mace \
    --model_name MACE-MH-1 \
    --supercell_matrix '[[2,0,0],[0,2,0],[0,0,2]]' \
    --output_dir phonon_results/

Verify the output: check phonon_results/phonon.yaml exists and there are no large imaginary modes at Γ.

3. Analyse Raman-Active Modes and Simulate Spectrum (MLIP Tier)
bash
${CLAUDE_SKILL_DIR}/../../venv/run cpu python ${CLAUDE_SKILL_DIR}/scripts/analyze_raman_modes.py \
    --phonon-yaml phonon_results/phonon.yaml \
    --structure relaxation/relaxed_structure.cif \
    --output-dir raman_results/ \
    --broadening 5.0 \
    --freq-max 1000

Parameters:

ParameterDescriptionDefault
--phonon-yamlPath to phonon.yaml from mat-phononrequired
--structureRelaxed structure file (CIF/POSCAR)required
--output-dirOutput directory./raman_results
--broadeningLorentzian half-width at half-maximum (cm⁻¹)5.0
--freq-maxMaximum frequency for spectrum plot (cm⁻¹)1000
--laser-wavelengthLaser wavelength in nm (for intensity pre-factor, if using DFT intensities)532

Output files:

  • raman_modes.json — table of all Γ-point modes with symmetry label, frequency, and Raman-activity classification
  • raman_spectrum.png/svg — simulated spectrum (MLIP tier uses equal intensities; DFT tier uses computed intensities)
  • raman_modes_table.csv — CSV table for further analysis

[!NOTE] On Raman intensity accuracy: The MLIP tier assigns equal intensity to all Raman-active modes. Peak positions are reliable; relative intensities are not. For quantitative comparison with experiment, proceed to Step 4.

Show full SKILL.md (332 more words)Show less
4. Compute Full Raman Intensities (DFT Tier — Optional)

This step uses VASP DFPT via atomate2 to obtain Born effective charges and the macroscopic dielectric tensor, then combines them with MLIP phonon eigenvectors to compute Raman tensors.

4a. Run VASP DFPT for Born charges + dielectric tensor:

The atomate2 server has no dedicated DFPT job, so run a static calculation with the DFPT tags as INCAR overrides:

bash
atomate2.run_atomate2_vasp_calculation(
    structures_path="relaxation/relaxed_structure.cif",
    output_dir="vasp_dfpt/",
    calculation_type="static",
    # DFPT: macroscopic dielectric tensor and Born effective charges
    config={"LEPSILON": True, "IBRION": 8, "EDIFF": 1e-8, "ENCUT": 520},
    execution_mode="local",  # "remote" submits through jobflow-remote instead
)

For a remote run, check on the job and fetch its results once it finishes:

bash
atomate2.get_atomate2_job_status(job_id="<job_id>")
atomate2.get_atomate2_results_by_id(job_ids=["<job_id>"], save_to_file="vasp_dfpt/results.json")

4b. Compute Raman intensities:

bash
${CLAUDE_SKILL_DIR}/../../venv/run cpu python ${CLAUDE_SKILL_DIR}/scripts/analyze_raman_modes.py \
    --phonon-yaml phonon_results/phonon.yaml \
    --structure relaxation/relaxed_structure.cif \
    --born-charges vasp_dfpt/OUTCAR \
    --output-dir raman_dft_results/ \
    --broadening 5.0

When --born-charges is provided, the script computes Raman tensors from the Born charges and dielectric tensor and uses the resulting intensities instead of equal weights.

5. Compare with Experiment (Optional)

If experimental Raman data is available as an image, use general-plot-digitizer or chem-db-spectra to extract peak positions and overlay with computed results.

Examples

Example: Rutile TiO₂

Rutile TiO₂ (point group D₄h) has 4 Raman-active modes at ~143, ~235, ~447, 612 cm⁻¹ experimentally.

bash
# 1. Relax with MACE
mace.load_model(model_name="MACE-MH-1")
mace.relax_structure(structure_data="TiO2_rutile.cif", relax_cell=True, fmax=0.001, output_dir="relax/")

# 2. Phonons
${CLAUDE_SKILL_DIR}/../../venv/run mlip python ${CLAUDE_SKILL_DIR}/../mat-phonon/scripts/calculate_phonon.py \
    --structure relax/relaxed_structure.cif --model_type mace --model_name MACE-MH-1 \
    --supercell_matrix '[[3,0,0],[0,3,0],[0,0,4]]' --output_dir phonon/

# 3. Raman analysis
${CLAUDE_SKILL_DIR}/../../venv/run cpu python ${CLAUDE_SKILL_DIR}/scripts/analyze_raman_modes.py \
    --phonon-yaml phonon/phonon.yaml --structure relax/relaxed_structure.cif \
    --output-dir raman/ --freq-max 800 --broadening 8.0

Expected: the script should identify B1g, Eg, A1g, and B2g modes (all Raman active in D₄h) with frequencies near experimental values.

Constraints

  • Tight relaxation first: Use fmax ≤ 0.001 eV/Å. Large residual forces produce spurious imaginary modes.
  • Supercell size: A 2×2×2 supercell (or larger) is recommended. The script reads pre-computed force constants from phonon.yaml; the supercell size affects the quality of Γ-point eigenvectors.
  • MLIP tier intensities: Equal intensities are used as a placeholder. Do not compare intensities from the MLIP tier quantitatively with experiment.
  • Acoustic modes: The three acoustic modes at Γ (near 0 cm⁻¹) are always excluded from the Raman spectrum.
  • Environments: Step 2 (phonon calculation) requires mlip (MACE or MatGL) or fairchem; Step 3 (analysis and plotting) runs in cpu.

References

  • Togo & Tanaka, "First principles phonon calculations in materials science", Scr. Mater., 2015. DOI
  • Lazzeri & Mauri, "First-principles calculation of vibrational Raman spectra in large systems", Phys. Rev. Lett., 2003. DOI
  • Batatia et al., "MACE: Higher Order Equivariant Message Passing Neural Networks for Fast and Accurate Force Fields", NeurIPS, 2022.

Author: Yu Yao Contact: GitHub @AI4SciDisc

© learningmatter-mit, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (scripts) in skills/mat-raman-spectra of learningmatter-mit/AtomisticSkills.

  • SKILL.md
  • examples/tio2-rutile/README.md
  • examples/tio2-rutile/raman_modes.json
  • examples/tio2-rutile/raman_modes_table.csv
  • examples/tio2-rutile/raman_spectrum.png
  • examples/tio2-rutile/replot.py
  • scripts/analyze_raman_modes.py

Open the folder on GitHubat commit 6257444

Compare with similar skills

Mat Raman Spectra next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Mat Raman Spectra compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Mat Raman Spectra this skilllearningmatter-mit/AtomisticSkills176—~2.3kAutomated safety check: PassMIT
MCP Server Builderanthropics/skills180k64 repos~2.3kAutomated safety check: PassApache-2.0
MCP Server BuildershareAI-lab/learn-claude-code78k5 repos~1.2kAutomated safety check: PassMIT
MCP Integration for Pluginsanthropics/claude-plugins-official38k11 repos~3.1kAutomated safety check: PassApache-2.0
Figma use_figma Plugin API Ruleswarpdotdev/warp65k4 repos~4.4kAutomated safety check: PassAGPL-3.0
Stitch to Remotion Walkthrough Videosgoogle-labs-code/stitch-skills8.4k6 repos~3.2kAutomated safety check: NotesApache-2.0

Similar skills

  • MCP Server Builder

    anthropics/skills

    Official

    Guides the design and implementation of Model Context Protocol servers in TypeScript or Python, from tool naming and error messages to evaluation.

    180k GitHub starsUsed in 64 repos~2.3k tokens
    Agent WorkflowsAuto-check passed
  • MCP Server Builder

    shareAI-lab/learn-claude-code

    Walks through building MCP servers in Python or TypeScript that expose tools, resources and prompts to Claude, with templates, registration and testing.

    78k GitHub starsUsed in 5 repos~1.2k tokens
    Agent WorkflowsAuto-check passed
  • MCP Integration for Plugins

    anthropics/claude-plugins-official

    Official

    Explains how to bundle Model Context Protocol servers in a Claude Code plugin, covering config files, stdio, SSE, HTTP and WebSocket server types, and authentication.

    38k GitHub starsUsed in 11 repos~3.1k tokens
    Agent WorkflowsAuto-check passed
  • Required groundwork before any use_figma call: the rules and reference files for running JavaScript in a Figma file through the Plugin API without common failures.

    65k GitHub starsUsed in 4 repos~4.4k tokens
    Frontend & DesignAuto-check passed
  • Stitch to Remotion Walkthrough Videos

    google-labs-code/stitch-skills

    Official

    Builds walkthrough videos from Stitch design projects using Remotion, with transitions, zoom effects and text overlays on each screen.

    8.4k GitHub starsUsed in 6 repos~3.2k tokens
    Media & CreativeAuto-check: notes
  • MCP Development

    coollabsio/coolify

    A skill your agent uses for Laravel MCP development. An agent skill from coollabsio/coolify.

    63k GitHub starsUsed in 1 repo~949 tokens
    Frontend & DesignAuto-check passed

More from learningmatter-mit/AtomisticSkills

All 129 skills in this repo
  • Drug Binding Site Definition

    learningmatter-mit/AtomisticSkills

    Define a docking search box (center coordinates + box dimensions in Angstroms) from a co-crystal ligand, binding-site residues, or a saved JSON specification.

    176 GitHub stars~2.9k tokensUpdated yesterday
    Auto-check passed
  • Drug Complex System Builder

    learningmatter-mit/AtomisticSkills

    Build a solvated, charge-neutralized protein-ligand complex for OpenMM molecular dynamics simulation.

    176 GitHub stars~2k tokensUpdated yesterday
    Auto-check passed
  • Drug Pocket Detection

    learningmatter-mit/AtomisticSkills

    Identify and rank ligandable pockets on a protein structure or model using geometry (fpocket) or an ML predictor (P2Rank).

    176 GitHub stars~4k tokensUpdated yesterday
    Auto-check passed
  • Chem Bond Dissociation

    learningmatter-mit/AtomisticSkills

    Calculate homolytic and heterolytic bond dissociation energies (BDEs) for all single bonds in a molecule using MLIPs with RDKit fragmentation.

    176 GitHub stars~2.5k tokensUpdated yesterday
    Auto-check passed
  • Chem Conformer Search

    learningmatter-mit/AtomisticSkills

    Generate molecular conformers with RDKit ETKDG, relax with MLIPs, and rank by energy with Boltzmann weighting.

    176 GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed
  • Chem DB Mof

    learningmatter-mit/AtomisticSkills

    Query multiple MOF databases (QMOF via MPContribs; ARC-MOF DB7/Majumdar et al.

    176 GitHub stars~1.9k tokensUpdated yesterday
    Auto-check passed

Questions about Mat Raman Spectra

What does Mat Raman Spectra do?

Calculate Raman-active phonon mode frequencies and simulate Raman spectra from MLIP phonon calculations; optionally compute full Raman intensities with DFT Born charges via atomate2. Mat Raman Spectra is an agent skill from learningmatter-mit/AtomisticSkills. Calculate Raman-active phonon mode frequencies and simulate Raman spectra from MLIP phonon calculations; optionally compute full Raman intensities with DFT Born charges via atomate2.

How do I install Mat Raman Spectra in Claude Code?

Run `npx skills add learningmatter-mit/AtomisticSkills --skill mat-raman-spectra -a claude-code`. Or copy the skill folder (skills/mat-raman-spectra in learningmatter-mit/AtomisticSkills) into .claude/skills/mat-raman-spectra in your project. Claude Code loads it when a task matches its description.

How do I install Mat Raman Spectra in Codex?

Run `npx skills add learningmatter-mit/AtomisticSkills --skill mat-raman-spectra -a codex`. Or copy the skill folder (skills/mat-raman-spectra in learningmatter-mit/AtomisticSkills) into .agents/skills/mat-raman-spectra in your project. Codex loads it when a task matches its description.

Can I use Mat Raman Spectra in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add learningmatter-mit/AtomisticSkills --skill mat-raman-spectra -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/mat-raman-spectra, .gemini/skills/mat-raman-spectra, .github/skills/mat-raman-spectra and .opencode/skills/mat-raman-spectra in your project.

What does Mat Raman Spectra need to run?

Going by SKILL.md and its folder, Mat Raman Spectra needs Python for the scripts in its folder. Our summary lists: Python 3.

Does Mat Raman Spectra access the network?

SKILL.md names 2 domains. As links in the text: doi.org and github.com. This is read from the text; nothing was executed.

Is Mat Raman Spectra safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Mat Raman Spectra use?

Mat Raman Spectra is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Mat Raman Spectra use?

About 2.3k tokens (SKILL.md is roughly 9.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Mat Raman Spectra?

Skills that share tags, products or a category with Mat Raman Spectra: MCP Server Builder (anthropics/skills, 180k stars), MCP Server Builder (shareAI-lab/learn-claude-code, 78k stars), MCP Integration for Plugins (anthropics/claude-plugins-official, 38k stars) and Figma use_figma Plugin API Rules (warpdotdev/warp, 65k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Mat Raman Spectra?

learningmatter-mit (a GitHub organization) maintains it in learningmatter-mit/AtomisticSkills, which has 176 GitHub stars. The repository holds 129 skills in this directory. The repository was last updated on October 7, 2026.

Source: learningmatter-mit/AtomisticSkills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.