Live on Poe · Zero-Retention Ephemeral Architecture

Verified Developer Tools for Document OCR, Regex & SQL

Apex Forge Technology builds high-accuracy, task-focused developer bots. Run production-grade extraction with OCR-Doc-Parser, ReDoS-safe validation with Regex-Gen-Tester, and schema-verified analysis with English-to-SQL.

100% Stateless RAM Compute (Zero Retention)
< 1.2s Edge Median Latency Profile
3 Specialized Developer Bots on Poe
183/183 Passing Continuous Quality Tests

Production Developer Tools

Each bot solves one concrete technical task with verifiable outputs and execution safeguards on Poe.

OCR-Doc-Parser Icon

OCR-Doc-Parser

@OCR-Doc-Parser

Extracts visible data from paper receipts, tax invoices, and bank statements into structured JSON with per-field confidence flags and automated arithmetic tax reconciliation.

  • Projection profile deskewing & blur detection
  • Tax ID / GSTIN regex validation rules
  • Automated subtotal + tax = total math verification
Best for: Bookkeepers, finance teams, and developers automating receipt transcription.
Regex-Gen-Tester Icon

Regex-Gen-Tester

@Regex-Gen-Tester

Generates regular expressions from plain English, executes them live against test strings inside an edge isolate, and flags catastrophic backtracking (ReDoS) vulnerability patterns.

  • Polynomial ReDoS backtrack heuristic scanner
  • Named capture group extraction breakdown
  • Multi-engine compatibility (JS, Python, PCRE)
Best for: Full-stack engineers creating robust validation rules without server crashes.
English-to-SQL Icon

English-to-SQL

@English-To-SQL

Transforms natural English questions into schema-grounded SQL, runs them in an in-memory SQLite sandbox, self-heals syntax errors, and provides formatted tabular previews.

  • In-memory temporary SQLite execution sandbox
  • Auto-healing syntax error correction
  • Destructive statement guards (DROP/DELETE checks)
Best for: Data analysts, backend engineers, and product teams querying relational data.

See How the Tools Work in Practice

Click between tools to inspect realistic inputs and verified production outputs.

Input: Document Photo Deskewed · Contrast Verified
Document Type: Paper Tax Invoice Vendor Header: Apex Cloud Systems Ltd. Invoice Number: #INV-2026-8819 Date: 2026-09-04 Line Item 1: Compute Tier A (x2)      $120.00 Line Item 2: Storage Volume 500GB    $45.00 Line Item 3: SSL Security Certificate $15.00 Subtotal: $180.00 | Tax (10%): $18.00 Total Stamped: $198.00
Output: Reconciled JSON 100% Math Match · Low Blur
{
  "vendor": "Apex Cloud Systems Ltd.",
  "invoice_number": "INV-2026-8819",
  "date": "2026-09-04",
  "currency": "USD",
  "subtotal": 180.00,
  "tax_total": 18.00,
  "grand_total": 198.00,
  "reconciliation": {
    "computed_total": 198.00,
    "delta": 0.00,
    "status": "ARITHMETIC_VERIFIED"
  },
  "field_confidence": {
    "vendor": 0.99,
    "grand_total": 1.0,
    "tax_id": 0.96
  }
}
Input: Plain English Rule Target: RFC-5322 Email Validation
User Instruction: "Generate a ReDoS-safe regex for corporate email addresses with subdomains. Then test against test@corp.apexforge.tech and invalid..format@com." Generated Pattern: ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,63}$
Output: Test Match & Safety Report ReDoS Safe · 0ms Backtrack
✓ test@corp.apexforge.tech   -> MATCH (0.02ms)
✗ invalid..format@com        -> REJECTED (0.01ms)
✗ user@domain                -> REJECTED (0.01ms)

=== ReDoS Safety Assessment ===
• Catastrophic Backtracking: PASSED (O(n) linear)
• Nested Quantifiers: NONE
• Engine Compatibility: V8, Python re, PCRE
Input: Natural Language Query Table: expenses (vendor, amount, date)
Schema: CREATE TABLE expenses (id INT, vendor TEXT, amount REAL, category TEXT, date TEXT); Question: "Find total spending per vendor for Q3 2026 where total exceeds $500, ordered from highest to lowest."
Output: Executed SQLite Query & Table Sandbox Executed · 0 Errors
SELECT vendor, ROUND(SUM(amount), 2) AS total_spend
FROM expenses
WHERE date BETWEEN '2026-07-01' AND '2026-09-30'
GROUP BY vendor
HAVING total_spend > 500.00
ORDER BY total_spend DESC;

| vendor              | total_spend |
|---------------------|-------------|
| Apex Cloud Systems  | $1,420.50   |
| FastFiber Transit   | $780.00     |

Extract, Validate, and Analyze

Connect individual tools into a seamless document-to-insight pipeline without manual transcription.

STEP 01 · OCR-DOC-PARSER

Photograph & Parse Document

Upload a receipt or invoice photo to OCR-Doc-Parser. The vision engine checks for blur, deskews tilted photos, extracts line items, and reconciles subtotals with tax.

STEP 02 · REGEX-GEN-TESTER

Verify Field Formats

Validate extracted tax identifiers or invoice codes using Regex-Gen-Tester. Test your validation pattern against real samples with safe execution guarantees.

STEP 03 · ENGLISH-TO-SQL

Query Your Data in SQL

Paste your expense table schema into English-to-SQL. Ask questions in natural English to aggregate monthly totals, compare vendors, and inspect result tables directly in chat.

Walk Through the Full Pipeline Guide →

Engineered with Verification Safeguards

Generic chatbots guess answers. Apex Forge Tools verify output through execution and explicit confidence scoring.

🔍 Per-Field OCR Confidence Flags

Every extracted vendor, date, and monetary amount includes confidence metrics. If lighting is uneven or numbers are ambiguous, the tool flags them for review rather than guessing.

⚖️ Arithmetic Tax Reconciliation

The parser automatically calculates whether subtotal + tax = grand total. Invoices with calculation mismatches are flagged immediately to prevent accounting errors.

Live Isolate Regex Execution

Patterns are compiled and executed against your positive and negative samples inside a secure V8 isolate, displaying capture groups, microsecond timing, and ReDoS safety analysis.

📊 In-Memory SQLite Verification

SQL queries are verified by seeding a temporary SQLite WebAssembly database with your schema, executing the query, and auto-correcting syntax errors before streaming results.

🛡️ Destructive Statement Warnings

Queries containing DROP, DELETE, or UPDATE statements without restrictive WHERE clauses trigger immediate safety warnings.

🔒 Zero Data Retention

Ephemeral processing architecture: user documents and database schemas exist strictly in temporary memory during the conversation turn and are never stored.

Transparent Limitations: These tools are developer and bookkeeping aids. OCR accuracy depends on image legibility, glare, and resolution; verify extracted totals before financial filing. English-to-SQL runs in an ephemeral SQLite sandbox; verify dialect differences before running on production PostgreSQL or MySQL databases.