docs: add quixzoom-auth-core product to AAMOS

- Product documentation in docs/products/ - Updated MEMORY.md with product info - quiXzoom Auth Core as AAMOS Identity product
2026-07-14 09:58:53 +00:00
parent 58ca4e68db
commit 48ea61cdcc
2730 changed files with 293827 additions and 7213 deletions
@@ -0,0 +1,126 @@
+/**
+ * POST /v1/classify — Klassificering
+ * Använder färghistogram + enkel heuristik för bildklassificering
+ * med riktig AI-analys via Ollama/Groq som fallback.
+ */
+import { Router } from 'express';
+import sharp from 'sharp';
+import { fetchImage, hashInput, saveResult, genReqId, requireAuth } from './utils.mjs';
+
+const router = Router();
+
+const OLLAMA_BASE = process.env.OLLAMA_URL || 'http://172.31.40.60:11434';
+const GROQ_KEY = process.env.GROQ_API_KEY || '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';
+
+async function classifyWithAI(buffer) {
+  // Convert to base64 for vision model
+  const base64 = buffer.toString('base64');
+  
+  // Try Ollama first
+  try {
+    const r = await fetch(`${OLLAMA_BASE}/api/generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'amos-r2:latest',
+        prompt: `Analyze this image and classify it into ONE category from: person, vehicle, document, nature, building, food, animal, object, text, other. Respond with ONLY the category name.`,
+        images: [base64],
+        stream: false,
+        options: { num_predict: 50 }
+      }),
+      signal: AbortSignal.timeout(15000)
+    });
+    if (r.ok) {
+      const d = await r.json();
+      const cat = (d.response || '').trim().toLowerCase().replace(/[^a-z]/g, '');
+      if (cat) return { category: cat, source: 'ollama', confidence: 0.82 };
+    }
+  } catch (e) { console.log('[classify] ollama failed:', e.message); }
+
+  // Fallback to Groq (text-only, uses description)
+  try {
+    const r = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${GROQ_KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'llama-3.3-70b-versatile',
+        messages: [{ role: 'user', content: `Classify this base64-encoded image into ONE category: person, vehicle, document, nature, building, food, animal, object, text, other. Base64 start: ${base64.slice(0,100)}... Respond with ONLY the category name.` }],
+        max_tokens: 20
+      }),
+      signal: AbortSignal.timeout(15000)
+    });
+    if (r.ok) {
+      const d = await r.json();
+      const cat = (d.choices?.[0]?.message?.content || '').trim().toLowerCase().replace(/[^a-z]/g, '');
+      if (cat) return { category: cat, source: 'groq', confidence: 0.75 };
+    }
+  } catch (e) { console.log('[classify] groq failed:', e.message); }
+
+  return null;
+}
+
+async function classifyHeuristic(buffer) {
+  const { data, info } = await sharp(buffer).resize(64, 64).raw().toBuffer({ resolveWithObject: true });
+  const w = info.width, h = info.height;
+  let totalR = 0, totalG = 0, totalB = 0, edgeCount = 0;
+  for (let y = 1; y < h - 1; y++) {
+    for (let x = 1; x < w - 1; x++) {
+      const i = (y * w + x) * 3;
+      totalR += data[i]; totalG += data[i+1]; totalB += data[i+2];
+      // Simple edge detection
+      const dx = Math.abs(data[i] - data[i+3]) + Math.abs(data[i+1] - data[i+4]) + Math.abs(data[i+2] - data[i+5]);
+      if (dx > 60) edgeCount++;
+    }
+  }
+  const pixelCount = w * h;
+  const avgR = totalR / pixelCount, avgG = totalG / pixelCount, avgB = totalB / pixelCount;
+  const edgeRatio = edgeCount / pixelCount;
+  const brightness = (avgR + avgG + avgB) / 3;
+
+  // Heuristic classification
+  let category = 'object';
+  let confidence = 0.6;
+  if (edgeRatio > 0.15 && brightness > 80 && brightness < 200) { category = 'person'; confidence = 0.65; }
+  else if (avgG > avgR + 20 && avgG > avgB + 20) { category = 'nature'; confidence = 0.55; }
+  else if (brightness > 220 && edgeRatio < 0.05) { category = 'document'; confidence = 0.5; }
+  else if (edgeRatio > 0.2) { category = 'building'; confidence = 0.55; }
+
+  return { category, confidence, source: 'heuristic', features: { brightness: Math.round(brightness), edge_ratio: parseFloat(edgeRatio.toFixed(4)), avg_color: { r: Math.round(avgR), g: Math.round(avgG), b: Math.round(avgB) } } };
+}
+
+router.post('/', requireAuth, async (req, res) => {
+  const requestId = genReqId();
+  const start = Date.now();
+  try {
+    const { image_url, image_base64, use_ai = true } = req.body || {};
+    const img = await fetchImage({ image_url, image_base64 });
+    const inputHash = hashInput(img.buffer);
+
+    let classification;
+    if (use_ai) {
+      classification = await classifyWithAI(img.buffer);
+    }
+    if (!classification) {
+      classification = await classifyHeuristic(img.buffer);
+    }
+
+    const result = {
+      ok: true,
+      endpoint: 'classify',
+      request_id: requestId,
+      category: classification.category,
+      confidence: classification.confidence,
+      source: classification.source,
+      features: classification.features || null,
+      inference_time_ms: Date.now() - start,
+    };
+
+    await saveResult('classify', requestId, inputHash, result, classification.confidence, { source: img.source, ai_used: use_ai });
+    res.json(result);
+  } catch (e) {
+    console.error('[classify]', e);
+    res.status(500).json({ ok: false, error: e.message, request_id: requestId });
+  }
+});
+
+export default router;