🔍 Viglet Turing ES

Enterprise Search Platform with Semantic Navigation, Chatbots, and Generative AI

🚀 What is Viglet Turing?

Viglet Turing (https://viglet.org/turing/) is a powerful enterprise search platform that revolutionizes how organizations discover, search, and interact with their content. By combining cutting-edge technologies like semantic navigation, intelligent chatbots, and generative artificial intelligence, Turing provides a comprehensive solution for modern enterprise search needs.

⭐ Key Features

Feature	Description
🧠 Semantic Navigation	Advanced search with intelligent content understanding and contextual results
🤖 AI-Powered Chatbots	Interactive conversational search with natural language processing
✨ Generative AI Integration	Leverage modern AI models for enhanced search experiences
🔗 Enterprise Connectors	Seamless integration with CMS platforms, databases, and file systems
🌐 Multi-Source Indexing	Index content from websites, documents, databases, and more
📊 Real-time Analytics	Monitor search performance and user behavior
🔒 Enterprise Security	Built-in authentication and authorization capabilities
📱 Modern UI/UX	React-based responsive interface with customizable themes

🏗️ Architecture & Components

Viglet Turing is built with a modern, scalable architecture supporting multiple deployment scenarios:

Core Components

• Turing App: Main Spring Boot application with REST APIs

• Turing UI: Modern React-based user interface

• Search Engine: Apache Solr integration with intelligent indexing

• Database Layer: Support for H2, MariaDB, and other databases

• Message Queue: Apache Artemis for asynchronous processing

Integration Ecosystem

🔌 Content Sources

• CMS Connectors: Adobe Experience Manager (AEM), WordPress, and more

• Web Crawler: Automated website content indexing

• Database Connectors: MySQL, PostgreSQL, Oracle, SQL Server

• File System: Local and network file indexing

🛠️ Developer Tools

• Java SDK: Full-featured client library for Java applications

• JavaScript SDK: TypeScript-ready SDK for web applications

• REST APIs: Comprehensive RESTful API for all operations

🚦 Quick Start

Prerequisites

• Java 21+ ☕

• Maven 3.6+ 📦

• Docker & Docker Compose (recommended) 🐳

Option 1: Docker Compose (Recommended)

# Clone the repository
git clone https://github.com/openviglet/turing.git
cd turing

# Start all services with Docker Compose
docker-compose up -d

# Access Turing at http://localhost:2700

Option 2: Local Development

# Clone and build
git clone https://github.com/openviglet/turing.git
cd turing

# Build the project
./mvnw clean install

# Run the application
./mvnw spring-boot:run -pl turing-app

# Access Turing at http://localhost:2700

🎯 First Steps After Installation

1. Access the Console: Open http://localhost:2700/console

2. Create a Site: Set up your first search site

3. Index Content: Use connectors or APIs to add your content

4. Start Searching: Experience semantic search with your data

💻 Code Examples

Java SDK Example

import com.viglet.turing.client.sn.HttpTurSNServer;
import com.viglet.turing.client.sn.TurSNQuery;
import com.viglet.turing.client.sn.response.QueryTurSNResponse;

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

// Create search query
TurSNQuery query = new TurSNQuery();
query.setQuery("artificial intelligence");
query.setRows(10);
query.setPageNumber(1);

// Execute search
QueryTurSNResponse response = turSNServer.query(query);
response.getResults().getDocument().forEach(doc -> {
    System.out.println("Title: " + doc.getFields().get("title"));
    System.out.println("Content: " + doc.getFields().get("content"));
});

JavaScript SDK Example

import { TurSNSiteSearchService } from '@openviglet/turing-js-sdk';

// Initialize search service
const searchService = new TurSNSiteSearchService('http://localhost:2700');

// Perform search
const results = await searchService.search('sample-site', {
  q: 'machine learning',
  rows: 10,
  currentPage: 1,
  localeRequest: 'en_US',
});

console.log(`Found ${results.queryContext?.count} results`);
results.results?.document?.forEach(doc => {
  console.log(`Title: ${doc.fields?.title}`);
  console.log(`Description: ${doc.fields?.description}`);
});

REST API Example

# Search via REST API
curl -X GET "http://localhost:2700/api/sn/sample-site/search?q=artificial%20intelligence&rows=10&_setlocale=en_US"

GraphQL API Example

API Endpoints

• GraphQL API: POST /graphql

• GraphiQL Interface: GET /graphiql

Example Usage

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

Integration Benefits

1. Type Safety: Strong typing prevents runtime errors

2. Flexible Queries: Clients can request exactly the data they need

3. Single Endpoint: All search operations through one GraphQL endpoint

4. Backward Compatibility: Existing REST API remains unchanged

5. Interactive Development: GraphiQL interface for query development

6. Consistent Results: Uses same search engine and processing as REST API

🛠️ Development Setup

Building from Source

# Clone repository
git clone https://github.com/openviglet/turing.git
cd turing

# Build all modules
./mvnw clean install

# Build specific components
./mvnw clean install -pl turing-app          # Main application
./mvnw clean install -pl turing-java-sdk     # Java SDK
cd turing-js-sdk/js-sdk-lib; npm run build              # JavaScript SDK

Running Tests

# Run all tests
./mvnw test

# Run specific module tests
./mvnw test -pl turing-app

Development Environment

# Start development stack
docker-compose -f docker-compose.dev.yml up -d

# Run app in development mode
./mvnw spring-boot:run -pl turing-app -Dspring-boot.run.profiles=development

🤝 Community & Contributing

Getting Involved

We welcome contributions from developers of all skill levels! Here’s how you can get started:

1. 🐛 Report Issues: Found a bug? Create an issue on GitHub

2. 💡 Feature Requests: Have an idea? We’d love to hear it

3. 📖 Documentation: Help improve our docs and examples

4. 🔧 Code Contributions: Submit pull requests for bug fixes and features

Contribution Guidelines

• Review our Contributing Guide

• Follow our Code of Conduct

• Check out issues labeled "good first issue" for beginners

Connect with Us

• 🌐 Website: https://viglet.org/turing/

• 🐛 Issues: https://github.com/openviglet/turing/issues

• 📋 Discussions: https://github.com/openviglet/turing/discussions

📚 Documentation & Resources

Essential Links

• 📖 Full Documentation: https://docs.viglet.com/turing/

• 💾 Downloads: https://viglet.org/turing/download/

• 🔧 API Documentation: https://turing.viglet.com/latest/javadoc/

SDK Documentation

• Java SDK: Java SDK Guide

• JavaScript SDK: JS SDK Guide

🐳 Deployment Options

Docker Production Setup

# Production with external database
docker-compose -f docker-compose.yml up -d

# Kubernetes deployment
kubectl apply -f k8s/

Traditional Deployment

# Build production JAR
./mvnw clean package -pl turing-app

# Run with production profile
java -jar turing-app/target/viglet-turing.jar

🆘 Troubleshooting

Common Issues

Q: Search results are empty A: Ensure your content is properly indexed and the search site is configured correctly.

Q: Docker containers won’t start A: Check that ports 2700, 8983, and 3306 are not in use by other applications.

Q: Build fails with Java version error A: Ensure you’re using Java 21 or higher. Check with java -version.

Getting Help

• 📋 Check our GitHub Discussions

• 🐛 Report bugs via GitHub Issues

• 📧 Email us at [email protected]

📄 License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

🌟 Star History

If you find Viglet Turing useful, please consider giving us a star on GitHub! ⭐

---

Built with ❤️ by the Viglet Team