Skip to main content

Introducing Scolta: Open Source AI Site Search Without the Middleman

Photo of Hank VanZile
Hank VanZile - Sr. Director, Customer Experience
June 11, 2026

Google keeps moving the bar for site search faster than many teams can keep up. AI Overviews in 2024 trained users to expect written answers, not blue links. At Google I/O in May, the company announced what it called the biggest upgrade to its search box in 25 years: generative interfaces built on the fly, conversational follow-ups baked into the core experience, and AI agents that run independent research on a user's behalf. Every one of those features widens the gap between what your users get on Google and what they get when they hit the search box on your own site. The expectation isn't going to stop climbing.

The way most teams are being told to ship that experience involves a vector database, an embedding pipeline, a chunking strategy, and ongoing tuning to keep relevance acceptable as content changes. It's a pattern with real use cases, well-suited to massive datasets of millions or billions of documents, but for most sites and platforms it's overbuilt.

At Tag1, we have been building AI site search without all that overhead across Drupal, WordPress, Laravel, Django, Next.js, Nuxt, Astro, and static sites. The patterns we developed are packaged up as an open source toolkit called Scolta, and this post is an introduction to what it is and how it works.

What Scolta Is

Scolta is a platform-agnostic, open source toolkit that implements a practical, "no middleman" approach to AI site search. There is no SaaS product to subscribe to: everything is developed in the open on GitHub, and each package installs from the registry you already use, whether that's drupal.org, Packagist, PyPI, or npm. You can do everything Scolta does without any of these, because the value is the architecture rather than the code, but Scolta gives you a head start on a path we have already walked.

Scolta is built in three layers:

  • The base is scolta-core, the search engine that runs in your visitor's browser and is identical on every platform.
  • On top of that sits a language library for each ecosystem - PHP, Python, or Node.js - and you use the one that matches your stack. It handles indexing and content export, plus the AI integration for that ecosystem.
  • The top layer is the platform adapters, which wrap a library in the conventions of a given framework: a Drupal module, a WordPress plugin, a Laravel package, a Django app with Wagtail support, and Next.js, Nuxt, and Astro modules for headless frontends.

The adapters turn setup into a package install and a settings page, but aren’t required. You can build directly on the language library, whether that means indexing a static site or wiring Scolta into a custom PHP app.

A Four-Stage Architecture

Infographic showing all four stages of the architecture.

Scolta delivers AI search across four stages that run end-to-end in under three seconds:

  1. Keyword search in the browser (~50ms)
  2. Query expansion through your LLM (~500ms)
  3. Merge and re-rank in memory (~100ms)
  4. AI summary generation through your LLM (~2 seconds)

Each stage is designed around a single idea explained in The Practical Path to AI Search intelligence gets added at search time, not at index time. That is the architectural choice that lets the rest of the picture stay light. Where the vector database playbook spends its budget pre-computing meaning into embeddings, Scolta lets the LLM you already have do that work at the moment a search query arrives.

The pipeline is also designed to surface value as it arrives. Stage 1 returns keyword matches in the browser in milliseconds, and those results are visible to the user before the AI stages have even started. The rest of the pipeline runs in the background while the user is already reviewing content, which keeps the search feeling responsive even when the full AI summary takes another couple of seconds to land.

What It Looks Like in Practice

The clearest way to see what these four stages do for a user is to watch a single query move through them, then watch a couple of follow-up questions build on the result. One of the demo sites we built on Scolta is a recipe site called Fork & Find, populated by thousands of recipes from the Wikibooks Cookbook.

Imagine a parent searches: "My son can't have gluten - what can I make for dessert?" Here is how that single query moves through Scolta's four stages:

  1. Keyword search runs in the browser against the recipe index, returning fast matches for the literal keywords.
  2. Query expansion sends the query to the LLM, which infers that "can't have gluten" means gluten-free and that maps to both wheat-free and celiac-friendly. In searching for those expanded queries, it even recognizes that some recipes are gluten-free by virtue of their ingredients without ever being labelled that way.
  3. Merge and re-rank combines the keyword hits across all of the expanded queries and applies the site's ranking rules. The expanded queries are clickable in the UI, so the user can see exactly how the system understood the question.
  4. AI summary generation writes a grounded summary from the top-ranked recipes, with inline citations back to specific pages.

From there, the search turns into a conversation, and each follow-up builds on what came before. These two questions show the kind of reasoning this makes possible:

  • "Which one of these would a five-year-old actually eat?" The LLM, working from the same content, narrows the list to recipes that are likely to land with a small kid - sweeter, simpler, less adventurous.
  • "My son loves to help. Can he safely help make these?" The LLM reads each recipe's instructions, flags the steps that are safe for a five-year-old to participate in (mixing, measuring, stirring) and the steps an adult needs to own (anything involving the oven or sharp knives), and even surfaces a note that one of the recipes is hard to overmix and particularly forgiving when a small child is the one stirring.

Each follow-up runs the full four-stage pipeline with the prior conversation maintained as context. The grounding rules stay in place, the citations keep pointing at real recipe pages, and the system is doing reasoning that a keyword search engine could not approach.

Try Scolta Today

Scolta core and the platform connectors are all open source and available right now:

Language libraries, for integrating Scolta directly into your application:

Platform adapters, for installing Scolta on the platform you already run:

For more information and self-guided demos, visit www.tag1.com/scolta/.

What's Next

Step-by-step posts walking through Scolta setup are on the way, one per platform - Drupal and WordPress come first, each a deep-dive with the implementation details that don't fit in a high-level introduction. From there the series moves beyond PHP: Wagtail on Django, then Scolta on a Node.js stack, with more platforms to follow.

Image by Mathias Reding from pexels

Related Insights

Work With Tag1

Be in Capable Digital Hands

Gain confidence and clarity with expert guidance that turns complex technical decisions into clear, informed choices—without the uncertainty.

Work With Us