pi-skill-search 0.1.0

package/skills/market-research-reports/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: market-research-reports
+description: Generate comprehensive market research reports (50+ pages) in the style of top consulting firms (McKinsey, BCG, Gartner). Features professional LaTeX formatting, extensive visual generation with scientific-schematics and generate-image, deep integration with research-lookup for data gathering, and multi-framework strategic analysis including Porter Five Forces, PESTLE, SWOT, TAM/SAM/SOM, and BCG Matrix.
+---
+
+# Market Research Reports
+
+## Overview
+
+Market research reports are comprehensive strategic documents that analyze industries, markets, and competitive landscapes to inform business decisions, investment strategies, and strategic planning. This skill generates **professional-grade reports of 50+ pages** with extensive visual content, modeled after deliverables from top consulting firms like McKinsey, BCG, Bain, Gartner, and Forrester.
+
+**Key Features:**
+- **Comprehensive length**: Reports are designed to be 50+ pages with no token constraints
+- **Visual-rich content**: 5-6 key diagrams generated at start (more added as needed during writing)
+- **Data-driven analysis**: Deep integration with research-lookup for market data
+- **Multi-framework approach**: Porter's Five Forces, PESTLE, SWOT, BCG Matrix, TAM/SAM/SOM
+- **Professional formatting**: Consulting-firm quality typography, colors, and layout
+- **Actionable recommendations**: Strategic focus with implementation roadmaps
+
+**Output Format:** LaTeX with professional styling, compiled to PDF. Uses the `market_research.sty` style package for consistent, professional formatting.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Creating comprehensive market analysis for investment decisions
+- Developing industry reports for strategic planning
+- Analyzing competitive landscapes and market dynamics
+- Conducting market sizing exercises (TAM/SAM/SOM)
+- Evaluating market entry opportunities
+- Preparing due diligence materials for M&A activities
+- Creating thought leadership content for industry positioning
+- Developing go-to-market strategy documentation
+- Analyzing regulatory and policy impacts on markets
+- Building business cases for new product launches
+
+## Visual Enhancement Requirements
+
+**CRITICAL: Market research reports should include key visual content.**
+
+Every report should generate **6 essential visuals** at the start, with additional visuals added as needed during writing. Start with the most critical visualizations to establish the report framework.
+
+### Visual Generation Tools
+
+**Use `scientific-schematics` for:**
+- Market growth trajectory charts
+- TAM/SAM/SOM breakdown diagrams (concentric circles)
+- Porter's Five Forces diagrams
+- Competitive positioning matrices
+- Market segmentation charts
+- Value chain diagrams
+- Technology roadmaps
+- Risk heatmaps
+- Strategic prioritization matrices
+- Implementation timelines/Gantt charts
+- SWOT analysis diagrams
+- BCG Growth-Share matrices
+
+```bash
+# Example: Generate a TAM/SAM/SOM diagram
+python skills/scientific-schematics/scripts/generate_schematic.py \
+  "TAM SAM SOM concentric circle diagram showing Total Addressable Market $50B outer circle, Serviceable Addressable Market $15B middle circle, Serviceable Obtainable Market $3B inner circle, with labels and arrows pointing to each segment" \
+  -o figures/tam_sam_som.png --doc-type report
+
+# Example: Generate Porter's Five Forces
+python skills/scientific-schematics/scripts/generate_schematic.py \
+  "Porter's Five Forces diagram with center box 'Competitive Rivalry' connected to four surrounding boxes: 'Threat of New Entrants' (top), 'Bargaining Power of Suppliers' (left), 'Bargaining Power of Buyers' (right), 'Threat of Substitutes' (bottom). Each box should show High/Medium/Low rating" \
+  -o figures/porters_five_forces.png --doc-type report
+```
+
+**Use `generate-image` for:**
+- Executive summary hero infographics
+- Industry/sector conceptual illustrations
+- Abstract technology visualizations
+- Cover page imagery
+
+```bash
+# Example: Generate executive summary infographic
+python skills/generate-image/scripts/generate_image.py \
+  "Professional executive summary infographic for market research report, showing key metrics in modern data visualization style, blue and green color scheme, clean minimalist design with icons representing market size, growth rate, and competitive landscape" \
+  --output figures/executive_summary.png
+```
+
+### Recommended Visuals by Section (Generate as Needed)
+
+| Section | Priority Visuals | Optional Visuals |
+|---------|-----------------|------------------|
+| Executive Summary | Executive infographic (START) | - |
+| Market Size & Growth | Growth trajectory (START), TAM/SAM/SOM (START) | Regional breakdown, segment growth |
+| Competitive Landscape | Porter's Five Forces (START), Positioning matrix (START) | Market share chart, strategic groups |
+| Risk Analysis | Risk heatmap (START) | Mitigation matrix |
+| Strategic Recommendations | Opportunity matrix | Priority framework |
+| Implementation Roadmap | Timeline/Gantt | Milestone tracker |
+| Investment Thesis | Financial projections | Scenario analysis |
+
+**Start with 6 priority visuals** (marked as START above), then generate additional visuals as specific sections are written and require visual support.
+
+---
+
+## Report Structure (50+ Pages)
+
+### Front Matter (~5 pages)
+
+#### Cover Page (1 page)
+- Report title and subtitle
+- Hero visualization (generated)
+- Date and classification
+- Prepared for / Prepared by
+
+#### Table of Contents (1-2 pages)
+- Automated from LaTeX
+- List of Figures
+- List of Tables
+
+#### Executive Summary (2-3 pages)
+- **Market Snapshot Box**: Key metrics at a glance
+
+### Core Analysis (~35 pages)
+
+

