Regex Vs Llm Structured Text

affaan-m/ECC/skills/regex-vs-llm-structured-text

作者 affaan-mef648e01899ba3e8dc6371642deaaf64b4477775无许可证275K 个星标收录于 2026年10月9日更新于 2026年10月9日仓库4天前更新

Decision framework for parsing structured text (quizzes, forms, invoices, receipts, tables) with a hybrid regex-first pipeline — regex extraction handles 95%+ cheaply, a confidence scorer flags low-confidence items, and an LLM validator fixes only the edge cases. Use when choosing between regex and LLM for text extraction, building a cheap document parser, or optimizing extraction cost and accuracy.

仅含说明Software Development AI & Agents

AI 生成的概览

面向结构化文本的混合解析决策框架与代码模式：以正则优先，仅对低置信度条目调用 LLM 校验。

功能: 说明在从测验题、表单、发票、收据等重复性文本中提取结构时，何时使用正则、何时使用 LLM。它给出决策树、架构图，以及正则解析器、置信度评分器、LLM 校验器和组合流程的 Python 代码。还列出生产指标、最佳实践与反模式，用于权衡成本与准确率。
适用场景: 适用于在结构化文本提取中选择正则还是 LLM、构建低成本文档解析器，或在保持准确率的同时减少 LLM 调用。适合测验题、表单字段、发票、收据、表格等重复格式。不适用于自由格式、变化很大的文本，框架建议这类情况直接使用 LLM。
运行要求: 该技能不附带脚本，仅为说明性内容。所述流程使用 Python 的 re 与 dataclasses 模块；可选的 LLM 校验步骤需要 Anthropic 风格的客户端以及访问 Haiku 级别模型的 API 权限。

Regex vs LLM for Structured Text Parsing

A practical decision framework for parsing structured text (quizzes, forms, invoices, documents). The key insight: regex handles 95-98% of cases cheaply and deterministically. Reserve expensive LLM calls for the remaining edge cases.

When to Activate

Parsing structured text with repeating patterns (questions, forms, tables)
Deciding between regex and LLM for text extraction
Building hybrid pipelines that combine both approaches
Optimizing cost/accuracy tradeoffs in text processing

Decision Framework

Is the text format consistent and repeating?├── Yes (>90% follows a pattern) → Start with Regex│   ├── Regex handles 95%+ → Done, no LLM needed│   └── Regex handles <95% → Add LLM for edge cases only└── No (free-form, highly variable) → Use LLM directly

Is the text format consistent and repeating?├── Yes (>90% follows a pattern) → Start with Regex│   ├── Regex handles 95%+ → Done, no LLM needed│   └── Regex handles <95% → Add LLM for edge cases only└── No (free-form, highly variable) → Use LLM directly

Architecture Pattern

Source Text    │    ▼[Regex Parser] ─── Extracts structure (95-98% accuracy)    │    ▼[Text Cleaner] ─── Removes noise (markers, page numbers, artifacts)    │    ▼[Confidence Scorer] ─── Flags low-confidence extractions    │    ├── High confidence (≥0.95) → Direct output    │    └── Low confidence (<0.95) → [LLM Validator] → Output

Source Text    │    ▼[Regex Parser] ─── Extracts structure (95-98% accuracy)    │    ▼[Text Cleaner] ─── Removes noise (markers, page numbers, artifacts)    │    ▼[Confidence Scorer] ─── Flags low-confidence extractions    │    ├── High confidence (≥0.95) → Direct output    │    └── Low confidence (<0.95) → [LLM Validator] → Output

Implementation

1. Regex Parser (Handles the Majority)

python

