ਸਰਚ ਸਰਵਿਸ ਆਰਕੀਟੈਕਚਰ: ਵੱਖਰੀ Flask ਐਪਲੀਕੇਸ਼ਨ Valkey ਨਾਲ

ਇਹ ਲੇਖ ਦੱਸਦਾ ਹੈ ਕਿ ਸਾਡੀ ਸਰਚ ਸਰਵਿਸ ਇੱਕ ਵੱਖਰੇ ਸਰਵਰ ਉੱਤੇ ਇੱਕ ਸਟੈਂਡਅਲੋਨ Flask ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਰੂਪ ਵਿੱਚ ਕਿਵੇਂ ਚੱਲਦੀ ਹੈ, ਜੋ ਕਿ ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ ਵਾਲੀ ਵੈਕਟਰ ਖੋਜ, ਕੈਚਿੰਗ ਅਤੇ ਆਟੋਕੰਪਲੀਟ ਲਈ Valkey (Redis ਫੋਰਕ) ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।

ਸਮੱਸਿਆ: ਸਰਚ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਸਕੇਲੇਬਿਲਟੀ

ਸਰਚ ਓਪਰੇਸ਼ਨ ਗਣਨਾਤਮਕ ਤੌਰ 'ਤੇ ਮਹਿੰਗੇ ਹੁੰਦੇ ਹਨ:

• ਫਿਲਟਰ ਐਕਸਟ੍ਰੈਕਸ਼ਨ: ਹਰ ਕੁਵਰੀ ਨਾਲ 2,500+ ਵਾਕਾਂਸ਼ਾਂ ਦਾ ਮੇਲ ਕਰੋ

• ਸੰਬੰਧਿਤ ਖੋਜਾਂ: 65K ਕੁਵਰੀਆਂ ਵਿੱਚ ਸਮਾਨਤਾ ਦੀ ਗਣਨਾ ਕਰੋ

• ਆਟੋਕੰਪਲੀਟ: 65K ਕੁਵਰੀਆਂ ਉੱਤੇ ਪ੍ਰੀਫਿਕਸ ਮੈਚਿੰਗ

• ਉਤਪਾਦ ਫਿਲਟਰਿੰਗ: 5K+ ਉਤਪਾਦਾਂ ਨੂੰ ਕਈ ਮਾਪਦੰਡਾਂ ਅਨੁਸਾਰ ਫਿਲਟਰ ਕਰੋ

ਇਹ ਓਪਰੇਸ਼ਨ ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਉੱਤੇ ਚਲਾਉਣ ਨਾਲ ਇਹ ਹੁੰਦਾ ਹੈ:

• ਹੌਲੀ ਪੰਨਾ ਲੋਡ: ਸਰਚ ਹੋਰ ਬੇਨਤੀਆਂ ਨੂੰ ਬਲੌਕ ਕਰਦੀ ਹੈ

• ਮੈਮੋਰੀ ਦਬਾਅ: ਐਮਬੈਡਿੰਗਜ਼ ਬਹੁਤ ਵੱਡੀ ਮੈਮੋਰੀ ਫੁੱਟਪ੍ਰਿੰਟ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹਨ

• CPU ਵਿਵਾਦ: ਸਮਾਨਤਾ ਗਣਨਾ CPU-ਇੰਟੈਂਸਿਵ ਹੈ

• ਸਕੇਲਿੰਗ ਮੁਸ਼ਕਲ: ਸਰਚ ਨੂੰ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਸਕੇਲ ਨਹੀਂ ਕਰ ਸਕਦੇ

ਸਾਨੂੰ ਇੱਕ ਸਮਰਪਿਤ ਸਰਚ ਸਰਵਿਸ ਦੀ ਲੋੜ ਹੈ ਜੋ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਸਕੇਲ ਕਰ ਸਕੇ।

ਹੱਲ: ਸਟੈਂਡਅਲੋਨ ਸਰਚ ਸਰਵਿਸ

ਅਸੀਂ ਇੱਕ ਸਮਰਪਿਤ ਸਰਵਰ ਉੱਤੇ ਇੱਕ ਵੱਖਰੀ Flask ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਉਂਦੇ ਹਾਂ:

Main Web Server
    ↓ HTTP API calls
Search Service
    ↓ Valkey queries
Valkey Server

ਇਹ ਆਰਕੀਟੈਕਚਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ:

• ਸੁਤੰਤਰ ਸਕੇਲਿੰਗ: ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕੀਤੇ ਬਿਨਾਂ ਸਰਚ ਸਰਵਿਸ ਨੂੰ ਸਕੇਲ ਕਰੋ

• ਸਰੋਤ ਅਲੱਗਤਾ: ਸਰਚ ਓਪਰੇਸ਼ਨ ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕਰਦੇ

• ਕੈਚਿੰਗ: Valkey ਤੇਜ਼ ਦੁਹਰਾਈ ਗਈ ਕੁਵਰੀਆਂ ਲਈ ਨਤੀਜੇ ਕੈਸ਼ ਕਰਦੀ ਹੈ

• ਉੱਚ ਉਪਲਬਧਤਾ: ਸਰਚ ਸਰਵਿਸ ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕੀਤੇ ਬਿਨਾਂ ਰੀਸਟਾਰਟ ਹੋ ਸਕਦੀ ਹੈ

ਸਰਚ ਸਰਵਿਸ ਕੰਪੋਨੈਂਟ

1. ਫਿਲਟਰ ਐਕਸਟ੍ਰੈਕਸ਼ਨ API

• ਐਂਡਪੋਇੰਟ: /api/extract_filters

• ਉਦੇਸ਼: ਕੁਦਰਤੀ ਭਾਸ਼ਾ ਦੀਆਂ ਕੁਵਰੀਆਂ ਤੋਂ ਸੰਗਠਿਤ ਫਿਲਟਰ ਕੱਢੋ

• ਉਦਾਹਰਣ:

GET /api/extract_filters?q=mini+pc+16gb+ram

Response:
{
  "Form Factor": "Mini PC",
  "Main Memory": "16"
}

ਲਾਗੂਕਰਨ:

• ਵਾਕਾਂਸ਼-ਤੋਂ-ਫਿਲਟਰ ਮੈਪਿੰਗਾਂ ਨੂੰ Valkey ਜਾਂ JSON ਤੋਂ ਲੋਡ ਕਰੋ

• ਵਰਡ ਬਾਉਂਡਰੀ regex ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਾਕਾਂਸ਼ਾਂ ਦਾ ਮੇਲ ਕਰੋ

• ਸੰਗਠਿਤ ਫਿਲਟਰ ਵਾਪਸ ਕਰੋ

ਕੈਚਿੰਗ: ਵਾਕਾਂਸ਼ ਮੈਪਿੰਗਾਂ Valkey ਵਿੱਚ ਕੈਸ਼ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ (30-ਦਿਨ TTL)

2. ਸੰਬੰਧਿਤ ਖੋਜਾਂ API

• ਐਂਡਪੋਇੰਟ: /api/related

• ਉਦੇਸ਼: ਵੈਕਟਰ ਖੋਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਰਥਾਤਮਕ ਤੌਰ 'ਤੇ ਸਮਾਨ ਕੁਵਰੀਆਂ ਲੱਭੋ

• ਉਦਾਹਰਣ:

POST /api/related
{
  "query": "mini pc",
  "limit": 10
}

Response:
{
  "related": [
    {"query": "small computer", "similarity": 0.92},
    {"query": "compact desktop", "similarity": 0.89},
    {"query": "mini pc 8gb", "similarity": 0.87}
  ]
}

ਲਾਗੂਕਰਨ:

• all-mpnet-base-v2 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੁਵਰੀ ਨੂੰ ਐਮਬੈਡ ਕਰੋ

• ਨੇੜਲੇ ਗੁਆਂਢੀਆਂ ਲਈ Valkey RediSearch ਨੂੰ ਕੁਵਰੀ ਕਰੋ

• ਸਮਾਨਤਾ ਦੇ ਅਨੁਸਾਰ ਕ੍ਰਮਬੱਧ ਚੋਟੀ ਦੇ N ਨਤੀਜੇ ਵਾਪਸ ਕਰੋ

ਕੈਚਿੰਗ: ਨਤੀਜੇ Valkey ਵਿੱਚ ਕੈਸ਼ ਕੀਤੇ ਜਾਂਦੇ ਹਨ (7-ਦਿਨ TTL)

3. ਆਟੋਕੰਪਲੀਟ API

• ਐਂਡਪੋਇੰਟ: /api/autocomplete

• ਉਦੇਸ਼: ਉਪਭੋਗਤਾ ਦੇ ਟਾਈਪ ਕਰਦੇ ਸਮੇਂ ਕੁਵਰੀਆਂ ਸੁਝਾਓ

• ਉਦਾਹਰਣ:

GET /api/autocomplete?q=mini+p&limit=5

Response:
{
  "suggestions": [
    "mini pc",
    "mini pc 16gb",
    "mini pc 8gb ram",
    "mini pc fanless",
    "mini pc windows 11"
  ]
}

ਲਾਗੂਕਰਨ:

• ਪ੍ਰੀਫਿਕਸ ਮੈਚਿੰਗ ਨਾਲ Valkey RediSearch ਨੂੰ ਕੁਵਰੀ ਕਰੋ

• ਪ੍ਰਸਿੱਧੀ ਦੁਆਰਾ ਰੈਂਕ ਕਰੋ (ਇੰਪ੍ਰੈਸ਼ਨ + ਕਲਿੱਕ ਸਕੋਰ)

• ਚੋਟੀ ਦੇ N ਸੁਝਾਅ ਵਾਪਸ ਕਰੋ

ਕੈਚਿੰਗ: Valkey ਵਿੱਚ ਆਟੋਕੰਪਲੀਟ ਇੰਡੈਕਸ (ਰੋਜ਼ਾਨਾ ਅੱਪਡੇਟ ਹੁੰਦਾ ਹੈ)

4. ਪ੍ਰਸਿੱਧ ਕੁਵਰੀਆਂ API

• ਐਂਡਪੋਇੰਟ: /api/popular

• ਉਦੇਸ਼: ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਕੁਵਰੀਆਂ ਪ੍ਰਾਪਤ ਕਰੋ

• ਉਦਾਹਰਣ:

GET /api/popular?limit=10

Response:
{
  "queries": [
    "mini pc",
    "thin client",
    "industrial pc",
    "all in one pc"
  ]
}

ਲਾਗੂਕਰਨ:

• ਕੁਵਰੀਆਂ ਨੂੰ Valkey ਜਾਂ JSON ਤੋਂ ਲੋਡ ਕਰੋ

• ਟ੍ਰੈਫਿਕ ਸਕੋਰ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕਰੋ (ਇੰਪ੍ਰੈਸ਼ਨ + ਕਲਿੱਕ)

• ਚੋਟੀ ਦੀਆਂ N ਕੁਵਰੀਆਂ ਵਾਪਸ ਕਰੋ

ਕੈਚਿੰਗ: ਪ੍ਰਸਿੱਧ ਕੁਵਰੀਆਂ Valkey ਵਿੱਚ ਕੈਸ਼ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ (30-ਦਿਨ TTL)

Valkey ਏਕੀਕਰਣ

Valkey ਇੱਕ Redis ਫੋਰਕ ਹੈ ਜੋ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ:

• ਵੈਕਟਰ ਖੋਜ: ਸਮਾਨਤਾ ਖੋਜ ਲਈ RediSearch ਮੋਡੀਊਲ

• ਕੈਚਿੰਗ: ਤੇਜ਼ ਇਨ-ਮੈਮੋਰੀ ਕੀ-ਵੈਲਯੂ ਸਟੋਰ

• ਆਟੋਕੰਪਲੀਟ: ਸਾਰਟ ਕੀਤੇ ਸੈੱਟਾਂ ਨਾਲ ਪ੍ਰੀਫਿਕਸ ਮੈਚਿੰਗ

• ਪਰਸਿਸਟੈਂਸ: ਟਿਕਾਊਤਾ ਲਈ AOF (ਐਪੈਂਡ-ਓਨਲੀ ਫਾਈਲ)

RediSearch ਨਾਲ ਵੈਕਟਰ ਖੋਜ

ਅਸੀਂ ਵੈਕਟਰ ਸਮਾਨਤਾ ਖੋਜ ਲਈ Valkey ਦਾ RediSearch ਮੋਡੀਊਲ ਵਰਤਦੇ ਹਾਂ:

ਇੰਡੈਕਸ ਬਣਾਉਣਾ:

client.ft("queries_idx").create_index([
    VectorField("embedding", "FLAT", {
        "TYPE": "FLOAT32",
        "DIM": 768,
        "DISTANCE_METRIC": "COSINE"
    }),
    TextField("query"),
    NumericField("score")
])

ਵੈਕਟਰ ਖੋਜ:

query_embedding = model.encode(query)
results = client.ft("queries_idx").search(
    Query("*=>[KNN 10 @embedding $vec AS score]")
    .sort_by("score")
    .return_fields("query", "score")
    .dialect(2),
    query_params={"vec": query_embedding.tobytes()}
)

ਇਹ ਕੋਸਾਈਨ ਸਮਾਨਤਾ ਦੁਆਰਾ 10 ਸਭ ਤੋਂ ਨੇੜਲੇ ਗੁਆਂਢੀਆਂ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਕੈਚਿੰਗ ਰਣਨੀਤੀ

ਅਸੀਂ Valkey ਵਿੱਚ ਕਈ ਡੇਟਾ ਕਿਸਮਾਂ ਨੂੰ ਕੈਸ਼ ਕਰਦੇ ਹਾਂ:

ਵਾਕਾਂਸ਼ ਮੈਪਿੰਗਾਂ (30-ਦਿਨ TTL):

client.setex(
    "seo:phrase_mappings",
    30 * 24 * 3600,
    json.dumps(phrase_mappings)
)

ਸੰਬੰਧਿਤ ਖੋਜਾਂ (7-ਦਿਨ TTL):

cache_key = f"related:{query_hash}"
client.setex(cache_key, 7 * 24 * 3600, json.dumps(results))

ਪ੍ਰਸਿੱਧ ਕੁਵਰੀਆਂ (30-ਦਿਨ TTL):

client.setex(
    "seo:popular_queries",
    30 * 24 * 3600,
    json.dumps(popular_queries)
)

ਆਟੋਕੰਪਲੀਟ ਇੰਡੈਕਸ (ਰੋਜ਼ਾਨਾ ਅੱਪਡੇਟ):

for query, score in queries:
    client.zadd("autocomplete:mini", {query: score})

ਸਾਰਟ ਕੀਤੇ ਸੈੱਟਾਂ ਨਾਲ ਆਟੋਕੰਪਲੀਟ

ਅਸੀਂ ਆਟੋਕੰਪਲੀਟ ਲਈ Valkey ਦੇ ਸਾਰਟ ਕੀਤੇ ਸੈੱਟ ਵਰਤਦੇ ਹਾਂ:

ਇੰਡੈਕਸ ਬਣਤਰ:

autocomplete:m     → ["mini pc": 5000, "mini computer": 3000]
autocomplete:mi    → ["mini pc": 5000, "mini computer": 3000]
autocomplete:min   → ["mini pc": 5000, "mini computer": 3000]
autocomplete:mini  → ["mini pc": 5000, "mini computer": 3000]

ਪ੍ਰੀਫਿਕਸ ਲੁੱਕਅੱਪ:

prefix = "mini"
results = client.zrevrange(f"autocomplete:{prefix}", 0, 9, withscores=True)

ਇਹ "mini" ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੀਆਂ ਚੋਟੀ ਦੀਆਂ 10 ਕੁਵਰੀਆਂ ਨੂੰ ਸਕੋਰ ਦੇ ਅਨੁਸਾਰ ਕ੍ਰਮਬੱਧ ਕਰਕੇ ਵਾਪਸ ਕਰਦਾ ਹੈ।

API ਸੰਚਾਰ

ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ HTTP ਰਾਹੀਂ ਸਰਚ ਸਰਵਿਸ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ:

ਫਿਲਟਰ ਐਕਸਟ੍ਰੈਕਸ਼ਨ

from app.shared.filter_service import extract_filters_from_query

filters = extract_filters_from_query("mini pc 16gb ram")
# Internally calls: GET SEARCH_SERVICE_URL/api/extract_filters?q=...

ਸੰਬੰਧਿਤ ਖੋਜਾਂ

import requests

response = requests.post(
    "SEARCH_SERVICE_URL/api/related",
    json={"query": "mini pc", "limit": 10},
    timeout=2
)
related = response.json()["related"]

ਆਟੋਕੰਪਲੀਟ

response = requests.get(
    "SEARCH_SERVICE_URL/api/autocomplete",
    params={"q": "mini p", "limit": 5},
    timeout=1
)
suggestions = response.json()["suggestions"]

ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਅਤੇ ਫਾਲਬੈਕ

ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਸਰਚ ਸਰਵਿਸ ਦੀਆਂ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ:

try:
    filters = extract_filters_from_query(query)
except Exception as e:
    logger.error(f"Search service failed: {e}")
    filters = {}  # Fallback to empty filters

ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਰਚ ਸਰਵਿਸ ਬੰਦ ਹੋਣ 'ਤੇ ਵੀ ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਕੰਮ ਕਰਦਾ ਰਹੇ।

### ਨੈੱਟਵਰਕ ਸੰਰਚਨਾ

ਸਾਰੇ ਸਰਵਰ ਇੱਕ ਨਿੱਜੀ ਨੈੱਟਵਰਕ ਉੱਤੇ ਹਨ:

- **ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ**: ਸਰਚ ਸਰਵਿਸ ਅਤੇ Valkey ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦਾ ਹੈ

- **ਸਰਚ ਸਰਵਿਸ**: Valkey ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੀ ਹੈ

- **Valkey**: ਸਿਰਫ ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਅਤੇ ਸਰਚ ਸਰਵਿਸ ਤੋਂ ਪਹੁੰਚਯੋਗ

ਸਰਚ ਸਰਵਿਸ ਜਾਂ Valkey ਤੱਕ ਕੋਈ ਬਾਹਰੀ ਪਹੁੰਚ ਨਹੀਂ ਹੈ।

## SEO ਪਾਈਪਲਾਈਨ ਨਾਲ ਏਕੀਕਰਣ

ਸਰਚ ਸਰਵਿਸ SEO ਪਾਈਪਲਾਈਨ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਹੁੰਦੀ ਹੈ:

### ਪੜਾਅ 11: Valkey ਵਿੱਚ ਮਾਈਗਰੇਟ ਕਰੋ

SEO ਪਾਈਪਲਾਈਨ Valkey ਵਿੱਚ ਡੇਟਾ ਲੋਡ ਕਰਦੀ ਹੈ:

```python
# Load query embeddings
for query, embedding in zip(queries, embeddings):
    client.hset(f"query:{query_hash}", mapping={
        "query": query,
        "embedding": embedding.tobytes(),
        "score": score
    })

# Create RediSearch index
client.ft("queries_idx").create_index([...])

ਵੇਰਵਿਆਂ ਲਈ Valkey ਮਾਈਗਰੇਸ਼ਨ ਦੇਖੋ।

ਕੁਵਰੀ ਲੌਗਿੰਗ

ਸਰਚ ਸਰਵਿਸ SEO ਪਾਈਪਲਾਈਨ ਲਈ ਕੁਵਰੀਆਂ ਲੌਗ ਕਰਦੀ ਹੈ:

log_entry = {
    "timestamp": datetime.now(timezone.utc).isoformat(),
    "query": query,
    "filters_extracted": filters,
    "results_count": len(results)
}
with open(SEO_LIVE_QUERIES_LOG, "a") as f:
    f.write(json.dumps(log_entry) + "\n")

ਇਹ ਲੌਗ ਪੜਾਅ 1d: ਲਾਈਵ ਕੁਵਰੀਆਂ ਲਿਆਓ ਵਿੱਚ ਵਾਪਸ ਜਾਂਦੇ ਹਨ।

ਹਵਾਲੇ

ਤਕਨੀਕੀ ਸੰਕਲਪ

• Valkey - ਅਧਿਕਾਰਤ ਵੈੱਬਸਾਈਟ

• Redis - ਅਧਿਕਾਰਤ ਵੈੱਬਸਾਈਟ (Valkey ਫੋਰਕ)

• RediSearch - ਵੈਕਟਰ ਖੋਜ ਮੋਡੀਊਲ

• Cosine Similarity - ਵਿਕੀਪੀਡੀਆ

ਸੰਬੰਧਿਤ ਲੇਖ

• ਫਿਲਟਰ ਐਕਸਟ੍ਰੈਕਸ਼ਨ - ਫਿਲਟਰ ਕਿਵੇਂ ਕੱਢੇ ਜਾਂਦੇ ਹਨ

• ਸੰਬੰਧਿਤ ਖੋਜ ਜਨਰੇਸ਼ਨ - ਸੰਬੰਧਿਤ ਖੋਜਾਂ ਕਿਵੇਂ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ

• ਐਮਬੈਡਿੰਗ ਰਣਨੀਤੀ - ਐਮਬੈਡਿੰਗਜ਼ ਕਿਵੇਂ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ

• SEO ਪਾਈਪਲਾਈਨ ਸੰਖੇਪ - ਸੰਪੂਰਨ ਪਾਈਪਲਾਈਨ ਆਰਕੀਟੈਕਚਰ

• Valkey ਮਾਈਗਰੇਸ਼ਨ - Valkey ਵਿੱਚ ਡੇਟਾ ਲੋਡ ਕਰਨਾ

ਸਾਰਾਂਸ਼

ਸਾਡੀ ਸਰਚ ਸਰਵਿਸ ਇੱਕ ਵੱਖਰੇ ਸਰਵਰ ਉੱਤੇ ਇੱਕ ਸਟੈਂਡਅਲੋਨ Flask ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਰੂਪ ਵਿੱਚ ਚੱਲਦੀ ਹੈ:

ਆਰਕੀਟੈਕਚਰ:

• ਸਮਰਪਿਤ ਸਰਵਰ ਉੱਤੇ ਸਟੈਂਡਅਲੋਨ Flask ਐਪ

• ਕੈਚਿੰਗ ਅਤੇ ਵੈਕਟਰ ਖੋਜ ਲਈ Valkey (Redis ਫੋਰਕ)

• ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਨਾਲ ਸੰਚਾਰ ਲਈ HTTP API

API:

• /api/extract_filters - ਕੁਵਰੀਆਂ ਤੋਂ ਫਿਲਟਰ ਕੱਢੋ

• /api/related - ਸਮਾਨ ਕੁਵਰੀਆਂ ਲੱਭੋ (ਵੈਕਟਰ ਖੋਜ)

• /api/autocomplete - ਕੁਵਰੀਆਂ ਸੁਝਾਓ (ਪ੍ਰੀਫਿਕਸ ਮੈਚਿੰਗ)

• /api/popular - ਪ੍ਰਸਿੱਧ ਕੁਵਰੀਆਂ ਪ੍ਰਾਪਤ ਕਰੋ

Valkey ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ:

• ਵੈਕਟਰ ਖੋਜ (RediSearch ਮੋਡੀਊਲ)

• ਕੈਚਿੰਗ (ਵਾਕਾਂਸ਼ ਮੈਪਿੰਗਾਂ ਲਈ 30-ਦਿਨ TTL)

• ਆਟੋਕੰਪਲੀਟ (ਸਾਰਟ ਕੀਤੇ ਸੈੱਟ)

• ਪਰਸਿਸਟੈਂਸ (AOF)

ਲਾਭ:

• ਸੁਤੰਤਰ ਸਕੇਲਿੰਗ

• ਸਰੋਤ ਅਲੱਗਤਾ

• ਉੱਚ ਪ੍ਰਦਰਸ਼ਨ (Valkey ਕੈਚਿੰਗ)

• ਨੁਕਸ ਸਹਿਣਸ਼ੀਲਤਾ (ਸਹੀ ਗਿਰਾਵਟ)

ਇਹ ਆਰਕੀਟੈਕਚਰ ਮੁੱਖ ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਜਵਾਬਦੇਹ ਰੱਖਦੇ ਹੋਏ ਤੇਜ਼, ਸਕੇਲੇਬਲ ਖੋਜ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।

← ਦਸਤਾਵੇਜ਼ ਇੰਡੈਕਸ ਵਾਪਸ