A Step-by-Step Guide to Semantic Search Using OpenSearch and OpenAI

In today’s world, building an intelligent and context-aware search system has become a priority for businesses across various industries. Traditional search solutions based on keywords often fail to capture the intent behind user queries. However, by combining OpenSearch with OpenAI embeddings, we can create a search system that understands the meaning of the query, enabling more relevant results. This guide will show you how to integrate OpenSearch with OpenAI embeddings in Java to build an efficient, semantic search system.

What is OpenSearch?

OpenSearch is an open-source, distributed search and analytics engine designed for large-scale, high-performance searches. It is a fork of Elasticsearch, with enhanced features and improved security, maintained by the community and Amazon Web Services (AWS). OpenSearch allows you to store, search, and analyze large volumes of data quickly and in real-time. It’s widely used for log and event data analysis, full-text search, and application monitoring.

Key Features of OpenSearch:

• Distributed Search: Handles massive datasets with high scalability.
• Full-Text Search: Supports powerful search capabilities, including keyword matching and phrase search.
• Real-Time Analytics: Allows for real-time analysis of log files, metrics, and business data.
• K-NN (k-Nearest Neighbors): Supports vector search, essential for semantic search applications.

What are OpenAI and Embeddings?

OpenAI is an artificial intelligence research and deployment company that provides advanced machine learning models, including language models like GPT (Generative Pretrained Transformer). OpenAI’s API offers access to powerful models capable of understanding and generating human-like text, as well as embeddings that represent text as high-dimensional vectors.

OpenAI Embeddings are vector representations of text that capture semantic meaning, making it easier to compare, search, and analyze text data. These embeddings allow for more relevant and accurate search results based on the meaning of words or sentences, not just keyword matching.

Key Features of OpenAI:

• Language Models: Generates human-like text, summaries, and responses.
• Embeddings: Converts text into numerical vectors that represent the semantic meaning of the text.
• Advanced AI: Supports various natural language processing (NLP) tasks, such as translation, summarization, and sentiment analysis.

Why Use OpenAI with OpenSearch?

OpenAI embeddings combined with OpenSearch provide a powerful solution for semantic search, enabling systems to understand and return results based on meaning rather than keywords alone. Here’s why combining OpenAI with OpenSearch makes sense:

➡️Enhanced Search Relevance

Traditional search engines rely on keyword matching, but OpenAI embeddings understand the context and meaning of words, allowing for semantically relevant search results. For example, a query about “summer jackets” could return results for “lightweight coats” or “rain jackets” if they are contextually relevant.

➡️Efficient Handling of High-Dimensional Data

OpenSearch’s k-NN (k-nearest neighbor) plugin is optimized for vector searches, which is ideal for the high-dimensional data generated by OpenAI embeddings. This allows for fast and scalable similarity searches in large datasets.

➡️Real-Time Semantic Matching

By storing OpenAI embeddings in OpenSearch, you can perform real-time semantic searches. As users enter queries, their embeddings are compared to the indexed embeddings in OpenSearch, enabling quick retrieval of the most relevant documents.

➡️Scalable Solution

OpenSearch provides horizontal scalability, meaning it can efficiently handle an ever-growing number of documents with embeddings, while OpenAI offers a deep semantic understanding of text data. Together, they provide an ideal setup for scalable and intelligent search.

➡️Better User Experience

When combining OpenAI’s understanding of natural language with OpenSearch’s powerful search engine, you can build systems that provide users with highly relevant, accurate, and meaningful search results, leading to a better overall user experience.

Use Cases

Example 1: E-commerce Product Search

Imagine an e-commerce store where users search for products not by name but by intent. With OpenAI embeddings, a user query such as “I need a warm winter jacket” can be semantically matched with products like “Down jacket” or “Winter coat”, even if those exact words don’t appear in the product descriptions.

Example 2: Document Retrieval

For knowledge management or customer support systems, OpenAI embeddings can help find the most relevant documents or responses based on the content’s meaning, not just keyword matches.

Example 3: Customer Feedback Analysis

OpenAI embeddings can be used to analyze customer feedback by matching similar reviews or comments, helping businesses identify recurring issues or popular products.

How Does it Work?

➡️OpenAI Embeddings

OpenAI provides APIs to generate embeddings, which are high-dimensional vector representations of text. These embeddings capture the semantic meaning of text, enabling advanced tasks like semantic search. For example:

• Input: “Find tech startups”
• Output: A 1536-dimensional vector representing the semantic meaning of the text.

➡️OpenSearch Integration

OpenSearch’s k-NN (k-nearest neighbor) plugin allows the storage and retrieval of these vectors. When a query is received, its embedding is calculated, and OpenSearch performs a similarity search to return the closest matches.

➡️End-to-End Flow

• Generate an embedding for both the query and document.
• Store the document with its embedding in OpenSearch.
• Perform a similarity search by comparing the query’s embedding with the document embeddings.

OpenAI Implementation

Since OpenAI does not offer a dedicated Java client, we will use an HTTP client to interact with the OpenAI API. Here’s how to generate embeddings for text using OpenAI’s API in Java.

@Service
public class OpenAIEmbeddingService {

    private static final String OPENAI_API_KEY = "your_openai_api_key";
    private static final String OPENAI_API_URL = "https://api.openai.com/v1/embeddings";

    public JSONArray getEmbedding(String text) throws IOException {
         CloseableHttpClient client = HttpClients.createDefault();
         HttpPost postRequest = new HttpPost(OPENAI_API_URL);

         JSONObject payload = new JSONObject();
         payload.put("input", text);
         payload.put("model", "text-embedding-ada-002");

         StringEntity entity = new StringEntity(payload.toString());
         postRequest.setEntity(entity);
         postRequest.setHeader("Authorization", "Bearer " + OPENAI_API_KEY);
         postRequest.setHeader("Content-Type", "application/json");

         try (CloseableHttpResponse response = client.execute(postRequest)) {
             String responseStr = EntityUtils.toString(response.getEntity());
             JSONObject jsonResponse = new JSONObject(responseStr);
             JSONArray embeddings = jsonResponse.getJSONArray("data");
             return embeddings.getJSONObject(0).getJSONArray("embedding");
         }
     }
}

<dependency>
    <groupId>org.opensearch.client</groupId>
    <artifactId>opensearch-java</artifactId>
    <version>2.10.4</version>
</dependency>

dependencies {
    implementation 'org.opensearch.client:opensearch-java:2.10.4'
}

public void createIndex(Long entityId, String indexName, IndexData document) {
    IndexRequest<IndexData> indexRequest = new IndexRequest.Builder<IndexData>()
          .index(indexName)
          .document(document)
          .build();

    openSearchClient.index(indexRequest);
}

public void deleteIndex(String indexId, String indexName) {
    if (indexId != null) {
       openSearchClient.delete(d -> d.index(indexName).id(indexId));
    }
}

public void updateIndex(String indexId, String indexName, IndexData document) {
    UpdateRequest<IndexData, IndexData> updateRequest = new UpdateRequest.Builder<IndexData, IndexData>()
             .index(indexName)
             .id(indexId)
             .doc(document)
             .build();

    openSearchClient.update(updateRequest, IndexData.class);
}

public <T> List<Hit<T>> searchIndexDocumentByIndexQueryAndIndexName(Query query, String indexName, Class<T> clazz) {
   SearchRequest searchRequest = new SearchRequest.Builder()
            .index(indexName)
            .query(query)
            .build();

   SearchResponse<T> searchResponse = openSearchClient.search(searchRequest, clazz);
   HitsMetadata<T> hits = searchResponse.hits();
   return hits.hits();
}

Connecting to OpenSearch: Role of AWS

If your OpenSearch instance is hosted on AWS, you need to authenticate requests using AWS credentials. Here’s how to set up the connection:

@Bean
   public OpenSearchClient openSearchClient() {
       AwsBasicCredentials awsCreds = AwsBasicCredentials.create(accessKeyId, secretKey);
       StaticCredentialsProvider credentialsProvider = StaticCredentialsProvider.create(awsCreds);

       SdkHttpClient httpClient = ApacheHttpClient.builder().build();
       return new OpenSearchClient(
               new AwsSdk2Transport(
                       httpClient,
                       openSearchEndpoint,
                       Region.US_EAST_1,
                       AwsSdk2TransportOptions.builder()
                               .setCredentials(credentialsProvider)
                               .build()
               )
       );
}

JSONArray embedding = openAIEmbeddingService.getEmbedding(companyDescription);
IndexData indexData = new IndexData(companyName, embedding.toList());

openSearchService.createIndex(companyId, "company-index", indexData);

JSONArray queryEmbedding = openAIEmbeddingService.getEmbedding(userQuery);

List<Hit<IndexData>> results = openSearchService.searchIndexDocumentByIndexQueryAndIndexName(
new Query.Builder().knn(q -> q.field("embedding").vector(queryEmbedding.toList()).k(5)).build(),"company-index", IndexData.class);