package/skills/markitdown/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: markitdown
+description: Convert files and office documents to Markdown. Supports PDF, DOCX, PPTX, XLSX, images (with OCR), audio (with transcription), HTML, CSV, JSON, XML, ZIP, YouTube URLs, EPubs and more.
+---
+
+# MarkItDown - File to Markdown Conversion
+
+## Overview
+
+MarkItDown is a Python tool developed by Microsoft for converting various file formats to Markdown. It's particularly useful for converting documents into LLM-friendly text format, as Markdown is token-efficient and well-understood by modern language models.
+
+**Key Benefits**:
+- Convert documents to clean, structured Markdown
+- Token-efficient format for LLM processing
+- Supports 15+ file formats
+- Optional AI-enhanced image descriptions
+- OCR for images and scanned documents
+- Speech transcription for audio files
+
+## Visual Enhancement with Scientific Schematics
+
+**When creating documents with this skill, always consider adding scientific diagrams and schematics to enhance visual communication.**
+
+If your document does not already contain schematics or diagrams:
+- Use the **scientific-schematics** skill to generate AI-powered publication-quality diagrams
+- Simply describe your desired diagram in natural language
+- Nano Banana Pro will automatically generate, review, and refine the schematic
+
+**For new documents:** Scientific schematics should be generated by default to visually represent key concepts, workflows, architectures, or relationships described in the text.
+
+**How to generate schematics:**
+```bash
+python scripts/generate_schematic.py "your diagram description" -o figures/output.png
+```
+
+## Quick Start
+
+# Or from source
+git clone https://github.com/microsoft/markitdown.git
+cd markitdown
+pip install -e 'packages/markitdown[all]'
+```
+
+### Command-Line Usage
+
+```bash
+# Basic conversion
+markitdown document.pdf > output.md
+
+# Specify output file
+markitdown document.pdf -o output.md
+
+# Pipe content
+cat document.pdf | markitdown > output.md
+
+# Enable plugins
+markitdown --list-plugins  # List available plugins
+markitdown --use-plugins document.pdf -o output.md
+```
+
+### Python API
+
+```python
+from markitdown import MarkItDown
+
+# Basic usage
+md = MarkItDown()
+result = md.convert("document.pdf")
+print(result.text_content)
+
+# Convert from stream
+with open("document.pdf", "rb") as f:
+    result = md.convert_stream(f, file_extension=".pdf")
+    print(result.text_content)
+```
+
+## Advanced Features
+
+### 1. AI-Enhanced Image Descriptions
+
+Use LLMs via OpenRouter to generate detailed image descriptions (for PPTX and image files):
+
+```python
+from markitdown import MarkItDown
+from openai import OpenAI
+
+# Initialize OpenRouter client (OpenAI-compatible API)
+client = OpenAI(
+    api_key="your-openrouter-api-key",
+    base_url="https://openrouter.ai/api/v1"
+)
+
+md = MarkItDown(
+    llm_client=client,
+    llm_model="anthropic/claude-opus-4.5",  # recommended for scientific vision
+    llm_prompt="Describe this image in detail for scientific documentation"
+)
+
+result = md.convert("presentation.pptx")
+print(result.text_content)
+```
+
+### 2. Azure Document Intelligence
+
+For enhanced PDF conversion with Microsoft Document Intelligence:
+
+```bash
+# Command line
+markitdown document.pdf -o output.md -d -e "<document_intelligence_endpoint>"
+
+

