Skip to content

Rule-Based Search Tutorial

This tutorial demonstrates how to perform rule-based searches using metadata filters to retrieve specific content from your knowledge base.

Overview

Learn how to:

  • Define metadata filters using UniqueQL syntax
  • Search content using rule-based queries
  • Retrieve content chunks based on search results

Prerequisites

  • Unique SDK installed and configured
  • Valid API credentials (API_KEY, APP_ID)
  • Content previously uploaded and indexed in your knowledge base
  • Environment variables set (COMPANY_ID, USER_ID)

Complete Example

Full Rule-Based Search Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
"""Rule-based searches.

The following tutorial shows how to perform rule-based search.
"""

import logging
import os
from logging import getLogger
from pathlib import Path

from dotenv import load_dotenv

logging.basicConfig(level=logging.INFO)
logger = getLogger(__name__)


def main():
    """
    Example of retrieving chunks based on a metadata filter search.
    This example assumes that the content has been previously uploaded and indexed.
    The search is performed using the `Content.get_info` method, which returns a list of content items
    that match the specified metadata filter.
    The content is then retrieved using the `Content.get` method, which returns the content object
    with the specified content ID.
    The content object contains a list of chunks, which are the individual pieces of content
    that match the search criteria.
    """
    import unique_sdk

    # Load environment variables
    load_dotenv(Path(__file__).parent / ".." / ".env")

    # Set up SDK configuration
    unique_sdk.api_key = os.getenv("API_KEY", "")
    unique_sdk.app_id = os.getenv("APP_ID", "")
    unique_sdk.api_base = os.getenv("API_BASE", "")
    company_id = os.getenv("COMPANY_ID", "")
    user_id = os.getenv("USER_ID", "")

    # Define a rule for the search
    metadata_filter = {
        "or": [
            {
                "and": [
                    {
                        "operator": "contains",
                        "path": ["folderIdPath"],
                        "value": "uniquepathid://",
                    },
                    {"operator": "contains", "path": ["title"], "value": "i"},
                ]
            }
        ]
    }

    content_info_result = unique_sdk.Content.get_info(
        user_id=user_id,
        company_id=company_id,
        metadataFilter=metadata_filter,
        skip=0,
        take=3,
    )

    logger.info(f"Total count: {content_info_result['totalCount']}")
    for item in content_info_result["contentInfos"]:
        content = unique_sdk.Content.search(
            user_id=user_id,
            company_id=company_id,
            where={
                "id": {
                    "equals": item["id"],
                }
            },
        )
        firstContent = content[0] if content else None
        if not firstContent:
            logger.warning(f"No content found for ID: {item['id']}")
            continue
        logger.info(
            f"Content ID: {firstContent.id}, Key: {firstContent.key}, Chunks Len: {len(firstContent.chunks)}"
        )


if __name__ == "__main__":
    main()