Simplify to stateless service - remove storage, keep only embedding generation

main.py

@@ -1,13 +1,22 @@
 """
 Embedding Service - FastAPI сервис для генерации эмбеддингов текста.
 
-Используется для матчинга лидов с объектами недвижимости на основе семантической близости.
+STATELESS сервис - не хранит данные, только генерирует эмбеддинги.
+Хранение эмбеддингов происходит на стороне бэкенда в PostgreSQL + pgvector.
+
+Используется для матчинга лидов с объектами недвижимости.
+
+Endpoints:
+  - POST /embed              - генерация эмбеддинга из текста
+  - POST /prepare-and-embed  - подготовка полей + эмбеддинг (ОСНОВНОЙ)
+  - POST /batch              - пакетная обработка
+  - GET  /health             - проверка здоровья
+  - GET  /model-info         - информация о модели
 """
 
 import os
 from typing import List, Optional, Dict, Any
 from contextlib import asynccontextmanager
-from uuid import uuid4
 
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
@@ -19,47 +28,36 @@ from dotenv import load_dotenv
 load_dotenv()
 
 # Конфигурация
-MODEL_NAME = os.getenv("EMBEDDING_MODEL", "sentence-transformers/paraphrase-multilingual-MiniLM-L6-v2")
-EMBEDDING_DIMENSIONS = int(os.getenv("EMBEDDING_DIMENSIONS", "384"))
+MODEL_NAME = os.getenv("EMBEDDING_MODEL", "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
+EMBEDDING_DIMENSIONS = 384
 
-# Глобальная модель (загружается при старте)
+# Глобальная модель
 model: Optional[SentenceTransformer] = None
 
-# In-memory хранилище эмбеддингов (для прототипа, в продакшене используется pgvector)
-# Структура: {entity_type: {entity_id: {"embedding": [...], "metadata": {...}}}}
-embedding_store: Dict[str, Dict[str, Dict[str, Any]]] = {
-    "leads": {},
-    "properties": {}
-}
-
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Загрузка модели при старте приложения."""
+    """Загрузка модели при старте."""
     global model
     print(f"Loading embedding model: {MODEL_NAME}")
-    # Оптимизация для минимального потребления памяти
     model = SentenceTransformer(MODEL_NAME, device='cpu')
-    # Используем half precision для экономии памяти (если доступно)
     try:
         model.half()
         print("Model converted to half precision (float16)")
     except Exception as e:
         print(f"Could not convert to half precision: {e}")
-    print(f"Model loaded successfully. Embedding dimensions: {model.get_sentence_embedding_dimension()}")
+    print(f"Model loaded. Dimensions: {model.get_sentence_embedding_dimension()}")
     yield
-    # Cleanup
     model = None
 
 
 app = FastAPI(
     title="Embedding Service",
-    description="Сервис для генерации эмбеддингов текста",
-    version="1.0.0",
+    description="Stateless сервис генерации эмбеддингов для матчинга недвижимости",
+    version="2.0.0",
     lifespan=lifespan
 )
 
-# CORS для локальной разработки
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -69,265 +67,144 @@ app.add_middleware(
 )
 
 
-# --- Pydantic Models ---
+# ============== Pydantic Models ==============
 
 class EmbedRequest(BaseModel):
-    """Запрос на генерацию эмбеддинга для одного текста."""
-    text: str = Field(..., min_length=1, description="Текст для генерации эмбеддинга")
+    """Запрос на генерацию эмбеддинга из готового текста."""
+    text: str = Field(..., min_length=1, description="Текст для эмбеддинга")
 
 
 class EmbedResponse(BaseModel):
     """Ответ с эмбеддингом."""
-    embedding: List[float] = Field(..., description="Векторное представление текста")
-    model: str = Field(..., description="Название используемой модели")
-    dimensions: int = Field(..., description="Размерность вектора")
-
-
-class EmbedBatchRequest(BaseModel):
-    """Запрос на пакетную генерацию эмбеддингов."""
-    texts: List[str] = Field(..., min_length=1, description="Список текстов")
-
-
-class EmbedBatchResponse(BaseModel):
-    """Ответ с пакетными эмбеддингами."""
-    embeddings: List[List[float]] = Field(..., description="Список векторных представлений")
-    model: str = Field(..., description="Название исп��льзуемой модели")
-    dimensions: int = Field(..., description="Размерность векторов")
-
-
-class SimilarityRequest(BaseModel):
-    """Запрос на вычисление косинусной близости."""
-    embedding1: List[float] = Field(..., description="Первый эмбеддинг")
-    embedding2: List[float] = Field(..., description="Второй эмбеддинг")
-
-
-class SimilarityResponse(BaseModel):
-    """Ответ с косинусной близостью."""
-    similarity: float = Field(..., description="Косинусная близость от -1 до 1")
-
-
-class HealthResponse(BaseModel):
-    """Ответ на health check."""
-    status: str
-    model: str
+    embedding: List[float]
     dimensions: int
 
 
-# --- Match Models ---
-
-class MatchRequest(BaseModel):
-    """Запрос на поиск похожих объектов по эмбеддингу."""
-    embedding: List[float] = Field(..., description="Эмбеддинг для поиска")
-    entity_type: str = Field(default="properties", description="Тип сущности для поиска (leads, properties)")
-    top_k: int = Field(default=5, ge=1, le=100, description="Количество результатов")
-    min_similarity: float = Field(default=0.0, ge=-1.0, le=1.0, description="Минимальный порог схожести")
-
-
-class MatchTextRequest(BaseModel):
-    """Запрос на поиск похожих объектов по тексту."""
-    text: str = Field(..., min_length=1, description="Текст для поиска")
-    entity_type: str = Field(default="properties", description="Тип сущности для поиска (leads, properties)")
-    top_k: int = Field(default=5, ge=1, le=100, description="Количество результатов")
-    min_similarity: float = Field(default=0.0, ge=-1.0, le=1.0, description="Минимальный порог схожести")
-
-
-class MatchResult(BaseModel):
-    """Результат матчинга."""
-    entity_id: str = Field(..., description="ID найденного объекта")
-    similarity: float = Field(..., description="Косинусная близость (0-1)")
-    metadata: Optional[Dict[str, Any]] = Field(default=None, description="Дополнительные данные объекта")
-
-
-class MatchResponse(BaseModel):
-    """Ответ с результатами матчинга."""
-    matches: List[MatchResult] = Field(..., description="Найденные объекты")
-    total_searched: int = Field(..., description="Количество проверенных объектов")
-
-
-class RegisterEmbeddingRequest(BaseModel):
-    """Запрос на регистрацию эмбеддинга объекта."""
-    entity_id: str = Field(..., description="ID объекта")
-    entity_type: str = Field(..., description="Тип сущности (leads, properties)")
-    text: str = Field(..., min_length=1, description="Текст для генерации эмбеддинга")
-    metadata: Optional[Dict[str, Any]] = Field(default=None, description="Дополнительные данные объекта")
-
-
-class RegisterEmbeddingFromVectorRequest(BaseModel):
-    """Запрос на регистрацию готового эмбеддинга."""
-    entity_id: str = Field(..., description="ID объекта")
-    entity_type: str = Field(..., description="Тип сущности (leads, properties)")
-    embedding: List[float] = Field(..., description="Готовый эмбеддинг")
-    metadata: Optional[Dict[str, Any]] = Field(default=None, description="Дополнительные данные объекта")
-
-
-class RegisterResponse(BaseModel):
-    """Ответ на регистрацию эмбеддинга."""
-    success: bool
-    entity_id: str
-    entity_type: str
-
-
-class DeleteEmbeddingRequest(BaseModel):
-    """Запрос на удаление эмбеддинга."""
-    entity_id: str = Field(..., description="ID объекта")
-    entity_type: str = Field(..., description="Тип сущности (leads, properties)")
+class PrepareAndEmbedRequest(BaseModel):
+    """
+    Запрос на подготовку текста из полей и генерацию эмбеддинга.
 
+    Это ОСНОВНОЙ endpoint для интеграции с Go Backend.
+    """
+    title: str = Field(default="", description="Название")
+    description: str = Field(default="", description="Описание")
+    requirement: Optional[Dict[str, Any]] = Field(default=None, description="Требования (JSON)")
+    price: Optional[float] = Field(default=None, description="Цена")
+    district: Optional[str] = Field(default=None, description="Район")
+    rooms: Optional[int] = Field(default=None, description="Количество комнат")
+    area: Optional[float] = Field(default=None, description="Площадь")
+    address: Optional[str] = Field(default=None, description="Адрес")
 
-class StoreStatsResponse(BaseModel):
-    """Статистика хранилища эмбеддингов."""
-    leads_count: int
-    properties_count: int
-    total_count: int
 
+class PrepareAndEmbedResponse(BaseModel):
+    """Ответ с эмбеддингом."""
+    embedding: List[float]
+    dimensions: int
+    prepared_text: str = Field(description="Подготовленный текст (для отладки)")
 
-# --- Bulk Index Models ---
 
-class BulkIndexItem(BaseModel):
-    """Один элемент для массовой индексации."""
+class BatchItem(BaseModel):
+    """Один элемент для пакетной обработки."""
     entity_id: str = Field(..., description="ID объекта")
-    text: str = Field(..., min_length=1, description="Текст для генерации эмбеддинга")
-    metadata: Optional[Dict[str, Any]] = Field(default=None, description="Дополнительные данные")
+    title: str = Field(default="")
+    description: str = Field(default="")
+    requirement: Optional[Dict[str, Any]] = None
+    price: Optional[float] = None
+    district: Optional[str] = None
+    rooms: Optional[int] = None
+    area: Optional[float] = None
+    address: Optional[str] = None
 
 
-class BulkIndexRequest(BaseModel):
-    """Запрос на массовую индексацию."""
-    entity_type: str = Field(..., description="Тип сущности (leads, properties)")
-    items: List[BulkIndexItem] = Field(..., description="Список объектов для индексации")
-    clear_existing: bool = Field(default=False, description="Очистить существующие данные перед индексацией")
+class BatchRequest(BaseModel):
+    """Запрос на пакетную обработку."""
+    items: List[BatchItem]
 
 
-class BulkIndexResult(BaseModel):
-    """Результат индексации одного элемента."""
+class BatchResultItem(BaseModel):
+    """Результат для одного элемента."""
     entity_id: str
-    success: bool
+    embedding: List[float]
+    success: bool = True
     error: Optional[str] = None
 
 
-class BulkIndexResponse(BaseModel):
-    """Ответ на массовую индексацию."""
-    total: int = Field(..., description="Всего элементов в запросе")
-    indexed: int = Field(..., description="Успешно проиндексировано")
-    failed: int = Field(..., description="Ошибок")
-    results: List[BulkIndexResult] = Field(..., description="Детали по каждому элементу")
-
-
-class ReindexFromDBRequest(BaseModel):
-    """Запрос на переиндексацию из внешнего источника (вызывается Go Backend)."""
-    entity_type: str = Field(..., description="Тип сущности (leads, properties)")
-    db_url: Optional[str] = Field(default=None, description="URL базы данных (опционально)")
-
-
-# --- Weighted Matching Models ---
-
-class ParameterWeights(BaseModel):
-    """Веса для различных параметров матчинга."""
-    price: float = Field(default=0.30, ge=0.0, le=1.0, description="Вес цены (по умолчанию 0.30)")
-    district: float = Field(default=0.25, ge=0.0, le=1.0, description="Вес района (по умолчанию 0.25)")
-    rooms: float = Field(default=0.20, ge=0.0, le=1.0, description="Вес количества комнат (по умолчанию 0.20)")
-    area: float = Field(default=0.10, ge=0.0, le=1.0, description="Вес площади (по умолчанию 0.10)")
-    semantic: float = Field(default=0.15, ge=0.0, le=1.0, description="Вес семантической близости (по умолчанию 0.15)")
-
-
-class PriceFilter(BaseModel):
-    """Фильтр по цене."""
-    min_price: Optional[float] = Field(default=None, description="Минимальная цена")
-    max_price: Optional[float] = Field(default=None, description="Максимальная цена")
-    tolerance_percent: float = Field(default=10.0, description="Допустимое отклонение в % (для мягкого фильтра)")
-
-
-class HardFilters(BaseModel):
-    """Жёсткие фильтры (объекты не прошедшие фильтр исключаются)."""
-    price: Optional[PriceFilter] = Field(default=None, description="Фильтр по цене")
-    districts: Optional[List[str]] = Field(default=None, description="Список допустимых районов")
-    rooms: Optional[List[int]] = Field(default=None, description="Список допустимого кол-ва комнат")
-    min_area: Optional[float] = Field(default=None, description="Минимальная площадь")
-    max_area: Optional[float] = Field(default=None, description="Максимальная площадь")
-
-
-class SoftCriteria(BaseModel):
-    """Мягкие критерии для ранжирования (влияют на score, но не исключают)."""
-    target_price: Optional[float] = Field(default=None, description="Желаемая цена")
-    target_district: Optional[str] = Field(default=None, description="Предпочтительный район")
-    target_rooms: Optional[int] = Field(default=None, description="Желаемое кол-во комнат")
-    target_area: Optional[float] = Field(default=None, description="Желаемая площадь")
-    metro_distance_km: Optional[float] = Field(default=None, description="Желаемое расстояние до метро (км)")
-    preferred_districts: Optional[List[str]] = Field(default=None, description="Список предпочтительных районов")
-
+class BatchResponse(BaseModel):
+    """Ответ на пакетную обработку."""
+    results: List[BatchResultItem]
+    dimensions: int
+    total: int
+    successful: int
 
-class WeightedMatchRequest(BaseModel):
-    """Запрос на взвешенный матчинга с приоритетами."""
-    text: str = Field(..., min_length=1, description="Текст запроса (описание требований)")
-    entity_type: str = Field(default="properties", description="Тип сущности для поиска")
-    top_k: int = Field(default=10, ge=1, le=100, description="Количество результатов")
 
-    # Настройка весов
-    weights: Optional[ParameterWeights] = Field(default=None, description="Веса параметров")
+class HealthResponse(BaseModel):
+    """Ответ health check."""
+    status: str
+    model: str
+    dimensions: int
 
-    # Фильтры
-    hard_filters: Optional[HardFilters] = Field(default=None, description="Жёсткие фильтры")
-    soft_criteria: Optional[SoftCriteria] = Field(default=None, description="Мягкие критерии")
 
-    # Минимальный порог
-    min_total_score: float = Field(default=0.0, ge=0.0, le=1.0, description="Минимальный общий score")
+# ============== Helper Functions ==============
 
+def prepare_text(
+    title: str = "",
+    description: str = "",
+    requirement: Optional[Dict[str, Any]] = None,
+    price: Optional[float] = None,
+    district: Optional[str] = None,
+    rooms: Optional[int] = None,
+    area: Optional[float] = None,
+    address: Optional[str] = None
+) -> str:
+    """Объединяет поля в текст для эмбеддинга."""
+    parts = []
 
-class WeightedMatchResult(BaseModel):
-    """Результат взвешенного матчинга с детализацией."""
-    entity_id: str
-    total_score: float = Field(..., description="Общий взвешенный score (0-1)")
+    if title:
+        parts.append(f"Название: {title}")
+    if description:
+        parts.append(f"Описание: {description}")
 
-    # Детализация по компонентам
-    price_score: float = Field(default=0.0, description="Score по цене (0-1)")
-    district_score: float = Field(default=0.0, description="Score по району (0-1)")
-    rooms_score: float = Field(default=0.0, description="Score по комнатам (0-1)")
-    area_score: float = Field(default=0.0, description="Score по площади (0-1)")
-    semantic_score: float = Field(default=0.0, description="Семантический score (0-1)")
+    if requirement:
+        req_parts = [f"{k}: {v}" for k, v in requirement.items() if v is not None]
+        if req_parts:
+            parts.append(f"Требования: {', '.join(req_parts)}")
 
-    metadata: Optional[Dict[str, Any]] = None
-    match_explanation: Optional[str] = Field(default=None, description="Объяснение почему объект подходит")
+    params = []
+    if price is not None:
+        params.append(f"цена {price:,.0f}₽")
+    if district:
+        params.append(f"район {district}")
+    if rooms is not None:
+        params.append(f"{rooms}-комнатная")
+    if area is not None:
+        params.append(f"площадь {area}м²")
+    if address:
+        params.append(f"адрес: {address}")
 
+    if params:
+        parts.append(f"Параметры: {', '.join(params)}")
 
-class WeightedMatchResponse(BaseModel):
-    """Ответ взвешенного матчинга."""
-    matches: List[WeightedMatchResult]
-    total_searched: int
-    filtered_out: int = Field(..., description="Отфильтровано жёсткими фильтрами")
-    weights_used: ParameterWeights
+    return ". ".join(parts)
 
 
-# --- Endpoints ---
+# ============== Endpoints ==============
 
 @app.get("/")
 async def root():
-    """
-    Корневая страница API.
-
-    Показывает информацию о сервисе и ссылки на документацию.
-    """
+    """Информация о сервисе."""
     return {
-        "service": "Matching Embedding Service",
-        "version": "1.0.0",
-        "status": "running",
-        "model": MODEL_NAME,
-        "docs": "/docs",
-        "redoc": "/redoc",
-        "health": "/health",
+        "service": "Embedding Service",
+        "version": "2.0.0",
+        "type": "STATELESS",
+        "description": "Генерирует эмбеддинги. Хранение на стороне Go Backend + pgvector.",
         "endpoints": {
-            "embedding": {
-                "single": "POST /embed",
-                "batch": "POST /embed-batch"
-            },
-            "matching": {
-                "by_text": "POST /match-text",
-                "by_vector": "POST /match",
-                "weighted": "POST /match-weighted"
-            },
-            "management": {
-                "register": "POST /register",
-                "bulk_index": "POST /index/bulk",
-                "stats": "GET /store/stats"
-            }
-        }
+            "POST /embed": "Эмбеддинг из готового текста",
+            "POST /prepare-and-embed": "Подготовка полей + эмбеддинг (ОСНОВНОЙ)",
+            "POST /batch": "Пакетная обработка",
+            "GET /health": "Проверка здоровья",
+            "GET /model-info": "Информация о модели для pgvector"
+        },
+        "docs": "/docs"
     }
 
 
@@ -346,822 +223,164 @@ async def health_check():
 @app.post("/embed", response_model=EmbedResponse)
 async def embed_text(request: EmbedRequest):
     """
-    Генерация эмбеддинга для одного текста.
+    Генерация эмбеддинга из готового текста.
 
-    Используется для получения векторного представления лида или объекта недвижимости.
+    Используйте если текст уже подготовлен на стороне бэкенда.
     """
     if model is None:
         raise HTTPException(status_code=503, detail="Model not loaded")
 
-    try:
-        embedding = model.encode(request.text, convert_to_numpy=True)
-        return EmbedResponse(
-            embedding=embedding.tolist(),
-            model=MODEL_NAME,
-            dimensions=len(embedding)
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Embedding generation failed: {str(e)}")
-
-
-@app.post("/embed-batch", response_model=EmbedBatchResponse)
-async def embed_batch(request: EmbedBatchRequest):
-    """
-    Пакетная генерация эмбеддингов.
-
-    Эффективнее для обработки нескольких текстов за раз.
-    """
-    if model is None:
-        raise HTTPException(status_code=503, detail="Model not loaded")
-
-    try:
-        embeddings = model.encode(request.texts, convert_to_numpy=True)
-        return EmbedBatchResponse(
-            embeddings=[emb.tolist() for emb in embeddings],
-            model=MODEL_NAME,
-            dimensions=embeddings.shape[1] if len(embeddings.shape) > 1 else len(embeddings)
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Batch embedding generation failed: {str(e)}")
-
-
-@app.post("/similarity", response_model=SimilarityResponse)
-async def compute_similarity(request: SimilarityRequest):
-    """
-    Вычисление косинусной близости между двумя эмбеддингами.
-
-    Возвращает значение от -1 (противоположные) до 1 (идентичные).
-    """
-    if len(request.embedding1) != len(request.embedding2):
-        raise HTTPException(
-            status_code=400,
-            detail="Embeddings must have the same dimensions"
-        )
-
-    try:
-        vec1 = np.array(request.embedding1)
-        vec2 = np.array(request.embedding2)
-
-        # Косинусная близость
-        similarity = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
-
-        return SimilarityResponse(similarity=float(similarity))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Similarity computation failed: {str(e)}")
-
-
-@app.post("/prepare-text")
-async def prepare_text_for_embedding(
-    title: str = "",
-    description: str = "",
-    requirement: dict = None
-):
-    """
-    Подготовка текста для генерации эмбеддинга.
-
-    Объединяет title, description и requirement в один текст для эмбеддинга.
-    """
-    parts = []
-
-    if title:
-        parts.append(f"Название: {title}")
-
-    if description:
-        parts.append(f"Описание: {description}")
-
-    if requirement:
-        req_parts = []
-        for key, value in requirement.items():
-            req_parts.append(f"{key}: {value}")
-        if req_parts:
-            parts.append(f"Требования: {', '.join(req_parts)}")
-
-    combined_text = ". ".join(parts)
-
-    return {"prepared_text": combined_text}
-
-
-# --- Matching Endpoints ---
-
-def _cosine_similarity(vec1: np.ndarray, vec2: np.ndarray) -> float:
-    """Вычисление косинусной близости между двумя векторами."""
-    norm1 = np.linalg.norm(vec1)
-    norm2 = np.linalg.norm(vec2)
-    if norm1 == 0 or norm2 == 0:
-        return 0.0
-    return float(np.dot(vec1, vec2) / (norm1 * norm2))
-
-
-def _calculate_price_score(obj_price: Optional[float], target_price: Optional[float], tolerance_percent: float = 20.0) -> float:
-    """
-    Вычисление score по цене.
-
-    Если цена объекта в пределах допуска от целевой - высокий score.
-    Чем дальше - тем ниже score.
-    """
-    if obj_price is None or target_price is None:
-        return 0.5  # Нейтральный score если данных нет
-
-    if target_price == 0:
-        return 0.5
-
-    # Процентное отклонение
-    deviation_percent = abs(obj_price - target_price) / target_price * 100
-
-    if deviation_percent <= tolerance_percent:
-        # В пределах допуска - линейно от 1.0 до 0.7
-        return 1.0 - (deviation_percent / tolerance_percent) * 0.3
-    else:
-        # За пределами допуска - быстро падает
-        extra_deviation = deviation_percent - tolerance_percent
-        score = 0.7 - (extra_deviation / 100) * 0.7
-        return max(0.0, score)
-
-
-def _calculate_district_score(
-    obj_district: Optional[str],
-    target_district: Optional[str],
-    preferred_districts: Optional[List[str]] = None
-) -> float:
-    """
-    Вычисление score по району.
-
-    Точное совпадение = 1.0
-    В списке предпочтительных = 0.7
-    Иначе = 0.3
-    """
-    if obj_district is None:
-        return 0.3
-
-    obj_district_lower = obj_district.lower().strip()
-
-    # Точное совпадение с целевым
-    if target_district and obj_district_lower == target_district.lower().strip():
-        return 1.0
-
-    # Проверяем в списке предпочтительных
-    if preferred_districts:
-        for pref in preferred_districts:
-            if obj_district_lower == pref.lower().strip():
-                return 0.7
-            # Частичное совпадение (например "Центральный" в "Центральный район")
-            if pref.lower() in obj_district_lower or obj_district_lower in pref.lower():
-                return 0.6
-
-    return 0.3
-
-
-def _calculate_rooms_score(obj_rooms: Optional[int], target_rooms: Optional[int]) -> float:
-    """
-    Вычисление score по количеству комнат.
-
-    Точное совпадение = 1.0
-    ±1 комната = 0.6
-    ±2 комнаты = 0.3
-    Больше разницы = 0.1
-    """
-    if obj_rooms is None or target_rooms is None:
-        return 0.5
-
-    diff = abs(obj_rooms - target_rooms)
-
-    if diff == 0:
-        return 1.0
-    elif diff == 1:
-        return 0.6
-    elif diff == 2:
-        return 0.3
-    else:
-        return 0.1
-
-
-def _calculate_area_score(obj_area: Optional[float], target_area: Optional[float], tolerance_percent: float = 15.0) -> float:
-    """
-    Вычисление score по площади.
-
-    Аналогично цене, но с меньшим допуском.
-    """
-    if obj_area is None or target_area is None:
-        return 0.5
-
-    if target_area == 0:
-        return 0.5
-
-    deviation_percent = abs(obj_area - target_area) / target_area * 100
-
-    if deviation_percent <= tolerance_percent:
-        return 1.0 - (deviation_percent / tolerance_percent) * 0.3
-    else:
-        extra_deviation = deviation_percent - tolerance_percent
-        score = 0.7 - (extra_deviation / 50) * 0.7
-        return max(0.0, score)
-
-
-def _passes_hard_filters(metadata: Dict[str, Any], filters: Optional[HardFilters]) -> bool:
-    """Проверка прохождения жёстких фильтров."""
-    if filters is None:
-        return True
-
-    # Фильтр по цене
-    if filters.price:
-        obj_price = metadata.get("price")
-        if obj_price is not None:
-            if filters.price.min_price and obj_price < filters.price.min_price:
-                return False
-            if filters.price.max_price and obj_price > filters.price.max_price:
-                return False
-
-    # Фильтр по районам
-    if filters.districts:
-        obj_district = metadata.get("district", "").lower().strip()
-        allowed = [d.lower().strip() for d in filters.districts]
-        if obj_district and obj_district not in allowed:
-            # Проверяем частичное совпадение
-            if not any(a in obj_district or obj_district in a for a in allowed):
-                return False
-
-    # Фильтр по комнатам
-    if filters.rooms:
-        obj_rooms = metadata.get("rooms")
-        if obj_rooms is not None and obj_rooms not in filters.rooms:
-            return False
-
-    # Фильтр по площади
-    obj_area = metadata.get("area")
-    if obj_area is not None:
-        if filters.min_area and obj_area < filters.min_area:
-            return False
-        if filters.max_area and obj_area > filters.max_area:
-            return False
-
-    return True
-
-
-def _generate_match_explanation(
-    price_score: float,
-    district_score: float,
-    rooms_score: float,
-    area_score: float,
-    semantic_score: float,
-    metadata: Dict[str, Any]
-) -> str:
-    """Генерация человеко-читаемого объяснения матча."""
-    reasons = []
-
-    if price_score >= 0.7:
-        price = metadata.get("price")
-        if price:
-            reasons.append(f"цена {price:,.0f}₽ в бюджете")
-
-    if district_score >= 0.7:
-        district = metadata.get("district")
-        if district:
-            reasons.append(f"район '{district}' подходит")
-
-    if rooms_score >= 0.7:
-        rooms = metadata.get("rooms")
-        if rooms:
-            reasons.append(f"{rooms}-комн. как нужно")
-
-    if area_score >= 0.7:
-        area = metadata.get("area")
-        if area:
-            reasons.append(f"площадь {area}м² подходит")
-
-    if semantic_score >= 0.6:
-        reasons.append("описание похоже на запрос")
-
-    if not reasons:
-        return "Частичное совпадение по параметрам"
-
-    return "; ".join(reasons)
-
-
-@app.post("/match", response_model=MatchResponse)
-async def match_by_embedding(request: MatchRequest):
-    """
-    Поиск похожих объектов по эмбеддингу.
-
-    Возвращает top_k наиболее похожих объектов указанного типа.
-    """
-    if request.entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {request.entity_type}. Allowed: leads, properties"
-        )
-
-    store = embedding_store[request.entity_type]
-    if not store:
-        return MatchResponse(matches=[], total_searched=0)
-
-    query_vec = np.array(request.embedding)
-
-    # Вычисляем схожесть со всеми объектами
-    similarities = []
-    for entity_id, data in store.items():
-        stored_vec = np.array(data["embedding"])
-        similarity = _cosine_similarity(query_vec, stored_vec)
-        if similarity >= request.min_similarity:
-            similarities.append((entity_id, similarity, data.get("metadata")))
-
-    # Сортируем по убыванию схожести и берем top_k
-    similarities.sort(key=lambda x: x[1], reverse=True)
-    top_matches = similarities[:request.top_k]
-
-    matches = [
-        MatchResult(entity_id=eid, similarity=sim, metadata=meta)
-        for eid, sim, meta in top_matches
-    ]
-
-    return MatchResponse(matches=matches, total_searched=len(store))
-
+    embedding = model.encode(request.text, convert_to_numpy=True)
+    return EmbedResponse(
+        embedding=embedding.tolist(),
+        dimensions=len(embedding)
+    )
 
-@app.post("/match-text", response_model=MatchResponse)
-async def match_by_text(request: MatchTextRequest):
-    """
-    Поиск похожих объектов по тексту.
 
-    Генерирует эмбеддинг для текста и ищет похожие объекты.
+@app.post("/prepare-and-embed", response_model=PrepareAndEmbedResponse)
+async def prepare_and_embed(request: PrepareAndEmbedRequest):
     """
-    if model is None:
-        raise HTTPException(status_code=503, detail="Model not loaded")
-
-    if request.entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {request.entity_type}. Allowed: leads, properties"
-        )
-
-    store = embedding_store[request.entity_type]
-    if not store:
-        return MatchResponse(matches=[], total_searched=0)
-
-    try:
-        # Генерируем эмбеддинг для текста запроса
-        query_embedding = model.encode(request.text, convert_to_numpy=True)
-        query_vec = np.array(query_embedding)
-
-        # Вычисляем схожесть со всеми объектами
-        similarities = []
-        for entity_id, data in store.items():
-            stored_vec = np.array(data["embedding"])
-            similarity = _cosine_similarity(query_vec, stored_vec)
-            if similarity >= request.min_similarity:
-                similarities.append((entity_id, similarity, data.get("metadata")))
-
-        # Сортируем по убыванию схожести и берем top_k
-        similarities.sort(key=lambda x: x[1], reverse=True)
-        top_matches = similarities[:request.top_k]
-
-        matches = [
-            MatchResult(entity_id=eid, similarity=sim, metadata=meta)
-            for eid, sim, meta in top_matches
-        ]
+    Подготовка текста из полей и генерация эмбеддинга.
 
-        return MatchResponse(matches=matches, total_searched=len(store))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Match by text failed: {str(e)}")
+    ⭐ ОСНОВНОЙ ENDPOINT для интеграции с Go Backend.
 
+    Пример запроса:
+    ```json
+    {
+        "title": "Ищу квартиру в центре",
+        "description": "Для семьи с детьми",
+        "price": 10000000,
+        "district": "Центральный",
+        "rooms": 3
+    }
+    ```
 
-@app.post("/register", response_model=RegisterResponse)
-async def register_embedding(request: RegisterEmbeddingRequest):
-    """
-    Регистрация объекта с автоматической генерацией эмбеддинга.
-
-    Используется для добавления лидов или объектов недвижимости в хранилище.
+    Go Backend сохраняет embedding в PostgreSQL:
+    ```sql
+    UPDATE leads SET embedding = $1 WHERE lead_id = $2
+    ```
     """
     if model is None:
         raise HTTPException(status_code=503, detail="Model not loaded")
 
-    if request.entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {request.entity_type}. Allowed: leads, properties"
-        )
-
-    try:
-        # Генерируем эмбеддинг
-        embedding = model.encode(request.text, convert_to_numpy=True)
-
-        # Сохраняем в хранилище
-        embedding_store[request.entity_type][request.entity_id] = {
-            "embedding": embedding.tolist(),
-            "metadata": request.metadata or {}
-        }
-
-        return RegisterResponse(
-            success=True,
-            entity_id=request.entity_id,
-            entity_type=request.entity_type
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Register embedding failed: {str(e)}")
-
-
-@app.post("/register-vector", response_model=RegisterResponse)
-async def register_embedding_from_vector(request: RegisterEmbeddingFromVectorRequest):
-    """
-    Регистрация объекта с готовым эмбеддингом.
-
-    Используется когда эмбеддинг уже был сгенерирован ранее.
-    """
-    if request.entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {request.entity_type}. Allowed: leads, properties"
-        )
-
-    # Сохраняем в хранилище
-    embedding_store[request.entity_type][request.entity_id] = {
-        "embedding": request.embedding,
-        "metadata": request.metadata or {}
-    }
-
-    return RegisterResponse(
-        success=True,
-        entity_id=request.entity_id,
-        entity_type=request.entity_type
+    prepared = prepare_text(
+        title=request.title,
+        description=request.description,
+        requirement=request.requirement,
+        price=request.price,
+        district=request.district,
+        rooms=request.rooms,
+        area=request.area,
+        address=request.address
     )
 
+    if not prepared:
+        raise HTTPException(status_code=400, detail="All fields are empty")
 
-@app.delete("/register", response_model=RegisterResponse)
-async def delete_embedding(request: DeleteEmbeddingRequest):
-    """
-    Удаление эмбеддинга объекта из хранилища.
-    """
-    if request.entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {request.entity_type}. Allowed: leads, properties"
-        )
-
-    store = embedding_store[request.entity_type]
-    if request.entity_id not in store:
-        raise HTTPException(
-            status_code=404,
-            detail=f"Entity {request.entity_id} not found in {request.entity_type}"
-        )
-
-    del store[request.entity_id]
-
-    return RegisterResponse(
-        success=True,
-        entity_id=request.entity_id,
-        entity_type=request.entity_type
-    )
-
+    embedding = model.encode(prepared, convert_to_numpy=True)
 
-@app.get("/store/stats", response_model=StoreStatsResponse)
-async def get_store_stats():
-    """
-    Получение статистики хранилища эмбеддингов.
-    """
-    leads_count = len(embedding_store.get("leads", {}))
-    properties_count = len(embedding_store.get("properties", {}))
-
-    return StoreStatsResponse(
-        leads_count=leads_count,
-        properties_count=properties_count,
-        total_count=leads_count + properties_count
+    return PrepareAndEmbedResponse(
+        embedding=embedding.tolist(),
+        dimensions=len(embedding),
+        prepared_text=prepared
     )
 
 
-@app.get("/store/{entity_type}")
-async def list_registered_entities(entity_type: str):
+@app.post("/batch", response_model=BatchResponse)
+async def batch_process(request: BatchRequest):
     """
-    Список зарегистрированных объектов указанного типа.
-    """
-    if entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {entity_type}. Allowed: leads, properties"
-        )
-
-    store = embedding_store[entity_type]
-    entities = [
-        {
-            "entity_id": eid,
-            "metadata": data.get("metadata", {}),
-            "embedding_dimensions": len(data.get("embedding", []))
-        }
-        for eid, data in store.items()
-    ]
-
-    return {"entity_type": entity_type, "count": len(entities), "entities": entities}
-
+    Пакетная обработка нескольких объектов.
 
-# --- Bulk Indexing Endpoints ---
-
-@app.post("/index/bulk", response_model=BulkIndexResponse)
-async def bulk_index(request: BulkIndexRequest):
-    """
-    Массовая индексация объектов.
-
-    Позволяет за один запрос проиндексировать множество лидов или объектов.
-    Используется для первоначальной загрузки данных или переиндексации.
+    Используйте для массовой индексации при первоначальной загрузке.
 
     Пример:
-    ```
-    POST /index/bulk
+    ```json
     {
-        "entity_type": "properties",
         "items": [
-            {"entity_id": "prop-1", "text": "3-комнатная квартира в центре", "metadata": {"price": 10000000}},
-            {"entity_id": "prop-2", "text": "Студия у метро", "metadata": {"price": 5000000}}
-        ],
-        "clear_existing": false
+            {"entity_id": "lead-1", "title": "Ищу квартиру", "rooms": 3},
+            {"entity_id": "lead-2", "title": "Нужен офис", "area": 100}
+        ]
     }
     ```
     """
     if model is None:
         raise HTTPException(status_code=503, detail="Model not loaded")
 
-    if request.entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {request.entity_type}. Allowed: leads, properties"
+    results = []
+    texts = []
+    valid_items = []
+
+    # Подготовка текстов
+    for item in request.items:
+        prepared = prepare_text(
+            title=item.title,
+            description=item.description,
+            requirement=item.requirement,
+            price=item.price,
+            district=item.district,
+            rooms=item.rooms,
+            area=item.area,
+            address=item.address
         )
-
-    # Очистка если нужно
-    if request.clear_existing:
-        embedding_store[request.entity_type] = {}
-
-    results: List[BulkIndexResult] = []
-    indexed = 0
-    failed = 0
-
-    # Собираем все тексты для батчевой генерации эмбеддингов (быстрее)
-    texts = [item.text for item in request.items]
-
-    try:
-        # Генерируем все эмбеддинги за один вызов модели
-        embeddings = model.encode(texts, convert_to_numpy=True, show_progress_bar=True)
-
-        # Сохраняем каждый
-        for i, item in enumerate(request.items):
-            try:
-                embedding_store[request.entity_type][item.entity_id] = {
-                    "embedding": embeddings[i].tolist(),
-                    "metadata": item.metadata or {}
-                }
-                results.append(BulkIndexResult(entity_id=item.entity_id, success=True))
-                indexed += 1
-            except Exception as e:
-                results.append(BulkIndexResult(entity_id=item.entity_id, success=False, error=str(e)))
-                failed += 1
-    except Exception as e:
-        # Если батч не удался, пробуем по одному
-        for item in request.items:
-            try:
-                embedding = model.encode(item.text, convert_to_numpy=True)
-                embedding_store[request.entity_type][item.entity_id] = {
-                    "embedding": embedding.tolist(),
-                    "metadata": item.metadata or {}
-                }
-                results.append(BulkIndexResult(entity_id=item.entity_id, success=True))
-                indexed += 1
-            except Exception as item_error:
-                results.append(BulkIndexResult(entity_id=item.entity_id, success=False, error=str(item_error)))
-                failed += 1
-
-    return BulkIndexResponse(
+        if prepared:
+            texts.append(prepared)
+            valid_items.append(item)
+        else:
+            results.append(BatchResultItem(
+                entity_id=item.entity_id,
+                embedding=[],
+                success=False,
+                error="All fields are empty"
+            ))
+
+    # Генерация эмбеддингов батчем
+    if texts:
+        embeddings = model.encode(texts, convert_to_numpy=True)
+        for i, item in enumerate(valid_items):
+            results.append(BatchResultItem(
+                entity_id=item.entity_id,
+                embedding=embeddings[i].tolist(),
+                success=True
+            ))
+
+    # Сортировка по порядку входных items
+    results_map = {r.entity_id: r for r in results}
+    sorted_results = [results_map[item.entity_id] for item in request.items]
+    successful = sum(1 for r in sorted_results if r.success)
+
+    return BatchResponse(
+        results=sorted_results,
+        dimensions=EMBEDDING_DIMENSIONS,
         total=len(request.items),
-        indexed=indexed,
-        failed=failed,
-        results=results
+        successful=successful
     )
 
 
-@app.delete("/index/{entity_type}")
-async def clear_index(entity_type: str):
-    """
-    Очистка индекса для указанного типа сущностей.
-
-    Удаляет все эмбеддинги указанного типа.
-    """
-    if entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {entity_type}. Allowed: leads, properties"
-        )
-
-    count = len(embedding_store[entity_type])
-    embedding_store[entity_type] = {}
-
-    return {"message": f"Cleared {count} {entity_type} from index", "deleted_count": count}
-
-
-@app.post("/index/sync")
-async def sync_index_info():
-    """
-    Получение информации для синхронизации.
-
-    Возвращает список всех entity_id в индексе, чтобы Go Backend мог
-    определить какие объекты нужно добавить/удалить.
-    """
-    return {
-        "leads": list(embedding_store["leads"].keys()),
-        "properties": list(embedding_store["properties"].keys())
-    }
-
-
-# --- Weighted Matching Endpoint ---
-
-@app.post("/match-weighted", response_model=WeightedMatchResponse)
-async def match_weighted(request: WeightedMatchRequest):
+@app.get("/model-info")
+async def get_model_info():
     """
-    Взвешенный матчинг с настраиваемыми приоритетами параметров.
-
-    Позволяет задать:
-    - Веса для каждого параметра (цена, район, комнаты, площадь, семантика)
-    - Жёсткие фильтры (объекты не прошедшие - исключаются)
-    - Мягкие критерии (влияют на ранжирование)
+    Информация о модели для настройки pgvector.
 
-    Пример использования:
-    ```json
-    {
-        "text": "Ищу 2-комнатную квартиру в центре до 10 млн",
-        "entity_type": "properties",
-        "top_k": 10,
-        "weights": {
-            "price": 0.35,      // Цена - главный приоритет
-            "district": 0.30,   // Район - второй по важности
-            "rooms": 0.20,      // Комнаты
-            "area": 0.05,       // Площадь менее важна
-            "semantic": 0.10    // Семантика для "мягких" критериев
-        },
-        "hard_filters": {
-            "price": {"max_price": 12000000},
-            "districts": ["Центральный", "Арбат", "Тверской"]
-        },
-        "soft_criteria": {
-            "target_price": 10000000,
-            "target_rooms": 2,
-            "target_district": "Центральный"
-        }
-    }
-    ```
+    Используйте для создания колонки правильной размерности.
     """
     if model is None:
         raise HTTPException(status_code=503, detail="Model not loaded")
 
-    if request.entity_type not in embedding_store:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unknown entity type: {request.entity_type}. Allowed: leads, properties"
-        )
-
-    store = embedding_store[request.entity_type]
-    if not store:
-        return WeightedMatchResponse(
-            matches=[],
-            total_searched=0,
-            filtered_out=0,
-            weights_used=request.weights or ParameterWeights()
-        )
-
-    # Используем переданные веса или значения по умолчанию
-    weights = request.weights or ParameterWeights()
-
-    # Нормализуем веса чтобы сумма = 1
-    total_weight = weights.price + weights.district + weights.rooms + weights.area + weights.semantic
-    if total_weight > 0:
-        w_price = weights.price / total_weight
-        w_district = weights.district / total_weight
-        w_rooms = weights.rooms / total_weight
-        w_area = weights.area / total_weight
-        w_semantic = weights.semantic / total_weight
-    else:
-        w_price = w_district = w_rooms = w_area = w_semantic = 0.2
-
-    # Генерируем эмбеддинг для текста запроса
-    try:
-        query_embedding = model.encode(request.text, convert_to_numpy=True)
-        query_vec = np.array(query_embedding)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to generate embedding: {str(e)}")
-
-    # Извлекаем soft criteria
-    soft = request.soft_criteria or SoftCriteria()
-
-    results = []
-    filtered_out = 0
-
-    for entity_id, data in store.items():
-        metadata = data.get("metadata", {})
-
-        # 1. Проверяем жёсткие фильтры
-        if not _passes_hard_filters(metadata, request.hard_filters):
-            filtered_out += 1
-            continue
-
-        # 2. Вычисляем score по каждому параметру
-
-        # Цена
-        price_score = _calculate_price_score(
-            metadata.get("price"),
-            soft.target_price,
-            tolerance_percent=20.0
-        )
-
-        # Район
-        district_score = _calculate_district_score(
-            metadata.get("district"),
-            soft.target_district,
-            soft.preferred_districts
-        )
-
-        # Комнаты
-        rooms_score = _calculate_rooms_score(
-            metadata.get("rooms"),
-            soft.target_rooms
-        )
-
-        # Площадь
-        area_score = _calculate_area_score(
-            metadata.get("area"),
-            soft.target_area
-        )
-
-        # Семантика
-        stored_vec = np.array(data["embedding"])
-        semantic_score = _cosine_similarity(query_vec, stored_vec)
-        # Нормализуем в 0-1 (косинусная близость может быть отрицательной)
-        semantic_score = (semantic_score + 1) / 2
-
-        # 3. Вычисляем взвешенный total score
-        total_score = (
-            w_price * price_score +
-            w_district * district_score +
-            w_rooms * rooms_score +
-            w_area * area_score +
-            w_semantic * semantic_score
-        )
-
-        # Пропускаем если ниже минимального порога
-        if total_score < request.min_total_score:
-            continue
-
-        # Генерируем объяснение
-        explanation = _generate_match_explanation(
-            price_score, district_score, rooms_score, area_score, semantic_score, metadata
-        )
-
-        results.append(WeightedMatchResult(
-            entity_id=entity_id,
-            total_score=round(total_score, 4),
-            price_score=round(price_score, 4),
-            district_score=round(district_score, 4),
-            rooms_score=round(rooms_score, 4),
-            area_score=round(area_score, 4),
-            semantic_score=round(semantic_score, 4),
-            metadata=metadata,
-            match_explanation=explanation
-        ))
-
-    # Сортируем по total_score и берём top_k
-    results.sort(key=lambda x: x.total_score, reverse=True)
-    top_results = results[:request.top_k]
-
-    return WeightedMatchResponse(
-        matches=top_results,
-        total_searched=len(store),
-        filtered_out=filtered_out,
-        weights_used=weights
-    )
-
+    dims = model.get_sentence_embedding_dimension()
 
-@app.get("/weights/presets")
-async def get_weight_presets():
-    """
-    Получить предустановленные наборы весов для разных сценариев.
-
-    Помогает фронтенду предложить пользователю готовые настройки.
-    """
     return {
-        "balanced": {
-            "name": "Сбалансированный",
-            "description": "Равномерное распределение приоритетов",
-            "weights": {"price": 0.25, "district": 0.25, "rooms": 0.20, "area": 0.15, "semantic": 0.15}
-        },
-        "budget_first": {
-            "name": "Бюджет важнее всего",
-            "description": "Максимальный приоритет на соответствие бюджету",
-            "weights": {"price": 0.45, "district": 0.20, "rooms": 0.15, "area": 0.10, "semantic": 0.10}
-        },
-        "location_first": {
-            "name": "Локация важнее всего",
-            "description": "Район и расположение - главный приоритет",
-            "weights": {"price": 0.20, "district": 0.40, "rooms": 0.15, "area": 0.10, "semantic": 0.15}
-        },
-        "family": {
-            "name": "Для семьи",
-            "description": "Важны комнаты и площадь",
-            "weights": {"price": 0.20, "district": 0.20, "rooms": 0.30, "area": 0.20, "semantic": 0.10}
-        },
-        "semantic_heavy": {
-            "name": "Умный поиск",
-            "description": "Максимальный приоритет на семантическое понимание запроса",
-            "weights": {"price": 0.15, "district": 0.15, "rooms": 0.15, "area": 0.10, "semantic": 0.45}
+        "model_name": MODEL_NAME,
+        "dimensions": dims,
+        "sql_examples": {
+            "extension": "CREATE EXTENSION IF NOT EXISTS vector;",
+            "column": f"ALTER TABLE leads ADD COLUMN embedding vector({dims});",
+            "index": f"CREATE INDEX ON leads USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);",
+            "search": """
+SELECT property_id, title, 1 - (embedding <=> $1) as similarity
+FROM properties
+WHERE embedding IS NOT NULL
+ORDER BY embedding <=> $1
+LIMIT 10;
+            """.strip()
         }
     }