package/skills/markitdown-docs/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: markitdown-docs
+description: Document conversion and format transformation. Use when converting between document formats (PDF, Word, HTML, Markdown), extracting text from binary formats, or processing structured documents. Trigger on imports of markitdown, pdfplumber, python-docx, or mentions of convert, PDF, document, format, extract text.
+---
+# markitdown-docs
+
+Use this skill for document format conversion and text extraction.
+
+## Core patterns
+
+- **PDF text**: `markitdown.convert('file.pdf')` for markdown output.
+- **Word**: `python-docx.Document('file.docx')` for structured access.
+- **HTML**: `BeautifulSoup(html, 'html.parser')` for web content extraction.
+- **Batch**: Loop directory with glob pattern for bulk conversion.
+
+## Rules
+
+- Always try `markitdown` first — it handles most formats automatically.
+- For scanned PDFs, use OCR (`pytesseract`) after converting to images.
+- Validate extracted text length — empty output may indicate encoding issues.
+
+## Anti-patterns
+
+- Don't assume PDF text extraction is 100% accurate — verify critical content.
+- Don't process large document collections sequentially — use parallel workers.
+- Don't ignore file encoding — always specify `encoding='utf-8'` when writing.
+
+

package/skills/matchms/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: matchms
+description: Spectral similarity and compound identification for metabolomics. Use for comparing mass spectra, computing similarity scores (cosine, modified cosine), and identifying unknown compounds from spectral libraries. Best for metabolite identification, spectral matching, library searching. For full LC-MS/MS proteomics pipelines use pyopenms.
+---
+
+# Matchms
+
+## Overview
+
+Matchms is an open-source Python library for mass spectrometry data processing and analysis. Import spectra from various formats, standardize metadata, filter peaks, calculate spectral similarities, and build reproducible analytical workflows.
+
+## Core Capabilities
+
+### 1. Importing and Exporting Mass Spectrometry Data
+
+Load spectra from multiple file formats and export processed data:
+
+```python
+from matchms.importing import load_from_mgf, load_from_mzml, load_from_msp, load_from_json
+from matchms.exporting import save_as_mgf, save_as_msp, save_as_json
+
+# Import spectra
+spectra = list(load_from_mgf("spectra.mgf"))
+spectra = list(load_from_mzml("data.mzML"))
+spectra = list(load_from_msp("library.msp"))
+
+# Export processed spectra
+save_as_mgf(spectra, "output.mgf")
+save_as_json(spectra, "output.json")
+```
+
+**Supported formats:**
+- mzML and mzXML (raw mass spectrometry formats)
+- MGF (Mascot Generic Format)
+- MSP (spectral library format)
+- JSON (GNPS-compatible)
+- metabolomics-USI references
+- Pickle (Python serialization)
+
+For detailed importing/exporting documentation, consult `(see docs)`.
+
+### 2. Spectrum Filtering and Processing
+
+Apply comprehensive filters to standardize metadata and refine peak data:
+
+```python
+from matchms.filtering import default_filters, normalize_intensities
+from matchms.filtering import select_by_relative_intensity, require_minimum_number_of_peaks
+
+# Apply default metadata harmonization filters
+spectrum = default_filters(spectrum)
+
+# Normalize peak intensities
+spectrum = normalize_intensities(spectrum)
+
+# Filter peaks by relative intensity
+spectrum = select_by_relative_intensity(spectrum, intensity_from=0.01, intensity_to=1.0)
+
+# Require minimum peaks
+spectrum = require_minimum_number_of_peaks(spectrum, n_required=5)
+```
+
+**Filter categories:**
+- **Metadata processing**: Harmonize compound names, derive chemical structures, standardize adducts, correct charges
+- **Peak filtering**: Normalize intensities, select by m/z or intensity, remove precursor peaks
+- **Quality control**: Require minimum peaks, validate precursor m/z, ensure metadata completeness
+- **Chemical annotation**: Add fingerprints, derive InChI/SMILES, repair structural mismatches
+
+Matchms provides 40+ filters. For the complete filter reference, consult `(see docs)`.
+
+### 3. Calculating Spectral Similarities
+
+Compare spectra using various similarity metrics:
+
+```python
+from matchms import calculate_scores
+from matchms.similarity import CosineGreedy, ModifiedCosine, CosineHungarian
+
+# Calculate cosine similarity (fast, greedy algorithm)
+scores = calculate_scores(references=library_spectra,
+                         queries=query_spectra,
+                         similarity_function=CosineGreedy())
+
+# Calculate modified cosine (accounts for precursor m/z differences)
+scores = calculate_scores(references=library_spectra,
+                         queries=query_spectra,
+                         similarity_function=ModifiedCosine(tolerance=0.1))
+
+# Get best matches
+best_matches = scores.scores_by_query(query_spectra[0], sort=True)[:10]
+```

