3 ways to use AI for sitewide entity optimization

Ready to discover three incredibly simple (yet powerful) strategies that will help you optimize quicker and more effectively?

Here’s what you’ll learn in this article:

How to use AI to provide a data source for on-page optimization.
Using AI to quickly create multiple schema types for every blog article on your website.
A free internal link solution that makes internal linking a breeze.

Key terminology

Before we begin, it’s important to connect these concepts to entities.

Entities

In machine learning, particularly in natural language processing, an entity is a significant thing or concept in a specific context.

For instance, “Apple” could be an entity that represents the technology company or an entity that represents a type of fruit, depending on the context.

Internal links

Internal links are hyperlinks that direct to another page on the same website. They help to establish an information hierarchy for the given website and guide visitors to high-priority sites.

From an SEO perspective, these links aid search engines in discovering, indexing, and understanding all the pages on your site.

Internal links can also help search engines understand the context and relationship between different pages and their content. This can assist the search engine in identifying relevant entities on your site.

Schema

Schema (or Schema.org) is a collaborative, community-driven project with a mission to create, maintain, and promote schemas for structured data on the Internet.

In other words, it’s a way to tag and categorize information on your webpage so that search engines can better understand what your page is about. This could be anything from a product review to an event announcement.

By using schema markup, you’re helping search engines identify and understand the entities present on your webpage.

EAV (Entity-Attribute-Value)

EAV is a data model used to describe entities where the number of attributes (properties, parameters) that can be used to describe them is potentially vast.

This is particularly useful in SEO because it helps represent information about entities flexibly, which can be beneficial in situations where the attributes used to describe an entity can vary widely.

Search engines seek to understand the searcher’s intent and the contextual meaning of terms as they appear in the searchable dataspace.

The concept of entities, backed by the use of schema, EAV, and internal links, enables the search engine to comprehend a website’s content more effectively and present the most relevant results to users.

Overall, the following three tactics enhance the “semantic understanding” of your website. Along with other SEO practices, they can help improve your site’s visibility in the SERPs.

1. The hexa grammarian prompt sequence

This prompt is specifically designed around entities. As we’ve covered in the definitive guide to entities, entity understanding is largely tied to grammar.

The nouns, adjectives, verbs, adverbs, prepositions, and EAV are all integrally tied to entities.

While it sounds confusing, it’s simpler than you might think. Here’s what ChatGPT says about its importance.

Here are the six prompts:

“Provide a comprehensive list of the most common verbs associated with the topic. Cluster the list and nest associated verbs.”
“Provide a comprehensive list of the most common nouns associated with the topic. Cluster the list and nest associated nouns.”
“Provide a comprehensive list of the most common adjectives associated with the topic. Cluster the list and nest associated adjectives.”
“Provide a comprehensive list of the most common adverbs associated with the topic. Cluster the list and nest associated verbs.”
“Provide a comprehensive list of the most common predicates associated with the topic.”
“Provide a comprehensive list of attributes associated with the topic.”

When you get your answers, you can save them however you like. I prefer a Google sheet.

I suggest using this list in a couple of different ways.

You can use the hexa-list to inform your content briefs. You could use the hexa-list to optimize existing content. You could even use this list to help you craft clever prompts for OpenAI.

I can’t give away all of the in-house secrets, but suffice it to say that this list can be used to help you with programmatic AI content deployment.

2. Schema and AI

Creating schema for hundreds of web pages is an absolute slog. Over the past few years, agencies have productized schema because it’s one of those tasks that no one wants to do.

Since schema is hard to understand and the benefits aren’t always understood, many people use an out-of-the-box solution (e.g., SEOpress, RankMath, Yoast).

This article’s co-author, Andrew Ansley, developed a straightforward system for schema generation. You don’t need to understand anything about schema to make this work.

All you need is an OpenAI playground and access to GPT-4.

For this example, we are going to use webpage schema so we can create a clear and structured declaration of the entities that are found in the blog article.

Setting up

Step 1: Grab the URL for your blog article.

Step 2: Provide the author, website URL, organization name, publisher name, and web page URL in the system text.

Step 3: Copy and paste your blog article text into the system text.

As you can see from the image, the system text is on the left. The actual prompting is in the middle of the page, functioning exactly like ChatGPT – with a major upgrade.

In playground, you can adjust settings and the system text functions as memory/context.

Inside the playground, you can use around 8,000 tokens (.75 words per token = 6,000 words).

The schema prompt

The prompt is straightforward. All you need to enter into the user box is:

“Create WebPage JSON-LD schema. Use about and mentions. The about and the mentions should use entities and the associated Wikipedia page.”

After you’re done, you’ll get some pro schema to add to your article. We typically use a plugin to inject header code into a blog article, but that is just one of many options.

If you don’t trust the AI, you can go to https://validator.schema.org/ and provide the code to see if it has any errors.

As you can see from the image, my pro schema code designed for entity optimization is free from flaws. Huzzah!

Another schema type that you can easily add to a blog is FAQPage schema.

FAQPage Schema

This schema type is simpler than the previous example. For this schema, you can delete your article text from the system and you can replace it with whatever you like.

The prompt is:

“Create FAQ schema.”

If you have the text inside of the system, it will generate something like the following example.

For those who prefer ChatGPT, you can just use the web browsing plugin (which is even simpler to use).

The only prompt you need is:

“Create FAQ schema for the URL [insert link here].”

If you want to do multiple URLs, you can add additional URLs and ask ChatGPT to create FAQ Schema for each URL.

I can’t help but nerd out over how easy it is to accomplish SEO tasks with AI. While I am showing a non-programmatic example here, you can literally explain what you want to build, and the AI will provide the code.

