GroupDocs.Search 24.9.0

Advanced Document Search & Indexing .NET API

GroupDocs.Search for .NET is a comprehensive library enabling developers to build advanced search and indexing capabilities into their .NET applications. It supports a wide range of document formats and provides features such as semantic search, entity recognition, sentiment analysis, and custom entity extraction. With its flexible API and support for various search types, developers can easily implement powerful search functionalities, enhance data analysis, and gain valuable insights from their documents.

Creating an Index

• Index Directory: Specify a directory where index data will be stored.
• Memory-Based Indexing: Option to create an index in memory for faster search (but not persistent).

Adding Documents to an Index

• Individual Files: Add files one by one using their paths.
• Directory Scanning: Add all supported documents within a specified directory and its subdirectories.
• File Streams: Index documents directly from streams for flexibility.

Updating and Maintaining an Index

• Incremental Updates: Add or remove individual documents without rebuilding the entire index.
• Index Optimization: Improve search performance by optimizing the index structure periodically.
• Index Backup and Restore: Create backups of the index for safety and restore them if needed.

Basic Search Functionality

• Full-Text Search: Index and search within the body text of documents.
• Metadata Search: Search based on document metadata (author, title, keywords, etc.).
• Supported File Formats: Search across various file types (DOCX, PDF, HTML, etc.).
• Simple Query Syntax: Use basic search terms and phrases.

Advanced Search Options

• Boolean Operators: Combine search terms using AND, OR, NOT for precise queries.
• Wildcards: Use * to match any character sequence, ? to match a single character.
• Regular Expressions: Employ powerful pattern matching for complex searches.
• Fuzzy Search: Find near matches even with typos or slight variations.
• Proximity Search: Search for words within a specified distance of each other.
• Field Search: Search within specific document fields or properties.

Filtering and Sorting Search Results

• Filter by Metadata: Narrow down results based on metadata values.
• Filter by Date Range: Limit results to documents within a specific time frame.
• Sort by Relevance: Order results based on their relevance to the search query.
• Sort by Date: Order results by document creation or modification date.
• Custom Sorting: Implement custom sorting logic based on specific criteria.

Working with Metadata

• Metadata Extraction: Automatically extract and index metadata during indexing.
• Metadata Search: Search and filter results based on extracted metadata.
• Metadata Display: Include metadata in search results for additional context.

Highlighting and Snippets

• Search Term Highlighting: Visually highlight search terms within the retrieved documents.
• Search Result Snippets: Display a short excerpt of text surrounding the search terms to provide context.

Semantic Search and Entity Recognition

• Semantic Search: Understand the meaning behind search queries and retrieve conceptually relevant results, going beyond keyword matching.
• Entity Recognition: Identify and extract named entities like people, organizations, locations, dates, and more from text.

Sentiment Analysis

• Sentiment Determination: Analyze text to determine the overall sentiment expressed, classifying it as positive, negative, or neutral.
• Sentiment Scoring: Assign sentiment scores to text, indicating the degree of positivity or negativity.

Document Classification

• Text Classification: Categorize documents into predefined classes or categories based on their content.
• Custom Classification: Train custom classification models to categorize documents according to specific criteria or taxonomies.

Custom Entity Extraction

• Custom Entity Definition: Define custom entity types and extraction rules based on specific requirements.
• Custom Entity Extraction: Extract user-defined entities from text using the defined rules and patterns.

Advanced Search API Features

• Creating Custom Analyzers: Tailor text processing during indexing and searching. Define tokenization rules, stemming algorithms, stop words, and more.
• Configuring Indexing Options: Control which file types and parts of documents are indexed. Set indexing depth and update frequency.
• Implementing Search Result Ranking: Customize the scoring algorithm to prioritize certain results. Factor in metadata, document structure, or other custom criteria.
• Semantic Search and Entity Recognition: Understand the meaning behind search queries. Identify named entities (people, organizations, locations, etc.) within text.
• Sentiment Analysis: Determine the overall sentiment (positive, negative, neutral) expressed in text.
• Document Classification: Categorize documents based on their content.
• Custom Entity Extraction: Define and extract custom entities from text.

Supported Document Formats

Supported Search Types

• Simple word search: Searches for the exact occurrence of a word in the indexed documents.
• Boolean search: Combines multiple search terms using logical operators like AND, OR, and NOT.
• Regular expression search: Uses patterns and expressions to search for complex text structures.
• Faceted search: Filters search results based on specific categories or fields.
• Case sensitive search: Differentiates between uppercase and lowercase characters in the search query.
• Flexible fuzzy search: Finds words with similar spelling, allowing for minor typing or spelling errors.
• Synonym search: Searches for words and their synonyms to expand search results.
• Homophone search: Finds words that sound the same but have different spellings.
• Wildcard search: Uses placeholders like * or ? to match varying characters or word fragments.
• Phrase search with wildcards: Searches for a specific phrase while allowing variations with wildcards.
• Search for different word forms: Matches different grammatical forms of a word, such as plural or tense variations.
• Date range search: Filters documents based on a specific date or a range of dates.
• Numeric range search: Finds data within a specified numeric range.
• Search by chunks (pages): Searches within specific sections or pages of a document.
• Search for different object types: Searches across various data types, such as text, numbers, dates, file names, and metadata.
• Combining different types of search into one search query: Mixes multiple search types, such as combining Boolean and wildcard searches in one query.
• Alias substitution in search queries: Replaces defined aliases with their full meanings during the search.
• Spell check during search: Automatically corrects minor spelling mistakes in the search query.
• Keyboard layout correction during search: Adjusts the search query for different keyboard layouts or language settings.
• Search queries in text or flexible object form: Accepts both textual and structured object-based search queries.
• Highlighting search results: Highlights the found terms or phrases directly in the document.
• Multiple simultaneous thread safe search: Allows multiple searches to be run concurrently without conflicts.
• Thread safe search during indexing, updating, or merging operations: Ensures safe searching while the index is being modified.
• Search over several indexes simultaneously: Performs searches across multiple indexes in a single operation.
• Reverse image search: Finds images based on similarity or matching image characteristics rather than text.

System Requirements

Install via NuGet

Using Package Manager GUI

1. Open your solution in Visual Studio.
2. Go to Tools → NuGet Package Manager → Manage NuGet Packages for Solution.
3. In the Browse tab, search for GroupDocs.Search.
4. Click Install to add it to your project.

Using Package Manager Console

1. Open your solution in Visual Studio.
2. Go to Tools → NuGet Package Manager → Package Manager Console.
3. Run the command:

   Install-Package GroupDocs.Search
   

4. GroupDocs.Search will be referenced in your project.

Install from Official Website

1. Download and unpack the ZIP or use the MSI installer from the official website.
2. In Visual Studio, right-click References and select Add Reference.
3. Browse and select GroupDocs.Search.dll, or choose from the installed components.
4. Click OK to complete the reference.

Indexing Documents from URL Using GroupDocs.Search for .NET

Learn how to index a document from a URL using GroupDocs.Search for .NET. This example demonstrates lazy initialization of documents from a URL and indexing them for efficient search in .NET applications.

    // Class to load a document from a URL with lazy initialization
    private class DocumentLoaderFromUrl : IDocumentLoader
    {
        private readonly string documentKey; // Document identifier (URL in this case)
        private readonly string url; // The URL to fetch the document from
        private readonly string extension; // The file extension of the document
        
        // Constructor to initialize document properties
        public DocumentLoaderFromUrl(string documentKey, string url, string extension)
        {
            this.documentKey = documentKey;
            this.url = url;
            this.extension = extension;
        }

        // Method to load the document from the URL stream
        public Document LoadDocument()
        {
            // Configure security protocols for web requests
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol =
                SecurityProtocolType.Ssl3 |
                SecurityProtocolType.Tls |
                SecurityProtocolType.Tls12 |
                SecurityProtocolType.Tls11;

            // Create a web request to access the URL
            WebRequest request = WebRequest.Create(url);
            using (WebResponse response = request.GetResponse())
            using (Stream stream = response.GetResponseStream())
            {
                // Copy the stream into memory
                MemoryStream memoryStream = new MemoryStream();
                stream.CopyTo(memoryStream);
                memoryStream.Position = 0;

                // Create a Document object from the memory stream
                Document document = Document.CreateFromStream(documentKey, DateTime.Now, extension, memoryStream);
                return document;
            }
        }

        // Method to close the document (empty in this case)
        public void CloseDocument()
        {
        }
    }

        // Define the index folder path where the index will be stored
        string indexFolder = @"c:\MyIndex";

        // Define the URL of the document to be indexed
        string url = "http://example.com/ExampleDocument.pdf";

        // Creating an index in the specified folder
        Index index = new Index(indexFolder);

        // Creating a document loader object to fetch the document from the URL
        string documentKey = url;
        IDocumentLoader documentLoader = new DocumentLoaderFromUrl(documentKey, url, ".pdf");

        // Creating a lazy-initialized document object
        Document document = Document.CreateLazy(DocumentSourceKind.Stream, documentKey, documentLoader);

        // Prepare an array of documents for indexing
        Document[] documents = new Document[] { document };

        // Indexing options (default options in this case)
        IndexingOptions options = new IndexingOptions();

        // Add the lazy-loaded document to the index
        index.Add(documents, options);

Source*

Homophone Search Using GroupDocs.Search for .NET

Learn how to perform homophone search using GroupDocs.Search for .NET. This code example demonstrates enabling homophone search to find similar-sounding words like "coal," "cole," and "kohl" in indexed documents.

// Specify the index folder path where the index will be created
string indexFolder = @"c:\MyIndex\";

// Specify the folder path containing documents to be indexed
string documentsFolder = @"c:\MyDocuments\";

// Creating an index in the specified folder
Index index = new Index(indexFolder);

// Adding documents to the index from the specified folder
index.Add(documentsFolder);

// Creating search options to enable homophone search
SearchOptions options = new SearchOptions();
options.UseHomophoneSearch = true; // Enabling homophone search

// Search for the word 'coal' in the indexed documents
// Homophone search will also find words that sound like 'coal', such as 'cole' and 'kohl'
SearchResult result = index.Search("coal", options);

Source*

Perform Shard Optimization using GroupDocs.Search for .NET

Learn how to optimize shards in a search network using GroupDocs.Search for .NET. This example demonstrates how to improve search performance by minimizing the number of index segments on each shard through the optimization process.

// Inform the user that the optimization process is starting
Console.WriteLine("Optimizing shards");

// Access the Indexer class for the current search network node
Indexer indexer = node.Indexer; // Assuming 'node' is defined elsewhere in your search network

// Create optimization options
OptimizeOptions options = new OptimizeOptions();

// Perform the optimization process on all shards
indexer.Optimize(options); // This reduces the number of index segments on each shard

Source*

Tags

Aspose | GroupDocs |Advanced Document Search | Indexing API | .NET Search Library | Semantic Search API | Boolean Search | Fuzzy Search | Metadata Search | Entity Recognition API | Sentiment Analysis | Custom Entity Extraction | Document Classification API | Full-Text Search | Field Search | Regular Expressions Search | Proximity Search | Custom Search Ranking | Indexing Optimization | Distributed Search Network | Reverse Image Search | Search API | .NET Document Search | Document Indexing API | GroupDocs.Search for .NET | Text Search API | Search Results Highlighting | Document Metadata Search | Snippets Extraction | Wildcard Search | Search API for .NET