Implement next.js

.env

@@ -17,7 +17,7 @@ PROJECT_NAME="Full Stack FastAPI Project"
 STACK_NAME=full-stack-fastapi-project
 
 # Backend
-BACKEND_CORS_ORIGINS="http://localhost,http://localhost:5173,https://localhost,https://localhost:5173,http://localhost.tiangolo.com"
+BACKEND_CORS_ORIGINS="http://localhost,http://localhost:5173,https://localhost,https://localhost:5173,http://localhost.tiangolo.com,http://localhost:3000"
 SECRET_KEY=changethis
 [email protected]
 FIRST_SUPERUSER_PASSWORD=changethis

.gitignore

@@ -4,3 +4,5 @@ node_modules/
 /playwright-report/
 /blob-report/
 /playwright/.cache/
+.env
+__pycache__

backend/app/api/main.py

@@ -1,13 +1,14 @@
 from fastapi import APIRouter
 
-from app.api.routes import items, login, private, users, utils
+from app.api.routes import colpali, items, login, private, users, utils
 from app.core.config import settings
 
 api_router = APIRouter()
 api_router.include_router(login.router)
 api_router.include_router(users.router)
 api_router.include_router(utils.router)
 api_router.include_router(items.router)
+api_router.include_router(colpali.router)
 
 
 if settings.ENVIRONMENT == "local":

backend/app/api/routes/colpali.py

@@ -0,0 +1,244 @@
+"""
+ColPali API routes for document embedding and search functionality.
+"""
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, BackgroundTasks
+from fastapi.responses import JSONResponse
+
+from app.api.deps import CurrentUser
+from app.models import (
+    ColPaliSearchRequest,
+    ColPaliSearchResponse,
+    ColPaliSearchResult,
+    ColPaliUploadRequest,
+    ColPaliUploadResponse,
+    Message,
+)
+from app.services.colpali import colpali_service
+
+router = APIRouter(prefix="/colpali", tags=["colpali"])
+
+
+@router.post("/search", response_model=ColPaliSearchResponse)
+def search_documents(
+    current_user: CurrentUser,
+    search_request: ColPaliSearchRequest,
+) -> Any:
+    """
+    Search for documents using ColPali semantic search.
+
+    This endpoint allows users to search through embedded documents using natural language queries.
+    The search uses ColPali's multimodal embedding approach with reranking for improved results.
+    """
+    try:
+        # Perform search using ColPali service
+        results = colpali_service.search(
+            query=search_request.query,
+            collection_name=search_request.collection_name,
+            search_limit=search_request.search_limit,
+            prefetch_limit=search_request.prefetch_limit,
+        )
+
+        # Format results
+        search_results = [
+            ColPaliSearchResult(
+                id=result["id"],
+                score=result["score"],
+                payload=result["payload"]
+            )
+            for result in results
+        ]
+
+        return ColPaliSearchResponse(
+            results=search_results,
+            query=search_request.query,
+            collection_name=search_request.collection_name,
+            total_results=len(search_results)
+        )
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Search failed: {str(e)}"
+        )
+
+
+@router.post("/upload", response_model=ColPaliUploadResponse)
+def upload_dataset(
+    current_user: CurrentUser,
+    upload_request: ColPaliUploadRequest,
+    background_tasks: BackgroundTasks,
+) -> Any:
+    """
+    Upload a dataset to Qdrant collection for ColPali search.
+
+    This endpoint processes and embeds documents from a specified dataset,
+    then uploads them to a Qdrant collection for later search operations.
+    The upload process runs in the background to avoid request timeouts.
+    """
+    try:
+        # Start upload process in background
+        def upload_task():
+            return colpali_service.upload_dataset(
+                dataset_name=upload_request.dataset_name,
+                collection_name=upload_request.collection_name,
+                batch_size=upload_request.batch_size,
+            )
+
+        # For now, we'll run synchronously but this could be made async
+        result = upload_task()
+
+        return ColPaliUploadResponse(
+            message=f"Upload completed. {result['total_uploaded']} out of {result['total_items']} items uploaded successfully.",
+            collection_name=upload_request.collection_name,
+            total_uploaded=result["total_uploaded"],
+            total_items=result["total_items"],
+            success=result["success"]
+        )
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Upload failed: {str(e)}"
+        )
+
+
+@router.get("/collections", response_model=list[str])
+def list_collections(current_user: CurrentUser) -> Any:
+    """
+    List all available Qdrant collections.
+
+    Returns a list of collection names that are available for search operations.
+    """
+    try:
+        collections = colpali_service.client.get_collections().collections
+        return [collection.name for collection in collections]
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to list collections: {str(e)}"
+        )
+
+
+@router.get("/collections/{collection_name}/info")
+def get_collection_info(
+    current_user: CurrentUser,
+    collection_name: str,
+) -> Any:
+    """
+    Get information about a specific collection.
+
+    Returns metadata and statistics about the specified collection.
+    """
+    try:
+        collection_info = colpali_service.client.get_collection(collection_name)
+        return {
+            "name": collection_name,
+            "vectors_count": collection_info.vectors_count,
+            "indexed_vectors_count": collection_info.indexed_vectors_count,
+            "points_count": collection_info.points_count,
+            "segments_count": collection_info.segments_count,
+            "config": {
+                "params": collection_info.config.params.dict() if collection_info.config.params else None,
+                "hnsw_config": collection_info.config.hnsw_config.dict() if collection_info.config.hnsw_config else None,
+                "optimizer_config": collection_info.config.optimizer_config.dict() if collection_info.config.optimizer_config else None,
+            }
+        }
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to get collection info: {str(e)}"
+        )
+
+
+@router.delete("/collections/{collection_name}", response_model=Message)
+def delete_collection(
+    current_user: CurrentUser,
+    collection_name: str,
+) -> Any:
+    """
+    Delete a collection and all its data.
+
+    WARNING: This operation is irreversible and will delete all embedded documents
+    in the specified collection.
+    """
+    try:
+        # Check if user is superuser for destructive operations
+        if not current_user.is_superuser:
+            raise HTTPException(
+                status_code=403,
+                detail="Only superusers can delete collections"
+            )
+
+        colpali_service.client.delete_collection(collection_name)
+        return Message(message=f"Collection '{collection_name}' deleted successfully")
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to delete collection: {str(e)}"
+        )
+
+
+@router.post("/collections/{collection_name}/create", response_model=Message)
+def create_collection(
+    current_user: CurrentUser,
+    collection_name: str,
+) -> Any:
+    """
+    Create a new empty collection for ColPali embeddings.
+
+    Creates a new Qdrant collection with the appropriate vector configuration
+    for ColPali embeddings (original, mean_pooling_rows, mean_pooling_columns).
+    """
+    try:
+        created = colpali_service.create_collection_if_not_exists(collection_name)
+
+        if created:
+            return Message(message=f"Collection '{collection_name}' created successfully")
+        else:
+            return Message(message=f"Collection '{collection_name}' already exists")
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to create collection: {str(e)}"
+        )
+
+
+@router.get("/health")
+def health_check() -> Any:
+    """
+    Health check endpoint for ColPali service.
+
+    Verifies that the ColPali model, Qdrant client, and other dependencies
+    are properly initialized and accessible.
+    """
+    try:
+        # Check Qdrant connection
+        collections = colpali_service.client.get_collections()
+
+        # Check model initialization
+        model_ready = colpali_service.model is not None and colpali_service.processor is not None
+
+        return {
+            "status": "healthy",
+            "qdrant_connected": True,
+            "collections_count": len(collections.collections),
+            "model_ready": model_ready,
+            "device": str(colpali_service.model.device) if colpali_service.model else "unknown"
+        }
+
+    except Exception as e:
+        return JSONResponse(
+            status_code=503,
+            content={
+                "status": "unhealthy",
+                "error": str(e),
+                "qdrant_connected": False,
+                "model_ready": False
+            }
+        )