package/skills/matlab/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: matlab
+description: MATLAB and GNU Octave numerical computing for matrix operations, data analysis, visualization, and scientific computing. Use when writing MATLAB/Octave scripts for linear algebra, signal processing, image processing, differential equations, optimization, statistics, or creating scientific visualizations. Also use when the user needs help with MATLAB syntax, functions, or wants to convert between MATLAB and Python code. Scripts can be executed with MATLAB or the open-source GNU Octave interpreter.
+---
+
+# MATLAB/Octave Scientific Computing
+
+MATLAB is a numerical computing environment optimized for matrix operations and scientific computing. GNU Octave is a free, open-source alternative with high MATLAB compatibility.
+
+## Quick Start
+
+**Running MATLAB scripts:**
+```bash
+# MATLAB (commercial)
+matlab -nodisplay -nosplash -r "run('script.m'); exit;"
+
+# GNU Octave (free, open-source)
+octave script.m
+```
+
+**Install GNU Octave:**
+```bash
+# macOS
+brew install octave
+
+# Ubuntu/Debian
+sudo apt install octave
+
+# Windows - download from https://octave.org/download
+```
+
+## Core Capabilities
+
+### 1. Matrix Operations
+
+MATLAB operates fundamentally on matrices and arrays:
+
+```matlab
+% Create matrices
+A = [1 2 3; 4 5 6; 7 8 9];  % 3x3 matrix
+v = 1:10;                     % Row vector 1 to 10
+v = linspace(0, 1, 100);      % 100 points from 0 to 1
+
+% Special matrices
+I = eye(3);          % Identity matrix
+Z = zeros(3, 4);     % 3x4 zero matrix
+O = ones(2, 3);      % 2x3 ones matrix
+R = rand(3, 3);      % Random uniform
+
+### 2. Linear Algebra
+
+```matlab
+% Eigenvalues and eigenvectors
+[V, D] = eig(A);     % V: eigenvectors, D: diagonal eigenvalues
+
+% Singular value decomposition
+[U, S, V] = svd(A);
+
+% Matrix decompositions
+[L, U] = lu(A);      % LU decomposition
+[Q, R] = qr(A);      % QR decomposition
+R = chol(A);         % Cholesky (symmetric positive definite)
+
+% Solve linear systems
+
+### 3. Plotting and Visualization
+
+```matlab
+% 2D Plots
+x = 0:0.1:2*pi;
+y = sin(x);
+plot(x, y, 'b-', 'LineWidth', 2);
+xlabel('x'); ylabel('sin(x)');
+title('Sine Wave');
+grid on;
+
+% Multiple plots
+hold on;
+plot(x, cos(x), 'r--');
+legend('sin', 'cos');
+
+### 4. Data Import/Export
+
+```matlab
+% Read tabular data
+T = readtable('data.csv');
+M = readmatrix('data.csv');
+
+% Write data
+writetable(T, 'output.csv');
+writematrix(M, 'output.csv');
+
+% MAT files (MATLAB native)
+save('data.mat', 'A', 'B', 'C');  % Save variables
+load('data.mat');                   % Load all
+S = load('data.mat', 'A');         % Load specific
+
+### 5. Control Flow and Functions
+
+```matlab
+% Conditionals
+if x > 0
+    disp('positive');
+elseif x < 0
+    disp('negative');
+else
+    disp('zero');
+end
+
+% Loops
+for i = 1:10
+    disp(i);
+
+### 6. Statistics and Data Analysis
+
+```matlab
+
+

