Merge GitHub repo and resolve conflicts

- Resolved merge conflicts by keeping local Hugging Face versions
- Local changes include test files and updated requirements

.python-version

@@ -0,0 +1,2 @@
+3.11.0
+

BACKEND_INTEGRATION.md

@@ -0,0 +1,278 @@
+# Интеграция Embedding Service с Go Backend
+
+## Адрес сервиса
+
+```
+https://calcifer0323-matching.hf.space
+```
+
+## Endpoints
+
+| Метод | Путь | Описание |
+|-------|------|----------|
+| GET | `/` | Информация о сервисе |
+| GET | `/health` | Проверка здоровья |
+| GET | `/model-info` | Информация о модели (размерность для pgvector) |
+| POST | `/embed` | Эмбеддинг из готового текста |
+| POST | `/prepare-and-embed` | ⭐ **ОСНОВНОЙ** - подготовка полей + эмбеддинг |
+| POST | `/batch` | Пакетная обработка |
+
+## Архитектура
+
+```
+Frontend → Go Backend → PostgreSQL + pgvector
+                ↓
+         Embedding Service (STATELESS)
+         (только генерирует эмбеддинги, не хранит)
+```
+
+---
+
+## Шаг 1: Настройка PostgreSQL + pgvector
+
+```sql
+-- Установить расширение
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Добавить колонку в leads (384 измерения)
+ALTER TABLE leads ADD COLUMN IF NOT EXISTS embedding vector(384);
+
+-- Добавить колонку в properties
+ALTER TABLE properties ADD COLUMN IF NOT EXISTS embedding vector(384);
+
+-- Создать индексы для быстрого поиска
+CREATE INDEX IF NOT EXISTS leads_embedding_idx 
+ON leads USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
+
+CREATE INDEX IF NOT EXISTS properties_embedding_idx 
+ON properties USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
+```
+
+---
+
+## Шаг 2: Интеграция в Go Backend
+
+### 2.1 HTTP клиент
+
+```go
+package embedding
+
+import (
+    "bytes"
+    "encoding/json"
+    "fmt"
+    "net/http"
+    "time"
+)
+
+const ServiceURL = "https://calcifer0323-matching.hf.space"
+
+type Client struct {
+    http *http.Client
+}
+
+func NewClient() *Client {
+    return &Client{
+        http: &http.Client{Timeout: 30 * time.Second},
+    }
+}
+
+// Request для /prepare-and-embed
+type PrepareAndEmbedRequest struct {
+    Title       string                 `json:"title,omitempty"`
+    Description string                 `json:"description,omitempty"`
+    Requirement map[string]interface{} `json:"requirement,omitempty"`
+    Price       *float64               `json:"price,omitempty"`
+    District    *string                `json:"district,omitempty"`
+    Rooms       *int                   `json:"rooms,omitempty"`
+    Area        *float64               `json:"area,omitempty"`
+    Address     *string                `json:"address,omitempty"`
+}
+
+// Response от /prepare-and-embed
+type PrepareAndEmbedResponse struct {
+    Embedding    []float32 `json:"embedding"`
+    Dimensions   int       `json:"dimensions"`
+    PreparedText string    `json:"prepared_text"`
+}
+
+// GetEmbedding - получить эмбеддинг для лида или объекта
+func (c *Client) GetEmbedding(req PrepareAndEmbedRequest) ([]float32, error) {
+    body, _ := json.Marshal(req)
+    
+    resp, err := c.http.Post(
+        ServiceURL+"/prepare-and-embed",
+        "application/json",
+        bytes.NewBuffer(body),
+    )
+    if err != nil {
+        return nil, fmt.Errorf("request failed: %w", err)
+    }
+    defer resp.Body.Close()
+
+    if resp.StatusCode != 200 {
+        return nil, fmt.Errorf("service returned %d", resp.StatusCode)
+    }
+
+    var result PrepareAndEmbedResponse
+    json.NewDecoder(resp.Body).Decode(&result)
+    
+    return result.Embedding, nil
+}
+```
+
+### 2.2 Работа с pgvector
+
+```go
+import "github.com/pgvector/pgvector-go"
+
+// Сохранение эмбеддинга
+func (r *LeadRepo) SaveEmbedding(ctx context.Context, leadID string, embedding []float32) error {
+    vec := pgvector.NewVector(embedding)
+    _, err := r.db.Exec(ctx,
+        `UPDATE leads SET embedding = $1 WHERE lead_id = $2`,
+        vec, leadID,
+    )
+    return err
+}
+
+// Поиск похожих объектов
+func (r *PropertyRepo) FindSimilar(ctx context.Context, leadEmbedding []float32, limit int) ([]Match, error) {
+    vec := pgvector.NewVector(leadEmbedding)
+    
+    rows, err := r.db.Query(ctx, `
+        SELECT property_id, title, price, district, rooms, area,
+               1 - (embedding <=> $1) as similarity
+        FROM properties
+        WHERE embedding IS NOT NULL
+        ORDER BY embedding <=> $1
+        LIMIT $2
+    `, vec, limit)
+    // ... обработка результатов
+}
+```
+
+---
+
+## Шаг 3: Флоу создания лида
+
+```go
+func (s *LeadService) CreateLead(ctx context.Context, req CreateLeadRequest) (*Lead, error) {
+    // 1. Сохранить лид в БД
+    lead, err := s.repo.Create(ctx, req)
+    if err != nil {
+        return nil, err
+    }
+
+    // 2. Получить эмбеддинг (можно асинхронно)
+    go func() {
+        embedding, err := s.embeddingClient.GetEmbedding(PrepareAndEmbedRequest{
+            Title:       lead.Title,
+            Description: lead.Description,
+            Price:       extractPrice(lead.Requirement),
+            District:    extractDistrict(lead.Requirement),
+            Rooms:       extractRooms(lead.Requirement),
+        })
+        if err != nil {
+            log.Printf("embedding failed for %s: %v", lead.ID, err)
+            return
+        }
+        s.repo.SaveEmbedding(context.Background(), lead.ID, embedding)
+    }()
+
+    return lead, nil
+}
+```
+
+---
+
+## Шаг 4: Эндпоинт матчинга
+
+```go
+// GET /leads/{id}/matches?limit=10
+func (h *Handler) GetMatches(w http.ResponseWriter, r *http.Request) {
+    leadID := chi.URLParam(r, "id")
+    limit := parseIntParam(r, "limit", 10)
+
+    // Получить эмбеддинг лида
+    leadEmbedding, err := h.leadRepo.GetEmbedding(r.Context(), leadID)
+    if err != nil {
+        respondError(w, "Lead has no embedding", 400)
+        return
+    }
+
+    // Найти похожие объекты
+    matches, err := h.propertyRepo.FindSimilar(r.Context(), leadEmbedding, limit)
+    if err != nil {
+        respondError(w, err.Error(), 500)
+        return
+    }
+
+    respondJSON(w, MatchesResponse{
+        LeadID:  leadID,
+        Matches: matches,
+    })
+}
+```
+
+---
+
+## API Response для Frontend
+
+```json
+GET /api/leads/{leadId}/matches
+
+{
+    "leadId": "550e8400-e29b-41d4-a716-446655440000",
+    "matches": [
+        {
+            "propertyId": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
+            "title": "3-комнатная квартира в центре",
+            "price": 9500000,
+            "district": "Центральный",
+            "rooms": 3,
+            "area": 78.5,
+            "similarity": 0.92
+        }
+    ]
+}
+```
+
+---
+
+## Зависимости Go
+
+```bash
+go get github.com/pgvector/pgvector-go
+```
+
+---
+
+## Проверка работоспособности
+
+```bash
+# Health check
+curl https://calcifer0323-matching.hf.space/health
+
+# Тест эмбеддинга
+curl -X POST https://calcifer0323-matching.hf.space/prepare-and-embed \
+  -H "Content-Type: application/json" \
+  -d '{"title": "Ищу квартиру", "price": 10000000, "rooms": 3}'
+
+# Информация о модели
+curl https://calcifer0323-matching.hf.space/model-info
+```
+
+---
+
+## FAQ
+
+**Q: Что если Embedding Service недоступен?**  
+A: Лид сохранится без эмбеддинга. Добавьте retry-логику или фоновую задачу.
+
+**Q: Как переиндексировать все записи?**  
+A: Используйте `/batch` endpoint для массовой обработки.
+
+**Q: Нужно ли хранить prepared_text?**  
+A: Нет, только для отладки. Храните только `embedding`.
+

build.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+echo "Build completed successfully!"
+
+python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')"
+echo "Pre-downloading embedding model to reduce cold start time..."
+
+pip install --no-cache-dir -r requirements.txt
+cd embedding-service
+echo "Installing Python dependencies..."
+
+# Render build script
+

embedding-service/Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Устанавливаем переменные окружения для оптимизации
+ENV PYTHONUNBUFFERED=1
+ENV TRANSFORMERS_CACHE=/tmp/transformers_cache
+ENV SENTENCE_TRANSFORMERS_HOME=/tmp/sentence_transformers
+ENV PIP_NO_CACHE_DIR=1
+
+# Install dependencies (используем production requirements)
+COPY requirements-prod.txt .
+RUN pip install --no-cache-dir -r requirements-prod.txt
+
+# Copy application
+COPY main.py .
+
+# Expose port
+EXPOSE 8082
+
+# Run with uvicorn (ограничиваем workers для экономии памяти)
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8082", "--workers", "1"]
+

embedding-service/main.py

@@ -0,0 +1,1133 @@
+"""
+Embedding Service - FastAPI сервис для генерации эмбеддингов текста.
+
+Используется для матчинга лидов с объектами недвижимости на основе семантической близости.
+"""
+
+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
+from pydantic import BaseModel, Field
+from sentence_transformers import SentenceTransformer
+import numpy as np
+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: 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()}")
+    yield
+    # Cleanup
+    model = None
+
+
+app = FastAPI(
+    title="Embedding Service",
+    description="Сервис для генерации эмбеддингов текста",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# CORS для локальной разработки
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# --- Pydantic Models ---
+
+class EmbedRequest(BaseModel):
+    """Запрос на генерацию эмбеддинга для одного текста."""
+    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
+    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 StoreStatsResponse(BaseModel):
+    """Статистика хранилища эмбеддингов."""
+    leads_count: int
+    properties_count: int
+    total_count: int
+
+
+# --- Bulk Index Models ---
+
+class BulkIndexItem(BaseModel):
+    """Один элемент для массовой индексации."""
+    entity_id: str = Field(..., description="ID объекта")
+    text: str = Field(..., min_length=1, description="Текст для генерации эмбеддинга")
+    metadata: Optional[Dict[str, Any]] = Field(default=None, description="Дополнительные данные")
+
+
+class BulkIndexRequest(BaseModel):
+    """Запрос на массовую индексацию."""
+    entity_type: str = Field(..., description="Тип сущности (leads, properties)")
+    items: List[BulkIndexItem] = Field(..., description="Список объектов для индексации")
+    clear_existing: bool = Field(default=False, description="Очистить существующие данные перед индексацией")
+
+
+class BulkIndexResult(BaseModel):
+    """Результат индексации одного элемента."""
+    entity_id: str
+    success: bool
+    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 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="Веса параметров")
+
+    # Фильтры
+    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")
+
+
+class WeightedMatchResult(BaseModel):
+    """Результат взвешенного матчинга с детализацией."""
+    entity_id: str
+    total_score: float = Field(..., description="Общий взвешенный score (0-1)")
+
+    # Детализация по компонентам
+    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)")
+
+    metadata: Optional[Dict[str, Any]] = None
+    match_explanation: Optional[str] = Field(default=None, description="Объяснение почему объект подходит")
+
+
+class WeightedMatchResponse(BaseModel):
+    """Ответ взвешенного матчинга."""
+    matches: List[WeightedMatchResult]
+    total_searched: int
+    filtered_out: int = Field(..., description="Отфильтровано жёсткими фильтрами")
+    weights_used: ParameterWeights
+
+
+# --- Endpoints ---
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Проверка здоровья сервиса."""
+    if model is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    return HealthResponse(
+        status="healthy",
+        model=MODEL_NAME,
+        dimensions=model.get_sentence_embedding_dimension()
+    )
+
+
+@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))
+
+
+@app.post("/match-text", response_model=MatchResponse)
+async def match_by_text(request: MatchTextRequest):
+    """
+    Поиск похожих объектов по тексту.
+
+    Генерирует эмбеддинг для текста и ищет похожие объекты.
+    """
+    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)}")
+
+
+@app.post("/register", response_model=RegisterResponse)
+async def register_embedding(request: RegisterEmbeddingRequest):
+    """
+    Регистрация объекта с автоматической генерацией эмбеддинга.
+
+    Используется для добавления лидов или объектов недвижимости в хранилище.
+    """
+    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
+    )
+
+
+@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
+    )
+
+
+@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
+    )
+
+
+@app.get("/store/{entity_type}")
+async def list_registered_entities(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"
+        )
+
+    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
+    {
+        "entity_type": "properties",
+        "items": [
+            {"entity_id": "prop-1", "text": "3-комнатная квартира в центре", "metadata": {"price": 10000000}},
+            {"entity_id": "prop-2", "text": "Студия у метро", "metadata": {"price": 5000000}}
+        ],
+        "clear_existing": false
+    }
+    ```
+    """
+    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"
+        )
+
+    # Очистка если нужно
+    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(
+        total=len(request.items),
+        indexed=indexed,
+        failed=failed,
+        results=results
+    )
+
+
+@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):
+    """
+    Взвешенный матчинг с настраиваемыми приоритетами параметров.
+
+    Позволяет задать:
+    - Веса для каждого параметра (цена, район, комнаты, площадь, семантика)
+    - Жёсткие фильтры (объекты не прошедшие - исключаются)
+    - Мягкие критерии (влияют на ранжирование)
+
+    Пример использования:
+    ```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
+    )
+
+
+@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}
+        }
+    }

embedding-service/requirements-prod.txt

@@ -0,0 +1,15 @@
+# Production requirements - оптимизировано для минимального потребления памяти
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+numpy>=1.24.0,<2.0.0
+pydantic==2.5.3
+python-dotenv==1.0.0
+
+# PyTorch CPU-only версия (значительно меньше памяти)
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch==2.1.2+cpu
+
+# Transformers совместимый с torch 2.1.2
+transformers==4.36.2
+sentence-transformers==2.2.2
+

embedding-service/requirements.txt

@@ -0,0 +1,10 @@
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+numpy>=1.24.0,<2.0.0
+pydantic>=2.5.0
+python-dotenv>=1.0.0
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch>=2.1.0,<2.2.0
+transformers>=4.36.0,<4.37.0
+sentence-transformers>=2.2.2
+

huggingface/.env.example

@@ -0,0 +1,6 @@
+# Environment variables for HuggingFace Space
+EMBEDDING_DIMENSIONS=384
+EMBEDDING_MODEL=sentence-transformers/paraphrase-multilingual-MiniLM-L6-v2
+
+# Не используются напрямую в HuggingFace, но могут быть настроены в Settings
+

huggingface/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

huggingface/.gitignore

@@ -0,0 +1,31 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+dist/
+*.egg-info/
+
+# Environment
+.env
+.env.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Cache
+.cache/
+*.log
+

huggingface/Dockerfile

@@ -0,0 +1,36 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# Dockerfile for HuggingFace Spaces
+
+FROM python:3.11-slim
+
+# Create user (required by HuggingFace)
+RUN useradd -m -u 1000 user
+USER user
+
+# Set PATH
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set working directory
+WORKDIR /app
+
+# Environment variables for optimization
+ENV PYTHONUNBUFFERED=1
+ENV TRANSFORMERS_CACHE=/home/user/.cache/transformers
+ENV SENTENCE_TRANSFORMERS_HOME=/home/user/.cache/sentence_transformers
+ENV HF_HOME=/home/user/.cache/huggingface
+ENV EMBEDDING_MODEL=sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2
+ENV EMBEDDING_DIMENSIONS=384
+
+# Copy requirements and install dependencies
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy application files
+COPY --chown=user main.py .
+
+# Expose port 7860 (HuggingFace Spaces standard)
+EXPOSE 7860
+
+# Start the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+

huggingface/README.md

@@ -0,0 +1,82 @@
+---
+title: Matching Embedding Service
+emoji: 🏠
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: mit
+app_port: 7860
+---
+
+# Matching Embedding Service
+
+Сервис для генерации эмбеддингов текста и семантического поиска объектов недвижимости.
+
+## Возможности
+
+- 🔢 Генерация эмбеддингов для русского и английского текста
+- 🔍 Семантический поиск и матчинг
+- 📊 In-memory хранилище векторов
+- 🚀 FastAPI с автоматической документацией
+- 🌐 CORS-ready для интеграции
+
+## API Документация
+
+После запуска доступна по адресам:
+- Swagger UI: `/docs`
+- ReDoc: `/redoc`
+
+## Модель
+
+Используется модель: `paraphrase-multilingual-MiniLM-L12-v2`
+- Поддержка 50+ языков (включая русский)
+- Размерность векторов: 384
+- 12 слоёв (лучшее качество чем L6-v2)
+- Оптимизирована для семантического поиска
+
+## Endpoints
+
+### Основные
+- `GET /health` - проверка работоспособности
+- `POST /embed` - генерация эмбеддинга для текста
+- `POST /embed-batch` - пакетная генерация эмбеддингов
+
+### Матчинг
+- `POST /match-text` - поиск похожих объектов по тексту
+- `POST /register` - регистрация объекта с эмбеддингом
+
+### Статистика
+- `GET /store/stats` - статистика хранилища
+
+## Использование
+
+```python
+import requests
+
+# Health check
+response = requests.get("https://calcifer0323-matching.hf.space/health")
+print(response.json())
+
+# Генерация эмбеддинга
+response = requests.post(
+    "https://calcifer0323-matching.hf.space/embed",
+    json={"text": "Уютная квартира в центре"}
+)
+embedding = response.json()["embedding"]
+```
+
+## Разработка
+
+Локальный запуск:
+```bash
+pip install -r requirements.txt
+uvicorn main:app --host 0.0.0.0 --port 7860
+```
+
+Docker:
+```bash
+docker build -t matching-service .
+docker run -p 7860:7860 matching-service
+```
+

huggingface/main.py

@@ -0,0 +1,386 @@
+"""
+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 fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Конфигурация
+MODEL_NAME = os.getenv("EMBEDDING_MODEL", "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
+EMBEDDING_DIMENSIONS = 384
+
+# Глобальная модель
+model: Optional[SentenceTransformer] = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Загрузка модели при старте."""
+    global model
+    print(f"Loading embedding model: {MODEL_NAME}")
+    model = SentenceTransformer(MODEL_NAME, device='cpu')
+    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. Dimensions: {model.get_sentence_embedding_dimension()}")
+    yield
+    model = None
+
+
+app = FastAPI(
+    title="Embedding Service",
+    description="Stateless сервис генерации эмбеддингов для матчинга недвижимости",
+    version="2.0.0",
+    lifespan=lifespan
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ============== Pydantic Models ==============
+
+class EmbedRequest(BaseModel):
+    """Запрос на генерацию эмбеддинга из готового текста."""
+    text: str = Field(..., min_length=1, description="Текст для эмбеддинга")
+
+
+class EmbedResponse(BaseModel):
+    """Ответ с эмбеддингом."""
+    embedding: List[float]
+    dimensions: int
+
+
+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 PrepareAndEmbedResponse(BaseModel):
+    """Ответ с эмбеддингом."""
+    embedding: List[float]
+    dimensions: int
+    prepared_text: str = Field(description="Подготовленный текст (для отладки)")
+
+
+class BatchItem(BaseModel):
+    """Один элемент для пакетной обработки."""
+    entity_id: str = Field(..., description="ID объекта")
+    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 BatchRequest(BaseModel):
+    """Запрос на пакетную обработку."""
+    items: List[BatchItem]
+
+
+class BatchResultItem(BaseModel):
+    """Результат для одного элемента."""
+    entity_id: str
+    embedding: List[float]
+    success: bool = True
+    error: Optional[str] = None
+
+
+class BatchResponse(BaseModel):
+    """Ответ на пакетную обработку."""
+    results: List[BatchResultItem]
+    dimensions: int
+    total: int
+    successful: int
+
+
+class HealthResponse(BaseModel):
+    """Ответ health check."""
+    status: str
+    model: str
+    dimensions: int
+
+
+# ============== 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 = []
+
+    if title:
+        parts.append(f"Название: {title}")
+    if description:
+        parts.append(f"Описание: {description}")
+
+    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)}")
+
+    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)}")
+
+    return ". ".join(parts)
+
+
+# ============== Endpoints ==============
+
+@app.get("/")
+async def root():
+    """Информация о сервисе."""
+    return {
+        "service": "Embedding Service",
+        "version": "2.0.0",
+        "type": "STATELESS",
+        "description": "Генерирует эмбеддинги. Хранение на стороне Go Backend + pgvector.",
+        "endpoints": {
+            "POST /embed": "Эмбеддинг из готового текста",
+            "POST /prepare-and-embed": "Подготовка полей + эмбеддинг (ОСНОВНОЙ)",
+            "POST /batch": "Пакетная обработка",
+            "GET /health": "Проверка здоровья",
+            "GET /model-info": "Информация о модели для pgvector"
+        },
+        "docs": "/docs"
+    }
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Проверка здоровья сервиса."""
+    if model is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    return HealthResponse(
+        status="healthy",
+        model=MODEL_NAME,
+        dimensions=model.get_sentence_embedding_dimension()
+    )
+
+
+@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")
+
+    embedding = model.encode(request.text, convert_to_numpy=True)
+    return EmbedResponse(
+        embedding=embedding.tolist(),
+        dimensions=len(embedding)
+    )
+
+
+@app.post("/prepare-and-embed", response_model=PrepareAndEmbedResponse)
+async def prepare_and_embed(request: PrepareAndEmbedRequest):
+    """
+    Подготовка текста из полей и генерация эмбеддинга.
+
+    ⭐ ОСНОВНОЙ ENDPOINT для интеграции с Go Backend.
+
+    Пример запроса:
+    ```json
+    {
+        "title": "Ищу квартиру в центре",
+        "description": "Для семьи с детьми",
+        "price": 10000000,
+        "district": "Центральный",
+        "rooms": 3
+    }
+    ```
+
+    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")
+
+    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")
+
+    embedding = model.encode(prepared, convert_to_numpy=True)
+
+    return PrepareAndEmbedResponse(
+        embedding=embedding.tolist(),
+        dimensions=len(embedding),
+        prepared_text=prepared
+    )
+
+
+@app.post("/batch", response_model=BatchResponse)
+async def batch_process(request: BatchRequest):
+    """
+    Пакетная обработка нескольких объектов.
+
+    Используйте для массовой индексации при первоначальной загрузке.
+
+    Пример:
+    ```json
+    {
+        "items": [
+            {"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")
+
+    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 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),
+        successful=successful
+    )
+
+
+@app.get("/model-info")
+async def get_model_info():
+    """
+    Информация о модели для настройки pgvector.
+
+    Используйте для создания колонки правильной размерности.
+    """
+    if model is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+
+    dims = model.get_sentence_embedding_dimension()
+
+    return {
+        "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()
+        }
+    }

huggingface/requirements.txt

@@ -0,0 +1,17 @@
+# Requirements for HuggingFace Space
+# Оптимизировано для стабильной работы
+
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+numpy>=1.24.0,<2.0.0
+pydantic==2.5.3
+python-dotenv==1.0.0
+
+# PyTorch - используем стандартную версию (HuggingFace имеет достаточно памяти)
+torch>=2.1.0,<2.2.0
+transformers==4.36.2
+
+# Sentence Transformers с совместимой версией huggingface_hub
+sentence-transformers==2.3.1
+huggingface_hub>=0.19.0,<0.20.0
+

render.yaml

@@ -0,0 +1,20 @@
+services:
+  - type: web
+    name: matching-embedding-service
+    runtime: python
+    region: frankfurt  # или oregon для США
+    plan: free  # бесплатный план, можно изменить на starter
+    rootDir: embedding-service
+    buildCommand: pip install --no-cache-dir -r requirements-prod.txt
+    startCommand: uvicorn main:app --host 0.0.0.0 --port $PORT --workers 1
+    healthCheckPath: /health
+    envVars:
+      - key: EMBEDDING_MODEL
+        value: sentence-transformers/paraphrase-multilingual-MiniLM-L6-v2
+      - key: EMBEDDING_DIMENSIONS
+        value: 384
+      - key: PYTHON_VERSION
+        value: 3.11.0
+      - key: TRANSFORMERS_CACHE
+        value: /tmp/transformers_cache
+

test-huggingface.ps1

@@ -0,0 +1,126 @@
+# Тест HuggingFace Space
+# Запустите после успешного деплоя
+
+$baseUrl = "https://calcifer0323-matching.hf.space"
+
+Write-Host "🧪 Тестирование HuggingFace Space: $baseUrl" -ForegroundColor Cyan
+Write-Host ""
+
+# Test 1: Health Check
+Write-Host "1️⃣ Health Check..." -ForegroundColor Yellow
+try {
+    $health = Invoke-RestMethod -Uri "$baseUrl/health" -Method Get
+    Write-Host "   ✅ Status: $($health.status)" -ForegroundColor Green
+    Write-Host "   ✅ Model: $($health.model)" -ForegroundColor Green
+    Write-Host "   ✅ Dimensions: $($health.embedding_dimensions)" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Error: $($_.Exception.Message)" -ForegroundColor Red
+    Write-Host "   💡 Space может еще собираться. Подождите 2-3 минуты." -ForegroundColor Yellow
+    exit
+}
+
+Write-Host ""
+
+# Test 2: Single Embedding
+Write-Host "2️⃣ Генерация одного эмбеддинга..." -ForegroundColor Yellow
+try {
+    $body = @{
+        text = "Современная трёхкомнатная квартира в центре Москвы"
+    } | ConvertTo-Json
+
+    $embedding = Invoke-RestMethod -Uri "$baseUrl/embed" -Method Post -Body $body -ContentType "application/json"
+    Write-Host "   ✅ Embedding dimensions: $($embedding.dimensions)" -ForegroundColor Green
+    Write-Host "   ✅ Vector length: $($embedding.embedding.Count)" -ForegroundColor Green
+    Write-Host "   ✅ First 5 values: $($embedding.embedding[0..4] -join ', ')" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Error: $($_.Exception.Message)" -ForegroundColor Red
+}
+
+Write-Host ""
+
+# Test 3: Batch Embeddings
+Write-Host "3️⃣ Пакетная генерация эмбеддингов..." -ForegroundColor Yellow
+try {
+    $body = @{
+        texts = @(
+            "Студия 30 кв.м, ремонт, метро рядом",
+            "2-комнатная квартира, 65 кв.м, Арбат",
+            "Пентхаус с панорамным видом"
+        )
+    } | ConvertTo-Json
+
+    $batch = Invoke-RestMethod -Uri "$baseUrl/embed-batch" -Method Post -Body $body -ContentType "application/json"
+    Write-Host "   ✅ Embeddings count: $($batch.embeddings.Count)" -ForegroundColor Green
+    Write-Host "   ✅ Dimensions: $($batch.dimensions)" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Error: $($_.Exception.Message)" -ForegroundColor Red
+}
+
+Write-Host ""
+
+# Test 4: Register Property
+Write-Host "4️⃣ Регистрация объекта недвижимости..." -ForegroundColor Yellow
+try {
+    $body = @{
+        entity_type = "properties"
+        entity_id = "test-prop-001"
+        text = "Просторная 3-комнатная квартира 85 кв.м, современный ремонт, район Арбат"
+        metadata = @{
+            price = 25000000
+            rooms = 3
+            area = 85
+            location = "Арбат"
+        }
+    } | ConvertTo-Json -Depth 3
+
+    $register = Invoke-RestMethod -Uri "$baseUrl/register" -Method Post -Body $body -ContentType "application/json"
+    Write-Host "   ✅ Registered: $($register.entity_id)" -ForegroundColor Green
+    Write-Host "   ✅ Type: $($register.entity_type)" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Error: $($_.Exception.Message)" -ForegroundColor Red
+}
+
+Write-Host ""
+
+# Test 5: Search Similar
+Write-Host "5️⃣ Поиск похожих объектов..." -ForegroundColor Yellow
+try {
+    $body = @{
+        entity_type = "properties"
+        query_text = "Хочу купить просторную квартиру в центре Москвы"
+        top_k = 5
+        min_similarity = 0.0
+    } | ConvertTo-Json
+
+    $matches = Invoke-RestMethod -Uri "$baseUrl/match-text" -Method Post -Body $body -ContentType "application/json"
+    Write-Host "   ✅ Matches found: $($matches.matches.Count)" -ForegroundColor Green
+    if ($matches.matches.Count -gt 0) {
+        Write-Host "   ✅ Top match ID: $($matches.matches[0].entity_id)" -ForegroundColor Green
+        Write-Host "   ✅ Similarity: $([math]::Round($matches.matches[0].similarity, 4))" -ForegroundColor Green
+    }
+} catch {
+    Write-Host "   ❌ Error: $($_.Exception.Message)" -ForegroundColor Red
+}
+
+Write-Host ""
+
+# Test 6: Stats
+Write-Host "6️⃣ Статистика хранилища..." -ForegroundColor Yellow
+try {
+    $stats = Invoke-RestMethod -Uri "$baseUrl/store/stats" -Method Get
+    Write-Host "   ✅ Total entities: $($stats.total_entities)" -ForegroundColor Green
+    Write-Host "   ✅ Properties: $($stats.by_type.properties)" -ForegroundColor Green
+    Write-Host "   ✅ Model: $($stats.model)" -ForegroundColor Green
+} catch {
+    Write-Host "   ❌ Error: $($_.Exception.Message)" -ForegroundColor Red
+}
+
+Write-Host ""
+Write-Host "=" * 60 -ForegroundColor Cyan
+Write-Host "🎉 Все тесты заверше��ы!" -ForegroundColor Green
+Write-Host ""
+Write-Host "📚 Swagger UI: $baseUrl/docs" -ForegroundColor Cyan
+Write-Host "📖 ReDoc: $baseUrl/redoc" -ForegroundColor Cyan
+Write-Host "🏠 Space: https://huggingface.co/spaces/Calcifer0323/matching" -ForegroundColor Cyan
+Write-Host ""
+