You don’t even need to ask the AI for code to accomplish a more programmatic approach to schema. You can use this simple prompt sequence:

“Create FAQ schema in JSON-LD format. Process one URL and when you are done with that task, initiate another prompt that continues the task until you process the final URL in the list.”

The answer looks like this:

When you use this method, the generation of results will end around the 6th URL.

If you give a list of URLs that exceed the output length, you can type the word “continue,” and then the AI will continue down the list of URLs.

3. The internal link script

Internal links are incredibly important for passing authority between pages, improving crawlability for Google Bot, and communicating topic relationships for entity optimization.

Here’s a script that Ansley created that only needs three things.

A Google Doc.
A Google Sheet.
App Scripts.

The doc is the article you’re writing that will link out to your other articles.

The Google Sheet contains all of your keywords and URLs. I use a sitemap.

The next step is to ask ChatGPT to identify the keyword from the URL slug.

Here is the script.

function addLinksFromSheet() {
// Your Google Sheets ID
var sheet = SpreadsheetApp.openById('1AOvyOL0PCVVjY86aEEx77RqUWthV1m5Vzs2SyXE2f7g').getActiveSheet();
// Get all the rows of data in the Sheet, excluding the headers
var data = sheet.getRange("A2:B" + sheet.getLastRow()).getValues();
// Iterate over all the rows
for (var i = 0; i < data.length; i++) {
// The first column in the row contains the text to be hyperlinked
var searchPhrase = data[i][0];
// The second column contains the URL
var hyperlink = data[i][1];
// Use your addLinks function to add the hyperlink to the doc
addLinks(searchPhrase, hyperlink);
}
}
function addLinks(searchPhrase, hyperlink) {
if (!searchPhrase) {
return;
}
// Your Google Doc ID
const document = DocumentApp.openById('1_T5BRHiNi3iPnEL6xtys2qEV9WNzPZAwsQdIqtgiFtI');
const body = document.getBody();
let search = null;
let count = 0;
while (count < 1) {
search = body.findText(searchPhrase, search ? search : null);
if (!search) {
break;
}
const searchElement = search.getElement();
const startIndex = search.getStartOffset();
const endIndex = search.getEndOffsetInclusive();
searchElement.asText().setLinkUrl(startIndex, endIndex, hyperlink);
count++;
}
document.saveAndClose();
}

I emphasized the part of the script that requires your own unique document slug.

The inspiration for this script came from Hamish’s YoTtube channel, Income Surfers. Hamish is a new YouTuber, but his content is solid if you’re wanting AI + SEO.

The GIF below demonstrates what to do with Google App Scripts.

Save project.
Click Run and accept permissions.

The results look like the screenshot below.

The perk of this setup is you can essentially equip any of your writers with an easy way to internally link.

One of the most difficult aspects of internal linking is the fact that most outsourced writers don’t know what to link to.

Set up a database and maintain that list so your writers can apply all the internal links you want them to use.

If you’d like to include additional keywords, you can go to ChatGPT and paste your data. I used five keywords and five URLs for illustration purposes.

Prompt:

“I want to expand this table further. Repeat each URL 5 times and provide 4 additional keywords associated to each URL. The new keywords should have high semantic relevance to the original keyword in the list.”

Output:

As you can see, I now have five keywords to choose from. To avoid linking to the same URL, you’ll need to modify the script. Here is the new version:

function addLinksFromSheet() {
  // Your Google Sheets ID
  var sheet = SpreadsheetApp.openById('1jTwgsEgz5X4BbiNDjQeHJrRVtYdGi3LEKEBvPgIYtg8').getActiveSheet();
  // Get all the rows of data in the Sheet, excluding the headers
  var data = sheet.getRange("A2:B" + sheet.getLastRow()).getValues();
  // Keep track of the used URLs
  var usedUrls = [];
  // Iterate over all the rows
  for (var i = 0; i < data.length; i++) {
    // The first column in the row contains the text to be hyperlinked
    var searchPhrase = data[i][0];
    // The second column contains the URL
    var hyperlink = data[i][1];
    // Check if this URL has been used already
    if (usedUrls.indexOf(hyperlink) === -1) {
      // It hasn't, so add the hyperlink to the doc
      addLinks(searchPhrase, hyperlink);
      // And mark this URL as used
      usedUrls.push(hyperlink);
    }
  }
}

function addLinks(searchPhrase, hyperlink) {
  if (!searchPhrase) {
    return;
  }
  // Your Google Doc ID
  const document = DocumentApp.openById('1rLL9J6Lag6McZ6F22R3ptyb7XFqg9Bc1qmEgobrTa3w');
  const body = document.getBody();
  let search = null;
  let count = 0;
  while (count < 1) {
    search = body.findText(searchPhrase, search ? search : null);
    if (!search) {
      break;
    }
    const searchElement = search.getElement();
    const startIndex = search.getStartOffset();
    const endIndex = search.getEndOffsetInclusive();
    searchElement.asText().setLinkUrl(startIndex, endIndex, hyperlink);
    count++;
  }
  document.saveAndClose();
}

Using AI for entity SEO

The three specific examples above show how AI can be used to dramatically reduce the time involved in optimizing for entities.

We always recommend utilizing AI for any repetitive or highly technical task and spending more of your time on the strategy or creative functions of SEO. Entity SEO is no different.

However, it is important to know that there are many other uses for AI when optimizing for entities, and this is by no means an exhaustive list.

Make sure to attend my session at SMX Advanced, taking place June 13-14, to learn more about Entity SEO and AI and why we believe Entity SEO will be crucial to top SERP positions in the future.

This article was co-authored by Andrew Ansley.

This is the third article in the entity SEO series. If you would like to start by reading the first two articles, they are linked here: