Overview

1. LipiCore-Engine

LipiCore-Engine is a high-performance, white-label search solution designed specifically for developers and product teams. Built on Apache Solr, it provides enterprise-grade search capabilities that can be seamlessly integrated into your applications with minimal configuration.

LipiCore-Engine delivers blazing fast search results even with millions of records.

LipiCore-Engine is a complete search infrastructure that handles everything from data ingestion to complex search queries. It’s designed to scale with your business while maintaining consistent performance.

1.1. Key Features

Feature	Description
Enterprise-Grade Performance	Built on Apache Solr with optimizations for speed and scalability. Handles millions of records with sub-second response times.
Advanced Search Capabilities	Full-text search, faceted navigation, filtering, auto-suggestions, spell correction and complex query support.
Data Synchronization	Push data updates via REST APIs or schedule batch imports from databases.
Multi-Language Support	Optimized for global applications with support for multiple languages.
Role-Based Security	Granular API access control with separate tokens for Admin, Configuration, Data Management and Search operations.
Complete White-Label Solution	Zero LipiCore-Engine branding. Fully customizable to match your brand identity and user experience.
Developer-First Design	RESTful JSON APIs with comprehensive documentation, code examples and interactive testing capabilities.

Feature

Description

Enterprise-Grade Performance

Built on Apache Solr with optimizations for speed and scalability. Handles millions of records with sub-second response times.

Advanced Search Capabilities

Full-text search, faceted navigation, filtering, auto-suggestions, spell correction and complex query support.

Data Synchronization

Push data updates via REST APIs or schedule batch imports from databases.

Multi-Language Support

Optimized for global applications with support for multiple languages.

Role-Based Security

Granular API access control with separate tokens for Admin, Configuration, Data Management and Search operations.

Complete White-Label Solution

Zero LipiCore-Engine branding. Fully customizable to match your brand identity and user experience.

Developer-First Design

RESTful JSON APIs with comprehensive documentation, code examples and interactive testing capabilities.

1.2. Use Cases

LipiCore-Engine excels in scenarios requiring fast, accurate search across large datasets.

Use Case	Description
E-commerce Platforms	Product search with filters, faceted navigation, price ranges and inventory management.
Business Intelligence Dashboards	Analytics, reporting and data exploration with aggregations and drill-down capabilities.
Data Analytics Platforms	Large-scale data exploration, filtering and visualization with statistical aggregations.

Use Case

Description

E-commerce Platforms

Product search with filters, faceted navigation, price ranges and inventory management.

Business Intelligence Dashboards

Analytics, reporting and data exploration with aggregations and drill-down capabilities.

Data Analytics Platforms

Large-scale data exploration, filtering and visualization with statistical aggregations.

1.3. Why LipiCore?

Performance: Blazing fast search across millions of records
Scalability: Handles growing data volumes without performance degradation
Flexibility: Customizable to match your exact requirements
Reliability: Enterprise-grade stability with 99.9% uptime
Support: Comprehensive documentation and developer support

2. Quick Link

2.1. Interactive Demo

Experience LipiCore-Engine capabilities with our interactive demo featuring real-world datasets and search scenarios.

Try the LipiCore-Engine Interactive Demo to see features in action.

Demo Includes

E-commerce Search: Product catalog with filters, facets and autocomplete
Content Search: Document search with highlighting and suggestions
Analytics Dashboard: Real-time aggregations and drill-down capabilities

2.2. Admin Panel

The LipiCore-Engine Admin Panel provides a web-based interface for testing and managing different collections.

Access the LipiCore-Engine Admin Panel for collection management.

Start with Panel

Navigate to the Admin Panel URL
Select your collection from the dropdown
Use the query as is or adjust to test search functionality

3. Getting Started

This section will help you get up and running with LipiCore-Engine APIs quickly.

3.1. Prerequisites

Before you begin, ensure you have:

A valid LipiCore license and configuration
API access credentials (tokens)
Basic understanding of REST APIs and JSON
Your data source ready for indexing

3.2. Authentication

LipiCore-Engine uses token-based authentication. All API requests require a valid token in the header.

Authorization: Bearer {Token}

3.2.1. Base URL

All API endpoints are relative to your LipiCore-Engine instance.

https://lipicore.your-domain.com/api

