Parses natural-language queries into editable structured representations and lets users (or the system itself) modify the parsed query and replay the search, supporting iterative refinement that pure free-text re-typing cannot match.
Patent Overview
- Filed
- 2017-08-28
- Granted
- 2019-06-11
- Application Number
- US 15/688,063
The Challenge
The Challenge
Users iterate on queries by retyping, which is slow and error-prone. A natural-language query can be parsed into structured components (entities, relationships, constraints) that the user could edit directly, but this requires reliable parsing and a usable editing interface.
- Retyping Slows Refinement — When a result set is close but not quite right, retyping the query forces the user to remember the full prior query plus the change they want. Friction adds up.
- Free Text Hides Intent Components — A natural-language query encodes entities, relationships, and constraints. Editing the underlying components directly is more precise than editing surface text.
- Parse Must Be Reliable — If the system parses the query wrong, editing the parsed representation propagates the error. The parser must produce accurate component decomposition.
- Editing UI Must Feel Natural — Users should edit semantic components without learning a query language. The UI must surface structured editing while feeling like natural query input.
- Replay Must Be Fast — Each edit triggers a replayed query. Replay latency must match standard query latency or the editing workflow stalls.
Innovation
How The System Works
The system parses each natural-language query into a structured representation, surfaces the structure as editable chips or fields, accepts user edits or system-suggested edits, and replays the modified query against the search backend with minimal latency.
- Parse Query Into Structure — The parser decomposes the natural-language query into typed components: entities, relationships, constraints, filters. The output is an editable structured representation.
- Surface Editable Components — The UI displays the components as chips or fields. Each chip can be edited, replaced, or removed independently.
- Accept User Or System Edits — Users edit chips directly. The system can also suggest edits (corrections, refinements) based on the result set and historical patterns.
- Reconstruct Modified Query — Edited components reassemble into a modified query, either in natural-language form (for visibility) or in structured form (for execution).
- Replay Against Backend — The modified query executes against the search backend. Caching of overlapping components keeps latency low.
- Update Results — New results render in the SERP. The editing UI persists so further edits are immediate.
- Log Edit Patterns — Which edits users make, which suggestions they accept, and how results change feeds back into both the parser and the suggestion model.
Structured Editing With Natural Feel
The patent's load-bearing idea is to expose the structured representation underlying every natural-language query, so users can refine semantically rather than re-typing. The structure stays in service of the natural feel; users do not learn a query language.
Edit The Meaning, Not The Text
Free-text editing operates on characters. Structured editing operates on meaning components. The latter is more precise and faster for refinement.
- Parse To Components — Every natural-language query becomes a structured object with entities, relationships, and constraints as separate components.
- Editable Chips — The UI exposes components as editable chips. Editing one chip does not require retyping the whole query.
- Fast Replay — Modified queries replay with minimal latency. Component caching keeps the edit-results loop tight.
Technical Foundation
Technical Foundation
The patent specifies the parser, the structured representation format, the editing UI, the replay backend, and the learning loop.
- Natural-Language Parser — A neural parser decomposes queries into typed components. Trained on annotated query corpora plus distant supervision from result-set behavior.
- Structured Representation — Standardized intermediate format encodes components and their relationships. The format is editable and serializable.
- Editing UI Layer — Chips render the components as editable. Edit gestures (click, type, replace, remove) map to component-level operations.
- Edit Suggestion Model — Learned model suggests likely edits based on result set, historical patterns, and user context. Suggestions appear inline.
- Replay Pipeline — Modified queries execute against the search backend. Caching of common components keeps latency low.
- Learning Loop — Which edits users make and which suggestions they accept feeds back into parser and suggestion model training.
The Process
The Process
The pipeline runs both in the initial query path (parse plus surface) and in subsequent edits (modify plus replay). Each cycle completes in standard query latency.
- Receive Initial Query — Natural-language query enters the system. Parser produces the structured representation.
- Surface Editable Structure — UI renders components as chips alongside standard SERP. Edit-suggestions appear as needed.
- User Or System Edits — User edits chips directly, or accepts a suggested edit. Edits trigger replay.
- Reconstruct And Replay — Modified components reassemble and execute. Cached components avoid redundant work.
- Render Updated Results — New results appear. Editing UI persists for further refinement.
- Accept Or Edit Again — User can accept the current results or continue editing. The loop is open-ended.
- Log For Learning — Final accepted queries, intermediate edits, and suggestion acceptance rates feed the learning loop.
Quality Control
Quality Control
Parser errors and bad edit suggestions can derail the editing experience. The patent specifies safeguards.
- Parse Confidence Threshold — If parse confidence is low, the system falls back to free-text editing instead of risking misleading chip surfacing. Users always see the original query for verification.
- Suggestion Quality Filter — Edit suggestions below a confidence threshold are suppressed. Better to offer fewer suggestions than to clutter the UI with bad ones.
- Edit Undo — Every edit can be undone. Users are not trapped in a modified state if an edit produces worse results.
- Latency SLA — Replay latency is bounded by SLA. Slow replays trigger a fallback that preserves the editing context while running the slower query path.
- Privacy In Edit Logging — Edit logs are pseudonymized. Sensitive query patterns are excluded from the learning data.
Real-World Application
Structured-query editing appears in Google's faceted search filters, conversational refinement (Search Generative Experience follow-ups), and emerging Assistant query-refinement flows.
- Component-level Edit Granularity — Edits operate on parsed components, not raw text. Users can refine one dimension at a time.
- Replay-fast Iteration Latency — Edited queries replay at standard query latency. The edit-results loop is tight enough for iterative refinement.
- Learning-loop Continuous Improvement — User edits and accepted suggestions feed back into parser and suggestion-model training.
Why Conversational Search Inherits This
Search Generative Experience and AI Overview follow-ups build on the parse-edit-replay primitives. A follow-up that says 'just the ones under 50 dollars' is the user editing a constraint chip implicitly through natural language.
Why Filter UI Trains User Patterns
Faceted filters teach users to think in components. Once trained, users compose queries that the parser handles cleanly. The patent's primitives shape user behavior over time, not just one query.
<\/section>What This Means for SEO
What This Means for SEO
When the engine parses, edits, and rewrites a query before searching, your content must match the rewritten query family, not the literal one.
- Query Rewrites Expand Match Surface — A query gets stemmed, synonymized, and reshaped. Pages that cover the synonym set and related phrasings catch the rewrites that the literal-match-only competitor misses.
- Edit Layers Smooth Out Typos — The system corrects typos and removes filler words. Targeting the corrected canonical form, not the raw query, is the durable strategy.
- Question Reformulations Are Discoverable — How a query gets reformulated tells you what the system thinks it really means. Watch the People Also Ask box, those are the reformulations the system is most confident about.