What is NLP in SEO | How Google SEO uses NLP

In SEO, NLP (natural language processing) helps search engines match content more precisely by analyzing meaning and user intent. According to a 2024 Moz study, 78% of high-ranking pages use this technology;

In Google's core algorithm, BERT, NLP accounts for more than 70% of the processing, improving the professionalism and reliability of the content, in line with EEAT guidelines.

Read in another language: 中文 · English

I'll explain in detail how Google uses NLP to make search results better at “understanding you”.

What is NLP

NLP (Natural Language Processing) is a technology that allows computers to understand, analyze and generate human language.

Every day, more than 8.5 billion searches are carried out worldwide (public data from Google, 2024), and about 60% of queries contain implicit meaning or ambiguous phrasing (for example, “Apple” can mean the fruit, the phone, or a music album).

Traditional search engines can only “match keywords”, while NLP can break down a jumbled text into semantic units (for example, breaking “iPhone 15 model 2025 waterproof test” into three entities: “2025 model”, “iPhone 15” and “waterproof test”), then build a semantic network through contextual relationships (such as the relationship between “waterproofing” and “smartphone function”), finally letting the machine “understand” the real intention behind the text.

The evolution from “keyword matching” to “semantic understanding”

To understand how NLP lets Google truly “read” the text, we have to go back to the “infancy” of search engines: from the 1990s to the early 2000s.

At the time, search technology was as primitive as a “word dictionary”: if a user typed “coffee”, the engine simply returned every page that contained the word “coffee”.

Some pages deliberately repeated “weight loss”, “weight loss”, “weight loss” in the content simply to turn up for anyone searching for “weight loss”.

The mechanical “word counter” (1990s–early 2000s)

Early search engines (such as AltaVista in 1995 and Yahoo in 1998) used TF-IDF (Term Frequency - Inverse Document Frequency) as their main algorithm, which in practice meant “count how many times a word appears on a page: the more often it appears, the more relevant the page is”.

For example, if a user searched for “Java”, the system put pages with a high frequency of words such as “Java programming” or “Java tutorial” first; but if it came across a page about “Java coffee” (a variety of coffee), it could still rank it as relevant by mistake, simply because “Java” appeared many times.

In 2003, a study by the University of California, Berkeley, analyzed results from the main search engines of the time: when users searched for “Apple”, 45% of the first 20 results were about the fruit, 30% about Apple products and the remaining 25% about irrelevant content such as “apple pie recipe” or “apple tree cultivation”. Users had to filter the results manually and, on average, clicked 3.2 links before finding what they wanted (Forrester data, 2003).

Some sites began to “exploit the loopholes”: for example, when a user searched for “best laptop”, low-quality sites repeated words like “best”, “laptop” and “recommended” in the page, and even used hidden text (white text on a white background) to fill the page with keywords.

In 2005 Google had to admit publicly: “About 30% of low-quality pages make it into the top 10 thanks to keyword stuffing.” (internal report by the Google Search Quality team)

The “fuzzy inference” of statistical models (mid-2000s–early 2010s)

In the mid-2000s, with the explosive growth of online content (approximately 1 billion web pages in 2000 and 50 billion in 2010), relying on keyword counts alone became completely ineffective.

Search engines began to introduce statistical models of language, trying to understand the relationships between words through “contextual probability”.

For example, in 2008 Google introduced the “phrase matching” technology: the system no longer looked only at individual words, but analyzed how often certain phrase combinations appeared.

For example, if a user searched for “how to prepare coffee”, the system favored pages that contained the words “prepare”, “coffee”, “water” and “temperature” together, rather than pages that contained only “coffee”. This technology increased the relevance of results by about 12% (data from Google's technical blog, 2009).

In 2012 Google went on to launch the “Knowledge Graph”, turning isolated words into a network of “entities + relationships”.

For example, “Einstein” was no longer just a word, but was labeled with properties such as “physicist”, “born in Ulm, Germany”, “formulated the theory of relativity”.

When the user searched for “Einstein,” the system not only returned biographical pages, but also directly displayed birth and death years, famous quotes, and even links to pages explaining “relativity.”

After the launch of the Knowledge Graph, Google's official data showed that 40% of user search needs were met directly (without clicking a link) (official Google presentation, 2013).

But it still wasn't enough: the Knowledge Graph relied on manually annotated “structured data”, while 90% of the content on the Internet is unannotated “unstructured text” (such as blogs and forums). For machines to understand this “messy text”, an even more powerful technology was needed.

From “statistical regularities” to “semantic understanding” (mid-2010s–today)

In the 2010s, advances in deep learning (especially in the development of neural networks) have fundamentally changed NLP. In 2013 Google researcher Tomas Mikolov proposed the Word2Vec model, which for the first time mapped words into a “vector space”: for example, the vector difference between “king” and “queen” is very similar to the difference between “man” and “woman”, which means the model can “understand” semantic relationships between words.

In 2016 Google introduced RankBrain into search (a ranking algorithm based on deep learning), capable of automatically “learning” the relationship between users' search behavior and content relevance.

For example, when a user searches for “cheap wireless earphones”, RankBrain analyzes which pages keep users longest and lose the fewest of them after the click, thereby inferring the real relationships between “cheap”, “wireless” and “earphones”.

According to data published by Google in 2017, RankBrain improved the relevance of long-tail queries (uncommon search terms) by 25% (such as “recommendations for bone conduction earphones suitable for running”).

In 2018 Google launched the BERT model (bidirectional Transformer architecture), definitively solving the problem of “contextual ambiguity”. Traditional models could only understand sentences “unidirectionally” (e.g. from left to right), whereas BERT analyzes “what comes before and what comes after” simultaneously.

For example, in the sentences “Xiaoming's apple is ripe” and “Xiaoming took a bite of the apple”, BERT can infer from the context that in both cases “apple” means the fruit. But if the sentence were “Xiaoming's Apple has released a new system”, BERT would immediately recognize that “Apple” means the company.

The effect of BERT was immediate:

Google's internal tests in 2019 showed that the CTR (click-through rate) of complex queries rose from 18% to 25%;

In 2023, according to public data from the Google Search Liaison team, BERT increased the accuracy of ambiguous queries from 58% to 82% (for example, when a user searches for “Python”, the model can tell from the context whether it is the programming language or the snake, an improvement of 24 percentage points).

From “matching words” to “understanding people”

Looking at how NLP evolved, the essential point is the search engine's shift from “mechanically executing instructions” to “understanding human needs”:

• Era 1.0 (keyword matching): the machine is like a “word counter”, capable only of literal matching;
• Era 2.0 (statistical models): the machine is like a “probabilistic analyst”, deducing intent through contextual probabilities;
• Era 3.0 (deep learning): the machine is like a “language apprentice”, which can “learn” semantic logic from big data.

In 2024, a Pew Research Center survey showed that 78% of users think today's search results “match real needs better”, while in 2010 that figure was only 41%.

Google Chief Scientist Jeff Dean put it this way: “The goal of NLP is not to let machines ‘read the text’, but to ‘understand people’.”

The “core work” of NLP

To allow a machine to “understand” a text, NLP must process the “fragments of information” present in the language step by step, just as humans do when breaking down a sentence.

When Google's NLP system (for example, an improved version of BERT) processes the content of a page, it strictly follows four stages to “decode” the text: tokenization → entity recognition → semantic correlation → contextual correction.

Phase 1: tokenization

Tokenization is the first step of NLP. Put simply, it means splitting a continuous sequence of text into independent “semantic units” (called “tokens”).

Chinese has no natural spaces between words (unlike English, where “apple pie” has a space), so tokenization is one of the central challenges of NLP for Chinese.

Technical principle:

Google's tokenization system uses a hybrid “rules + deep learning” model:

• Rule base: contains millions of common Chinese combinations (such as “prepare coffee”, “pour-over kettle”, “waterproof test”), which are matched first;
• Deep learning model: a fine-tuned version of BERT that dynamically predicts words missing from the vocabulary (for example, new terms like “dopamine dressing”).

Practical case:

Take the content “How do I brew a rich, aromatic cup of pour-over coffee?” as an example: the tokenization system has to determine the correct way to segment it. Possible segmentations:

• Incorrect segmentation: “how to/prepareu/a cup/aromatic/pour-over coffee” (breaks sensible combinations like “a cup”, “aromatic”, “pour-over coffee”);
• Correct segmentation: “how to/make/a cup/aromatic/pour-over coffee” (conforms to natural Chinese usage).

Supporting data:

Google's 2023 internal tests show its tokenization system achieves 97.3% accuracy on common Chinese web pages, but only 89% for rare terms in YMYL industries (such as law and medicine), because fewer rules are available for specialist terminological collocations.

To address this problem, Google trains additional “domain-specific tokenization models” for vertical pages (for example, a medical model stores the correct segmentation of terms like “myocardial infarction” and “coronary artery”).

Phase 2: entity recognition

After tokenization, NLP has to identify the “entities” in the text, that is, key information such as people, objects, times, places and events.

Entities are the “skeleton” of the content and help the machine quickly identify the theme of the page.

Technical principle:

Google uses a multitask learning model (Multi-Task Learning) that simultaneously trains entity recognition, part-of-speech tagging (e.g. nouns and verbs) and relationship extraction.

The model predicts for each token whether it belongs to an entity and labels its type (such as “TIME”, “PRODUCT”, “PERSON”).

Examples of entity types:

Practical case:

When processing the sentence “The IP68 waterproof test of the iPhone 15 from September 2025 shows that it resisted 30 minutes at a depth of 6 meters”, the entity recognition system will produce:

• TIME: “September 2025”
• PRODUCT: “iPhone 15”
• ATTRIBUTE: “IP68 waterproof rating” “6-meter depth” “30 minutes”
• EVENT: “waterproof test”

Supporting data:

According to Google's 2024 technical blog, its entity recognition model achieves 92% recall on general-domain text (that is, the ratio of entities correctly recognized to all real entities), but on long texts (over 5000 characters) recall drops to 85%, because entity density is lower and the model tends to miss some.

That is why Google introduced a “segment processing” strategy: long text is split into paragraphs of about 500 characters, entities are recognized segment by segment and the results are then merged, raising recall on long texts to 90%.

Phase 3: semantic correlation

After tokenization and entity recognition, NLP must clarify the logical relationships between words (such as “belongs to”, “cause”, “attribute”), transforming dispersed tokens into a structured semantic network.

This phase decides whether the machine can really “understand” the actual meaning of the sentence.

Technical principle:

Google takes a hybrid approach based on pre-trained language models + Knowledge Graph:

• Pre-trained models (like BERT) learn from large amounts of text the “implicit relationships” between words (e.g., “running shoes” and “sports equipment” have a hierarchical relationship);
• Google's Knowledge Graph provides structured knowledge (for example, the brand of “iPhone 15” is “Apple” and the launch date is “September 2023”), used to verify and complete the relationships learned by the model.

Examples of relationship types:

Practical case:

When processing the sentence “When choosing running shoes, the cushioned midsole is crucial, because it can reduce the pressure on the knees”, the semantic correlation system will establish:

• an attribute relationship between “running shoes” and “cushioned midsole”;
• a causal relationship between “cushioned midsole” and “reduce pressure on the knees”.

Supporting data:

Google's 2023 internal tests show that its semantic correlation model recognizes common relationships with 88% accuracy, but for complex relationships (such as “indirect causation”) accuracy is only 72%. For example, in the sentence “Wearing unsuitable shoes for a long time can lead to a deformation of the arch of the foot, which in turn can cause back pain”, the relationship between “unsuitable shoes” and “back pain” is indirect, and the model tends to treat it as having no direct link. To solve this problem, Google introduced “chain-of-thought reasoning”: by connecting two distant entities through intermediate nodes (such as “arch deformation”), accuracy on complex relationship recognition rose to 85%.

Phase 4: contextual correction

Some words, taken on their own, are ambiguous (for example, “Apple” can mean the fruit or the brand), so their meaning has to be corrected using the whole paragraph or even the whole page.

This is the key phase in which NLP “understands” the text, and it is also the phase that depends most on context.

Technical principle:

Google uses a bidirectional attention mechanism (as in BERT's core design), which allows the model to “look” at the beginning and end of the sentence at the same time, dynamically adjusting the meaning of each token.

For example, when the model processes “Xiaoming's apple is ripe”, the initial meaning of “apple” can be “fruit”;

but when it processes the next sentence “He plans to use Apple to release a new system”, it returns to the earlier context and realizes that “releasing a new system” has nothing to do with a fruit, thereby correcting the meaning of “Apple” to “technology company”.

Practical case:

Taking the content “The latest iPhone 15 released by Apple supports satellite communication, which is good news for outdoor lovers” as an example:

• if you only look at the word “Apple”, the model may misinterpret it as “fruit”;
• when combined with the next phrase “released iPhone 15”, the model corrects “Apple” to “technology company”;
• adding the reference to “outdoor lovers” further confirms that the “satellite communication” feature of the iPhone 15 is linked to outdoor scenarios.

Supporting data:

A 2024 Google user behavior study shows that, in ambiguous query scenarios (such as searching for “Python”), context-corrected results are 37% more relevant than uncorrected ones.

When processing pages, contextual correction raises the rate of identifying the meaning of ambiguous terms correctly from 62% to 89% (data based on Google's internal tests).

NLP saves users 30% of search time every day

When a user searches, the most immediate experience is: “Will I be able to find what I want faster?”

According to Microsoft's 2024 report on user behavior, with NLP-optimized search engines, the average time to find the desired information drops from 87 seconds to 59 seconds (about 30% less).

Ambiguous queries

In a search session, about 40% of queries contain ambiguous words (such as “Apple”, “Python”, “Java”). Traditional search engines treat these queries as ordinary keywords and return many irrelevant results.

Thanks to semantic disambiguation (Word Sense Disambiguation, WSD), NLP can establish the true meaning of a word based on context, directly filtering out unnecessary content.

What this looks like in practice:

• Case 1: searching for “Python”: the user may want tutorials on the programming language (62%), information about the snake (18%), or queries related to the Python language (20%). A traditional engine returns every page containing “Python”, so the user has to filter 10-15 irrelevant links by hand across the first 3 pages; with NLP, the system infers the user's intent from the page content (such as “print() function” or “web scraping tutorial”) and shows programming results first. In Google's 2023 internal tests, the share of effective results on the first screen for ambiguous queries rose from 38% to 72%, while the average number of clicks fell from 2.3 to 1.1.
• Case 2: searching for “Java”: the user may be looking for the programming language (55%), a travel guide to the Indonesian island of Java (25%), or a variety of coffee (20%). By analyzing related words on the page (for example, “JVM” and “Spring framework” for programming, “Tanah Lot” and “volcano” for tourism), NLP can quickly identify the user's real need. A 2024 Pew Research survey shows that the time it took to complete an ambiguous search dropped from 112 seconds to 68 seconds (40 seconds less).

Technical basis:

NLP's ability to disambiguate relies on double verification of “contextual vectors” and the “Knowledge Graph”.

For example, when the user searches for “Java”, the model extracts other keywords present on the page (such as “coffee”, “programming”, “island”) and maps them to the Knowledge Graph entities (“Java (programming language)”, “Java (island)”), then determines the most relevant entity by calculating vector similarity (such as cosine similarity) and finally returns the correct result.

Implicit needs

The terms users search for usually express only 10%-20% of the core need; the remaining 80%-90% is implicit (for example, “price”, “difficulty”, “usage scenario”).

Through Semantic Expansion, NLP can expand related needs outward from the central terms, actively covering intentions the user has not expressed explicitly.

What this looks like in practice:

• Case 1: searching for “recipes to lose weight”: the user may be implying needs such as “low-calorie”, “easy to make”, “suitable for office workers”, “sugar-free”. A traditional engine only matches pages containing “weight loss” and “recipes”, and may show “extreme diets” or “complicated pastry recipes”; with NLP, the system analyzes words commonly associated with “weight loss” (such as “calories”, “fast”, “home-cooked”) and shows pages like “low-calorie breakfast in 15 minutes” or “recipes to take to work” first. A 2022 Google A/B test shows that in results covering implicit needs, users' dwell time went from 45 to 78 seconds (+73%), because there is no need for a second search such as “low-calorie weight-loss recipes”.
• Case 2: searching for “what to wear when it rains”: the user may be implying needs such as “waterproof”, “non-slip”, “lightweight”, “warm”. A traditional engine returns generic results such as “raincoat” or “umbrella”; NLP, however, can recognize the attributes of a “rainy day” scenario (humidity, risk of slipping) and link them to features such as “waterproof material”, “non-slip sole” and “foldability”, recommending concrete products like a “waterproof shell jacket” or “non-slip boots”. According to a 2024 eMarketer survey, in e-commerce search that covers implicit needs, the conversion rate goes from 3.2% to 5.8% (users are more likely to click through and buy).

Technical basis:

Semantic expansion relies on training with a “word vector space” and “user behavior data”.

For example, Google's BERT model maps “weight loss recipes” into a high-dimensional vector space, where words like “low-calorie” and “easy to make” are very close vector-wise;

at the same time, the system analyzes historical search data (for example, users who search for “recipes to lose weight” often click on “low-calorie breakfast”), further verifying the relevance of these implicit needs and finally producing a lexicon of expanded terms.

Cross-scenario adaptation

The scenario in which the user searches (time, place, device) directly influences the need. Thanks to Context Awareness, NLP can dynamically adapt its understanding of the query and provide results that are better suited to the current context.

What this looks like in practice:

• Temporal scenario: if a user searches for “jacket” in winter, NLP prioritizes keywords like “padded”, “warm”, “down”; if the search is for “jacket” in summer, it first shows “anti-UV”, “lightweight”, “breathable” items. According to Google's 2023 seasonal search data, after context adaptation, user satisfaction with the results goes from 68% to 85% (because the results respond better to seasonal needs).
• Geographical scenario: if a user searches for “hotpot” in Shanghai, NLP recommends popular local spots; if the search is for “hotpot” in Chengdu, it prioritizes authentic Sichuan hotpot. In 2024 Google Maps and Search integration tests, after adapting to the local context, the probability that users click on “nearby businesses” goes from 22% to 47% (because the results are more relevant).
• Device scenario: if a user searches “petrol station near me” on a smartphone, NLP favors results with “navigation”, “real-time fuel price” and “nearest” (suited to quick decisions on the go); on a computer, it can show “list of stations”, “user reviews” and “promotions” (suited to more thorough research). A 2024 Microsoft study across multiple devices shows that after adapting to the device, the time needed for users to complete the task is reduced by 42% (from 90 to 52 seconds on smartphones and from 120 to 69 seconds on computers).

Technical basis:

Context awareness depends on “metadata extraction” and “real-time data integration”.

For example, the system extracts time (via device time), location (via IP or GPS) and device type (smartphone/computer) from the query, and adjusts the semantic weight by combining them with real-time data (such as weather, traffic and store opening status).

For example, if a user searches for “jacket” on a rainy day, the system retrieves the chance of rain in the area in real time and strengthens the weight of the “waterproof” attribute.

How NLP saves time

How Google Search NLP “understands” the text of a page

Google's NLP technology turns the text of a page into a machine-readable “semantic network” through four steps: “tokenization → entity recognition → semantic correlation → contextual correction”.

Over 50 billion words are processed every day (Google data 2024), with a tokenization accuracy of 97.3% and an entity recognition recall of 92%, ultimately making it possible to automatically distinguish whether “Apple” indicates the fruit or the phone, whether “Python” corresponds to a programming tutorial or a snake. When users search for relevant content, the percentage of effective results on the first screen goes from 38% to 72% (internal testing 2023).

Tokenization: dividing the text into the “minimum machine-intelligible blocks”

Simply put, it means breaking down a continuous sequence of text into meaningful “minimal linguistic units” (called “tokens”).

For languages like English, which have natural spaces, simply splitting on spaces is enough (for example, “coffee mug” becomes “coffee” + “mug”);

but for languages like Chinese and Japanese, which lack spaces, a segmentation error can completely compromise entity recognition and semantic understanding in later stages.

Rule base + deep learning

Google's tokenization system adopts a hybrid model: the “rule base takes priority, deep learning fills the gaps”, with the central goal of segmenting text “quickly and accurately”.

Rule base

The rule base is the “foundation” of Google's tokenization system. It contains frequent collocation patterns of the world's major languages (for example, in Chinese “prepare coffee”, “pour-over kettle”, “waterproof test”, and in English “espresso machine”, “drip coffee”). These collocations come from statistical analysis of online text: Google crawls web pages and calculates how often each pair of adjacent words co-occurs (for example, the probability that “coffee” follows “prepare” is 92%, while the probability that “rice” follows it is 85%), ultimately forming a “collocation dictionary” of millions of entries.

For example, when processing the Chinese sentence “How do I brew a rich, aromatic cup of pour-over coffee?”, the rule base prioritizes high-frequency combinations such as “brew/coffee” and “pour-over/coffee”, correctly segmenting it as “how to/brew/a cup/aromatic/pour-over coffee”;

if it encounters “Java programming”, the rule base recognizes “Java” as a programming language and “programming” as an action, segmenting it as “Java/programming” rather than “Jav/a/prog/ramming” (incorrect segmentation).

Deep learning

Although efficient, the rule base cannot cover all cases: every day many neologisms (such as “dopamine dressing”, “metaverse”) and specialized terms (such as in law “pre-contractual liability” or in medicine “myocardial infarction”) appear on the Internet, which are not included in the rule base. In these cases Google calls a fine-tuned BERT model to make a dynamic prediction.

BERT (Bidirectional Transformer) is a pre-trained language model that can understand the meaning of words from context.

For example, when encountering “dopamine dressing,” a term absent from the rule base, BERT can infer from the context (such as “bright colors,” “good mood,” “fashion”) that it is a new term describing a style of clothing, and segment it as a single “dopamine dressing” unit, rather than segmenting it incorrectly.

Comparison of technical details:

Multilingual adaptation

Google supports tokenization in over 100 languages, but the characteristics of those languages differ greatly, so rules and models have to be adapted case by case.

Chinese: no spaces + high ambiguity

The difficulty of Chinese lies in the absence of spaces and polysemy. For example, the phrase “乒乓球拍卖完了” can be segmented in two ways:

• Correct: “ping-pong racket / has all been sold” (where “ping-pong racket” is the product);
• Incorrect: “ping-pong / auction / over” (where “auction” is interpreted as action).

Google resolves the ambiguity via a contextual probability model: the frequency with which “ping-pong racket” co-occurs as a single unit (e.g. 90% on e-commerce pages) is much higher than for the combination “ping-pong + auction” (only 5% in sports news), so the correct segmentation is preferred.

Arabic: right-to-left script + connected letterforms

Arabic is written from right to left and, in some cases, the words appear without clear separations. Google's tokenization system first reverses the reading order in a processable left-to-right direction, then uses the rule base to identify the correct boundaries.

Swahili: agglutinative language characteristics

Swahili is an agglutinative language, which expresses meanings by adding affixes to the root (for example “mtoto” means “child”, “watoto” means “children”). Google's tokenization model recognizes affix boundaries, correctly segmenting “watoto” into a structure that can be interpreted as “plural + child.”

Google's 2023 multilingual tokenization tests show 98% accuracy for major languages like English and Spanish, but only 92% for more complex languages like Arabic and Swahili.

To improve results, Google has set up a “team of language experts” for each language, which manually annotates over 100,000 typical sentences to train dedicated tokenization models.

How tokenization errors affect search results

Tokenization is the basis of all subsequent stages of NLP. If segmentation is incorrect, it can lead to entity recognition failure, distorted semantic correlations, and ultimately a decline in the relevance of search results. Here are two real cases:

Case 1: “Java coffee” e-commerce page

One page is titled “Java coffee: pour-over level smoothness”. The correct tokenization would be “Java / coffee / : / pour-over level / soft / taste”. If the segmentation were wrong, the entity recognition system could treat meaningless sequences as separate entities, preventing Google from linking them to the correct product “Java coffee”. When a user searches for “Java coffee”, the page would be filtered out by mistake.

Case 2: legal page “pre-contractual liability”

A legal blog contains the text “Pre-contractual liability refers to the damage caused to one party by the other party's breach of the principle of good faith”. Correct tokenization would keep “pre-contractual liability” as a single legal term. If it were split badly into isolated words, the entity recognition system would fail to connect it to the right legal concept, pushing the page down the rankings for the query “pre-contractual liability”.

Supporting data:

Google's internal tests show that tokenization errors can drop the target page by 3-5 positions in search results (A/B test data, 2023) and reduce the chance of users clicking it by 42% (because the result is less relevant).

“Extract” the key points from the text

When the user searches for “iPhone 15 model 2025 waterproof test”, Google must quickly understand that the core of the page is “iPhone 15” (product), “September 2025” (time), “waterproof test” (event)

This key information is called an “entity”.

Multitask learning model (Multi-Task Learning)

Google's entity recognition system is based on a multitask learning model (Multi-Task Learning), which simultaneously trains three tasks: “entity recognition”, “part-of-speech tagging” and “relation extraction”, improving efficiency by sharing basic parameters.

Put simply, the model learns all three at once:

• which words are entities (e.g. “iPhone 15” is a product);
• what grammatical role they have in the sentence (for example “iPhone 15” is a noun);
• what relationships exist between the entities (for example “iPhone 15” is produced by “Apple”).

Fundamental technical details:

• BERT fine-tuned: starting from Google's pre-trained BERT model, fine-tuning is run on large amounts of annotated data (such as Wikipedia, news and e-commerce pages) so that the model learns the contextual characteristics of entities. For example, in the sentence “iPhone 15 was released in September 2025”, “September 2025” and “iPhone 15” are linked through BERT's contextual vectors, and the model can tell that the former is a time and the latter a product.
• Entity type classifier: A “type classification head” is added in the output layer of BERT, which predicts the specific type of each entity (such as TIME, PRODUCT, PERSON). The classifier is based on over 50 predefined entity types (covering both general and vertical domains), for example:

How NLP determines what the user wants

Google's NLP technology determines the user's real needs by analyzing the query's “intent type” (informational / navigational / transactional), “semantic expansion” (implicit needs) and “context adaptation” (time / place / device).

Google processes over 8.5 billion searches per day (2024 data). The CTR of informative queries increased from 12% to 28% after the introduction of NLP, while the accuracy of ambiguous queries increased from 58% to 82% thanks to BERT optimization.

Types of intent

1. Information need: the user wants to “learn something”

Characteristic words: “how to”, “principle”, “reason”, “tutorial” etc.

Examples: if a user searches for “how to make pour-over coffee” or “causes of myocardial infarction”, NLP will match tutorial or explanatory pages.

Supporting data: Google's 2023 internal tests show that the share of effective results on the first screen for informational queries rose from 38% to 72% thanks to the recognition of keywords such as “how to”.

2. Navigational need: the user wants to “find a specific site”

Characteristic words: “official site”, “official”, “login”, “registration” etc.

Examples: if a user searches for “Taobao official site” or “Apple ID login”, NLP sends the user straight to the official site rather than to third-party pages.

Supporting data: Microsoft research from 2024 shows that, in navigational queries, the probability of the user clicking on the target site increased from 45% to 89% thanks to the precise recognition of terms such as “official”.

3. Transactional need: the user wants to “buy goods/services”

Characteristic words: “recommended”, “cheap”, “discount”, “purchase” etc.

Examples: if a user searches for “cheap mechanical keyboard recommendations” or “petrol station near me”, NLP will show e-commerce pages or local businesses first.

Supporting data: According to a 2024 eMarketer survey, the conversion rate of transactional queries increased from 3.2% to 5.8% thanks to NLP covering implicit needs such as “recommended” and “discount”.

Comparison table of intent types:

For an editing workflow, continue with the practical NLP content audit: check entity names, terminology, conditions and the next step your page gives the reader.