Feel free to explore LipiCore-Engine through various APIs (Search, Data & Admin).

APIs (Search)

LipiCore-Engine provides a comprehensive set of search APIs designed to handle various search scenarios. Each API is optimized for specific use cases while maintaining consistent performance and response formats.

Search Types

LipiCore-Engine offers 5 specialized search APIs, each designed for specific functionality:

API Type	Description & Use Cases
Query Search	The primary search API for full-text search, filtering and faceted navigation. Supports complex queries, sorting, highlighting and pagination. Ideal for product catalogs, content search and data exploration.
Group Search	Specialized API for searching within predefined groups or categories. Enables quick categorization and group-based filtering. Perfect for hierarchical data structures and category-based navigation.
Auto Suggest	Real-time text completion and suggestion API. Provides intelligent suggestions as users type, improving search experience and discoverability. Essential for search-as-you-type interfaces.
Spell Correction	Intelligent spelling correction based on your indexed data. Automatically suggests corrections for misspelled search terms, improving search accuracy and user experience.
Combined Search	API that combines multiple search operations into a single request. Executes searches in parallel for optimal performance. Reduces network overhead and improves response times.

API Type

Description & Use Cases

Query Search

The primary search API for full-text search, filtering and faceted navigation. Supports complex queries, sorting, highlighting and pagination. Ideal for product catalogs, content search and data exploration.

Group Search

Specialized API for searching within predefined groups or categories. Enables quick categorization and group-based filtering. Perfect for hierarchical data structures and category-based navigation.

Auto Suggest

Real-time text completion and suggestion API. Provides intelligent suggestions as users type, improving search experience and discoverability. Essential for search-as-you-type interfaces.

Spell Correction

Intelligent spelling correction based on your indexed data. Automatically suggests corrections for misspelled search terms, improving search accuracy and user experience.

Combined Search

API that combines multiple search operations into a single request. Executes searches in parallel for optimal performance. Reduces network overhead and improves response times.

Common Features

All search APIs share these common capabilities:

Authentication: Token-based security
Pagination: Configurable result limits and offsets
Error Handling: Consistent error response format
Performance: Sub-second response times
Scalability: Handles millions of records efficiently

Best Practices

Use the appropriate API for your use case
Implement proper error handling
Use pagination for large result sets
Combine multiple operations when possible

4. Query

Table 1. Params
Param	Default	Example	Description
ref	N/A	"q1"	Reference id/key/string of request going back in response as is. It has nothing to do with the search. It helps multiple requests from caller to track each of them correctly.
text	N/A	"Bud"	Standard text search which applies to various fields by default
searchFields	N/A	"name^2 company short_desc^0.5"	Each field’s importance can be boosted differently for the text search. Given example boosts matches in name with double multiplier, keeps company at default weight and lowers the importance of short_desc by half.
quickSearch	false	true	Standard text search which applies to selected fields to support a faster result
query	N/A	"name:Vineyards"	The query search feature enables field-level searches through direct Solr queries
sort	N/A	"gluten_free desc,name asc"	The sort enables manual sorting on response docs
fuzzy	0	1	Fuzzy search allows values 0 (default), 1 or 2. Adds number of character fuzziness during search. Applies to "text" and "search" both having string values. (Example: Search of "roam" with fuzzy=1, will match terms like roams & foam. It will also match the word "roam" itself.)
filters	N/A	{"category_s":"Beer","sugar_free": true}	Filters the results with additional query by specific fields
join	N/A	{"collection": "gls-price","from": "product_id","to": "product_id","query": "id:(3913_10229 9267_10229) AND inventory:true"}	To join from another collection in Solr, specify the `collection` → provide collection name `from` → from field `to` → to field `query` → provide Join Clause
facetLimit	5	10	Number of top buckets required within each facet
facets	N/A	["brand_s","type_s"]	Facet fields to have positive counts of the values
highlighting	N/A	["name","short_desc"]	With highlights, now json renders more readable format with colors
facetSorts	N/A	{ "region_s":"index asc", "item_type_s":"count asc" }	Applies sorting on facets: defaults to `count desc`. Supports sorting: `count asc` for ascending count, or `index desc` for descending value.
statFacets	N/A	{"avgPrice": "avg(price)"}	Used for statistical calculations on fields within your dataset. (Example: min(price) ,max(price) ,sum(price), avg(price), count(price), percentile(field, 90), stddev(field),median(price))
rangeFacets	N/A	{ "prices": { "field": "price", "start": "0", "end": "100", "gap": "10" } }	Used for range facets on fields within your dataset. In JSON, `start`, `end`, and `gap` are always strings; the API maps them to Solr `RangeFacetMap` as either integer ranges, floating-point ranges, or date/time ranges. `rangeFacets` → Request attribute used to define range facets `prices` → The field that will return the response for range facets. `field` → The field on which the range facet will be applied. `start` → The starting value of the range. `end` → The ending value of the range. `gap` → The interval (or gap) between the values in the range. This is optional and if not specified, the default value is calculated as (end - start) )
nestedFacets	N/A	{ "country_s": { "facetLimit": 5, "nestedFacetSort": "yFacet", "statFacets": { "yFacet": "sum(unit_price)" }, "nestedFacets": { "item_type_s": { "facetLimit": 5, "nestedFacetSort": "yFacet", "statFacets": { "yFacet": "sum(unit_price)" } } } } }	Nested facets generated multi-dimension results with combinations of "facets" and "statFacets". Extremely useful for dashboards and visualisations.
nestedFacetSort	N/A	`avg_unit_price asc` OR `count desc` OR `count asc` OR `index desc` OR `index asc`	Defines sorting behavior for nested facets. Defaults to descending count (count desc). Supports custom sorting: `avg_unit_price desc` for descending order, or `avg_unit_price asc` for ascending order.
start	0	11	Need record from
rows	10	20	Number of records (Pagination size)
nested	false	true	If nested is true, response includes child as part of parent. Child docs always remains parallel to parent as separate docs.
return	All Fields	["id","sku","name","image","brand"]	Returns all fields in response. If specified, returns only those specified fields.

Multi-word effect can be applicable in "filters & text" by escaping double quote. {"brand_s": "\"Johny Walker\""}

In "facets", use "_s" postfix for field having single text value (not "list" value). It gives non-tokenised proper as-is full multi-words value in filters.

+ - && || ! ( ) { } [ ] ^ " ~ * ? : / characters are reserved and not supported directly in search: To include any of these characters in the search text, prefix them with a backslash (\) to escape them.

4.1. Special Cases

4.1.1. Escape

Problem

If "starts with" queries have more than one word, they give unexpected results. For example, "…:Bud Li*" gives results starting with "Li…" because Solr is a tokenized mechanism that treats "Bud" and "Li" as separate tokens.

Solution

Simply escape all spaces in "starts with" queries using backslashes to prevent tokenization. This tells Solr to treat the phrase as a single token.

Table 2. Examples
Query Type	Query	Result
Starts with - Without escape	`"…:Bud Li*"`	Matches anything starting with "Li" (e.g., "Light", "Lite", "Lincoln") because Solr tokenizes "Bud Li" into separate tokens.
Starts with - With escape	`"…:Bud\\ Li*"`	Matches only results starting with "Bud Li" (e.g., "Bud Light", "Bud Lite") because the escaped space prevents tokenization.
Multi-word in filters	`{"brand_s": "\"Johny Walker\""}`	Matches exact multi-word phrase "Johny Walker" in filters. Escaped double quotes ensure the phrase is treated as a single token.
Multi-word in text	`"text": "\"Johny Walker\""`	Matches exact multi-word phrase "Johny Walker" in text search. Escaped double quotes ensure the phrase is treated as a single token.

4.1.2. Word Boosting

Problem

First word in search may not have higher search priority. For example, searching "Bud Lite" may return "Miller Lite" first instead of "Bud Light" because a four-character match ("Lite" matches in "Miller Lite") gives higher priority than a three-character match ("Bud" matches in "Bud Light").

Solution

Use the caret (^) notation to boost specific words in your search query. It gives higher priority to the boosted word/s. The number after caret (^) indicates the boost factor.

Table 3. Examples
Boost	Search Query	Description
Natural scoring (no boost)	`"Bud Lite"`	Uses natural scoring without any word preference. Results are ranked based on character match relevance.
Single word boost	`"Bud^2 Lite"`	Gives preference to "Bud" with a boost factor of 2. It prioritizes results containing "Bud" over "Lite" alone.
Multiple words boost	`"Bud Light^3 Ice^2"`	Boosts "Light" with factor 3 and "Ice" with factor 2. Higher numbers indicate higher priority. Results matching "Light" will have highest priority, followed by "Ice", then "Bud".

