🚀 Spellcheck API – Anwendungsfälle
SaaS, KI-Assistenten, CMS & mehr

// Strapi Plugin oder Next.js API Route
async function autoCorrectBeforePublish(articleBody) {
  const paragraphs = articleBody.split('\n\n').filter(Boolean);

  // Parallel korrigieren (max. 5 gleichzeitig)
  const corrected = [];
  for (let i = 0; i < paragraphs.length; i += 5) {
    const batch = await Promise.all(
      paragraphs.slice(i, i + 5).map(p =>
        framespell.spellcheck({ text: p, language: 'de' })
      )
    );
    corrected.push(...batch.map(r => r.corrected));
  }

  return corrected.join('\n\n');
}

// Frontend: Debounce + API-Aufruf über eigene Backend-Route
const textarea = document.querySelector('#ticket-body');
let debounceTimer;

textarea.addEventListener('input', () => {
  clearTimeout(debounceTimer);
  debounceTimer = setTimeout(async () => {
    const text = textarea.value.trim();
    if (text.length < 20) return;

    // Eigene Backend-Route aufrufen (API Key bleibt serverseitig)
    const { corrected } = await fetch('/api/spellcheck', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ text })
    }).then(r => r.json());

    // Unterschiede hervorheben
    if (corrected !== text) showCorrectionHint(corrected);
  }, 600); // 600ms nach letztem Tastenanschlag
});

import os, requests

SPELL_URL = "https://framespell.pages.dev/api/spellcheck"
SPELL_KEY  = os.environ["FRAMESPELL_API_KEY"]

def preprocess_prompt(user_input: str) -> str:
    """Korrigiert den Nutzer-Prompt bevor er an das LLM gesendet wird."""
    resp = requests.post(
        SPELL_URL,
        json={"text": user_input, "language": "de"},
        headers={"X-API-Key": SPELL_KEY},
        timeout=5
    )
    result = resp.json()
    return result["data"]["corrected"] if result["success"] else user_input


def ask_llm(user_prompt: str) -> str:
    clean_prompt = preprocess_prompt(user_prompt)

    # Weiterleitung an beliebiges LLM (OpenAI, Anthropic, etc.)
    # response = openai_client.chat.completions.create(...)
    return f"[LLM called with]: {clean_prompt}"


# Test
raw    = "Was ist die Hauptstat von Deutshland?"
answer = ask_llm(raw)
print(answer)  # Prompt wird zu: "Was ist die Hauptstadt von Deutschland?"

import os, requests, csv
from concurrent.futures import ThreadPoolExecutor, as_completed

API_URL = "https://framespell.pages.dev/api/spellcheck"
API_KEY = os.environ["FRAMESPELL_API_KEY"]

def correct_product(row):
    desc = row["description"]
    resp = requests.post(
        API_URL,
        json={"text": desc, "language": "de"},
        headers={"X-API-Key": API_KEY},
        timeout=8
    ).json()
    row["description_corrected"] = resp["data"]["corrected"] if resp["success"] else desc
    return row

# CSV einlesen und parallel korrigieren
with open("products.csv", newline="", encoding="utf-8") as f:
    products = list(csv.DictReader(f))

with ThreadPoolExecutor(max_workers=10) as pool:
    futures   = [pool.submit(correct_product, p) for p in products]
    corrected = [f.result() for f in as_completed(futures)]

print(f"✓ {len(corrected)} Produkte bereinigt")

async function checkStudentAnswer(originalText) {
  const resp = await fetch('/api/spellcheck', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ text: originalText })
  });
  const { corrected } = await resp.json();

  // Wörter vergleichen und Fehler hervorheben
  const origWords = originalText.split(' ');
  const corrWords = corrected.split(' ');

  return origWords.map((word, i) => {
    if (word !== corrWords[i]) {
      return `<mark class="error">${word}</mark>
             <span class="fix">→ ${corrWords[i]}</span>`;
    }
    return word;
  }).join(' ');
}

// Rendering im DOM
const feedback = await checkStudentAnswer('Ich wone in Münhen');
document.querySelector('#feedback').innerHTML = feedback;
// → "Ich <mark>wone</mark> → wohne in <mark>Münhen</mark> → München"

async function validateEmailBeforeSend(campaign) {
  const fields = [campaign.subject, campaign.preheader, campaign.body];
  const corrected = await Promise.all(
    fields.map(f => framespell.spellcheck({ text: f, language: 'de' }))
  );

  const hasErrors = fields.some((f, i) => f !== corrected[i].corrected);

  if (hasErrors) {
    return {
      approved: false,
      suggestions: {
        subject:   corrected[0].corrected,
        preheader: corrected[1].corrected,
        body:      corrected[2].corrected,
      }
    };
  }

  return { approved: true };
}