AI hallucináció mitigáció — miért történik és hogyan kezeld?

Az AI nem hazudik. Csak nem tudja, hogy nem tudja. És ez sokkal veszélyesebb.

Mi az a hallucináció valójában?

Az AI hallucináció akkor történik, amikor egy nyelvi modell (LLM) magabiztosan állít valamit, ami nem igaz. Nem hibát csinál, nem hibaüzenetet ad — egyszerűen kitalál egy választ, amely nyelvtanilag tökéletes, stilisztikailag meggyőző, és tartalmilag hamis.

Példák a való életből:

• Egy ügyvéd ChatGPT-vel írt egy bírósági beadványt → 6 olyan jogesetre hivatkozott, amelyek nem léteznek (Mata v. Avianca ügy, 2023)
• Egy egészségügyi chatbot rossz gyógyszer-dózist javasolt magabiztosan
• Egy enterprise AI-asszisztens olyan vállalati policy-ra hivatkozott, ami sosem volt policy

A hallucináció nem bug — hanem a működés természetes következménye. Ha nem érted, miért történik, nem fogod tudni kezelni.

Miért hallucinálnak a modellek?

A nyelvi modellek nem „tudnak" — predikálnak

Egy LLM nem tudás-adatbázis. Egy valószínűségi szöveg-folytató: az adott kontextusra a legvalószínűbb következő tokent generálja. Ha megkérdezed, hogy „Ki írta a Háború és békét?", nem ránéz egy listára — hanem statisztikai mintákból rekonstruálja, hogy az ilyen kérdésekre milyen válasz a legvalószínűbb.

Ha a kérdésben szereplő adatok gyakran jelentek meg a tréningadatban → helyes válasz. Ha ritkán vagy egyáltalán nem jelentek meg → a modell kitölti a hiányt valószínű, de hamis adattal.

A négy fő ok

Tréning adat hiánya vagy konfliktusa A modell nem találkozott a kérdéssel — vagy ellentmondásos információt látott (pl. egy könyv két különböző szerzővel említve). Mégis válaszol — ez a feladata.

Túl magas „temperature" (kreativitás) A temperature paraméter szabályozza, mennyire térjen el a legvalószínűbb választól. Magas érték → kreatívabb, de hallucinációra hajlamosabb.

Long context degradation A 100K+ token kontextus elejére a modell kevésbé figyel oda. A „lost in the middle" jelenség: a hosszú dokumentum közepét gyakran rosszul olvassa.

Prompt ambiguitás Ha a kérdés nem egyértelmű, a modell „választ" egy értelmezést. Ha rossz értelmezést választ → magabiztos, de irreleváns válasz.

A „tudás illúziója"

A legveszélyesebb: az LLM nem tudja, hogy nem tudja. Nincs belső konfidencia-mérője a faktualitásra. Ezért:

• ❌ Nem mond „nem tudom"-ot magától (kivéve, ha tanították rá)
• ❌ Nem jelzi, hogy bizonytalan
• ❌ Nem különbözteti meg a memorizált tényt és a kitalált összeállítást

Ez technikai korlát — nem rossz szándék.

A hallucináció 5 típusa

Nem minden hallucináció ugyanolyan. Ezért nem ugyanaz a kezelése sem.

Típus	Mi történik?	Példa	Hogyan kezeld?
Faktuális	Konkrét tény hamis	„Budapest fővárosa Lengyelországnak"	RAG, validáció
Forrás-fabrikáció	Kitalált hivatkozás	Nem létező könyv / jogeset	Forrás-link kötelezővé tétele
Logikai	Rossz következtetés helyes adatokból	Matek hiba	Chain-of-thought, kalkulátor tool
Instrukciós	Nem teszi, amit kérsz	„Csak JSON-t adj vissza" → szöveggel kezdi	Structured output, Zod / Pydantic
Kontextus-eltévedés	Korábbi konverzációt rosszul idéz	„Ahogy mondtad, X..." (nem mondtad)	Rövidebb kontextus, summary

Gyakorlati mitigációs technikák

RAG — Retrieval Augmented Generation

A leggyakoribb és leghatékonyabb mitigáció: ne hagyd, hogy a modell „emlékezzen" — adj neki forrást.

Hogyan működik:

Felhasználó: „Mit mond a 2024-es szabadság-policy a home office-ról?"
   ↓
Vector DB lekérdezés (a kérdés embeddingje alapján)
   ↓
Top-5 releváns dokumentum-chunk visszaadva
   ↓
Prompt: „Ezen dokumentumok alapján válaszolj: [chunkok] ... Kérdés: ..."
   ↓
LLM válasz forrás-hivatkozással

Kód-példa (egyszerűsített):