4.1.3. Fuzzy

Problem

Searching "henesy" with fuzzy=2 returns "honest" as the first result and "hennessy" as the second result, even though "hennessy" is phonetically closer to "henesy".

Understanding

Fuzzy search works based on pure character count differences, not phonetics or visual similarity.
Fuzzy search works on pure character count differences (Levenshtein distance). It calculates how many characters need to be changed, added, or removed to match the search term.
Complex queries with AND, OR, parentheses, or multiple colons are not supported with fuzzy search

Table 4. Examples
Search Query	Result	Explanation
`"henesy"` with `fuzzy=2`	"honest" (first), "hennessy" (second)	"honest" has 2 character differences (e, h swapped, n added) without adding characters, which algorithm considers a better match than "hennessy" which has 2 character differences with 2 added characters.
`"roam"` with `fuzzy=1`	"roam", "foam", "roams"	Matches terms within 1 character difference: "roam" (exact match), "foam" (changed 'r' to 'f'), "roams" (added 's').
`"cat"` with `fuzzy=1`	"cat", "cut", "bat", "cats"	Matches terms within 1 edit distance: "cat" (exact match), "cut" (changed 'a' to 'u'), "bat" (changed 'c' to 'b'), "cats" (added 's').
Phonetic mismatch	`"phonic"` with `fuzzy=2` does NOT match "fonic"	Fuzzy does not consider phonetics. "phonic" and "fonic" are phonetically similar but have different character patterns, so fuzzy does not match them.

4.2. Search Query

POST /api/v1/search/query/{collection}

Param	Default	Example	Description
ref	N/A	"g1"	Reference id/key/string of request going back in response as is. It has nothing to do with search. It helps caller to track correctly.
text*	N/A	"Be"	Standard text search which applies to provided groups
groups*	N/A	["category_s","type_s"]	Groups to search text in
starts	false	true	Search text as starts with
contains	false	false	Search text as contains
limit	5	10	Number of records combined in return

Type	Example	Description
text	Giraffe on a Bicycle	Represents text data, typically used for database columns of type `text` or `varchar`. (Supports tokenized search.)
string	Orange	Represents string data, typically used for database columns of type `text` or `varchar`.
int	100	Represents integer values, used for database columns of type `int` (e.g., 100, 25).
long	12312363734	Represents long integer values, used for database columns of type `long` (e.g., 12312363734, 24312312734).
double	123.00	Represents floating-point values with decimals, used for database columns of type `double` (e.g., 123.00, 243.45).
boolean	true, false, 1, 0	Represents boolean values, typically used for database columns of type `boolean` (e.g., true, false, 1, 0).
date	2025-01-01T08:10:08	Represents date-time values, commonly used for database columns of type `date` (e.g., 2025-01-01 08:00:24.0).
jsonlist	["apple","orange"]	List of values in json format.
nested	{"store_id":2,"store_count":200}	Object in json format.
nestedlist	[{"product_id":2,"quantity":1,"price":10.99},{"product_id":179,"quantity":1,"price":5.99}]	List of Object in json format.

Param	Default	Example	Description
separator	,	"%09"	Character used as field separator. This parameter is global; for per-field usage, see the split parameter.
trimFields	N/A	name,description	Remove leading and trailing whitespace from values of the given fields.
header	true	false	Set to true if first line of input contains field names. These will be used if the fieldnames parameter is absent.
fieldnames	N/A	id,name,category,price	List of field names to use when adding documents.
literalFields	N/A	color,red,stamp,2025-10-29T10:02:24.000Z	Comma-separated key/value pairs for literal fields in alternating order: `key1,value1,key2,value2`.
skipFields	N/A	state,country	List of field names to skip.
skipLines	0	5	Number of lines to discard in the input stream before the CSV data starts, including the header, if present.
encapsulator	N/A	"	The character optionally used to surround values to preserve characters such as the CSV separator or whitespace.
escape	N/A	"\"	The character used for escaping CSV separators or other reserved character.
splitFields	N/A	sizes	Split a field into multiple values by a separate parser.
rowid	N/A	"id"	Map the rowid (line number) to a field specified by the value of the parameter.
rowidOffset	0	10	Add the given offset (as an integer) to the rowid before adding it to the document.
commit	true	false	Issues a commit after the data has been ingested.

	GET `/health/{}`	Check For
