Upload 5 files

Dockerfile

@@ -0,0 +1,22 @@
+# Use an official Python runtime
+FROM python:3.10
+
+# Set the working directory
+WORKDIR /app
+
+# Copy requirements and install them
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the backend code
+COPY . .
+
+# Create the temp directory and give it permission to save images
+RUN mkdir -p temp_uploads
+RUN chmod -R 777 temp_uploads
+
+# Hugging Face requires apps to run on port 7860
+EXPOSE 7860
+
+# Start the FastAPI server
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,104 @@
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List
+from PIL import Image
+import os
+import shutil
+import uuid
+import re
+import inflect  # <-- NEW: Import inflect
+
+from src.models import AIModelManager
+from src.cloud_db import CloudDB
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+print("Loading AI Models and Cloud DB...")
+ai = AIModelManager()
+db = CloudDB()
+# Initialize the inflect engine
+p = inflect.engine() 
+print("Ready!")
+
+os.makedirs("temp_uploads", exist_ok=True)
+
+# --- NEW: Standardization Function ---
+def standardize_category_name(name: str) -> str:
+    """Converts ' Cows ', 'COWS', or 'cow' all into 'cow'."""
+    # 1. Lowercase and strip accidental edge spaces
+    clean_name = name.strip().lower()
+    
+    # 2. Replace inner spaces with underscores (e.g., 'sports cars' -> 'sports_cars')
+    clean_name = re.sub(r'\s+', '_', clean_name)
+    
+    # 3. Remove weird special characters just in case (keep only letters, numbers, underscores)
+    clean_name = re.sub(r'[^\w\s]', '', clean_name)
+    
+    # 4. Convert plural to singular (if it's already singular, it returns False, so we keep the clean_name)
+    singular_name = p.singular_noun(clean_name)
+    if singular_name:
+        return singular_name
+        
+    return clean_name
+# -------------------------------------
+
+@app.post("/api/upload")
+async def upload_new_images(files: List[UploadFile] = File(...), folder_name: str = Form(...)):
+    """Handles bulk uploading of multiple images at once."""
+    uploaded_urls = []
+    
+    # Clean the folder name before doing anything else!
+    standardized_folder = standardize_category_name(folder_name)
+    
+    try:
+        for file in files:
+            temp_path = f"temp_uploads/{file.filename}"
+            with open(temp_path, "wb") as buffer:
+                shutil.copyfileobj(file.file, buffer)
+                
+            # Upload to Cloudinary using the perfectly clean folder name
+            image_url = db.upload_image(temp_path, standardized_folder)
+            
+            img = Image.open(temp_path).convert('RGB')
+            vector = ai.encode_image(img)
+            
+            image_id = str(uuid.uuid4())
+            db.add_vector(vector, image_url, image_id)
+            
+            os.remove(temp_path)
+            uploaded_urls.append(image_url)
+            
+        # Return the standardized name so the frontend knows what was actually saved
+        return {
+            "message": f"Successfully added {len(files)} images to category '{standardized_folder}'!", 
+            "urls": uploaded_urls
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ... (Your /api/search endpoint stays exactly the same) ...
+@app.post("/api/search")
+async def search_database(file: UploadFile = File(...)):
+    try:
+        temp_path = f"temp_uploads/query_{file.filename}"
+        with open(temp_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+            
+        img = Image.open(temp_path).convert('RGB')
+        vector = ai.encode_image(img)
+        
+        results = db.search(vector, top_k=10)
+        os.remove(temp_path)
+        
+        return {"results": results}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

requirements.txt

@@ -0,0 +1,93 @@
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.12.1
+certifi==2026.2.25
+charset-normalizer==3.4.4
+click==8.3.1
+cloudinary==1.44.1
+contourpy==1.3.3
+cuda-bindings==12.9.4
+cuda-pathfinder==1.4.0
+cycler==0.12.1
+fastapi==0.135.1
+filelock==3.25.0
+fonttools==4.61.1
+fsspec==2026.2.0
+h11==0.16.0
+hf-xet==1.3.2
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==0.36.2
+idna==3.11
+inflect==7.5.0
+Jinja2==3.1.6
+kiwisolver==1.4.9
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+matplotlib==3.10.8
+mdurl==0.1.2
+more-itertools==10.8.0
+mpmath==1.3.0
+networkx==3.6.1
+numpy==2.4.2
+nvidia-cublas-cu12==12.8.4.1
+nvidia-cuda-cupti-cu12==12.8.90
+nvidia-cuda-nvrtc-cu12==12.8.93
+nvidia-cuda-runtime-cu12==12.8.90
+nvidia-cudnn-cu12==9.10.2.21
+nvidia-cufft-cu12==11.3.3.83
+nvidia-cufile-cu12==1.13.1.3
+nvidia-curand-cu12==10.3.9.90
+nvidia-cusolver-cu12==11.7.3.90
+nvidia-cusparse-cu12==12.5.8.93
+nvidia-cusparselt-cu12==0.7.1
+nvidia-nccl-cu12==2.27.5
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nvshmem-cu12==3.4.5
+nvidia-nvtx-cu12==12.8.90
+opencv-python==4.13.0.92
+orjson==3.11.7
+packaging==24.2
+pillow==12.1.1
+pinecone==8.1.0
+pinecone-client==6.0.0
+pinecone-plugin-assistant==3.0.2
+pinecone-plugin-interface==0.0.7
+polars==1.38.1
+polars-runtime-32==1.38.1
+protobuf==7.34.0
+psutil==7.2.2
+pydantic==2.12.5
+pydantic_core==2.41.5
+Pygments==2.19.2
+pyparsing==3.3.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+python-multipart==0.0.22
+PyYAML==6.0.3
+regex==2026.2.28
+requests==2.32.5
+rich==14.3.3
+safetensors==0.7.0
+scipy==1.17.1
+sentencepiece==0.2.1
+setuptools==82.0.0
+shellingham==1.5.4
+six==1.17.0
+starlette==0.52.1
+sympy==1.14.0
+tokenizers==0.21.4
+torch==2.10.0
+torchvision==0.25.0
+tqdm==4.67.3
+transformers==4.48.0
+triton==3.6.0
+typeguard==4.5.1
+typer==0.24.1
+typer-slim==0.24.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+ultralytics==8.4.19
+ultralytics-thop==2.0.18
+urllib3==2.6.3
+uvicorn==0.41.0

src/cloud_db.py

@@ -0,0 +1,58 @@
+import os
+import cloudinary
+import cloudinary.uploader
+from pinecone import Pinecone
+from dotenv import load_dotenv
+
+# Load keys from the .env file
+load_dotenv()
+
+class CloudDB:
+    def __init__(self):
+        # 1. Connect to Cloudinary
+        cloudinary.config(
+            cloud_name=os.getenv("CLOUDINARY_CLOUD_NAME"),
+            api_key=os.getenv("CLOUDINARY_API_KEY"),
+            api_secret=os.getenv("CLOUDINARY_API_SECRET")
+        )
+        
+        # 2. Connect to Pinecone
+        self.pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))
+        self.index = self.pc.Index(os.getenv("PINECONE_INDEX_NAME"))
+
+    def upload_image(self, file_path, folder_name="visual_search"):
+        """Uploads an image to Cloudinary and returns the public URL."""
+        response = cloudinary.uploader.upload(file_path, folder=folder_name)
+        return response['secure_url']
+
+    def add_vector(self, vector, image_url, image_id):
+        """Saves the vector and the image URL to Pinecone."""
+        # Convert numpy array to list for Pinecone
+        vector_list = vector.tolist() if hasattr(vector, 'tolist') else vector
+        
+        self.index.upsert(vectors=[{
+            "id": image_id,
+            "values": vector_list,
+            "metadata": {"image_url": image_url}
+        }])
+
+    def search(self, query_vector, top_k=10, min_score=0.60): # <-- CHANGED baseline to 0.60
+        """Searches Pinecone and filters out baseline 'random noise' matches."""
+        vector_list = query_vector.tolist() if hasattr(query_vector, 'tolist') else query_vector
+        
+        response = self.index.query(
+            vector=vector_list,
+            top_k=top_k,
+            include_metadata=True
+        )
+        
+        results = []
+        for match in response['matches']:
+            # Only keep the image if it's an ACTUAL mathematical match (60% or higher)
+            if match['score'] >= min_score:
+                results.append({
+                    "url": match['metadata']['image_url'],
+                    "score": match['score']
+                })
+            
+        return results

src/models.py

@@ -0,0 +1,58 @@
+# src/models.py
+import torch
+from PIL import Image
+from transformers import AutoProcessor, AutoModel
+from ultralytics import YOLO
+
+class AIModelManager:
+    def __init__(self):
+        # Load SigLIP (Vision & Text Encoder)
+        self.processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224",use_fast=False)
+        self.model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
+        self.model.eval() # Set to evaluation mode
+        
+        # Load YOLOv11 (Nano version for speed)
+        self.yolo = YOLO('yolov8n.pt') # Will auto-download the tiny weights
+
+    def encode_image(self, image: Image.Image):
+        """Converts a PIL Image into a vector."""
+        inputs = self.processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = self.model.get_image_features(**inputs)
+            
+            # Extract the raw tensor from the output object
+            if hasattr(outputs, 'image_embeds'):
+                image_features = outputs.image_embeds
+            elif hasattr(outputs, 'pooler_output'):
+                image_features = outputs.pooler_output
+            else:
+                image_features = outputs
+                
+        return image_features.flatten().numpy()
+
+    def encode_text(self, text: str):
+        """Converts a text string into a vector."""
+        inputs = self.processor(text=text, return_tensors="pt", padding="max_length")
+        with torch.no_grad():
+            outputs = self.model.get_text_features(**inputs)
+
+            # Hugging Face quirk: Extract the raw tensor from the             output object
+            if hasattr(outputs, 'text_embeds'):
+                text_features = outputs.text_embeds
+            elif hasattr(outputs, 'pooler_output'):
+                text_features = outputs.pooler_output
+            else:
+                text_features = outputs
+                
+        return text_features.flatten().numpy()
+
+    def get_crops_from_image(self, image: Image.Image):
+        """Uses YOLO to find objects and returns a list of cropped PIL Images."""
+        results = self.yolo(image, conf=0.5) # Only keep confident detections
+        crops = []
+        for result in results:
+            for box in result.boxes.xyxy: # Get bounding box coordinates
+                x1, y1, x2, y2 = map(int, box.tolist())
+                cropped_img = image.crop((x1, y1, x2, y2))
+                crops.append(cropped_img)
+        return crops