async function ragQuery(question: string) {
  // 1. A kérdés embeddingje
  const queryEmbedding = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: question
  });

  // 2. Releváns chunkok keresése
  const relevantDocs = await vectorDb.search({
    embedding: queryEmbedding.data[0].embedding,
    topK: 5,
    minScore: 0.75 // alacsony score → ne is válaszoljon
  });

  // 3. Ha nincs releváns dokumentum → ne hallucináljon
  if (relevantDocs.length === 0) {
    return "Nem találtam erre választ a dokumentációban.";
  }

  // 4. Strukturált prompt forrásokkal
  const context = relevantDocs
    .map((d, i) => `[Forrás ${i+1}: ${d.source}]\n${d.content}`)
    .join("\n\n");

  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [{
      role: "system",
      content: `Csak a megadott forrásokra támaszkodva válaszolj.
        Ha a forrás nem tartalmazza a választ, mondd: "Nincs erre vonatkozó információm".
        Minden állítás után jelöld meg a forrást [Forrás N] formátumban.`
    }, {
      role: "user",
      content: `Források:\n${context}\n\nKérdés: ${question}`
    }],
    temperature: 0.1
  });

  return response.choices[0].message.content;
}

Best practice-ek:

• Minimum score küszöb: ha a top-1 relevancia 0.75 alatt, ne válaszolj
• Forrás-citálás kötelezővé tétele a system promptban
• Chunk size: 200-500 token a legjobb (nem túl rövid, nem túl hosszú)
• Hybrid search: vector + keyword kombináció (BM25 + cosine)

Strukturált output — fogd kényszerre a modellt

Ha a modellnek konkrét struktúrát kell visszaadnia, sokkal kevésbé hallucinál.

Példa Zod + OpenAI structured output-tal:

import { z } from "zod";
import { zodResponseFormat } from "openai/helpers/zod";

const InvoiceSchema = z.object({
  invoiceNumber: z.string(),
  totalAmount: z.number(),
  currency: z.enum(["HUF", "EUR", "USD"]),
  items: z.array(z.object({
    description: z.string(),
    quantity: z.number(),
    unitPrice: z.number()
  })),
  // Kritikus: ha bizonytalan, jelölje
  confidence: z.enum(["high", "medium", "low"]),
  uncertainFields: z.array(z.string()).optional()
});

const response = await openai.chat.completions.parse({
  model: "gpt-4o",
  messages: [
    { role: "system", content: "Olvasd ki a számla adatait. Csak amit biztosan látsz." },
    { role: "user", content: invoiceText }
  ],
  response_format: zodResponseFormat(InvoiceSchema, "invoice")
});

A confidence és uncertainFields mezők kényszerítik a modellt, hogy ismerje el a bizonytalanságot. Ha confidence === "low" → manuális review.

Chain-of-Thought és önkritika

Chain-of-Thought (CoT): kérd meg a modellt, hogy lépésről lépésre gondolkodjon.

Rossz prompt: „Hány alma marad, ha 10-ből 3-at kétszer eladsz?"
Jó prompt: „Lépésenként gondolkodj. 1) Mennyi alma van kezdetben?
            2) Mennyi az első eladás után? 3) Mennyi a második után?"

Self-critique: 2 lépéses generálás:

// 1. lépés: válasz
const answer = await generate(question);

// 2. lépés: önkritika
const critique = await generate(`
  Az alábbi válasz a kérdésre:
  Kérdés: ${question}
  Válasz: ${answer}

  Vizsgáld meg kritikusan:
  1. Vannak-e nem alátámasztott állítások?
  2. Vannak-e logikai hibák?
  3. Vannak-e kitalált tények vagy hivatkozások?

  Add vissza a javított, csak biztos információkat tartalmazó választ.
`);

A self-critique 30-50%-kal csökkentheti a hallucinációt — cserébe 2x token-költség.

Tool use — kalkulátor, kereső, adatbázis

A modell rossz matekban, rossz dátumokban, rossz valós-idejű adatokban. Adj neki tool-okat.

const tools = [
  {
    type: "function",
    function: {
      name: "calculate",
      description: "Matematikai kifejezés kiértékelése",
      parameters: { /* ... */ }
    }
  },
  {
    type: "function",
    function: {
      name: "search_database",
      description: "Adatbázis keresés ügyfél-adatokra",
      parameters: { /* ... */ }
    }
  },
  {
    type: "function",
    function: {
      name: "web_search",
      description: "Aktuális információk keresése",
      parameters: { /* ... */ }
    }
  }
];

A modell tool_call-t ad ki → te futtatod → eredmény visszamegy a modellhez. Az adat valódi, a modell csak interpretál.

Temperature és sampling

Faktuális feladatokhoz:

{
  temperature: 0.1,    // alacsony kreativitás
  top_p: 0.95,         // szűk valószínűség-mező
  presence_penalty: 0,
  frequency_penalty: 0
}

Kreatív feladatokhoz (marketing szöveg, brainstorm):

{
  temperature: 0.8,
  top_p: 0.95
}

Soha ne használj magas temperature-t faktuális válaszhoz.

Detektálás — hogyan ismerd fel a hallucinációt?

