Viglet Turing

Viglet Turing is open source enterprise search with generative AI. Faceted semantic search, hybrid BM25 + vector ranking, RAG chat with citations, and AI agents with MCP tools, over your own content and on your own servers. It runs on Apache Solr, Elasticsearch or embedded Lucene, with the LLM of your choice: a self-hosted alternative to Algolia, Coveo and Lucidworks.

Site: turing.viglet.org · Docs: docs.viglet.org/turing · Compare: Turing vs Algolia, Coveo, Lucidworks and Elasticsearch · AEM: enterprise search for Adobe AEM

Table of Contents

• Who it is for
• Try it in 60 seconds
• Why Turing?
• What’s inside
• Architecture at a glance
• Installation
  • Docker Compose (full stack)
  • Build from source
  • Kubernetes
• Code examples
  • REST API
  • JavaScript / TypeScript
  • Java
  • GraphQL
• Project structure
• FAQ
• Part of the Viglet suite
• Documentation
• Contributing
• License

Who it is for

Teams that run a corporate portal or website and need search on it. Maybe you pay Algolia or Coveo per record and per query, or keep a Solr or Elasticsearch cluster going by hand, and now you also want an AI chat that answers from your own content, with sources, without sending that content to a vendor.

Turing gives you both in one self-hosted platform: the search experience (facets, autocomplete, spotlights, ranking rules) and the AI layer (RAG chat with citations, agents, MCP), on the search engine you already run or on the embedded one.

It is a common fit for Adobe Experience Manager sites: the Viglet Dumont connector reads AEM on-premise, AMS and AEM as a Cloud Service, and feeds Turing.

Try it in 60 seconds

docker run -p 2700:2700 -e TURING_ADMIN_PASSWORD=turing123 \
  ghcr.io/openviglet/turing-ce:latest

Then open http://localhost:2700/console and log in as admin / turing123. TURING_ADMIN_PASSWORD (minimum 6 characters) is applied on the first boot only and never overwrites a password you already set: leave it out and the console asks you to choose one on first access.

You need no external search engine, no vector database and no API key to start: Turing ships an embedded Lucene index and works offline until you plug in Solr, Elasticsearch or an LLM.

Tip	Getting content in. Turing indexes whatever you post to its indexing API, so you can push documents straight from your own code. To pull content from Adobe AEM, WordPress, databases, filesystems and web crawls, run Viglet Dumont, the Data Exchange Platform of the same family.

Why Turing?

Teams that outgrow their CMS’s built-in search usually choose between rebuilding search in-house and sending their content to a hosted vendor. Turing is a third option: a complete search platform you run yourself.

	Viglet Turing	Hosted search SaaS
Where content lives	Your servers: indexes, embeddings and query logs never leave	Vendor cloud
Search backend	Pluggable: Solr, Elasticsearch, or embedded Lucene	Proprietary, fixed
LLM for RAG	Your choice: OpenAI, Anthropic, Gemini, Mistral, Cohere, Bedrock, or local Ollama	Vendor’s model, or none
Cost model	Apache 2.0: no per-query, per-record or per-seat metering	Metered by records, queries or seats
Extensibility	Custom search-engine plugins, agent tools and MCP servers	Plugin marketplace
Regulated or air-gapped deploys	Supported: runs fully offline	Usually not an option

The full comparison, product by product, is at turing.viglet.org/compare.

What’s inside

Capability	Description
Semantic Navigation	Faceted search, spotlights, targeting rules, autocomplete, ranking rules, multi-language
Hybrid ranking	BM25 keyword + kNN vector retrieval fused with Reciprocal Rank Fusion, plus pluggable rerankers
Generative AI (RAG)	Streaming LLM answers grounded in your indexed content, with inline source citations
AI Agents	Assistants with their own LLM, native provider tools (web search, code execution), and MCP servers
Multi-engine	One API over Apache Solr, Elasticsearch, or embedded Apache Lucene: swap without rewriting
Indexing API	Push documents over REST/JSON, one at a time or in bulk, with a versioned field manifest (schema as code)
Connectors	Adobe AEM, WordPress, databases, filesystem and web crawls, through Viglet Dumont
File parsing	Apache Tika extraction for PDF and Office files uploaded to Turing or attached in chat
Admin console	React 19 console for sites, fields, facets, agents, prompts and analytics
APIs and SDKs	REST, GraphQL and SSE streaming; a Java SDK (Maven Central) and JS/TS SDKs (npm)

Architecture at a glance

Turing is the search and AI layer. Extraction from content sources is a separate, optional product, Viglet Dumont, so you can also feed the index straight from your own application.

    Content sources          Viglet Dumont            Viglet Turing               Your apps
  ┌─────────────────┐      ┌───────────────┐      ┌──────────────────────┐    ┌───────────────┐
  │ Adobe AEM       │      │  Connectors   │      │  Indexing API        │    │ Site search   │
  │ WordPress       │─────▶│  Extraction   │─────▶│  Semantic Navigation │───▶│ RAG chat      │
  │ Databases       │      │  Scheduling   │      │  Hybrid BM25 + kNN   │    │ Admin console │
  │ Filesystem      │      │  Deltas       │      │  RAG · Agents · MCP  │    │ Your own app  │
  │ Web crawl       │      └───────────────┘      └──────────┬───────────┘    │ REST /GraphQL │
  └─────────────────┘                                        │                └───────────────┘
                                                             │
     Your own app ──────── POST /api/sn/import ─────────────┤
                           (skip Dumont entirely)            │
                                              ┌──────────────┴──────────────┐
                                              │ Apache Solr · Elasticsearch │
                                              │  · embedded Apache Lucene   │
                                              └─────────────────────────────┘

