How to Ground LLM Answers With Citations and Cut Hallucinations

A citation looks like evidence and is only a claim about a source, so it needs checking like any other claim.

Ask a model something your documents do not cover and it answers anyway. It sounds confident. It uses your format. It offers specifics.

In this test a bare prompt invented an answer to all four questions it had no basis for. One sentence took that to zero. Then adding citations, which sounds like it should help further, made things slightly worse.

In this article, let us look at how to measure all of that. We will build the piece most systems skip, which is checking whether a cited source really says what the answer claims.

What grounding actually means

Grounding means handing the model the text to answer from, then telling it to stay inside that text.

That is a smaller idea than it sounds. You are not making the model more truthful in general. You are narrowing what counts as a source for this one answer, and asking it to admit when that source runs out.

The admitting part matters more than people expect. Give a model good sources and no permission to say "I do not know" and it will still produce something. Producing text is what it does, and the most likely output is a plausible answer built from nearby material.

Citations are a separate idea layered on top. A citation says which piece of the supplied text a claim came from. That helps a reader check your work. It is not a guarantee, and that gap is what this article spends its time on.

What you need before you start

Everything here runs on one machine. A Linux box, which a KodeKloud playground gives you, or your own laptop.

You need two models. A small local one to answer questions, and a stronger one to check those answers. The split is deliberate, because checking is a different job from answering.

Install Ollama for the answers

sudo apt-get update && sudo apt-get install -y zstd python3 python3-venv
curl -fsSL https://ollama.com/install.sh | sh
curl http://localhost:11434/
ollama pull llama3.2:1b

Ollama is running from that third command means the service already started. A connection refused means you need ollama serve & first.

Get a key for the checker

KodeKey gives you one key reaching Claude, GPT and Gemini through a single OpenAI compatible endpoint.

export KODEKEY_API_KEY="your key here"

Set up the project

mkdir grounding && cd grounding
python3 -m venv .venv
source .venv/bin/activate

There is nothing to install, since everything below uses the standard library. You will build four files as you work through the article.

Step 1: Set up sources and questions

Create sources.py. The sources are numbered because citations need something to point at.

SOURCES = [
    {"id": 1, "title": "Pod restart behaviour",
     "text": "When a pod enters CrashLoopBackOff, Kubernetes waits longer between "
             "each restart, doubling up to a maximum of five minutes. Deleting the "
             "pod makes the controller recreate it within seconds."},
    {"id": 2, "title": "Exit codes",
     "text": "Exit code 137 is 128 plus signal 9, which is kill. The kernel out of "
             "memory killer stopped the process. The memory limit is enforced per "
             "container rather than per pod."},
    {"id": 3, "title": "Credential rotation",
     "text": "Rotate the credential in the secret store first, then update the "
             "Kubernetes secret, then restart the deployment. The application does "
             "not watch the secret for changes."},
    {"id": 4, "title": "Node maintenance",
     "text": "Cordon the node first so the scheduler stops placing new pods on it, "
             "then drain it. A deployment with one replica and a disruption budget "
             "requiring one available will block the drain."},
]

QUESTIONS = [
    {"q": "What is the maximum restart backoff?", "source": 1, "answerable": True},
    {"q": "What does exit code 137 mean?", "source": 2, "answerable": True},
    {"q": "Is the memory limit per pod or per container?", "source": 2, "answerable": True},
    {"q": "What do I update first when rotating a credential?", "source": 3, "answerable": True},
    {"q": "Why would a drain never finish?", "source": 4, "answerable": True},
    {"q": "Should I cordon before draining?", "source": 4, "answerable": True},
    {"q": "What is the default pod CPU request?", "source": None, "answerable": False},
    {"q": "How do I configure horizontal pod autoscaling?", "source": None, "answerable": False},
    {"q": "What port does the kubelet listen on?", "source": None, "answerable": False},
    {"q": "How long does a rolling update take?", "source": None, "answerable": False},
]

Four of those questions have no answer in the sources. Those are the important ones. Ask about a topic your sources cover and you get a reasonable answer either way, grounded or not. So a test set of only answerable questions tells you nothing about hallucination.

The source field records which source holds each answer. That is what makes checking citations possible later.

Step 2: Measure three prompts

Create compare.py. It runs every question through three prompt styles and counts how often the model invents an answer it has no basis for.

import json
import re
import urllib.request

from sources import SOURCES, QUESTIONS

BLOCK = "\n\n".join(f"[{s['id']}] {s['title']}\n{s['text']}" for s in SOURCES)

PROMPTS = {
    "bare": "Question: {q}\n\nAnswer briefly.",

    "grounded": ("Answer using only the sources below. If they do not contain the "
                 "answer, say you do not know.\n\nSources:\n{block}\n\n"
                 "Question: {q}\n\nAnswer briefly."),

    "grounded + cite": ("Answer using only the sources below. Cite the source number "
                        "in square brackets after each fact, like [2]. If the sources "
                        "do not contain the answer, say you do not know and cite "
                        "nothing.\n\nSources:\n{block}\n\nQuestion: {q}\n\nAnswer briefly."),
}


def ask(prompt, model="llama3.2:1b"):
    body = json.dumps({
        "model": model, "prompt": prompt, "stream": False,
        "options": {"num_predict": 90, "temperature": 0},
    }).encode()
    request = urllib.request.Request(
        "http://localhost:11434/api/generate", data=body,
        headers={"Content-Type": "application/json"},
    )
    return json.loads(urllib.request.urlopen(request).read())["response"].strip()


results = {}
for name, template in PROMPTS.items():
    rows = []
    for item in QUESTIONS:
        answer = ask(template.format(block=BLOCK, q=item["q"]))
        rows.append({**item, "answer": answer,
                     "cited": [int(n) for n in re.findall(r"\[(\d+)\]", answer)]})
    results[name] = rows

json.dump(results, open("runs.json", "w"), indent=1)
print("saved runs.json")

python3 compare.py

Saving the answers lets you score them repeatedly without regenerating. That matters, because the next step changes how they are scored.

Step 3: Count the invented answers

Create score.py. For each unanswerable question it decides whether the model admitted it did not know, or invented something.

That decision needs a method. The obvious one is to look for phrases like "I do not know". It turns out to be wrong here, and finding out why is worth more than the result.

The alternative is to ask another model. You send it the reply, plus a yes or no question about whether that reply declined. This is usually called using a judge. A judge is just a second model whose only job is grading the first one's work.

import json
import os
import urllib.request

RUNS = json.load(open("runs.json"))


def refused_by_keyword(answer):
    """The tempting approach, included to show why it fails."""
    lowered = answer.lower()
    return any(phrase in lowered for phrase in
               ["do not know", "not contain", "no information", "not provided"])


def refused_by_judge(answer, model="claude-haiku-4-5-20251001"):
    """Ask a model whether the reply declined, rather than matching words."""
    prompt = (f"Does this reply decline to answer, saying it does not know or that "
              f"the sources do not cover it?\n\nReply: {answer}\n\n"
              f"Answer with one word, YES or NO.")
    body = json.dumps({
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 4, "temperature": 0,
    }).encode()
    request = urllib.request.Request(
        "https://api.ai.kodekloud.com/v1/chat/completions", data=body,
        headers={"Content-Type": "application/json",
                 "Authorization": f"Bearer {os.environ['KODEKEY_API_KEY']}"},
    )
    reply = json.loads(urllib.request.urlopen(request).read())
    return reply["choices"][0]["message"]["content"].strip().upper().startswith("YES")


print(f"  {'prompt':18s}{'keyword check':>15s}{'judge':>9s}")
for name, rows in RUNS.items():
    unanswerable = [r for r in rows if not r["answerable"]]
    by_keyword = sum(1 for r in unanswerable if not refused_by_keyword(r["answer"]))
    by_judge = sum(1 for r in unanswerable if not refused_by_judge(r["answer"]))
    print(f"  {name:18s}{by_keyword:>12}/4{by_judge:>6}/4")

python3 score.py

python3 score.py

prompt              keyword check    judge
  bare                         4/4      4/4
  grounded                     0/4      0/4
  grounded + cite              2/4      1/4

Three things in that table are worth separating.

The bare prompt invented an answer every single time. That is not a bad model. It is a model doing its job, never having been told the job had boundaries.

One sentence fixed it completely. Telling the model to use only the sources, and to say when they fall short, took four out of four down to zero. No other change in this article comes close.

And the keyword check disagreed with the judge. It counted two inventions where there was one, because it looked for "not provided" and the model wrote "do not provide". Your measurement can fail the same way your system can. A measurement nobody checked is just a confident number.

Step 4: The result that surprises people

Look at the last row again. Adding a citation instruction to a working grounded prompt made it worse, going from zero inventions back up to one.

That is worth understanding rather than dismissing as noise, since the mechanism is a general one.

The grounded prompt asks for one behaviour. Answer from the sources, or decline. The citation prompt asks for three at once. Answer from the sources, attach a bracketed number to each fact, and decline when they fall short. A small model asked for three things does the easiest ones first, and producing an answer with a citation attached is easier than deciding no answer exists.

There is a second pull in the wrong direction. Having been told what a good answer looks like, complete with brackets, the model has a template to fill rather than a judgement to make.

That last column is the other half of the problem. The model was asked to cite a source for every fact. It did so on one of the six questions it could answer, so the instruction was mostly ignored.

Practise the whole pipeline

Grounding sits inside retrieval, and the quality of what you retrieve sets the ceiling on what grounding can do. The Fundamentals of RAG course covers ingestion, chunking, search strategy and building a complete pipeline.

Step 5: Verify the citations

Here is the failure that matters most. It is also the one almost nobody checks for.

One answer came back like this:

The kubelet listens on port 10250 [1].

Source 1 is about pod restart behaviour. It says nothing about kubelets and nothing about ports. So the model invented a fact and attached a citation to it. Worse, the citation makes that invented fact look better sourced than the true ones, which arrived with no brackets at all.

A citation is a claim about a source. Like any other claim it can be checked, and the checking is mechanical.

Create verify.py.

import json
import os
import re
import urllib.request

from sources import SOURCES

BY_ID = {s["id"]: s for s in SOURCES}

CHECK = """Does this source actually support the claim?

Source [{id}] {title}:
{text}

Claim: {claim}

Answer with one word, YES or NO."""


def supports(claim, source_id, model="claude-haiku-4-5-20251001"):
    source = BY_ID.get(source_id)
    if source is None:
        return False, "cited a source that does not exist"

    body = json.dumps({
        "model": model,
        "messages": [{"role": "user",
                      "content": CHECK.format(claim=claim, **source)}],
        "max_tokens": 4, "temperature": 0,
    }).encode()
    request = urllib.request.Request(
        "https://api.ai.kodekloud.com/v1/chat/completions", data=body,
        headers={"Content-Type": "application/json",
                 "Authorization": f"Bearer {os.environ['KODEKEY_API_KEY']}"},
    )
    reply = json.loads(urllib.request.urlopen(request).read())
    ok = reply["choices"][0]["message"]["content"].strip().upper().startswith("YES")
    return ok, "supported" if ok else "the source does not say this"


def check_answer(answer):
    """Every sentence carrying a citation is a claim to verify."""
    results = []
    for sentence in re.split(r"(?<=[.!?])\s+", answer):
        for cited in re.findall(r"\[(\d+)\]", sentence):
            claim = re.sub(r"\s*\[\d+\]", "", sentence).strip()
            ok, why = supports(claim, int(cited))
            results.append({"claim": claim, "source": int(cited),
                            "ok": ok, "why": why})
    return results


if __name__ == "__main__":
    EXAMPLES = [
        "The kubelet listens on port 10250 [1].",
        "The maximum restart backoff is five minutes [1].",
        "Exit code 137 means the out of memory killer stopped the process [2].",
        "Rotate the credential in the secret store first [2].",
        "The memory limit is per container [9].",
    ]
    for example in EXAMPLES:
        for result in check_answer(example):
            mark = "ok  " if result["ok"] else "FAIL"
            print(f"  [{mark}] [{result['source']}] {result['claim'][:58]}")
            if not result["ok"]:
                print(f"          {result['why']}")

python3 verify.py

python3 verify.py

[FAIL] [1] The kubelet listens on port 10250.
          the source does not say this
  [ok  ] [1] The maximum restart backoff is five minutes.
  [ok  ] [2] Exit code 137 means the out of memory killer stopped the p
  [FAIL] [2] Rotate the credential in the secret store first.
          the source does not say this
  [FAIL] [9] The memory limit is per container.
          cited a source that does not exist

Those five examples cover the three ways a citation goes wrong. The verifier catches all of them.

The first is an invented fact with a citation attached, where the source exists and says nothing on the subject. The fourth is a true fact pointed at the wrong source, since credential rotation is source 3 rather than source 2. That one is easiest to miss by eye, because the claim itself is correct. The fifth cites a source that does not exist, which needs no model call to catch.

Handle that last one first, because it is free. Checking every cited number is in range is a dictionary lookup, and it catches the most obviously broken case before you pay for anything.

What this costs and when it is worth it

Verification costs one extra model call per citation. Not free, and not always needed.

Sampling is the option people forget. Checking one answer in fifty costs almost nothing and still tells you your rate. That rate is what tells you whether to check them all.

Putting it together

Here is the order that works, based on the measurements above.

Start with the grounding instruction. It is one sentence and it removed every invented answer here. Give the model explicit permission to decline, because without it a model always produces something.

Add citations only after checking that grounding still holds. The measurement here showed the combination can weaken it on a small model.

Then verify the citations rather than trusting them. Start with the free range check, and use a model only for the claims that survive it.

And measure the unanswerable questions specifically. That is where the behaviour you care about lives. A test set full of answerable questions reports success while your system invents things at the edges.

What you should be able to answer now

What single change cuts hallucination most? Tell the model to answer only from the sources, and to say when they fall short. That took four invented answers out of four down to zero.

Why might adding citations make grounding worse? It turns one instruction into three, and a small model satisfies the easiest ones first. Producing an answer with brackets is easier than deciding no answer exists.

Why is a citation not proof? It is a claim about a source, not a quote from one. The model here cited a source about pod restarts as the basis for a fact about kubelet ports.

What should you check first when verifying? Whether the cited source number exists at all. That check is free, and it catches the most clearly broken case.

The most useful thing here is not the verifier. It is that the questions with no answer were the only ones that told us anything, and most test sets contain none.

Ready to Build the Rest of the Pipeline?

Grounding is one layer of making an AI answer trustworthy. The Fundamentals of RAG course covers retrieval end to end, the Vector Database for GenAI course goes deeper on storage, and the AI Learning Path sequences both alongside agents and MCP. Start by writing four questions your documents cannot answer.

FAQs