In my last few articles, I’ve focused on the big picture: how AI is changing visibility in Search, what frameworks we can use to adapt, and how publishers can think strategically beyond classic SEO. The feedback has been fantastic, but it also raised a recurring question: “This is great theory, but what does it actually look like in a real-world scenario?”
This article is my answer. To ground these high-level concepts, I’m turning to a subject I know and love from personal passion: the world of tabletop miniature painting. It’s a niche with deep lore, hard data, passionate personas, and complex customer journeys, which makes it the perfect stress test for any modern SEO strategy. So, we’ll invent a hypothetical online store, “The Mini Painter Co.,” and focus on a single product line, Star Wars: Legion. My goal is to provide a concrete, step-by-step actional case study, albeit fictional, that moves from the theoretical frameworks we’ve discussed into a fully realised, practical blueprint.
Beyond the Shopping Cart
“The Mini Painter Co.” is an ecommerce that operates at the intersection of two distinct passions:
- The strategic depth of tabletop gaming.
- The creative artistry of miniature painting.
Its customers are not a monolith; they are personas like “Ian the Gamer,” who seeks victory on the tabletop, and “Gianluca the Painter,” who seeks beauty on the model.
A traditional e-commerce experience, with its rigid categories and basic faceted navigation, serves neither of them fully.
How can we build a digital space that understands the nuanced journey of both Ian and Gianluca? The answer lies in transforming our website from a simple catalogue into a sentient store, aka an intelligent, interconnected system that understands context, anticipates needs, and provides expert guidance.
Part 1: Constructing the Digital Brain: A Unified Knowledge Graph
The foundation of our sentient store is not a database, but a flexible, interconnected web of knowledge: our “brain”.
We construct this by building and then merging several specialised Knowledge Graphs (KGs).
Step 1: The Seven Pillars of Knowledge
We begin by architecting seven distinct but related KGs, each a domain of expertise.
- The Brand KG: Defines our identity, and it is essential, for instance, for Online Reputation Management, also in AI Search surfaces and for connecting the personal “brands” of the influencers working with us to the brand of Mini Painter Co.
Example Nodes: Brand:The_Mini_Painter_Co, Website:minipainterco.com, Policy:Shipping_Policy.
Example Relationships: Website:minipainterco.com ownedBy Brand:The_Mini_Painter_Co. - The Star Wars: Legion KG: The game’s encyclopedia.
Example Nodes: Unit:Rebel_Commandos, Upgrade:Duck_and_Cover, Weapon:DH-447_Sniper_Rifle.
Example Relationships: Unit:Rebel_Commandos canEquip Upgrade:Duck_and_Cover; Weapon:DH-447_Sniper_Rifle hasKeyword Pierce_1. - The Shopping KG: Our internal inventory and commerce engine.
Example Nodes: Product:SWQ16, Promotion:Christmas_Sale_2025.
Example Relationships: Product: SWQ16 correspondsTo Unit:Rebel_Commandos; Product:SWQ16 hasPrice 29.99; Product:c hasStockLevel 73. - The Internal Link KG: The architectural blueprint of our website.
Example Nodes: URL:/blog/painting-endor-camouflage, URL:/products/rebel-commandos.
Example Relationships: URL:/blog/painting-endor-camouflage linksTo URL:/products/rebel-commandos. - The Star Wars Lore KG: The rich narrative tapestry.
Example Nodes: Character:Cassian_Andor, Event:Battle_of_Scarif, Location:Scarif.
Example Relationships: Character:Cassian_Andor participatedIn Event:Battle_of_Scarif; Unit:Rebel_Commandos foughtOn Location:Endor. - The Mini Painting KG: The artist’s workshop.
Example Nodes: Technique:Edge_Highlighting, PaintType:Contrast, Tool:Airbrush.
Example Relationships: Technique:Edge_Highlighting isUsedFor Detailing_Armor; PaintType:Contrast isIdealFor Speed_Painting. - The Lexical Graphs: The semantic dictionary. This is a meta-layer for each KG.
Example Nodes: Term:Commander, Term:Leader, Term:Officer.
Example Relationships: Term:Commander isSynonymFor Term:Leader; Term:Flanking isRelatedTo Term:Maneuvre.
The Brand and the Star Wars: Legion KGs are relatively easy to build because they rely almost completely on our internal data and information.
The Star Wars Lore, KG, too, should not pose a significant problem because we have excellent resources, such as Wookiepedia and the Databank on the official Star Wars website.
Building the Mini Painting KG is more complicated, because the information is scattered amongst articles, videos on YouTube, Instagram reels and PDFs, so much that it should be created from scratch. This initial difficulty, though, also represents the biggest added value of creating it: making The Mini Painter Co. the source of truth about the mini painting hobby.
When creating the Knowledge Graphs, then, we should always have clear these two needs:
- We must ground the ontologies on real-world knowledge, aka we must involve domain experts like product managers and competitive painters.
- We must plan for recurring maintenance because new techniques emerge, new products are released, and Lucasfilm produces new movies, series, video games, et al.
Step 2: The Merge – Creating a Single, Unified Reality
This is the most critical technical step. We merge these seven graphs into one cohesive whole.
How the Merge Works
- Unified Identifiers (URIs)
Every entity in our entire system gets a unique address, like a web URL. For example, the Rebel Commandos unit is mpco:unit/rebel_commandos.
- Entity Matching
When matching, we will use different techniques, like:
- Exact Matching (i.e., Luke Skywalker).
- Fuzzy Matching (i.e., Darth Vader vs Vader)
- Property-based matching (i.e., Anakin Skywalker and Legion 501st match with Galactic Republic)
- Entity Alignment with owl:sameAs
We identify nodes that represent the same concept across different graphs and link them.
Legion:Rebel_Commandos owl:sameAs Lore:Rebel_Pathfinders.
Legion:Rebel_Commandos owl:sameAs Shopping:Product:SWQ16.
- Mapping
We align different property names. For example, we create a rule that Lore:allegiance is equivalent to Legion:faction.
When building the Knowledge Graph, this will likely happen through RDF property equivalence (owl:equivalentProperty).
- Ingestion
The graphs are combined. Now, a single query can traverse relationships across all original domains.
The result? We can now ask questions like: “Show me all Rebel units that fought on Scarif, are currently in stock, and have a beginner-friendly painting guide on the blog.“
Unleashing Inferences: Discovering Hidden Pathways
With a Merged KG, we can perform inferences: deriving new, implicit knowledge from the explicit facts we’ve encoded.
What is an inference?
We can define an inference like this: if Fact A implies Fact B, and Fact B implies Fact C, the system can infer that Fact A implies Fact C.
More technically, an inference is achieved via rule-based reasoning (RDFS/OWL) or embedding proximity in vector space, depending on the implementation layer.
In plain English, inferences are the machine’s reasoning.
Example in Action:
- Fact 1: The Unit:Rebel_Commandos node has a relationship foughtOn the Location:Endor node.
- Fact 2: The Unit:AT-ST node also has a relationship foughtOn the Location:Endor node.
- Inference: The system creates a new, implicit link: Unit:Rebel_Commandos isThematicallyLinkedTo Unit:AT-ST with the context Battle_of_Endor.
The Impact on Catalogue Navigation
This moves us beyond basic “Customers also bought…” recommendations.
We can now create dynamic, narrative-driven navigation categories on our e-commerce site:
- “Build Your Battle of Endor Force” Collection: Dynamically populates with Rebel Commandos, AT-STs, Ewoks, and Speeder Bikes. This appeals to both Ian (for a lore-accurate army) and Gianluca (for a cohesive diorama project).
- “Stealth Operations” Collection: Infers a collection of units with keywords like Scout and Infiltrate, like Rebel Commandos and Imperial Scout Troopers, creating a tactical theme.
Part 2: Connecting to the Customer’s Mind: Search Intelligence
Our Knowledge Graph “brain” now needs to listen.
We achieve this by analysing the search landscape to understand user intent at a granular level.
Step 3: The Search Intelligence Audit for “Rebel Commandos”
We go far beyond simple keyword research; we map the entire “conversation” around this product, as I explained in this post about “0-click SEO“.
Main Sources of Search Intelligence
- People Also Ask (PAA)
“Are Rebel Commandos good in Legion?”, “How many Rebel Commandos can you have?”
Tool I use: Alsoasked.com
- People Also Search For (PAS)
“Star Wars Legion Rebel Commandos List”, “Star Wars Legion Rebel Veterans”, “Star Wars Legion Rebel Pathfinders”.
Tool I use: SerpAPI
- Images Search Tag (essential also for Entity Search)
Star Wars: Legion Rebel Commandos > Painting – Rebel Troopers – Endor – Leia Organa – Cassian Andor…
- Query Fan-out (these are key!)
We analyse the branches and follow-up questions generated by AI Mode/Overviews (powered by Gemini) and LLMs like ChatGPT. A search for “Rebel Commandos painting” fans out to:
- “Best upgrade cards for Rebel Commandos“.
- “Synergy between Rebel Commandos and Captain Cassian Andor“
- “Checklist for assembling and painting Rebel Commandos“
- “Lore behind special force commandos in Star Wars“
This provides a rich roadmap of the user’s entire thought process.
Tools I use: Qforia by Ipullrank for AI Mode/Overviews query fan-out and ChatGPT Path by Ayima.
- LLM Answers Entity Analysis
If we want to be visible in AI Search, we should analyse the answers provided by AI models
If we ask Gemini, “What’s the best way to use Rebel Commandos?“, and its answer consistently mentions entities like “Leia Organa”, “flanking manoeuvres”, and “objective control”, we know these are critical concepts we must connect to the Rebel_Commandos node in our KG.
Step 4: The Bridge – Connecting Search Intent to the KG with NER
How do we connect unstructured text from a search query to our structured KG? The answer is Named Entity Recognition (NER).
What is NER?
NER is an AI model that automatically scans text and identifies key entities like people, products, locations, and concepts.
The Process
- Input Query: A user searches for “tips for painting the sniper in the Rebel Commandos Endor team“.
- NER Extraction: The NER model processes this and extracts:
– Technique: “painting”
– Weapon: “sniper”
– Unit: “rebel commandos”
– Location: “Endor” - Entity Matching: Our system then takes these extracted strings and finds the corresponding nodes in our Merged KG (Technique:Painting, Weapon:DH-447_Sniper_Rifle, Unit:Rebel_Commandos, Location:Endor).
- Result: The system now understands the user’s precise, multi-faceted intent and can retrieve information that connects all these nodes.
Part 3: The Strategy in Action: The Ultimate Content Hub
Armed with this deep understanding, we build a content hub for “Rebel Commandos” that can now be designed from something more than a standard product page to a definitive resource engineered to serve our personas.
Step 5: The “Rebel Commandos” Hub Architecture
- Universal Core: Product SKU, price, “Add to Cart” button, assembly instructions.
- Cluster for “Ian the Gamer”:
- Content: “Tactical Guide: Flanking with Rebel Commandos,” “Synergy Analysis: Pairing with Jyn Erso vs. Cassian Andor,” “List Building: Integrating Commandos into a 500pt Skirmish Force.”
- Source: Directly answers fan-out queries like “best commander for rebel commandos.”
- Cluster for “Gianluca the Painter”:
- Content: “Colour Theory: Official Endor Camouflage Palette,” “Step-by-Step Guide: Painting Realistic Fabric Textures on Cloaks,” “Advanced Tutorial: Object Source Lighting (OSL) for the DLT-19X Sniper Rifle.”
- Source: Directly answers fan-out queries like “how to paint sniper rifle glow.”
Part 4: The Future is Agentic
To future-proof our ecommerce means to make our store interactive, leveraging Multi-agent Collaborative Problem-solving (MCPs).
The Value of Lexical Graphs for Embeddings
Before agents can work, they need a nuanced understanding of language. This is where embeddings and our Lexical Graphs become critical.
What are embeddings?
An embedding is a process that converts an entity (like “Rebel Commandos”) or a word (like “commander”) into a series of numbers (a vector).
In this “vector space,” concepts with similar meanings are located close together.
More technically, we train our embedding model using both text corpora and graph relationships (a form of knowledge-infused embeddings).
- The Problem: Without guidance, an AI might see “commander,” “leader,” and “operative” as completely different words. Their vectors could be far apart.
- The Lexical Graph Solution: Our Lexical Graph explicitly states that commander is a synonym for leader and that both are types of character. When we train our embedding model, we feed it these relationships. The model is forced to learn that these words are semantically close and pushes their vectors together in the space.
- The Result: Our system gains a deep, semantic understanding. A user can search for “Rebel squad leader,” and the system (understanding that “leader” is close to “commander”) will intelligently return results for Captain Rex and Jyn Erso, providing a far superior result.
Step 6: Deploying the Agent Team
Our agents use the Merged KG as their shared brain and the semantic embeddings as their shared language.
- The Scenario: A user types into the chat box on our website: “I’m new. I need an easy-to-paint, effective Rebel unit for my first tournament.“
- The Collaboration:
- The Coordinator Agent receives the query and delegates.
- The Legion Strategist queries the KG for Rebel units with a high effectiveness rating and a low complexity score. It identifies Rebel Commandos.
- The Painting Coach queries the KG for painting guides linked to Rebel Commandos with difficulty: beginner. It finds our “Battle-Ready Contrast Method” guide.
- The In-Store Quartermaster queries the Shopping KG to confirm Product:SWQ16 is in stock and finds the specific contrast paints mentioned in the guide, checking their stock levels too.
- The Coordinator synthesises the final response: “Great choice for a new player! I recommend the Rebel Commandos. They are very effective for flanking. We have them in stock [link]. For an easy, battle-ready paint scheme, here is our 3-step guide using contrast paints. I’ve put the unit and all the required paints into a cart for you here [link].“
But… what if that same search has been done on Google AI Mode or ChatGPT?
Part 5: The Strategic Shift: From Destination to Authoritative Source
Not all LLMs are made equal. So, let’s see two different scenarios where all the work we did on our ecommerce has different outcomes, but both are still positive.
Scenario 1: The User Searches on Google AI Mode
When a user types “I’m new. I need an easy-to-paint, effective Rebel unit for my first tournament” into Google, the AI Mode kicks in, and it tries to understand intent and synthesise an answer from the most reliable sources on the web.
Our internal agents don’t “act” here.
Instead, the work they could do has already been pre-published and structured on our website in a way that Google’s AI can easily digest.
Here’s how we ensure Google’s AI chooses us:
- The Content Hub as AI-Bait: The multi-dimensional content hub we designed for “Rebel Commandos” is the perfect source. It directly addresses the user’s query from multiple angles (effectiveness, ease of painting).
- Schema.org Structured Data: Not directly at this moment, but previous to this moment (when Google parses, indexes and ranks documents), we should have extensively and properly used structured data, to give Google the correct understanding of our content, thanks to the schema labelling.
- The KG as a Consistency Engine: Because all our content is derived from the same Merged KG, the information is incredibly consistent. The paints mentioned in the painting guide are perfectly matched to the products in the shopping graph. This consistency signals high authority to Google.
The Result in Google AI Mode
Google’s AI synthesises its answer. Because our content is the most structured, comprehensive, and authoritative, the AI-generated snapshot will:
- Directly recommend the Rebel Commandos, citing our “Tactical Takedown” article.
- Outline the easy painting steps, pulling directly from our HowTo structured content and citing our painting guide. It might even display a thumbnail from our video.
- Link back to our website as the primary source for this information.
We didn’t deploy our agents on Google, but we deployed the results of their potential work in a perfectly structured format that Google’s AI could not ignore. We have successfully influenced the external AI to give the user the exact answer our internal agents would have, and driven the traffic back to us.
Scenario 2: The User Searches on ChatGPT
Interacting with a Large Language Model like ChatGPT offers a more direct integration path: APIs and Custom GPTs (Actions).
Here, we can allow ChatGPT to “talk” to our internal agents through a secure, controlled gateway.
- Creating “The Mini Painter Co. GPT”: We would publish a custom GPT in OpenAI’s store. This is a specialised version of ChatGPT that knows how to use our company’s tools.
- The API as a “Headless” Agent System: We create a secure API endpoint authenticated via OAuth 2.0 or API keys. This API is essentially a “front door” to our internal Coordinator Agent. ChatGPT can send a structured request to this door, but it can’t come inside our system.
The Collaboration Flow would look like this
- User Prompt: The user, using our custom “The Mini Painter Co. GPT,” types: “I’m new. I need an easy-to-paint, effective Rebel unit for my first tournament.“
ChatGPT understands Intent: The LLM parses the query and understands the core needs: new_player, easy_paint, effective, rebel_unit, tournament.
- API Call: Instead of just searching the web, the GPT is programmed to make a specific API call to our system. The call might look like this:
JSON
POST api.minipainterco.com/recommendation {“persona”: “new_player”,“faction”: “Rebel”,“needs”: [“easy_to_paint”, “effective_in_tournament”]}
- Our Internal Agents Activate: This API call triggers our internal Coordinator Agent on our own servers.
- The Coordinator receives the request and delegates it exactly as described in the original scenario.
- The Legion Strategist finds the Rebel Commandos based on effectiveness.
- The Painting Coach finds the difficulty: beginner’s guide.
- The In-Store Quartermaster checks stock and assembles a list of products.
- Synthesised API Response: The Coordinator synthesises the perfect answer and sends it back to ChatGPT in a clean, structured JSON format. It does not send back raw data, but a fully formed recommendation.
- ChatGPT Presents the Answer: ChatGPT receives the authoritative response from our API and presents it to the user in natural language:
“Based on expert data from The Mini Painter Co., a great choice for a new player is the Rebel Commandos. They are very effective for flanking and objective control. They are currently in stock.
For an easy, battle-ready paint scheme, The Mini Painter Co. recommends their ‘3-Step Contrast Method’ guide [link to our blog].
I can even put the unit and all the required paints into a shopping cart for you on their website. Would you like me to do that?“
In this scenario, we have allowed an external AI to leverage the full collaborative power of our internal agent team through a controlled API, turning ChatGPT into a powerful sales and support channel for our business.
This is our Knowledge Hub. A system designed not just to sell products, but to become a reliable source of truth for its entire niche.
It understands context to guide users on our site, and it shares its expertise so clearly that external AIs like Google can use it to build better answers. It solves hobby problems for users, wherever their search begins.
This is the future of specialised e-commerce.