Automatikus validáció

Forrás-ellenőrzés: ha a modell forrásra hivatkozik, automatikusan ellenőrizd, hogy létezik-e:

async function validateCitations(answer: string, sources: Source[]) {
  const citationPattern = /\[Forrás (\d+)\]/g;
  const citations = [...answer.matchAll(citationPattern)];

  for (const match of citations) {
    const sourceIndex = parseInt(match[1]) - 1;
    if (sourceIndex >= sources.length) {
      throw new Error(`Hallucinált forrás-hivatkozás: ${match[0]}`);
    }
  }
}

Schema validáció: ha JSON-t vársz, validáld:

try {
  const parsed = InvoiceSchema.parse(JSON.parse(response));
} catch (e) {
  // Hallucinált / hibás struktúra
  retry();
}

Konfidencia-mérés

Logprobs használata: a modell logprobs paraméterrel megadja, mennyire volt magabiztos minden tokennél.

const response = await openai.chat.completions.create({
  // ...
  logprobs: true,
  top_logprobs: 5
});

const avgLogprob = response.choices[0].logprobs.content
  .reduce((sum, t) => sum + t.logprob, 0) / response.choices[0].logprobs.content.length;

if (avgLogprob < -1.5) {
  // Alacsony konfidencia → manuális review vagy újrakérdezés
}

LLM-as-a-judge

Egy másik LLM (akár ugyanaz, külön hívással) ítélje meg a választ:

Prompt: „Az alábbi kérdés-válasz párnál:
        - Faktuálisan helyes a válasz? (1-5)
        - Tartalmaz-e nem alátámasztott állítást? (igen/nem)
        - Vannak-e ellentmondások? (igen/nem)
        Válasz JSON formátumban."

Ez nem tökéletes (a judge is hallucinálhat), de sok hibát kiszűr.

Production checklist

Mielőtt élesíted az AI-funkciót, ellenőrizd:

• RAG van-e ott, ahol faktuális válasz szükséges?
• Minimum relevance score van-e beállítva?
• „Nem tudom" opciót tanítottad-e a system promptban?
• Forrás-citálás kötelező-e?
• Structured output van-e ott, ahol struktúra kell?
• Temperature alacsony (0.0-0.3) faktuális esetekben?
• Tool use ott, ahol matematika, dátum, valós adat kell?
• Validáció futtatja-e az outputot (schema, citation, business logic)?
• Monitoring: logolod-e a low-confidence eseteket?
• Human-in-the-loop kritikus döntéseknél (gyógyszer, jog, pénzügy)?
• Disclaimer: tudja-e a felhasználó, hogy AI válaszolt?

Üzleti kockázat-management

A technikai mitigáció mellett üzleti döntéseket is kell hozni:

Kockázati zónák

Use case	Kockázat	Stratégia
Marketing szöveg generálás	Alacsony	LLM önállóan, emberi review publikálás előtt
Belső ügyfél-info chatbot	Közepes	RAG + forrás-citálás + „bizonytalan esetben emberhez"
Jogi / orvosi tanácsadás	Magas	Csak emberi szakértő mellett, soha nem önállóan
Pénzügyi tranzakció döntés	Kritikus	AI csak javasol, ember dönt, audit log

A „90% sikerráta" csapdája

Ha az AI 90%-ban helyes, az kiváló lehet — de katasztrofális is. Egy ügyfélszolgálati chatbotnál a 10% hiba elviselhető. Egy gyógyszerdózis-javaslatnál soha.

A kérdés: mi a hiba költsége?

• Ha alacsony → engedheted az autonómiát
• Ha magas → human-in-the-loop kötelező

Összefoglalás: 7 takeaway

1. A hallucináció nem bug — a működés természetes következménye. A modell predikál, nem tud.
2. 5 típus van: faktuális, forrás-fabrikáció, logikai, instrukciós, kontextus-eltévedés. Mindegyikhez más mitigáció.
3. RAG a leghatékonyabb — adj a modellnek forrást, ne hagyd, hogy emlékezzen. Minimum score, hibrid search, citálás kötelezővé tétele.
4. Strukturált output — ha kényszered, kevésbé hallucinál. Zod / Pydantic schema, confidence mező.
5. Tool use matekra, dátumra, valós adatra. Soha ne hagyd a modellt számolni.
6. Temperature 0.1-0.3 faktuális esetben. A kreativitás és a faktualitás ellentét.
7. Human-in-the-loop kritikus döntésnél. A 90% sikerráta csapda — a 10% hiba költsége dönt.

A hallucináció nem szüntethető meg teljesen — de csökkenthető 1-2%-os szintre a megfelelő architektúrával. A különbség egy „AI-funkció demo-ra" és egy „enterprise-ready AI-rendszer" között nem a modell, hanem a körülötte épített validációs réteg.

A modell egy kreatív gyerek. Te vagy a felelős felnőtt mellette.