package/skills/matplotlib/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: matplotlib
+description: Publication-quality data visualization and plotting. Use when creating figures, charts, plots, heatmaps, scatter plots, bar charts, subplots, or customizing axes, legends, colormaps. Trigger on imports of matplotlib, pyplot, plt, or mentions of plotting, visualization, figure, chart, graph rendering.
+---
+# matplotlib
+
+Use this skill for creating publication-quality scientific plots.
+
+## Core patterns
+
+- **Figure + Axes**: `fig, ax = plt.subplots(nrows, ncols, figsize=(8, 6))`.
+- **Plot types**: `ax.plot()`, `ax.scatter()`, `ax.bar()`, `ax.hist()`, `ax.imshow()`.
+- **Labels**: `ax.set_xlabel()`, `ax.set_ylabel()`, `ax.set_title()`.
+- **Legend**: `ax.legend(loc='best')` after label= in plot calls.
+- **Save**: `fig.savefig('out.png', dpi=300, bbox_inches='tight')`.
+
+## Rules
+
+- Always use OO interface (`fig, ax`) — never `plt.plot()` for complex figures.
+- Close figures: `plt.close(fig)` to prevent memory leaks in loops.
+- Set `dpi=300` for publications; `dpi=72` for screen/web.
+- Use `tight_layout()` or `constrained_layout=True` to avoid label clipping.
+
+## Anti-patterns
+
+- Don't call `plt.show()` in scripts — use `savefig()` instead.
+- Don't create hundreds of figures without closing — memory leak.
+- Don't hardcode colors for categories — use colormaps (`viridis`, `tab10`).
+
+

package/skills/mcp-setup/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: mcp-setup
+description: Configure popular MCP servers for enhanced agent capabilities
+---
+
+
+# MCP Setup
+
+Configure Model Context Protocol (MCP) servers to extend Claude Code's capabilities with external tools like web search, file system access, and GitHub integration.
+
+## Overview
+
+MCP servers provide additional tools that Claude Code agents can use. This skill helps you configure popular MCP servers using the `claude mcp add` command-line interface.
+
+## Step 1: Choose a Setup Path
+
+Use **AskUserQuestion** with **one question at a time** and **no more than 3 options per question**. Recent Claude Code builds reject larger option payloads as invalid tool parameters, so keep the MCP selection flow staged.
+
+### Step 1.1: First menu
+
+**Question:** "What kind of MCP setup would you like?"
+
+**Options:**
+1. **Recommended starter setup** - Fast path for the most common OMC MCP additions
+2. **Individual popular server** - Pick one built-in server from a short follow-up menu
+3. **Custom server** - Add your own stdio or HTTP MCP server
+
+### Step 1.2: If the user chooses "Recommended starter setup"
+
+Ask a follow-up **AskUserQuestion**:
+
+**Question:** "Which recommended MCP bundle should I configure?"
+
+**Options:**
+1. **Context7 only (Recommended)** - Zero-config docs/context server
+2. **Context7 + Exa** - Docs/context plus enhanced web search
+3. **Full recommended bundle** - Context7, Exa, Filesystem, and GitHub
+
+Map that choice to the server list you will configure.
+
+### Step 1.3: If the user chooses "Individual popular server"
+
+Ask a follow-up **AskUserQuestion**:
+
+**Question:** "Which server should I configure first?"
+
+**Options:**
+1. **Context7 (Recommended)** - Documentation and code context from popular libraries
+2. **Exa Web Search** - Enhanced web search (replaces built-in websearch)
+3. **More server choices** - Filesystem, GitHub, or the full recommended bundle
+
+If the user chooses **More server choices**, ask one more **AskUserQuestion**:
+
+**Question:** "Which additional MCP option do you want?"
+
+**Options:**
+1. **Filesystem (Recommended)** - Extended file system access with additional capabilities
+2. **GitHub** - GitHub API integration for issues, PRs, and repository management
+3. **Full recommended bundle** - Configure Context7, Exa, Filesystem, and GitHub together
+
+### Step 1.4: If the user chooses "Custom server"
+
+Skip directly to the **Custom MCP Server** section below.
+
+## Step 2: Gather Required Information
+
+### For Context7:
+No API key required. Ready to use immediately.
+
+### For Exa Web Search:
+Ask for API key:
+```
+Do you have an Exa API key?
+- Get one at: https://exa.ai
+- Enter your API key, or type 'skip' to configure later
+```
+
+### For Filesystem:
+Ask for allowed directories:
+```
+Which directories should the filesystem MCP have access to?
+Default: Current working directory
+Enter comma-separated paths, or press Enter for default
+```

