PCR Primer Design

Design and validate primers for PCR, qPCR and sequencing.

Overview

Problem. Need specific, dimer-free, valid primers to amplify DNA.

Learning goals

• Hard constraints: Tm match, no dimers, specificity
• Requirements differ by application

Figures

Tutorial

Comprehensive PCR and qPCR primer design following MIQE 2.0 guidelines with automated validation.

When to Use This Skill

Use this skill when you need: - ✅ qPCR primers with MIQE 2.0 compliance for publication - ✅ Standard PCR primers for cloning, genotyping, or amplification (100-1000 bp) - ✅ TaqMan probes for probe-based qPCR assays - ✅ Rigorous validation (specificity, dimers, secondary structures) - ✅ Publication-quality documentation with comprehensive reports

Quick Start (Example)

Test this skill with a sample qPCR design in ~2 minutes:

# Example: Design qPCR primers for a 700bp target sequence
from scripts.design_qpcr_primers import design_qpcr_primers

# Sample GAPDH sequence (700 bp, exon 3-4 region)
sequence = "ATGGGGAAGGTGAAGGTCGGAGTCAACGGATTTGGTCGTATTGGGCGCCTGGTCACCAGGGCTGCTTTTAACTCTGGTAAAGTGGATATTGTTGCCATCAATGACCCCTTCATTGACCTCAACTACATGGTTTACATGTTCCAATATGATTCCACCCATGGCAAATTCCATGGCACCGTCAAGGCTGAGAACGGGAAGCTTGTCATCAATGGAAATCCCATCACCATCTTCCAGGAGCGAGATCCCTCCAAAATCAAGTGGGGCGATGCTGGCGCTGAGTACGTCGTGGAGTCCACTGGCGTCTTCACCACCATGGAGAAGGCTGGGGCTCATTTGCAGGGGGGAGCCAAAAGGGTCATCATCTCTGCCCCCTCTGCTGATGCCCCCATGTTCGTCATGGGTGTGAACCATGAGAAGTATGACAACAGCCTCAAGATCATCAGCAATGCCTCCTGCACCACCAACTGCTTAGCACCCCTGGCCAAGGTCATCCATGACAACTTTGGTATCGTGGAAGGACTCATGACCACAGTCCATGCCATCACTGCCACCCAGAAGACTGTGGATGGCCCCTCCGGGAAACTGTGGCGTGATGGCCGCGGGGCTCTCCAGAACATCATCCCTGCCTCTACTGGCGCTGCCAAGGCTGTGGGCAAGGTCATCCCTGAGCTGAACGGGAAGCTCACTGGCATGGCCTTCCGTGTCCCCACTGCCAACGTGTCAGTGGTGGACCTGACCTGCCGTCTAGAAAAACCTGCCAAATATGATGACATCAAGAAGGTGGTGAAGCAGGCGTCGGAGGGCCCCCTCAAGGGCATCCTGGGCTACACTGAGCACCAGGTGGTCTCCTCTGACTTCAACAGCGACACCCACTCCTCCACCTTTGACGCTGGGGCTGGCATTGCCCTCAACGACCACTTTGTCAAGCTCATTTCCTGGTATGACAACGAATTTGGCTACAGCAACAGGGTGGTGGACCTCATGGCCCACATGGCCTCCAAGGAGTAAGACCCCTGGACCACCAGCCCCAGCAAGAGCACAAGAGGAAGAGAGAGACCCTCACTGCTGGGGAGTCCCTGCCACACTCAGTCCCCCACCACACTGAATCTCCCCTCCTCACAGTTGCCATGTAGACCCCTTGAAGAGGGGAGGGCTCTCTCTTCCTCTTGTGCTCTTGCTGGGGCTGGCATTGCCCTCAACGACCACTTTGTCAAGCTCATTTCCTGGTATGACAACG"

primers = design_qpcr_primers(
    sequence=sequence,
    amplicon_size_range=(80, 120),
    num_return=5
)

print(f"Found {len(primers['primers'])} primer pairs")
print(f"MIQE-compliant: {sum(p.get('miqe_compliant', False) for p in primers['primers'])}")

What you get: 3-5 MIQE-compliant primer pairs, amplicons 80-120 bp, Tm matched within 2°C

For your own data: Follow Clarification Questions below to provide your sequence.

Installation

Core packages:

pip install primer3-py biopython plotnine plotnine-prism pandas requests openpyxl

Recommended: Use virtual environment:

python -m venv pcr_env
source pcr_env/bin/activate  # Windows: pcr_env\Scripts\activate
pip install -r requirements.txt

Software Requirements

*GPL v2 permits use in AI agent applications (execution, not distribution).

NCBI API: Primer-BLAST access is free. Rate limit: 3 requests/second (no API key) or 10/second (with free API key). See references/primer_design_best_practices.md#ncbi-api-setup for API key setup.

Inputs

See references/primer_design_best_practices.md#input-preparation for sequence preparation guidelines.

Outputs

See references/code_examples.md#export-examples for format details.

Clarification Questions

1. Input Sequence (ASK THIS FIRST)

Do you have a specific DNA sequence to design primers for?

• Option A: Upload FASTA file or provide file path
• Option B: Provide GenBank/RefSeq accession (e.g., NM_001256799)
• Option C: Provide gene name + organism (will fetch from NCBI)
• Option D: Paste sequence directly

If uploaded: Is this the complete target sequence or a specific region?

Expected: 150+ bp for qPCR, 300+ bp for standard PCR

2. PCR Application

What is your intended use for these primers?

• qPCR (Quantitative PCR) - Gene expression, 70-140 bp amplicons, MIQE-compliant
• Standard PCR - General amplification, cloning, genotyping, 100-1000 bp amplicons
• TaqMan Assay - Probe-based qPCR with fluorescent detection
• Multiplex PCR - Multiple targets simultaneously, compatible Tm required
• Sequencing - Sanger sequencing, single-direction primer
• SNP Genotyping - Allele-specific amplification

Default: qPCR (most common for gene expression studies)

3. Design Parameters

Do you want to use application-specific default parameters or customize?

• Standard parameters (recommended) - Optimized for selected application
• Custom Tm range - Specify melting temperature range (default: 58-62°C for qPCR)
• Custom amplicon size - Specify product size range
• Custom GC range - Adjust GC% (default: 40-60%)
• Avoid regions - Exclude specific sequences (SNPs, repeats, etc.)

For qPCR: Target exon-exon junction or ensure intron >1kb (MIQE guideline)?

To understand design parameters: See references/parameter_ranges.md

4. Validation Level

How thoroughly should primers be validated?

• Basic - Tm, GC%, dimer check (~1 min, sufficient for most uses)
• Standard - Basic + in-silico PCR (~2-3 min, recommended)
• Complete - Standard + NCBI Primer-BLAST (~5-10 min, publication-quality)
• MIQE-compliant - Complete + full documentation (qPCR only, ~10 min)

Note: NCBI Primer-BLAST requires internet and respects rate limits (slower but most thorough).

5. Output Requirements

What outputs do you need?

• Export format: CSV (default), Excel, JSON, IDT order format, or MIQE checklist
• Report format: Markdown (default), HTML, or text
• Visualizations: Generate primer alignment plots? (yes/no)
• Number of primers: How many primer pairs to return? (default: 5)

For qPCR: MIQE checklist is automatically generated.

Standard Workflow

🚨 EXECUTE EXACTLY AS SHOWN - Do not modify these commands.

CRITICAL: Use relative paths (scripts/, references/). DO NOT construct absolute paths.

Step 1: Load Target Sequence

Option A: Load from FASTA file

from Bio import SeqIO
record = SeqIO.read("your_sequence.fasta", "fasta")
sequence = str(record.seq)

Option B: Load from GenBank accession

See references/code_examples.md#loading-sequences for NCBI fetching code.

Option C: Paste sequence directly

# For quick testing, paste your target sequence
sequence = "ATGGGGAAGGTGAAGGTCGGAGTCAACGGATTTGGTCGTATTGGG..."  # Your sequence here

Step 2: Design Primers

Choose based on application (from Clarification Question #2):

For qPCR (most common):

from scripts.design_qpcr_primers import design_qpcr_primers

primers = design_qpcr_primers(
    sequence=sequence,
    amplicon_size_range=(70, 140),  # MIQE guideline
    tm_match_threshold=2.0,
    num_return=5
)

For Standard PCR:

from scripts.design_standard_primers import design_pcr_primers

primers = design_pcr_primers(
    sequence=sequence,
    amplicon_size_range=(100, 1000),
    tm_range=(55, 65),
    num_return=5
)

For TaqMan Assay:

from scripts.design_taqman_probes import design_taqman_assay

assay = design_taqman_assay(
    sequence=sequence,
    probe_tm_offset=8.0,  # Probe Tm = primer Tm + 8°C
    num_return=5
)

For custom parameters: Read references/parameter_ranges.md and adapt ranges to your requirements.

Step 3: Validate Primers

Basic validation (recommended for all):

from scripts.check_dimers import analyze_dimers
from scripts.check_secondary_structures import analyze_secondary_structures

top_primer = primers['primers'][0]

# Check dimers
dimer_result = analyze_dimers(
    [top_primer['forward_seq'], top_primer['reverse_seq']],
    temperature=60.0
)

# Check secondary structures
fwd_structure = analyze_secondary_structures(top_primer['forward_seq'], 60.0)
rev_structure = analyze_secondary_structures(top_primer['reverse_seq'], 60.0)

Complete validation (for publication):

from scripts.validate_specificity import in_silico_pcr

# In-silico PCR (fast)
products = in_silico_pcr(
    forward_primer=top_primer['forward_seq'],
    reverse_primer=top_primer['reverse_seq'],
    sequence=sequence
)

# For NCBI Primer-BLAST: See [references/code_examples.md#validation-examples](references/code_examples.md#validation-examples)
# Note: Requires internet, respects rate limits (3 req/sec)

Step 4: Generate Reports and Export

from scripts.generate_reports import generate_primer_report
from scripts.export_results import export_primers

# Generate report
report = generate_primer_report(
    primers=primers,
    validation_results={
        'dimers': dimer_result,
        'secondary_structures': {'forward': fwd_structure, 'reverse': rev_structure}
    },
    output_format="markdown",
    include_miqe_checklist=(application == 'qpcr')  # From Clarification Question #2
)

# Export in requested format(s)
export_primers(primers, format="csv", output_file="primers.csv")
export_primers(primers, format="excel", output_file="primers.xlsx")

# For qPCR: MIQE checklist
if application == 'qpcr':
    export_primers(primers, format="miqe_checklist", output_file="miqe_checklist.xlsx")

For visualization plots: See references/code_examples.md#visualization

That's it! The scripts handle all design and validation automatically.

Common Issues

For detailed troubleshooting: See references/troubleshooting_guide.md

Suggested Next Steps

After successful primer design:

1. Order primers - Use IDT order format export for direct ordering
2. Optimize PCR conditions - Test annealing temperature gradient (Tm ± 3°C)
3. Validate experimentally: - Test specificity (gel electrophoresis, melt curve for qPCR) - Optimize primer concentration (50-900 nM range) - Verify amplicon size (gel or bioanalyzer)
4. For qPCR - Perform standard curve, efficiency calculation, melt curve analysis
5. Document - Save MIQE checklist and validation reports for publication

Related protocols: See references/primer_design_best_practices.md#experimental-validation

Related Skills

• qPCR Data Analysis - Analyze qPCR Cq values after experimental validation
• Sanger Sequencing Analysis - Analyze results from sequencing primers
• Gene Expression Normalization - Choose reference genes for qPCR

References

Documentation

• Primer Design Best Practices - Comprehensive design guidelines
• MIQE 2.0 Guidelines - qPCR standards and compliance
• Parameter Ranges - Recommended parameter values
• Troubleshooting Guide - Common issues and solutions
• Code Examples - Complete code examples for all applications

Key Publications

• MIQE 2.0: Bustin SA, et al. (2025) Clinical Chemistry 71(6):634-660
• Primer3: Untergasser A, et al. (2012) Nucleic Acids Research 40(15):e115
• Primer-BLAST: Ye J, et al. (2012) BMC Bioinformatics 13:134

Online Resources

• NCBI Primer-BLAST: https://www.ncbi.nlm.nih.gov/tools/primer-blast/
• Primer3 Web: https://primer3.ut.ee/
• MIQE Guidelines: https://rdml.org/miqe.html

Code preview

scripts/__init__.py

# This file makes the scripts directory a Python package
# Required for imports like: from scripts.design_qpcr_primers import design_qpcr_primers

scripts/calculate_tm.py

"""
Calculate melting temperatures using multiple methods.

This module provides functions for calculating primer Tm using various
algorithms and salt correction methods.
"""

import primer3
from Bio.SeqUtils import MeltingTemp as mt
from Bio.Seq import Seq
from typing import Dict


def calculate_tm_comprehensive(
    primer_sequence: str,
    method: str = "nearest_neighbor",
    salt_conc: float = 50.0,
    dna_conc: float = 200.0,
    mg_conc: float = 0.0,
    dntp_conc: float = 0.0
) -> Dict:
    """
    Calculate melting temperature using multiple methods.

    Parameters
    ----------
    primer_sequence : str
        Primer sequence
    method : str
        Tm calculation method:
        - "nearest_neighbor" (most accurate, default)
        - "salt_adjusted" (salt-adjusted formula)
        - "gc_content" (simple GC% method)
        - "all" (calculate using all methods)
    salt_conc : float
        Monovalent cation (Na+, K+) concentration in mM. Default: 50.0
    dna_conc : float
        DNA/primer concentration in nM. Default: 200.0
    mg_conc : float
        Mg2+ concentration in mM. Default: 0.0
    dntp_conc : float
        dNTP concentration in mM. Default: 0.0

    Returns
    -------
    dict
        Dictionary with Tm values from different methods

    Example
    -------
    >>> tm_results = calculate_tm_comprehensive(
    ...     "ATGCGTACGATCGATCG",
    ...     method="all",
    ...     salt_conc=50.0
    ... )
    >>> print(f"Nearest-Neighbor Tm: {tm_results['tm_nn']:.1f}°C")
    """

    # Validate input
    primer_sequence = primer_sequence.upper().strip()

    if not all(base in 'ATCGN' for base in primer_sequence):
        raise ValueError("Primer must contain only A, T, C, G, or N")

    if len(primer_sequence) < 10:
        raise ValueError("Primer too short for accurate Tm calculation (minimum 10 bp)")

    results = {
        'primer_sequence': primer_sequence,
        'primer_length': len(primer_sequence),
    }

    # Method 1: Nearest-Neighbor (most accurate)
    if method in ["nearest_neighbor", "all"]:
        # Using primer3
        tm_nn_primer3 = primer3.calcTm(
            primer_sequence,
            mv_conc=salt_conc,
            dv_conc=mg_conc,
            dntp_conc=dntp_conc,

scripts/check_dimers.py

"""
Check for primer dimers and cross-dimers.

This module analyzes primer-primer interactions to identify potential
dimer formation that can reduce PCR efficiency.
"""

import primer3
from typing import List, Dict


def analyze_dimers(
    primer_list: List[str],
    temperature: float = 60.0,
    dg_threshold: float = -5.0,
    mv_conc: float = 50.0,
    dv_conc: float = 0.0,
    dntp_conc: float = 0.8,
    dna_conc: float = 50.0
) -> Dict:
    """
    Analyze primer dimers and cross-dimers for a set of primers.

    Parameters
    ----------
    primer_list : list of str
        List of primer sequences to analyze
    temperature : float
        PCR annealing temperature in °C. Default: 60.0
    dg_threshold : float
        ΔG threshold in kcal/mol for flagging dimers. Default: -5.0
        Dimers with ΔG < threshold are likely to form
    mv_conc : float
        Monovalent cation concentration in mM. Default: 50.0
    dv_conc : float
        Divalent cation concentration in mM. Default: 0.0
    dntp_conc : float
        dNTP concentration in mM. Default: 0.8
    dna_conc : float
        DNA concentration in nM. Default: 50.0

    Returns
    -------
    dict
        Dictionary containing:
        - 'interactions': list of all primer-primer interactions
        - 'problematic_dimers': list of dimers below threshold
        - 'has_issues': bool indicating if any dimers exceed threshold

    Example
    -------
    >>> primers = ["ATGCGTACGATCGATCG", "CGTAGCTAGCTAGCTAG"]
    >>> analysis = analyze_dimers(primers, temperature=60.0)
    >>> if analysis['has_issues']:
    ...     print("⚠ Primer dimers detected!")
    """

    # Validate inputs
    primer_list = [p.upper().strip() for p in primer_list]

    if len(primer_list) < 2:
        raise ValueError("Need at least 2 primers to check for dimers")

    for primer in primer_list:
        if not all(base in 'ATCGN' for base in primer):
            raise ValueError(f"Invalid primer sequence: {primer}")

    interactions = []
    problematic_dimers = []

    # Check all pairwise interactions
    for i, primer1 in enumerate(primer_list):
        for j, primer2 in enumerate(primer_list):
            if i <= j:  # Check each pair once, including self-dimers
                # Determine interaction type
                if i == j:
                    interaction_type = "self-dimer"
                    primer1_name = f"Primer_{i+1}"
                    primer2_name = f"Primer_{i+1}"
                else:

Companion files