import refrom dataclasses import dataclass
@dataclass(frozen=True)class ParsedItem:    id: str    text: str    choices: tuple[str, ...]    answer: str    confidence: float = 1.0
def parse_structured_text(content: str) -> list[ParsedItem]:    """Parse structured text using regex patterns."""    pattern = re.compile(        r"(?P<id>\d+)\.\s*(?P<text>.+?)\n"        r"(?P<choices>(?:[A-D]\..+?\n)+)"        r"Answer:\s*(?P<answer>[A-D])",        re.MULTILINE | re.DOTALL,    )    items = []    for match in pattern.finditer(content):        choices = tuple(            c.strip() for c in re.findall(r"[A-D]\.\s*(.+)", match.group("choices"))        )        items.append(ParsedItem(            id=match.group("id"),            text=match.group("text").strip(),            choices=choices,            answer=match.group("answer"),        ))    return items

import refrom dataclasses import dataclass
@dataclass(frozen=True)class ParsedItem:    id: str    text: str    choices: tuple[str, ...]    answer: str    confidence: float = 1.0
def parse_structured_text(content: str) -> list[ParsedItem]:    """Parse structured text using regex patterns."""    pattern = re.compile(        r"(?P<id>\d+)\.\s*(?P<text>.+?)\n"        r"(?P<choices>(?:[A-D]\..+?\n)+)"        r"Answer:\s*(?P<answer>[A-D])",        re.MULTILINE | re.DOTALL,    )    items = []    for match in pattern.finditer(content):        choices = tuple(            c.strip() for c in re.findall(r"[A-D]\.\s*(.+)", match.group("choices"))        )        items.append(ParsedItem(            id=match.group("id"),            text=match.group("text").strip(),            choices=choices,            answer=match.group("answer"),        ))    return items

2. Confidence Scoring

Flag items that may need LLM review:

python

@dataclass(frozen=True)class ConfidenceFlag:    item_id: str    score: float    reasons: tuple[str, ...]
def score_confidence(item: ParsedItem) -> ConfidenceFlag:    """Score extraction confidence and flag issues."""    reasons = []    score = 1.0
    if len(item.choices) < 3:        reasons.append("few_choices")        score -= 0.3
    if not item.answer:        reasons.append("missing_answer")        score -= 0.5
    if len(item.text) < 10:        reasons.append("short_text")        score -= 0.2
    return ConfidenceFlag(        item_id=item.id,        score=max(0.0, score),        reasons=tuple(reasons),    )
def identify_low_confidence(    items: list[ParsedItem],    threshold: float = 0.95,) -> list[ConfidenceFlag]:    """Return items below confidence threshold."""    flags = [score_confidence(item) for item in items]    return [f for f in flags if f.score < threshold]

@dataclass(frozen=True)class ConfidenceFlag:    item_id: str    score: float    reasons: tuple[str, ...]
def score_confidence(item: ParsedItem) -> ConfidenceFlag:    """Score extraction confidence and flag issues."""    reasons = []    score = 1.0
    if len(item.choices) < 3:        reasons.append("few_choices")        score -= 0.3
    if not item.answer:        reasons.append("missing_answer")        score -= 0.5
    if len(item.text) < 10:        reasons.append("short_text")        score -= 0.2
    return ConfidenceFlag(        item_id=item.id,        score=max(0.0, score),        reasons=tuple(reasons),    )
def identify_low_confidence(    items: list[ParsedItem],    threshold: float = 0.95,) -> list[ConfidenceFlag]:    """Return items below confidence threshold."""    flags = [score_confidence(item) for item in items]    return [f for f in flags if f.score < threshold]

3. LLM Validator (Edge Cases Only)

python

