Slot Filling

Also Known As

TL;DR

Explanation

Slot filling is the information-extraction task of populating a predefined schema of typed fields - the slots - from unstructured input such as a user utterance, a support ticket, or a document paragraph. Given a frame like FlightBooking with slots {origin, destination, depart_date, passengers}, a slot filler reads "Book two seats from Berlin to Lisbon next Friday" and returns origin=Berlin, destination=Lisbon, depart_date=<next Friday resolved>, passengers=2. The output is a structured record ready for a downstream API or database write, not a bag of tagged spans.

Slot filling sits at the intersection of several NLP subtasks and is often confused with them. Named entity recognition detects and types spans, but slot filling must also decide which slot a span belongs to inside a specific frame - the same city mention could be origin or destination depending on context. Relation extraction produces triples between entities, while slot filling produces role-labeled attributes of a single frame. Semantic role labeling assigns predicate-argument roles at the sentence level, which is closely related but not tied to a business schema. In dialogue systems slot filling also spans multiple turns: the user may supply the destination in turn one and the date in turn three, and the tracker must carry values forward, handle updates ("actually, make it Saturday"), and detect when the frame is complete enough to act.

Modern implementations range from grammars and regex-plus-gazetteer patterns for narrow domains, to joint intent-classification-and-slot-tagging models using BIO tags over transformer encoders, to LLM prompt-based extraction that emits JSON conforming to the schema. Each approach must handle normalization (mapping "next Friday" to an ISO date, "two" to 2), validation against slot types and allowed values, and confidence-based confirmation when a value is ambiguous. The failure modes are quiet: silently accepting a low-confidence value, overwriting a user-corrected slot with a stale extraction, or emitting a record that passes JSON schema checks but violates business constraints. Robust systems evaluate per-slot precision and recall, not just overall accuracy, and treat unfilled or uncertain slots as first-class states that trigger clarification rather than default guesses.

Common Misconception

Why It Matters

Common Mistakes

• Equating slot filling with NER and assigning slots purely by entity type, ignoring that context decides whether a city is origin or destination.
• Skipping value normalization so raw surface forms like 'next Friday' or 'two' reach the API instead of ISO dates and integers.
• Overwriting user-corrected slot values with stale extractions from earlier turns because there is no proper dialogue state tracker.
• Reporting only aggregate accuracy and missing that one critical slot has poor recall while common slots inflate the overall number.
• Treating missing or low-confidence slots as defaults rather than triggering an explicit clarification turn.

Avoid When

• The input is already structured through a form or API and slot values arrive as explicit fields.
• The domain is open-ended and cannot be captured by a fixed slot schema without constant churn.
• You only need to detect that entities exist without assigning them to business roles, where plain NER suffices.
• Every action is safe to retry and clarification cost is higher than acting on best-guess extractions.

When To Use

• Building a task-oriented dialogue system or voice assistant that must call APIs with typed arguments.
• Extracting structured records from free-text tickets, emails, or transcripts for downstream automation.
• Turning LLM outputs into schema-conformant JSON that can be validated and safely executed.
• Populating forms or workflows from natural-language input while tracking which required fields remain unfilled.

Code Examples

# Naive slot filling: map NER labels straight to slot names, no context, no normalization.
import re, spacy

nlp = spacy.load("en_core_web_sm")

def fill_slots(utterance):
    doc = nlp(utterance)
    slots = {"origin": None, "destination": None, "depart_date": None, "passengers": None}
    for ent in doc.ents:
        if ent.label_ == "GPE":
            # Blindly overwrites: last city wins, no idea which is origin vs destination.
            slots["destination"] = ent.text
            slots["origin"] = ent.text
        elif ent.label_ == "DATE":
            slots["depart_date"] = ent.text        # raw 'next Friday', not an ISO date
        elif ent.label_ == "CARDINAL":
            slots["passengers"] = ent.text         # string '2' or word 'two'
    return slots

print(fill_slots("Book two seats from Berlin to Lisbon next Friday"))
# origin and destination both 'Lisbon', depart_date 'next Friday', passengers 'two'

# Context-aware slot filling with role assignment, normalization, and validation.
from dataclasses import dataclass, field
from datetime import date
from dateutil import parser as dateparser
import spacy

nlp = spacy.load("en_core_web_sm")
WORD_NUM = {"one": 1, "two": 2, "three": 3, "four": 4, "five": 5}

@dataclass
class FlightFrame:
    origin: str | None = None
    destination: str | None = None
    depart_date: date | None = None
    passengers: int | None = None
    low_confidence: list[str] = field(default_factory=list)

def fill_slots(utterance: str, frame: FlightFrame | None = None) -> FlightFrame:
    frame = frame or FlightFrame()
    doc = nlp(utterance)
    # Use surrounding prepositions to assign role, not just entity type.
    for ent in doc.ents:
        prev = doc[ent.start - 1].text.lower() if ent.start > 0 else ""
        if ent.label_ == "GPE":
            if prev in {"from", "leaving"}:
                frame.origin = ent.text
            elif prev in {"to", "toward"}:
                frame.destination = ent.text
            else:
                frame.low_confidence.append(f"city:{ent.text}")
        elif ent.label_ == "DATE":
            try:
                frame.depart_date = dateparser.parse(ent.text, fuzzy=True).date()
            except (ValueError, TypeError):
                frame.low_confidence.append(f"date:{ent.text}")
        elif ent.label_ == "CARDINAL":
            token = ent.text.lower()
            frame.passengers = int(token) if token.isdigit() else WORD_NUM.get(token)
    return frame

def missing_slots(frame: FlightFrame) -> list[str]:
    return [n for n in ("origin", "destination", "depart_date", "passengers")
            if getattr(frame, n) is None]

frame = fill_slots("Book two seats from Berlin to Lisbon next Friday")
# origin=Berlin, destination=Lisbon, depart_date=<resolved date>, passengers=2
# missing_slots(frame) drives clarification if anything is still None.

Tags

🧠 Logic Engine

References

• https://web.stanford.edu/~jurafsky/slp3/15.pdf
• https://aclanthology.org/N18-2050/
• https://arxiv.org/abs/1902.10909
• https://rasa.com/docs/rasa/domain/#slots