personal-consumption-service/app/routes/vector_store/routes.py

# @description: 
# @author: licanglong
# @date: 2025/11/20 14:22
import uuid
from typing import List

from qdrant_client.models import VectorParams, Distance, PointStruct

from app.routes.vector_store import vector_store_router
from app.client.VectorStoreClient import vector_store_client
from app.constants.vector_store import VectorStoreCollection
from app.models.Result import SysResult
from app.models.dto import RiskRuleList, RiskDecisionCaseList, IndustryProfileList, RiskSignalList


@vector_store_router.put('/risk/rule')
async def put_risk_rule(data: dict):
    risk_rules = RiskRuleList(risk_rules=data).risk_rules
    collection_name = VectorStoreCollection.RULE_EMBED_STORE
    await vector_store_client.create_collection(
        collection_name=collection_name,
        vectors_config=VectorParams(
            size=1792,
            distance=Distance.COSINE,
        ),
    )

    points: List[PointStruct] = []

    for item in risk_rules:
        vector = vector_store_client.embedding.encode(item.embedding_text)
        point_id = str(uuid.uuid4())
        item.rule_id = point_id
        points.append(
            PointStruct(
                id=point_id,
                vector=vector.tolist(),
                payload=item.dict(),
            )
        )

    await vector_store_client.client.upsert(
        collection_name=collection_name,
        points=points,
    )
    return SysResult.success()


@vector_store_router.put('/risk/case')
async def put_case_rule(data: dict):
    decision_cases = RiskDecisionCaseList(decision_cases=data).decision_cases
    collection_name = VectorStoreCollection.CASE_EMBED_STORE
    await vector_store_client.create_collection(
        collection_name=collection_name,
        vectors_config=VectorParams(
            size=1792,
            distance=Distance.COSINE,
        ),
    )

    points: List[PointStruct] = []

    for item in decision_cases:
        vector = vector_store_client.embedding.encode(item.embedding_text)
        point_id = str(uuid.uuid4())
        item.case_id = point_id
        points.append(
            PointStruct(
                id=point_id,
                vector=vector.tolist(),
                payload=item.dict(),
            )
        )
    await vector_store_client.client.upsert(
        collection_name=collection_name,
        points=points,
    )
    return SysResult.success()


@vector_store_router.put('/risk/industry')
async def put_industry_rule(data: dict):
    industry_profiles = IndustryProfileList(industry_profiles=data).industry_profiles
    collection_name = VectorStoreCollection.MERCHANTS_EMBED_STORE
    await vector_store_client.create_collection(
        collection_name=collection_name,
        vectors_config=VectorParams(
            size=1792,
            distance=Distance.COSINE,
        ),
    )

    points: List[PointStruct] = []

    for item in industry_profiles:
        vector = vector_store_client.embedding.encode(item.embedding_text)
        point_id = str(uuid.uuid4())
        item.merchant_industry_id = point_id
        points.append(
            PointStruct(
                id=point_id,
                vector=vector.tolist(),
                payload=item.dict(),
            )
        )

    await vector_store_client.client.upsert(
        collection_name=collection_name,
        points=points,
    )
    return SysResult.success()


@vector_store_router.put('/risk/signal')
async def put_signal_rule(data: dict):
    signals = RiskSignalList(signals=data).signals
    collection_name = VectorStoreCollection.RULE_EMBED_STORE
    await vector_store_client.create_collection(
        collection_name=collection_name,
        vectors_config=VectorParams(
            size=1792,
            distance=Distance.COSINE,
        ),
    )

    points: List[PointStruct] = []

    for item in signals:
        vector = vector_store_client.embedding.encode(item.embedding_text)
        point_id = str(uuid.uuid4())
        item.signal_id = point_id
        points.append(
            PointStruct(
                id=point_id,
                vector=vector.tolist(),
                payload=item.dict(),
            )
        )

    await vector_store_client.client.upsert(
        collection_name=collection_name,
        points=points,
    )
    return SysResult.success()


@vector_store_router.get('/risk/rule')
async def get_risk_rule(data: dict):
    vector = vector_store_client.embedding.encode(data.get('query', ""))
    query_response = await vector_store_client.client.query_points(
        collection_name=VectorStoreCollection.RULE_EMBED_STORE,
        query=vector.tolist(),
        limit=5,
        score_threshold=0.5
    )
    rules = []
    for point in query_response.points:
        rules.append({
            "id": point.id,
            "score": point.score,
            "payload": point.payload,
        })
    return SysResult.success(data=rules)