def validate_with_llm(    item: ParsedItem,    original_text: str,    client,) -> ParsedItem:    """Use LLM to fix low-confidence extractions."""    response = client.messages.create(        model="claude-haiku-4-5-20251001",  # Cheapest model for validation        max_tokens=500,        messages=[{            "role": "user",            "content": (                f"Extract the question, choices, and answer from this text.\n\n"                f"Text: {original_text}\n\n"                f"Current extraction: {item}\n\n"                f"Return corrected JSON if needed, or 'CORRECT' if accurate."            ),        }],    )    # Parse LLM response and return corrected item...    return corrected_item

def validate_with_llm(    item: ParsedItem,    original_text: str,    client,) -> ParsedItem:    """Use LLM to fix low-confidence extractions."""    response = client.messages.create(        model="claude-haiku-4-5-20251001",  # Cheapest model for validation        max_tokens=500,        messages=[{            "role": "user",            "content": (                f"Extract the question, choices, and answer from this text.\n\n"                f"Text: {original_text}\n\n"                f"Current extraction: {item}\n\n"                f"Return corrected JSON if needed, or 'CORRECT' if accurate."            ),        }],    )    # Parse LLM response and return corrected item...    return corrected_item

4. Hybrid Pipeline

python

def process_document(    content: str,    *,    llm_client=None,    confidence_threshold: float = 0.95,) -> list[ParsedItem]:    """Full pipeline: regex -> confidence check -> LLM for edge cases."""    # Step 1: Regex extraction (handles 95-98%)    items = parse_structured_text(content)
    # Step 2: Confidence scoring    low_confidence = identify_low_confidence(items, confidence_threshold)
    if not low_confidence or llm_client is None:        return items
    # Step 3: LLM validation (only for flagged items)    low_conf_ids = {f.item_id for f in low_confidence}    result = []    for item in items:        if item.id in low_conf_ids:            result.append(validate_with_llm(item, content, llm_client))        else:            result.append(item)
    return result

def process_document(    content: str,    *,    llm_client=None,    confidence_threshold: float = 0.95,) -> list[ParsedItem]:    """Full pipeline: regex -> confidence check -> LLM for edge cases."""    # Step 1: Regex extraction (handles 95-98%)    items = parse_structured_text(content)
    # Step 2: Confidence scoring    low_confidence = identify_low_confidence(items, confidence_threshold)
    if not low_confidence or llm_client is None:        return items
    # Step 3: LLM validation (only for flagged items)    low_conf_ids = {f.item_id for f in low_confidence}    result = []    for item in items:        if item.id in low_conf_ids:            result.append(validate_with_llm(item, content, llm_client))        else:            result.append(item)
    return result

Real-World Metrics

From a production quiz parsing pipeline (410 items):

Best Practices

Start with regex — even imperfect regex gives you a baseline to improve
Use confidence scoring to programmatically identify what needs LLM help
Use the cheapest LLM for validation (Haiku-class models are sufficient)
Never mutate parsed items — return new instances from cleaning/validation steps
TDD works well for parsers — write tests for known patterns first, then edge cases
Log metrics (regex success rate, LLM call count) to track pipeline health

Anti-Patterns to Avoid

Sending all text to an LLM when regex handles 95%+ of cases (expensive and slow)
Using regex for free-form, highly variable text (LLM is better here)
Skipping confidence scoring and hoping regex "just works"
Mutating parsed objects during cleaning/validation steps
Not testing edge cases (malformed input, missing fields, encoding issues)

When to Use

Quiz/exam question parsing
Form data extraction
Invoice/receipt processing
Document structure parsing (headers, sections, tables)
Any structured text with repeating patterns where cost matters

来源与署名

来源：affaan-m/ECC位于skills/regex-vs-llm-structured-text提交ef648e0

许可证：无许可证

内容归原作者所有。SourceWeft 从公开仓库中收录这些内容。

举报或申请下架

Metric	Value
Regex success rate	98.0%
Low confidence items	8 (2.0%)
LLM calls needed	~5
Cost savings vs all-LLM	~95%
Test coverage	93%

Regex Vs Llm Structured Text

Regex vs LLM for Structured Text Parsing

When to Activate

Decision Framework

Architecture Pattern

Implementation

1. Regex Parser (Handles the Majority)

2. Confidence Scoring

3. LLM Validator (Edge Cases Only)

4. Hybrid Pipeline

Real-World Metrics

Best Practices

Anti-Patterns to Avoid

When to Use

来源与署名

更多来自 affaan-m/ECC 的技能

Unified Notifications Ops

Verification Loop

Ui To Vue

Unified Memory

Visa Doc Translate

Team Builder

更多Software Development技能

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices