સર્ચ સર્વિસ આર્કિટેક્ચર: સ્ટેન્ડઅલોન Flask એપ્લિકેશન Valkey સાથે

આ લેખ સમજાવે છે કે કેવી રીતે અમારી સર્ચ સર્વિસ એક અલગ સર્વર પર સ્ટેન્ડઅલોન Flask એપ્લિકેશન તરીકે ચાલે છે, જે ઉચ્ચ-પ્રદર્શન વેક્ટર સર્ચ, કેશિંગ અને ઓટોકમ્પ્લીટ માટે Valkey (Redis ફોર્ક) નો ઉપયોગ કરે છે.

સમસ્યા: સર્ચ કામગીરી અને સ્કેલેબિલિટી

સર્ચ ઓપરેશન્સ ગણતરીની દૃષ્ટિએ ખર્ચાળ છે:

• ફિલ્ટર એક્સટ્રેક્શન: દરેક ક્વેરી સામે 2,500+ શબ્દસમૂહો મેચ કરો

• સંબંધિત શોધો: 65K ક્વેરીઓ વચ્ચે સમાનતાની ગણતરી કરો

• ઓટોકમ્પ્લીટ: 65K ક્વેરીઓ પર પ્રિફિક્સ મેચિંગ

• ઉત્પાદન ફિલ્ટરિંગ: બહુવિધ માપદંડો દ્વારા 5K+ ઉત્પાદનો ફિલ્ટર કરો

આ ઓપરેશન્સ મુખ્ય વેબ સર્વર પર ચલાવવાથી થાય છે:

• ધીમા પેજ લોડ: સર્ચ અન્ય વિનંતીઓને અવરોધે છે

• મેમરી દબાણ: એમ્બેડિંગ્સ ખૂબ મોટી મેમરી ફૂટપ્રિન્ટ માટે જવાબદાર છે

• CPU સ્પર્ધા: સમાનતાની ગણતરી CPU-સઘન છે

• સ્કેલિંગ મુશ્કેલી: સર્ચને સ્વતંત્ર રીતે સ્કેલ કરી શકાતું નથી

અમને એક સમર્પિત સર્ચ સર્વિસની જરૂર છે જે સ્વતંત્ર રીતે સ્કેલ કરી શકે.

ઉપાય: સ્ટેન્ડઅલોન સર્ચ સર્વિસ

અમે એક સમર્પિત સર્વર trên અલગ 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 માંથી phrase-to-filter mappings લોડ કરો

• વર્ડ બાઉન્ડ્રી 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()}
)

આ cosine સમાનતા દ્વારા 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 માં ડેટા લોડ કરે છે:

# 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 કેશિંગ)

• ફોલ્ટ ટોલરન્સ (ગ્રેસફુલ ડિગ્રેડેશન)

આ આર્કિટેક્ચર મુખ્ય વેબ સર્વરને પ્રતિભાવશીલ રાખીને ઝડપી, સ્કેલેબલ સર્ચ સક્ષમ બનાવે છે.

---

← દસ્તાવેજીકરણ ઇન્ડેક્સ પર પાછા જાઓ