package/skills/medchem/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: medchem
+description: Medicinal chemistry filters. Apply drug-likeness rules (Lipinski, Veber), PAINS filters, structural alerts, complexity metrics, for compound prioritization and library filtering.
+---
+
+# Medchem
+
+## Overview
+
+Medchem is a Python library for molecular filtering and prioritization in drug discovery workflows. Apply hundreds of well-established and novel molecular filters, structural alerts, and medicinal chemistry rules to efficiently triage and prioritize compound libraries at scale. Rules and filters are context-specific—use as guidelines combined with domain expertise.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Applying drug-likeness rules (Lipinski, Veber, etc.) to compound libraries
+- Filtering molecules by structural alerts or PAINS patterns
+- Prioritizing compounds for lead optimization
+- Assessing compound quality and medicinal chemistry properties
+- Detecting reactive or problematic functional groups
+- Calculating molecular complexity metrics
+
+## Core Capabilities
+
+### 1. Medicinal Chemistry Rules
+
+Apply established drug-likeness rules to molecules using the `medchem.rules` module.
+
+**Available Rules:**
+- Rule of Five (Lipinski)
+- Rule of Oprea
+- Rule of CNS
+- Rule of leadlike (soft and strict)
+- Rule of three
+- Rule of Reos
+- Rule of drug
+- Rule of Veber
+- Golden triangle
+- PAINS filters
+
+# Apply Rule of Five to a SMILES string
+smiles = "CC(=O)OC1=CC=CC=C1C(=O)O"  # Aspirin
+passes = mc.rules.basic_rules.rule_of_five(smiles)
+# Returns: True
+
+# Check specific rules
+passes_oprea = mc.rules.basic_rules.rule_of_oprea(smiles)
+passes_cns = mc.rules.basic_rules.rule_of_cns(smiles)
+```
+
+**Multiple Rules with RuleFilters:**
+
+```python
+import datamol as dm
+import medchem as mc
+
+# Load molecules
+mols = [dm.to_mol(smiles) for smiles in smiles_list]
+
+# Create filter with multiple rules
+rfilter = mc.rules.RuleFilters(
+    rule_list=[
+        "rule_of_five",
+        "rule_of_oprea",
+        "rule_of_cns",
+        "rule_of_leadlike_soft"
+    ]
+)
+
+# Apply filters with parallelization
+results = rfilter(
+    mols=mols,
+    n_jobs=-1,  # Use all CPU cores
+    progress=True
+)
+```
+
+**Result Format:**
+Results are returned as dictionaries with pass/fail status and detailed information for each rule.
+
+### 2. Structural Alert Filters
+
+Detect potentially problematic structural patterns using the `medchem.structural` module.
+
+**Available Filters:**
+
+1. **Common Alerts** - General structural alerts derived from ChEMBL curation and literature
+2. **NIBR Filters** - Novartis Institutes for BioMedical Research filter set
+3. **Lilly Demerits** - Eli Lilly's demerit-based system (275 rules, molecules rejected at >100 demerits)
+
+**Common Alerts:**
+
+```python
+import medchem as mc
+
+# Create filter
+alert_filter = mc.structural.CommonAlertsFilters()
+
+# Check single molecule
+mol = dm.to_mol("c1ccccc1")
+has_alerts, details = alert_filter.check_mol(mol)
+
+# Batch filtering with parallelization
+results = alert_filter(
+    mols=mol_list,
+    n_jobs=-1,
+    progress=True
+)
+
+