Status	GET `/health/status`	Status of overall health
Ping	GET `/health/ping`	Data Search health
Solr	GET `/health/solr`	Apache Solr Index Server health
All	GET `/health/all`	Combined all health

Role	Description
ADMIN	Provides access to administrative APIs, such as Solr client refresh or update operations.
DATA	Allows access to data import and deletion APIs, such as Solr data import and deletion.
SEARCH	Enables access to search-related endpoints, including search, group and suggest functionalities.

Type	For
`IMPORT`	Import data operations to collections
`DELETE`	Deletion operations upon data from collections
`TOKEN`	Token management

Verb	Usage
`[GET]`	Used to retrieve a resource
`[POST]`	Used to create a new resource
`[PUT]`	Used to update an existing resource with full updates
`[PATCH]`	Used to update an existing resource with partial updates
`[DELETE]`	Used to delete an existing resource

Status Code	Abbreviation	Error Codes	Usage
`200`	`OK`		Standard response for successful HTTP requests.
`401`	`UNAUTHORIZED`	1xxx	The request is missing the auth or access in order to fulfill the request.
`400`	`BAD_REQUEST`	2xxx	The request is malformed, bad, invalid or having constraints.
`404`	`NOT_FOUND`	3xxx	The requested resource does not exist.
`409`	`CONFLICT`	8xxx	The request could not be completed due to a conflict with the current state of the target resource.
`500`	`INTERNAL_SERVER_ERROR`	9xxx	A generic error given when an unexpected condition was encountered.

Code	Key	Description
`1001`	`ACCESS_TOKEN_MISSING`	Access token is missing
`1002`	`ACCESS_TOKEN_INVALID`	Access token is invalid
`1003`	`ACCESS_TOKEN_EXPIRED`	Access token has been expired - {0}
`1004`	`ACCESS_TOKEN_NOT_CREATED`	Access token not created - {0}
`1031`	`LICENSE_KEY_INVALID`	License key invalid - {0}
`1032`	`LICENSE_AUTH_INVALID`	License auth invalid - {0}
`1033`	`LICENSE_EXPIRED`	License is expired - {0}
`1041`	`AUTH_INVALID`	Auth invalid - {0}
`1101`	`UNAUTHORIZED_ACCESS`	Unauthorized access
`1102`	`UNAUTHORIZED_COLLECTION_ACCESS`	Unauthorized collection access
`2001`	`REQUIRED_PARAM`	Required {0} parameter {1} is missing
`2051`	`INVALID_ENTITY`	Invalid entity {0}
`2052`	`INVALID_PARAMS`	Invalid parameters
`2053`	`INVALID_VALUE`	Invalid value {0}
`2054`	`INVALID_INSTANCE`	Invalid instance {0}
`2055`	`INVALID_ACCOUNT`	Invalid account
`2056`	`INVALID_MAPPINGS`	Invalid Mappings for collection
`2101`	`ALREADY_EXIST_ENTITY`	Entity {0} with value {1} already exists
`2221`	`SOLR_RECORDS_RANGE_EXCEED`	Solr records range exceeded
`2222`	`SOLR_COLLECTIONS_RANGE_EXCEED`	Solr collections range exceeded
`2301`	`CONSTRAINT_VIOLATION`	Constraint violation
`2401`	`UNABLE_TO_PARSE`	Unable to parse {0} exception {1}
`3001`	`NOT_FOUND_ENTITY`	Entity {0} not found for {1}
`9001`	`EXCEPTION`	Generic exception
`9002`	`NULL_POINTER_EXCEPTION`	Null pointer exception
`9003`	`SQL_EXCEPTION`	SQL exception
`9005`	`CUSTOM_EXCEPTION`	Custom exception
`9006`	`SOLR_CLIENT_EXCEPTION`	Solr client exception
`9007`	`HTTP_CLIENT_EXCEPTION`	HttpClient exception
`9008`	`LIPI_ACCOUNT_CLIENT_EXCEPTION`	LipiAccountClient exception
`9009`	`CONFIG_EXCEPTION`	Config exception

LipiCore-Engine Guide (White Label)