backend/app/core/config.py

@@ -57,6 +57,9 @@ def all_cors_origins(self) -> list[str]:
     POSTGRES_PASSWORD: str = ""
     POSTGRES_DB: str = ""
 
+    # ColPali/Qdrant settings
+    QDRANT_URL: str = "http://localhost:6333"
+
     @computed_field  # type: ignore[prop-decorator]
     @property
     def SQLALCHEMY_DATABASE_URI(self) -> PostgresDsn:

backend/app/models.py

@@ -111,3 +111,38 @@ class TokenPayload(SQLModel):
 class NewPassword(SQLModel):
     token: str
     new_password: str = Field(min_length=8, max_length=40)
+
+
+# ColPali models
+class ColPaliSearchRequest(SQLModel):
+    query: str = Field(min_length=1, max_length=1000, description="Search query for ColPali")
+    collection_name: str = Field(default="le-collection", description="Qdrant collection name")
+    search_limit: int = Field(default=20, ge=1, le=100, description="Number of results to return")
+    prefetch_limit: int = Field(default=200, ge=1, le=1000, description="Number of results to prefetch")
+
+
+class ColPaliSearchResult(SQLModel):
+    score: float = Field(description="Similarity score")
+    payload: dict = Field(description="Document metadata")
+    id: str = Field(description="Document ID")
+
+
+class ColPaliSearchResponse(SQLModel):
+    results: list[ColPaliSearchResult]
+    query: str
+    collection_name: str
+    total_results: int
+
+
+class ColPaliUploadRequest(SQLModel):
+    dataset_name: str = Field(description="Name of the dataset to upload")
+    collection_name: str = Field(default="le-collection", description="Qdrant collection name")
+    batch_size: int = Field(default=4, ge=1, le=16, description="Batch size for processing")
+
+
+class ColPaliUploadResponse(SQLModel):
+    message: str
+    collection_name: str
+    total_uploaded: int
+    total_items: int
+    success: bool

backend/app/services/__init__.py

@@ -0,0 +1 @@
+# Services module