Installation

Docker Compose (full stack)

git clone https://github.com/openviglet/turing.git
cd turing
docker compose up -d

Build from source

Requires Java 21+ and Maven 3.6+ (the ./mvnw wrapper is included).

git clone https://github.com/openviglet/turing.git
cd turing
./mvnw clean install
java -jar turing-app/target/viglet-turing.jar

Kubernetes

Manifests are in k8s/; a single-file deployment is in k8s.yaml.

Packaged installers (Windows .exe, .zip, Linux AppImage) are attached to every release.

Code examples

REST API

# Faceted search
curl "http://localhost:2700/api/sn/sample-site/search?q=enterprise+search&rows=10&_setlocale=en_US"

# Autocomplete
curl "http://localhost:2700/api/sn/sample-site/ac?q=enterp&_setlocale=en_US"

# RAG chat (SSE stream, answers with citations)
curl "http://localhost:2700/api/sn/sample-site/chat?q=What+is+enterprise+search"

JavaScript / TypeScript

import { TurSNSiteSearchService } from '@viglet/turing-react-sdk';

const search = new TurSNSiteSearchService('http://localhost:2700');
const results = await search.search('sample-site', {
  q: 'machine learning', rows: 10, localeRequest: 'en_US'
});

results.results?.document?.forEach(doc => console.log(doc.fields?.title));

A zero-dependency vanilla JS build (@viglet/turing-sdk) is also published for plain <script> tags and Adobe Edge Delivery Services blocks.

Java

HttpTurSNServer server = new HttpTurSNServer("http://localhost:2700/api/sn/MySite");

TurSNQuery query = new TurSNQuery();
query.setQuery("artificial intelligence");
query.setRows(10);

QueryTurSNResponse response = server.query(query);
response.getResults().getDocument().forEach(doc ->
    System.out.println(doc.getFields().get("title"))
);

GraphQL

query {
  siteSearch(
    siteName: "sample-site"
    searchParams: { q: "technology", rows: 10, p: 1 }
    locale: "en_US"
  ) {
    queryContext { count, responseTime }
    results { document { fields { title, text, url } } }
  }
}

Interactive GraphiQL IDE at http://localhost:2700/graphiql.

Project structure

turing/
├── turing-app/           # Spring Boot 4 backend (Java 21)
├── frontend/             # pnpm + Turborepo monorepo
│   ├── apps/turing-app/  #   React 19 + TypeScript admin console (Vite, shadcn/ui)
│   ├── apps/marketplace/ #   example applications
│   └── packages/         #   SDKs: react-sdk, sdk (vanilla JS), react-ui, shared-types
├── turing-commons/       # Shared library
├── turing-spring/        # Shared Spring library
├── turing-java-sdk/      # Java SDK
├── turing-marketplace/   # Marketplace packages
├── turing-utils/         # Utilities
├── containers/           # Container build assets
├── k8s/                  # Kubernetes manifests
└── docker-compose.yaml   # Docker Compose stack

FAQ

Is Viglet Turing an open source alternative to Algolia or Coveo? Yes. It covers the same ground (faceted search, autocomplete, merchandising-style spotlights and ranking rules, AI answers over your content) under the Apache 2.0 license, self-hosted, with no metering by record or query. See the comparison.

Does it work with Adobe Experience Manager? Yes. Viglet Dumont reads AEM on-premise, AMS and AEM as a Cloud Service, and indexes it into Turing. Walkthrough: enterprise search for Adobe AEM.

Can I run a RAG chat on my own servers? Yes. The chat answers from your indexed content with inline citations, and the LLM is your choice, including a local model through Ollama, so nothing has to leave your network.

Do I need Solr or Elasticsearch? No. Turing ships an embedded Lucene index. Plug in Solr or Elasticsearch when you want to, behind the same API.

Is it free? Yes. Apache License 2.0: you can use, modify and deploy it commercially, including in closed-source products.

Part of the Viglet suite

Three open source products that work together, or each on its own:

Product	What it does
Viglet Dumont · Data Exchange Platform	Connects your sources (AEM, WordPress, databases, files, web) and delivers their content to Turing or any other search engine
Viglet Turing · Enterprise Search	This repository: search, semantic navigation, RAG chat and AI agents over that content
Viglet Shio · Agent-ready CMS	A CMS that people run from the console and AI agents run over MCP; it renders pages or delivers them over REST and GraphQL

More at viglet.org.

Documentation

docs.viglet.org/turing	Architecture, configuration, connectors, admin guide
AEM search guide	Adding enterprise search and AI to Adobe Experience Manager
Comparison	Turing vs Algolia, Coveo, Lucidworks, Elasticsearch and DIY RAG
Javadoc	API reference for the Java classes
Changelog	What shipped in each release

Contributing

Contributions are welcome: bug reports, docs, search-engine plugins, agent tools and code.

• Found a bug? Open an issue

• Questions or ideas? Join the Discussions

• Want to code? Read CONTRIBUTING.md and open a pull request

See also the security policy, the code of conduct and the support options.

If Turing is useful to you, a star on the repository helps other teams find it.

License

Apache License 2.0: see LICENSE.

---

Built by the Viglet Team · turing.viglet.org