Slot Filling

A semantic frame is a predefined template of slots representing the parameters required to fulfill a user's intent. Each slot has a type (e.g., date, city, cuisine), a prompt for missing values, and often a validation constraint. For example, a book_flight frame defines slots for origin, destination, departure_date, and passenger_count. The frame acts as the contract between natural language understanding and the execution API, ensuring all necessary variables are captured before a transaction is committed.

Slot filling is rarely completed in a single user utterance. A dialogue manager tracks which slots are filled, which are missing, and which are ambiguous. It drives a mixed-initiative conversation, where the system asks targeted clarifying questions—known as slot prompting—to elicit missing required parameters. For instance, if a user says 'Book a flight to London,' the system will prompt for the origin city and departure_date in subsequent turns, maintaining a persistent dialogue state until the frame is complete.

Extracted slot values must be mapped to canonical entities. A raw string like 'next Tuesday' is parsed into a normalized ISO 8601 date. A city name like 'NYC' is resolved to a specific airport code (JFK, LGA, EWR) via an entity linking step against a knowledge base. This normalization is critical: the downstream booking API requires structured data, not free text. Techniques include:

• Gazetteer matching for known entities
• Rule-based date/time parsing with temporal anchoring
• Fuzzy matching against a product catalog for items like 'large iced latte'

Users rely on deixis ('this one,' 'there') and anaphora ('it,' 'his') to refer to previously mentioned entities. Slot filling systems must resolve these references to maintain context. For example, in the exchange: 'Show me flights to Paris' followed by 'Book the cheapest one,' the system must resolve 'the cheapest one' to a specific flight entity from the prior turn's results. This requires a coreference resolution module that links pronouns and demonstratives to their antecedents in the dialogue history and populates the correct slot.

Not all slot values are explicitly stated. A query like 'I need a ride to the airport' implies the user's current location as the pickup_location slot. Systems use default reasoning and contextual signals—such as GPS coordinates, user profile data, or session history—to infer missing values without prompting. This reduces dialogue friction. A food ordering system might infer delivery_address from the user's saved profile, filling the slot silently and only confirming the value in the final order summary.

Dialogue state management must handle slot carryover—retaining values across turns—and slot resets when the user changes their intent. If a user says 'Find Italian restaurants' and then 'Actually, make it Mexican,' the cuisine slot is overwritten while the location slot persists. Conversely, a complete intent switch (e.g., from find_restaurant to book_flight) triggers a frame reset, clearing all slots. Robust systems also implement timeout policies to clear stale slots after periods of inactivity.

The task of categorizing a user's query into a predefined intent category (e.g., book_flight, check_balance). Intent classification determines what the user wants to do, while slot filling extracts the parameters needed to execute that intent.

• Works upstream of slot filling to select the correct semantic frame
• Common architectures: fine-tuned BERT classifiers, few-shot LLM prompts
• Example: "Find me a flight to London" → Intent: search_flight

The process of identifying and classifying key elements like people, organizations, locations, and dates from unstructured text. Entity extraction provides the raw material that slot filling maps into structured template fields.

• Uses sequence labeling models (e.g., spaCy, BERT-based NER)
• Distinction: entity extraction identifies what an entity is; slot filling maps it to a role in a task
• Example: "London" → Entity: GPE → Slot: destination_city

Converts natural language into a structured logical form (e.g., SQL, lambda calculus, API calls) that machines can execute directly. Slot filling is a lightweight form of semantic parsing focused on template completion.

• Full semantic parsing handles nested logic, comparisons, and aggregations
• Slot filling is sufficient for frame-based task completion
• Example: "Flights under $500" → SELECT * FROM flights WHERE price < 500

Maintains a running estimate of the user's goals and constraints across multi-turn conversations. Slot filling populates individual turns; dialogue state tracking accumulates and updates those slots over time.

• Handles slot updates, deletions, and contradictions
• Critical for systems that allow users to revise requests
• Example: User says "Actually, make that Paris" → DST updates destination_city from "London" to "Paris"

Breaks complex, multi-faceted queries into atomic sub-queries that can be independently resolved. Each sub-query may require its own slot filling operation before results are synthesized.

• Essential for multi-hop reasoning across data sources
• Enables parallel slot filling across independent constraints
• Example: "Compare flights and hotels in Tokyo next Tuesday" → two separate slot-filling operations

Identifies all expressions in a text that refer to the same real-world entity. In dialogue systems, coreference resolution ensures that pronouns and anaphora are correctly mapped to previously filled slots.

• Links "it," "that one," "the cheaper option" to specific slot values
• Prevents slot duplication and inconsistency in multi-turn interactions
• Example: "Show me the 3 PM flight. Book it." → resolves "it" to the previously mentioned flight entity