Upload 35 files

.gitignore

@@ -0,0 +1,178 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/master/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+# ChromaDB Vector Database (local data)
+chroma_db/
+*.bin
+*.sqlite3
+
+# Environment files
+.env
+.env.local
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+
+# Virtual environment
+venv/
+env/
+
+# IDE files
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Temporary files
+temp/
+tmp/
+

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.10.13-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (for better caching)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port (HuggingFace Spaces uses 7860)
+EXPOSE 7860
+
+# Run application (change port to 7860)
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

alembic.ini

@@ -0,0 +1,116 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = migrations
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to migrations/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = postgresql://codequery_user:codequery_pass_2025@localhost:5432/codequery_dev
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

app/api/v1/chat.py

@@ -0,0 +1,370 @@
+from fastapi import APIRouter, Depends, HTTPException, Header
+from sqlalchemy.orm import Session
+from typing import List
+from app.database import get_db
+from app.models.repository import Repository, RepositoryStatusEnum
+from app.models.conversation import Conversation, Message
+from app.core.config import settings
+from app.services import EmbeddingService, VectorService, ChatService
+from pydantic import BaseModel
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Define the models directly in this file
+class ChatRequest(BaseModel):
+    """Request model for chat with repository"""
+    query: str
+    repository_id: int
+
+class ChatResponse(BaseModel):
+    """Response model for chat"""
+    response: str
+    sources: List[dict]
+    repository_name: str
+    context_chunks_used: int
+    model_used: str
+    success: bool
+
+def verify_client_secret(x_client_secret: str = Header(..., alias="X-Client-Secret")):
+    """Verify request comes from authorized Next.js client"""
+    if x_client_secret != settings.nextjs_secret:
+        raise HTTPException(
+            status_code=403, 
+            detail="Unauthorized client - invalid secret"
+        )
+    return True
+
+def get_user_id(x_user_id: str = Header(..., alias="X-User-ID")):
+    """Extract and validate user ID from header"""
+    if not x_user_id or len(x_user_id.strip()) == 0:
+        raise HTTPException(status_code=400, detail="User ID required")
+    return x_user_id.strip()
+
+def verify_repository_ownership(repository_id: int, user_id: str, db: Session):
+    """Verify user owns the repository"""
+    repository = db.query(Repository).filter(
+        Repository.id == repository_id,
+        Repository.user_id == user_id
+    ).first()
+    
+    if not repository:
+        raise HTTPException(status_code=404, detail="Repository not found or access denied")
+    
+    return repository
+
+@router.post("/", response_model=ChatResponse)
+async def chat_with_repository(
+    request: ChatRequest,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Chat with a repository using QODEX AI"""
+    logger.info(f"💬 QODEX Chat: '{request.query[:60]}...' for repo {request.repository_id} (user: {user_id})")
+    
+    # Verify repository ownership
+    repository = verify_repository_ownership(request.repository_id, user_id, db)
+    
+    if repository.status != RepositoryStatusEnum.READY:
+        status_messages = {
+            RepositoryStatusEnum.PENDING: "Repository is pending processing. Please wait.",
+            RepositoryStatusEnum.PROCESSING: "Repository is currently being processed. Please wait.",
+            RepositoryStatusEnum.FAILED: f"Repository processing failed: {repository.error_message}"
+        }
+        raise HTTPException(
+            status_code=400, 
+            detail=status_messages.get(repository.status, "Repository not ready for chat")
+        )
+    
+    try:
+        # Initialize services
+        embedding_service = EmbeddingService()
+        vector_service = VectorService()
+        chat_service = ChatService()
+        
+        # Generate query embedding
+        logger.info(f"🔍 Generating embedding for query...")
+        query_embedding = await embedding_service.generate_query_embedding(request.query)
+        
+        # Search for similar code chunks
+        logger.info(f"🔎 Searching for relevant code chunks...")
+        similar_chunks = await vector_service.search_similar_code(
+            repository_id=request.repository_id,
+            query_embedding=query_embedding,
+            top_k=5
+        )
+        
+        if not similar_chunks:
+            logger.warning(f"⚠️ No relevant chunks found for query in repo {request.repository_id}")
+            return ChatResponse(
+                response="I couldn't find any relevant code chunks for your question. Try asking about something more specific to this repository, or check if the repository was processed correctly.",
+                sources=[],
+                repository_name=repository.name,
+                context_chunks_used=0,
+                model_used="no_results",
+                success=False
+            )
+        
+        logger.info(f"✅ Found {len(similar_chunks)} relevant code chunks")
+        
+        # Generate AI response
+        logger.info(f"🤖 Generating AI response with Gemini...")
+        ai_response = await chat_service.generate_response(
+            query=request.query,
+            code_chunks=similar_chunks,
+            repository_name=repository.name
+        )
+        
+        # Save conversation if successful
+        if ai_response['success']:
+            try:
+                # Create or get conversation
+                conversation = db.query(Conversation).filter(
+                    Conversation.repository_id == request.repository_id
+                ).first()
+                
+                if not conversation:
+                    conversation = Conversation(
+                        repository_id=request.repository_id,
+                        title=f"Chat about {repository.name}"
+                    )
+                    db.add(conversation)
+                    db.commit()
+                    db.refresh(conversation)
+                
+                # Save user message
+                user_message = Message(
+                    conversation_id=conversation.id,
+                    role="user",
+                    content=request.query
+                )
+                db.add(user_message)
+                
+                # Save assistant response
+                assistant_message = Message(
+                    conversation_id=conversation.id,
+                    role="assistant",
+                    content=ai_response['response'],
+                    citations=ai_response['sources']
+                )
+                db.add(assistant_message)
+                
+                db.commit()
+                logger.info(f"💾 Saved conversation for repo {request.repository_id} (user: {user_id})")
+                
+            except Exception as save_error:
+                logger.warning(f"⚠️ Failed to save conversation: {save_error}")
+                # Continue anyway - don't fail the response
+        
+        logger.info(f"🎉 QODEX chat successful for repo {request.repository_id} (user: {user_id})")
+        
+        return ChatResponse(
+            response=ai_response['response'],
+            sources=ai_response['sources'],
+            repository_name=repository.name,
+            context_chunks_used=len(similar_chunks),
+            model_used=ai_response['model_used'],
+            success=ai_response['success']
+        )
+        
+    except Exception as e:
+        logger.error(f"❌ Error in QODEX chat processing: {e}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Failed to process chat request: {str(e)}"
+        )
+
+# ✅ NEW: Direct messages route (Option 1 solution!)
+@router.get("/{repository_id}/messages")
+async def get_repository_chat_messages(
+    repository_id: int,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Get all chat messages for a repository directly - SINGLE API CALL!"""
+    
+    # Verify repository ownership
+    repository = verify_repository_ownership(repository_id, user_id, db)
+    
+    # Get conversation for this repository
+    conversation = db.query(Conversation).filter(
+        Conversation.repository_id == repository_id
+    ).first()
+    
+    if not conversation:
+        return {
+            "repository_id": repository_id,
+            "repository_name": repository.name,
+            "user_id": user_id,
+            "conversation_id": None,
+            "messages": [],
+            "total_messages": 0
+        }
+    
+    # Get all messages
+    messages = db.query(Message).filter(
+        Message.conversation_id == conversation.id
+    ).order_by(Message.created_at.asc()).all()
+    
+    return {
+        "repository_id": repository_id,
+        "repository_name": repository.name,
+        "user_id": user_id,
+        "conversation_id": conversation.id,
+        "messages": [
+            {
+                "id": msg.id,
+                "role": msg.role,
+                "content": msg.content,
+                "citations": msg.citations,
+                "created_at": msg.created_at
+            }
+            for msg in messages
+        ],
+        "total_messages": len(messages)
+    }
+
+@router.get("/{repository_id}/conversations")
+async def get_repository_conversations(
+    repository_id: int,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Get all conversations for a repository (user must own it)"""
+    
+    # Verify repository ownership
+    repository = verify_repository_ownership(repository_id, user_id, db)
+    
+    conversations = db.query(Conversation).filter(
+        Conversation.repository_id == repository_id
+    ).order_by(Conversation.created_at.desc()).all()
+    
+    return {
+        "repository_id": repository_id,
+        "repository_name": repository.name,
+        "user_id": user_id,
+        "conversations": conversations,
+        "total_conversations": len(conversations)
+    }
+
+@router.get("/conversations/{conversation_id}/messages")
+async def get_conversation_messages(
+    conversation_id: int,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Get all messages in a conversation (user must own the repository)"""
+    
+    conversation = db.query(Conversation).filter(Conversation.id == conversation_id).first()
+    if not conversation:
+        raise HTTPException(status_code=404, detail="Conversation not found")
+    
+    # Verify user owns the repository
+    verify_repository_ownership(conversation.repository_id, user_id, db)
+    
+    messages = db.query(Message).filter(
+        Message.conversation_id == conversation_id
+    ).order_by(Message.created_at.asc()).all()
+    
+    return {
+        "conversation_id": conversation_id,
+        "repository_id": conversation.repository_id,
+        "user_id": user_id,
+        "messages": messages,
+        "total_messages": len(messages)
+    }
+
+# ✅ NEW: User-specific chat routes
+@router.get("/users/{target_user_id}/conversations")
+async def get_user_all_conversations(
+    target_user_id: str,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Get all conversations for a specific user across all their repositories"""
+    
+    # Security: Users can only access their own conversations
+    if user_id != target_user_id:
+        raise HTTPException(status_code=403, detail="Access denied - can only access your own conversations")
+    
+    # Get all repositories for this user
+    user_repos = db.query(Repository).filter(Repository.user_id == target_user_id).all()
+    repo_ids = [repo.id for repo in user_repos]
+    
+    if not repo_ids:
+        return {
+            "user_id": target_user_id,
+            "total_conversations": 0,
+            "conversations": []
+        }
+    
+    # Get all conversations for user's repositories
+    conversations = db.query(Conversation).filter(
+        Conversation.repository_id.in_(repo_ids)
+    ).order_by(Conversation.created_at.desc()).all()
+    
+    return {
+        "user_id": target_user_id,
+        "total_conversations": len(conversations),
+        "conversations": [
+            {
+                "id": conv.id,
+                "repository_id": conv.repository_id,
+                "repository_name": conv.repository.name,
+                "title": conv.title,
+                "created_at": conv.created_at,
+                "message_count": len(conv.messages)
+            }
+            for conv in conversations
+        ]
+    }
+
+@router.post("/{repository_id}/test")
+async def test_repository_search(
+    repository_id: int,
+    query: str = "main function",
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Test endpoint to verify repository search functionality (user must own it)"""
+    
+    # Verify repository ownership
+    repository = verify_repository_ownership(repository_id, user_id, db)
+    
+    if repository.status != RepositoryStatusEnum.READY:
+        raise HTTPException(status_code=400, detail="Repository not ready")
+    
+    try:
+        embedding_service = EmbeddingService()
+        vector_service = VectorService()
+        
+        query_embedding = await embedding_service.generate_query_embedding(query)
+        results = await vector_service.search_similar_code(repository_id, query_embedding, top_k=3)
+        
+        return {
+            "repository": repository.name,
+            "user_id": user_id,
+            "query": query,
+            "results_found": len(results),
+            "top_matches": [
+                {
+                    "file": result['file_path'],
+                    "lines": f"{result['start_line']}-{result['end_line']}",
+                    "similarity": round(result['similarity'], 3),
+                    "preview": result['content'][:200] + "..."
+                }
+                for result in results
+            ],
+            "test_successful": len(results) > 0
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Test failed: {str(e)}")

app/api/v1/repositories.py

@@ -0,0 +1,277 @@
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks, Header
+from sqlalchemy.orm import Session
+from typing import List
+from app.database import get_db
+from app.models.repository import Repository, RepositoryStatusEnum
+from app.schemas.repository import RepositoryCreate, RepositoryResponse
+from app.core.config import settings
+from app.services import GitHubService, EmbeddingService, VectorService
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+async def process_repository_background(repository_id: int, user_id: str):
+    """Background task to process repository with hybrid RAG"""
+    logger.info(f"🚀 Starting QODEX HYBRID RAG processing for repository {repository_id} (user: {user_id})")
+    
+    from app.database import SessionLocal
+    db = SessionLocal()
+    
+    github_service = GitHubService()
+    embedding_service = EmbeddingService()
+    vector_service = VectorService()
+    
+    temp_dir = None
+    
+    try:
+        repository = db.query(Repository).filter(
+            Repository.id == repository_id,
+            Repository.user_id == user_id
+        ).first()
+        
+        if not repository:
+            logger.error(f"❌ Repository {repository_id} not found for user {user_id}")
+            return
+        
+        repository.status = RepositoryStatusEnum.PROCESSING
+        db.commit()
+        logger.info(f"📊 Repository {repository_id} status: PROCESSING")
+        
+        logger.info(f"📥 Step 1: Cloning repository {repository.github_url}")
+        temp_dir = await github_service.clone_repository(repository.github_url)
+        
+        logger.info(f"📁 Step 2: Extracting code files from {repository.name}")
+        code_chunks = await github_service.extract_code_files(temp_dir)
+        
+        if not code_chunks:
+            raise Exception("No supported code files found in repository")
+        
+        logger.info(f"✅ Found {len(code_chunks)} code chunks")
+        
+        logger.info(f"⚡ Step 3: Generating embeddings with LOCAL SentenceTransformers")
+        embedded_chunks = await embedding_service.generate_embeddings_batch(code_chunks)
+        
+        if not embedded_chunks:
+            raise Exception("Failed to generate local embeddings")
+        
+        logger.info(f"💾 Step 4: Storing embeddings in ChromaDB")
+        await vector_service.store_embeddings(repository_id, embedded_chunks)
+        
+        repository.status = RepositoryStatusEnum.READY
+        repository.error_message = None
+        db.commit()
+        
+        logger.info(f"🎉 SUCCESS! QODEX Repository {repository_id} is READY for chat! (user: {user_id})")
+        
+    except Exception as e:
+        error_message = str(e)
+        logger.error(f"❌ Error processing repository {repository_id}: {error_message}")
+        
+        try:
+            repository = db.query(Repository).filter(Repository.id == repository_id).first()
+            if repository:
+                repository.status = RepositoryStatusEnum.FAILED
+                repository.error_message = error_message[:500]
+                db.commit()
+        except Exception as db_error:
+            logger.error(f"❌ Failed to update repository status: {str(db_error)}")
+    
+    finally:
+        if temp_dir:
+            github_service.cleanup_temp_dir(temp_dir)
+        db.close()
+
+def verify_client_secret(x_client_secret: str = Header(..., alias="X-Client-Secret")):
+    """Verify request comes from authorized Next.js client"""
+    if x_client_secret != settings.nextjs_secret:
+        raise HTTPException(
+            status_code=403, 
+            detail="Unauthorized client - invalid secret"
+        )
+    return True
+
+def get_user_id(x_user_id: str = Header(..., alias="X-User-ID")):
+    """Extract and validate user ID from header"""
+    if not x_user_id or len(x_user_id.strip()) == 0:
+        raise HTTPException(status_code=400, detail="User ID required")
+    return x_user_id.strip()
+
+@router.post("/", response_model=RepositoryResponse)
+async def add_repository(
+    repository: RepositoryCreate,
+    background_tasks: BackgroundTasks,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Add new repository for QODEX processing"""
+    
+    # Verify user_id matches between header and body
+    if repository.user_id != user_id:
+        raise HTTPException(status_code=400, detail="User ID mismatch between header and body")
+    
+    logger.info(f"📥 NEW QODEX REQUEST: {repository.name} - {repository.github_url} (user: {user_id})")
+    
+    # Validate GitHub URL
+    if not repository.github_url.startswith(('https://github.com/', 'git@github.com:')):
+        raise HTTPException(status_code=400, detail="Invalid GitHub URL format")
+    
+    # Check for duplicates for this user
+    existing = db.query(Repository).filter(
+        Repository.github_url == repository.github_url,
+        Repository.user_id == user_id
+    ).first()
+    
+    if existing:
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Repository already exists with ID: {existing.id}. Status: {existing.status.value}"
+        )
+    
+    # Create repository record
+    db_repository = Repository(
+        name=repository.name,
+        github_url=repository.github_url,
+        user_id=user_id,
+        status=RepositoryStatusEnum.PENDING
+    )
+    db.add(db_repository)
+    db.commit()
+    db.refresh(db_repository)
+    
+    # Start background processing
+    background_tasks.add_task(process_repository_background, db_repository.id, user_id)
+    
+    logger.info(f"✅ Repository {db_repository.id} created and queued for processing (user: {user_id})")
+    return db_repository
+
+@router.get("/", response_model=List[RepositoryResponse])
+async def get_user_repositories(
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Get all repositories for the authenticated user"""
+    repositories = db.query(Repository).filter(
+        Repository.user_id == user_id
+    ).order_by(Repository.created_at.desc()).all()
+    
+    logger.info(f"📋 Retrieved {len(repositories)} repositories for user {user_id}")
+    return repositories
+
+@router.get("/{repository_id}", response_model=RepositoryResponse)
+async def get_repository(
+    repository_id: int,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Get specific repository by ID (user must own it)"""
+    repository = db.query(Repository).filter(
+        Repository.id == repository_id,
+        Repository.user_id == user_id
+    ).first()
+    
+    if not repository:
+        raise HTTPException(status_code=404, detail="Repository not found or access denied")
+    
+    return repository
+
+@router.delete("/{repository_id}")
+async def delete_repository(
+    repository_id: int,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Delete repository and all associated data (user must own it)"""
+    repository = db.query(Repository).filter(
+        Repository.id == repository_id,
+        Repository.user_id == user_id
+    ).first()
+    
+    if not repository:
+        raise HTTPException(status_code=404, detail="Repository not found or access denied")
+    
+    try:
+        # Delete vector data from ChromaDB
+        vector_service = VectorService()
+        await vector_service.delete_repository_data(repository_id)
+        logger.info(f"🗑️ Deleted vector data for repository {repository_id}")
+    except Exception as e:
+        logger.warning(f"⚠️ Error deleting vector data for repo {repository_id}: {e}")
+    
+    try:
+        # Delete conversations and messages (CASCADE should handle this)
+        db.delete(repository)
+        db.commit()
+        logger.info(f"🗑️ Successfully deleted repository {repository_id} (user: {user_id})")
+    except Exception as e:
+        logger.error(f"❌ Error deleting repository {repository_id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to delete repository")
+    
+    return {
+        "message": f"Repository {repository_id} deleted successfully",
+        "repository_id": repository_id,
+        "user_id": user_id,
+        "success": True
+    }
+
+@router.get("/{repository_id}/status")
+async def get_repository_status(
+    repository_id: int,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Get detailed repository status (user must own it)"""
+    repository = db.query(Repository).filter(
+        Repository.id == repository_id,
+        Repository.user_id == user_id
+    ).first()
+    
+    if not repository:
+        raise HTTPException(status_code=404, detail="Repository not found or access denied")
+    
+    # Count conversations for this repository
+    from app.models.conversation import Conversation
+    conversation_count = db.query(Conversation).filter(
+        Conversation.repository_id == repository_id
+    ).count()
+    
+    return {
+        "id": repository.id,
+        "user_id": repository.user_id,
+        "name": repository.name,
+        "github_url": repository.github_url,
+        "status": repository.status.value,
+        "error_message": repository.error_message,
+        "created_at": repository.created_at,
+        "updated_at": repository.updated_at,
+        "is_ready_for_chat": repository.status == RepositoryStatusEnum.READY,
+        "conversation_count": conversation_count,
+        "processing_complete": repository.status in [RepositoryStatusEnum.READY, RepositoryStatusEnum.FAILED]
+    }
+
+# ✅ NEW: User-specific routes
+@router.get("/users/{target_user_id}/repositories", response_model=List[RepositoryResponse])
+async def get_specific_user_repositories(
+    target_user_id: str,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_user_id),
+    _: bool = Depends(verify_client_secret)
+):
+    """Get repositories for a specific user (must be same user)"""
+    
+    # Security: Users can only access their own repositories
+    if user_id != target_user_id:
+        raise HTTPException(status_code=403, detail="Access denied - can only access your own repositories")
+    
+    repositories = db.query(Repository).filter(
+        Repository.user_id == target_user_id
+    ).order_by(Repository.created_at.desc()).all()
+    
+    return repositories

app/api/v1/router.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+from .repositories import router as repositories_router
+from .chat import router as chat_router
+
+api_router = APIRouter()
+
+# Include only core functionality
+api_router.include_router(repositories_router, prefix="/repositories", tags=["repositories"])
+api_router.include_router(chat_router, prefix="/chat", tags=["chat"])

app/core/config.py

@@ -0,0 +1,24 @@
+import os
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    # Database
+    database_url: str = os.getenv("DATABASE_URL", "sqlite:///./test.db")
+    
+    # Security
+    secret_key: str = os.getenv("SECRET_KEY", "production-secret-key-change-me")
+    nextjs_secret: str = os.getenv("NEXTJS_SECRET", "qodex-production-secret-2025")
+    algorithm: str = "HS256"
+    access_token_expire_minutes: int = 30
+    
+    # API Keys
+    gemini_api_key: str = os.getenv("GEMINI_API_KEY", "")
+    
+    # App
+    environment: str = os.getenv("ENVIRONMENT", "production")
+    debug: bool = os.getenv("DEBUG", "false").lower() == "true"
+    
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

app/core/database.py

@@ -0,0 +1,28 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from .config import settings
+
+# ✅ Production-ready engine configuration
+engine = create_engine(
+    settings.database_url,
+    pool_size=5,           # Reduced for Neon free tier
+    max_overflow=10,       # Reduced for free tier
+    pool_pre_ping=True,
+    pool_recycle=3600,
+    echo=False,            # Disable SQL logging in production
+    pool_timeout=30,
+    connect_args={
+        "sslmode": "require"  # Required for Neon
+    } if settings.database_url.startswith("postgresql") else {}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/core/security.py

@@ -0,0 +1,39 @@
+from passlib.context import CryptContext
+from jose import JWTError, jwt
+from datetime import datetime, timedelta
+from typing import Optional
+from .config import settings
+
+# Password hashing context
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a plain password against its hash"""
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password: str) -> str:
+    """Hash a password"""
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    """Create a JWT access token"""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=settings.access_token_expire_minutes)
+    
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.secret_key, algorithm=settings.algorithm)
+    return encoded_jwt
+
+def verify_token(token: str) -> Optional[str]:
+    """Verify JWT token and return email"""
+    try:
+        payload = jwt.decode(token, settings.secret_key, algorithms=[settings.algorithm])
+        email: str = payload.get("sub")
+        if email is None:
+            return None
+        return email
+    except JWTError:
+        return None

app/database.py

@@ -0,0 +1,30 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+# ✅ Add connection pooling here too
+engine = create_engine(
+    DATABASE_URL,
+    pool_size=10,          # ✅ Allow 10 concurrent connections
+    max_overflow=20,       # ✅ Allow 20 more if needed
+    pool_pre_ping=True,    # ✅ Verify connections are alive
+    pool_recycle=3600,     # ✅ Recycle connections every hour
+    pool_timeout=30,       # ✅ Wait 30s for available connection
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/main.py

@@ -0,0 +1,72 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.api.v1 import repositories, chat
+from app.core.database import engine, Base
+from datetime import datetime
+import os
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="QODEX API",
+    description="AI-powered code repository chat system",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# CORS configuration for production
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "https://qodex.vercel.app",              # Your frontend domain
+        "https://qodex-frontend.vercel.app",     # Alternative frontend domain
+        "http://localhost:3000",                 # Local development
+        "http://127.0.0.1:3000",                # Local development
+    ],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["*"],
+)
+
+# Create tables on startup
+@app.on_event("startup")
+async def startup_event():
+    """Create database tables on startup"""
+    try:
+        Base.metadata.create_all(bind=engine)
+        logger.info("🗄️ Database tables created successfully")
+    except Exception as e:
+        logger.error(f"❌ Error creating database tables: {e}")
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for monitoring services"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat(),
+        "service": "QODEX API",
+        "version": "1.0.0",
+        "environment": os.getenv("ENVIRONMENT", "production"),
+        "message": "QODEX is running smoothly! 🚀"
+    }
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "Welcome to QODEX API! 🚀",
+        "description": "AI-powered code repository chat system",
+        "docs": "/docs",
+        "health": "/health",
+        "status": "running",
+        "version": "1.0.0"
+    }
+
+# Include routers
+app.include_router(repositories.router, prefix="/api/v1/repositories", tags=["repositories"])
+app.include_router(chat.router, prefix="/api/v1/chat", tags=["chat"])

app/models/__init__.py

@@ -0,0 +1,5 @@
+# app/models/__init__.py
+from .repository import Repository
+from .conversation import Conversation, Message
+
+__all__ = ["Repository", "Conversation", "Message"]

app/models/conversation.py

@@ -0,0 +1,38 @@
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, JSON, Text
+from sqlalchemy.sql import func
+from sqlalchemy.orm import relationship
+from app.core.database import Base
+
+class Conversation(Base):
+    """Conversation model - linked to repository only"""
+    __tablename__ = "conversations"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    repository_id = Column(Integer, ForeignKey("repositories.id"), nullable=False)
+    title = Column(String, nullable=False, default="New Conversation")
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # Relationships
+    repository = relationship("Repository", back_populates="conversations")
+    messages = relationship("Message", back_populates="conversation", cascade="all, delete-orphan")
+    
+    def __repr__(self):
+        return f"<Conversation(id={self.id}, repository_id={self.repository_id}, title='{self.title}')>"
+
+class Message(Base):
+    """Message model for chat history"""
+    __tablename__ = "messages"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    conversation_id = Column(Integer, ForeignKey("conversations.id"), nullable=False)
+    role = Column(String, nullable=False)  # 'user' or 'assistant'
+    content = Column(Text, nullable=False)
+    citations = Column(JSON, nullable=True)  # Store code citations as JSON
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    
+    # Relationships
+    conversation = relationship("Conversation", back_populates="messages")
+    
+    def __repr__(self):
+        return f"<Message(id={self.id}, role='{self.role}', conversation_id={self.conversation_id})>"

app/models/repository.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, Integer, String, DateTime, Enum
+from sqlalchemy.sql import func
+from sqlalchemy.orm import relationship
+from app.core.database import Base
+import enum
+
+class RepositoryStatusEnum(enum.Enum):
+    """Repository processing status"""
+    PENDING = "PENDING"
+    PROCESSING = "PROCESSING"
+    READY = "READY"
+    FAILED = "FAILED"
+
+class Repository(Base):
+    """Repository model with user ownership"""
+    __tablename__ = "repositories"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(String, nullable=False, index=True)  # ✅ Added back!
+    github_url = Column(String, nullable=False, unique=True)
+    name = Column(String, nullable=False)
+    status = Column(Enum(RepositoryStatusEnum), default=RepositoryStatusEnum.PENDING)
+    error_message = Column(String, nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # Relationships
+    conversations = relationship("Conversation", back_populates="repository", cascade="all, delete-orphan")
+    
+    def __repr__(self):
+        return f"<Repository(id={self.id}, user_id='{self.user_id}', name='{self.name}', status={self.status.value})>"

app/schemas/chat.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+
+class CodeCitation(BaseModel):
+    file_path: str
+    start_line: int
+    end_line: int
+    code_snippet: str
+
+class MessageCreate(BaseModel):
+    content: str
+
+class MessageResponse(BaseModel):
+    id: int
+    role: str
+    content: str
+    citations: Optional[List[CodeCitation]] = None
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+class ConversationResponse(BaseModel):
+    id: int
+    repository_id: int
+    title: str
+    messages: List[MessageResponse]
+    created_at: datetime
+    
+    class Config:
+        from_attributes = True
+
+class QueryRequest(BaseModel):
+    question: str
+    conversation_id: Optional[int] = None
+
+class QueryResponse(BaseModel):
+    answer_id: str
+    natural_language_answer: str
+    citations: List[CodeCitation]
+    conversation_id: int

app/schemas/repository.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+from enum import Enum
+
+class RepositoryStatus(str, Enum):
+    PENDING = "PENDING"
+    PROCESSING = "PROCESSING"
+    READY = "READY"
+    FAILED = "FAILED"
+
+class RepositoryCreate(BaseModel):
+    name: str
+    github_url: str
+    user_id: str  # ✅ Added back!
+
+class RepositoryResponse(BaseModel):
+    id: int
+    user_id: str  # ✅ Added back!
+    name: str
+    github_url: str
+    status: RepositoryStatus
+    error_message: Optional[str] = None
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    
+    class Config:
+        from_attributes = True

app/services/__init__.py

@@ -0,0 +1,6 @@
+from .github_service import GitHubService
+from .embedding_service import EmbeddingService
+from .vector_service import VectorService
+from .chat_service import ChatService
+
+__all__ = ['GitHubService', 'EmbeddingService', 'VectorService', 'ChatService']

app/services/chat_service.py

@@ -0,0 +1,128 @@
+import google.generativeai as genai
+import os
+from typing import List, Dict
+import logging
+from dotenv import load_dotenv
+
+load_dotenv()
+logger = logging.getLogger(__name__)
+
+class ChatService:
+    def __init__(self):
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            logger.warning("⚠️ GEMINI_API_KEY not found - chat will use fallback responses")
+            self.model = None
+            self.gemini_available = False
+        else:
+            try:
+                genai.configure(api_key=api_key)
+                self.model = genai.GenerativeModel('gemini-2.0-flash')
+                self.gemini_available = True
+                logger.info("🤖 Gemini chat service initialized")
+            except Exception as e:
+                logger.error(f"❌ Failed to initialize Gemini: {e}")
+                self.model = None
+                self.gemini_available = False
+    
+    async def generate_response(self, query: str, code_chunks: List[Dict], repository_name: str) -> Dict:
+        if not self.gemini_available:
+            return self.generate_fallback_response(query, code_chunks, repository_name)
+        
+        try:
+            context = self.prepare_context(code_chunks)
+            
+            prompt = f"""You are an expert code assistant analyzing the {repository_name} repository.
+
+User Question: {query}
+
+Relevant Code Context:
+{context}
+
+Instructions:
+1. Answer the user's question based on the provided code context
+2. Reference specific files and line numbers when relevant
+3. Explain code functionality clearly
+4. If context is insufficient, say so clearly
+5. Be specific and technical but also clear
+
+Your Expert Analysis:"""
+            
+            response = self.model.generate_content(prompt)
+            
+            sources = []
+            for chunk in code_chunks:
+                sources.append({
+                    'file_path': chunk['file_path'],
+                    'start_line': chunk['start_line'],
+                    'end_line': chunk['end_line'],
+                    'similarity': round(chunk['similarity'], 3),
+                    'preview': chunk['content'][:200] + "..."
+                })
+            
+            return {
+                'response': response.text,
+                'sources': sources,
+                'context_chunks_used': len(code_chunks),
+                'repository_name': repository_name,
+                'model_used': 'gemini-2.0-flash',
+                'success': True
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Gemini error: {e}")
+            if "429" in str(e) or "quota" in str(e).lower():
+                return self.generate_quota_response(query, code_chunks, repository_name)
+            return self.generate_fallback_response(query, code_chunks, repository_name)
+    
+    def prepare_context(self, code_chunks: List[Dict]) -> str:
+        context_sections = []
+        for i, chunk in enumerate(code_chunks, 1):
+            context_sections.append(f"""
+Code Reference {i}:
+File: {chunk['file_path']}
+Lines: {chunk['start_line']}-{chunk['end_line']}
+Similarity: {chunk['similarity']:.2f}
+{chunk['content']}
+""")
+        return "\n".join(context_sections)
+    
+    def generate_quota_response(self, query: str, code_chunks: List[Dict], repository_name: str) -> Dict:
+        context = self.prepare_context(code_chunks)
+        response = f"""🚫 Gemini quota exceeded, but I found {len(code_chunks)} relevant code sections:
+
+{context}
+
+The search found relevant code with similarity scores from {min(c['similarity'] for c in code_chunks):.2f} to {max(c['similarity'] for c in code_chunks):.2f}. Please try again in a few minutes when quota resets."""
+        
+        return self.create_response_dict(response, code_chunks, repository_name, 'quota_exceeded')
+    
+    def generate_fallback_response(self, query: str, code_chunks: List[Dict], repository_name: str) -> Dict:
+        context = self.prepare_context(code_chunks)
+        response = f"""Found {len(code_chunks)} relevant code sections for: "{query}"
+
+{context}
+
+Note: AI analysis requires API configuration. The search results above show the most relevant code."""
+        
+        return self.create_response_dict(response, code_chunks, repository_name, 'fallback')
+    
+    def create_response_dict(self, response: str, code_chunks: List[Dict], repository_name: str, model_used: str) -> Dict:
+        sources = []
+        for chunk in code_chunks:
+            sources.append({
+                'file_path': chunk['file_path'],
+                'start_line': chunk['start_line'],
+                'end_line': chunk['end_line'],
+                'similarity': round(chunk['similarity'], 3),
+                'preview': chunk['content'][:200] + "..."
+            })
+        
+        return {
+            'response': response,
+            'sources': sources,
+            'context_chunks_used': len(code_chunks),
+            'repository_name': repository_name,
+            'model_used': model_used,
+            'success': True
+        }

app/services/embedding_service.py

@@ -0,0 +1,63 @@
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from typing import List, Dict
+import logging
+
+logger = logging.getLogger(__name__)
+
+class EmbeddingService:
+    def __init__(self):
+        try:
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+            logger.info("🤖 Local embedding service initialized (all-MiniLM-L6-v2)")
+        except Exception as e:
+            logger.error(f"❌ Failed to load SentenceTransformer model: {e}")
+            raise Exception("Failed to initialize local embedding model")
+    
+    async def generate_embedding(self, text: str, title: str = "") -> List[float]:
+        try:
+            content = f"File: {title}\n\nCode:\n{text}" if title else text
+            embedding = self.model.encode(content)
+            return embedding.tolist()
+        except Exception as e:
+            logger.error(f"❌ Error generating local embedding: {e}")
+            raise
+    
+    async def generate_embeddings_batch(self, chunks: List[Dict]) -> List[Dict]:
+        logger.info(f"🔄 Generating LOCAL embeddings for {len(chunks)} chunks...")
+        
+        texts = []
+        for chunk in chunks:
+            content = f"""File: {chunk['file_path']}
+Lines: {chunk['start_line']}-{chunk['end_line']}
+Type: {chunk['chunk_type']}
+
+Code:
+{chunk['content']}"""
+            texts.append(content)
+        
+        try:
+            embeddings = self.model.encode(texts, show_progress_bar=True, batch_size=32)
+            
+            embedded_chunks = []
+            for i, (chunk, embedding) in enumerate(zip(chunks, embeddings)):
+                embedded_chunk = {
+                    **chunk,
+                    'embedding': embedding.tolist(),
+                    'content_length': len(chunk['content'])
+                }
+                embedded_chunks.append(embedded_chunk)
+        except Exception as e:
+            logger.error(f"❌ Failed to generate batch embeddings: {e}")
+            raise
+        
+        logger.info(f"✅ Generated {len(embedded_chunks)} LOCAL embeddings successfully")
+        return embedded_chunks
+    
+    async def generate_query_embedding(self, query: str) -> List[float]:
+        try:
+            embedding = self.model.encode(query)
+            return embedding.tolist()
+        except Exception as e:
+            logger.error(f"❌ Error generating query embedding: {e}")
+            raise

app/services/github_service.py

@@ -0,0 +1,150 @@
+import git
+import os
+import tempfile
+import shutil
+from typing import List, Dict
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+class GitHubService:
+    def __init__(self):
+        self.supported_extensions = {
+            '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.cpp', '.c', 
+            '.cs', '.go', '.rs', '.php', '.rb', '.swift', '.kt', '.scala',
+            '.html', '.css', '.scss', '.sass', '.vue', '.svelte', '.dart',
+            '.r', '.m', '.mm', '.h', '.hpp', '.cc', '.cxx', '.sql'
+        }
+        self.ignore_dirs = {
+            '.git', 'node_modules', '__pycache__', '.venv', 'venv', 
+            'build', 'dist', '.next', '.nuxt', 'coverage', '.pytest_cache',
+            'vendor', 'target', 'bin', 'obj', '.gradle', '.idea', '.vscode'
+        }
+    
+    async def clone_repository(self, github_url: str) -> str:
+        """Clone repository to temporary directory"""
+        temp_dir = tempfile.mkdtemp(prefix="codequery_")
+        logger.info(f"🔄 Cloning {github_url} to {temp_dir}")
+        
+        try:
+            # Clone with depth=1 for faster cloning (only latest commit)
+            repo = git.Repo.clone_from(github_url, temp_dir, depth=1)
+            logger.info(f"✅ Successfully cloned repository")
+            return temp_dir
+        except Exception as e:
+            # Clean up on failure
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+            raise Exception(f"Failed to clone repository: {str(e)}")
+    
+    def chunk_code_content(self, content: str, file_path: str, max_chunk_size: int = 1000) -> List[Dict]:
+        """Split code into meaningful chunks"""
+        chunks = []
+        lines = content.split('\n')
+        
+        # For small files, return as single chunk
+        if len(content) <= max_chunk_size:
+            return [{
+                'content': content,
+                'file_path': file_path,
+                'chunk_index': 0,
+                'start_line': 1,
+                'end_line': len(lines),
+                'chunk_type': 'full_file'
+            }]
+        
+        # For larger files, split by functions/classes or line count
+        current_chunk = []
+        current_size = 0
+        chunk_index = 0
+        start_line = 1
+        
+        for i, line in enumerate(lines, 1):
+            current_chunk.append(line)
+            current_size += len(line) + 1  # +1 for newline
+            
+            # Split on function/class definitions or when chunk gets too large
+            is_function_start = any(line.strip().startswith(keyword) for keyword in 
+                                  ['def ', 'function ', 'class ', 'interface ', 'public class'])
+            
+            if (current_size >= max_chunk_size) or (is_function_start and len(current_chunk) > 1):
+                if len(current_chunk) > 1:  # Don't create empty chunks
+                    chunks.append({
+                        'content': '\n'.join(current_chunk[:-1] if is_function_start else current_chunk),
+                        'file_path': file_path,
+                        'chunk_index': chunk_index,
+                        'start_line': start_line,
+                        'end_line': i - (1 if is_function_start else 0),
+                        'chunk_type': 'code_block'
+                    })
+                    chunk_index += 1
+                    start_line = i if is_function_start else i + 1
+                    current_chunk = [line] if is_function_start else []
+                    current_size = len(line) + 1 if is_function_start else 0
+        
+        # Add remaining chunk
+        if current_chunk:
+            chunks.append({
+                'content': '\n'.join(current_chunk),
+                'file_path': file_path,
+                'chunk_index': chunk_index,
+                'start_line': start_line,
+                'end_line': len(lines),
+                'chunk_type': 'code_block'
+            })
+        
+        return chunks
+    
+    async def extract_code_files(self, repo_path: str) -> List[Dict]:
+        """Extract and chunk all code files from repository"""
+        code_chunks = []
+        total_files = 0
+        
+        logger.info(f"📁 Extracting code files from {repo_path}")
+        
+        for root, dirs, files in os.walk(repo_path):
+            # Skip ignored directories
+            dirs[:] = [d for d in dirs if d not in self.ignore_dirs]
+            
+            for file in files:
+                file_path = Path(root) / file
+                
+                # Skip large files (>1MB)
+                if file_path.stat().st_size > 1024 * 1024:
+                    continue
+                    
+                if file_path.suffix in self.supported_extensions:
+                    try:
+                        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                            content = f.read()
+                        
+                        # Skip empty files
+                        if not content.strip():
+                            continue
+                            
+                        relative_path = str(file_path.relative_to(repo_path))
+                        
+                        # Chunk the file content
+                        chunks = self.chunk_code_content(content, relative_path)
+                        code_chunks.extend(chunks)
+                        total_files += 1
+                        
+                        if total_files % 50 == 0:
+                            logger.info(f"📊 Processed {total_files} files, {len(code_chunks)} chunks so far...")
+                            
+                    except Exception as e:
+                        logger.warning(f"⚠️ Error reading file {file_path}: {e}")
+                        continue
+        
+        logger.info(f"✅ Extracted {len(code_chunks)} code chunks from {total_files} files")
+        return code_chunks
+    
+    def cleanup_temp_dir(self, temp_dir: str):
+        """Clean up temporary directory"""
+        try:
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+                logger.info(f"🧹 Cleaned up temporary directory: {temp_dir}")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to cleanup {temp_dir}: {e}")

app/services/vector_service.py

@@ -0,0 +1,118 @@
+import chromadb
+from chromadb.config import Settings
+import os
+from typing import List, Dict, Optional
+import logging
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+class VectorService:
+    def __init__(self):
+        self.client = chromadb.PersistentClient(
+            path="./chroma_db",
+            settings=Settings(
+                anonymized_telemetry=False,
+                allow_reset=True
+            )
+        )
+        logger.info("🗄️ ChromaDB client initialized")
+    
+    def create_collection(self, repository_id: int) -> chromadb.Collection:
+        collection_name = f"repo_{repository_id}"
+        
+        try:
+            collection = self.client.get_collection(collection_name)
+            logger.info(f"📚 Using existing collection: {collection_name}")
+        except:
+            collection = self.client.create_collection(
+                name=collection_name,
+                metadata={"repository_id": repository_id}
+            )
+            logger.info(f"🆕 Created new collection: {collection_name}")
+        
+        return collection
+    
+    async def store_embeddings(self, repository_id: int, embedded_chunks: List[Dict]):
+        logger.info(f"💾 Storing {len(embedded_chunks)} embeddings for repository {repository_id}")
+        
+        collection = self.create_collection(repository_id)
+        
+        documents = []
+        embeddings = []
+        metadatas = []
+        ids = []
+        
+        for i, chunk in enumerate(embedded_chunks):
+            chunk_id = f"chunk_{repository_id}_{chunk['chunk_index']}_{i}"
+            
+            documents.append(chunk['content'])
+            embeddings.append(chunk['embedding'])
+            metadatas.append({
+                'file_path': chunk['file_path'],
+                'start_line': chunk['start_line'],
+                'end_line': chunk['end_line'],
+                'chunk_type': chunk['chunk_type'],
+                'content_length': chunk['content_length'],
+                'repository_id': repository_id
+            })
+            ids.append(chunk_id)
+        
+        batch_size = 100
+        for i in range(0, len(documents), batch_size):
+            end_idx = min(i + batch_size, len(documents))
+            
+            collection.add(
+                documents=documents[i:end_idx],
+                embeddings=embeddings[i:end_idx],
+                metadatas=metadatas[i:end_idx],
+                ids=ids[i:end_idx]
+            )
+        
+        logger.info(f"✅ Successfully stored all embeddings for repository {repository_id}")
+    
+    async def search_similar_code(self, repository_id: int, query_embedding: List[float], top_k: int = 5) -> List[Dict]:
+        collection_name = f"repo_{repository_id}"
+        
+        try:
+            collection = self.client.get_collection(collection_name)
+        except:
+            logger.warning(f"⚠️ Collection {collection_name} not found")
+            return []
+        
+        results = collection.query(
+            query_embeddings=[query_embedding],
+            n_results=top_k,
+            include=['documents', 'metadatas', 'distances']
+        )
+        
+        search_results = []
+        for i in range(len(results['documents'][0])):
+            # Fix similarity calculation
+            distance = results['distances'][0][i]
+            # Convert distance to similarity (higher is better)
+            similarity = max(0.0, 1.0 - distance)  # Ensure positive similarity
+            
+            search_results.append({
+                'content': results['documents'][0][i],
+                'metadata': results['metadatas'][0][i],
+                'similarity': similarity,
+                'file_path': results['metadatas'][0][i]['file_path'],
+                'start_line': results['metadatas'][0][i]['start_line'],
+                'end_line': results['metadatas'][0][i]['end_line']
+            })
+        
+        # Sort by similarity (highest first)
+        search_results.sort(key=lambda x: x['similarity'], reverse=True)
+        
+        logger.info(f"🔍 Found {len(search_results)} similar code chunks")
+        return search_results
+    
+    def delete_repository_data(self, repository_id: int):
+        collection_name = f"repo_{repository_id}"
+        
+        try:
+            self.client.delete_collection(collection_name)
+            logger.info(f"🗑️ Deleted collection: {collection_name}")
+        except:
+            logger.warning(f"⚠️ Collection {collection_name} not found for deletion")

migrations/README

@@ -0,0 +1 @@
+Generic single-database configuration.

migrations/env.py

@@ -0,0 +1,57 @@
+from logging.config import fileConfig
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+from alembic import context
+import os
+import sys
+
+# Add the app directory to the path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+
+from app.core.database import Base
+# Remove user import - we don't need it anymore
+# from app.models.user import User  # ❌ REMOVED
+from app.models.repository import Repository
+from app.models.conversation import Conversation, Message
+
+# this is the Alembic Config object
+config = context.config
+
+# Interpret the config file for Python logging
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# Set the target metadata
+target_metadata = Base.metadata
+
+def run_migrations_offline() -> None:
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+def run_migrations_online() -> None:
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

migrations/script.py.mako

@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

migrations/versions/16e292816c22_initial_migration.py

@@ -0,0 +1,83 @@
+"""Initial migration
+
+Revision ID: 16e292816c22
+Revises: 
+Create Date: 2025-10-23 20:12:28.092984
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '16e292816c22'
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('users',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('email', sa.String(), nullable=False),
+    sa.Column('name', sa.String(), nullable=False),
+    sa.Column('hashed_password', sa.String(), nullable=False),
+    sa.Column('is_active', sa.Boolean(), nullable=True),
+    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=True),
+    sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_users_email'), 'users', ['email'], unique=True)
+    op.create_index(op.f('ix_users_id'), 'users', ['id'], unique=False)
+    op.create_table('repositories',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('user_id', sa.Integer(), nullable=False),
+    sa.Column('github_url', sa.String(), nullable=False),
+    sa.Column('name', sa.String(), nullable=False),
+    sa.Column('status', sa.Enum('PENDING', 'PROCESSING', 'READY', 'FAILED', name='repositorystatus'), nullable=True),
+    sa.Column('error_message', sa.String(), nullable=True),
+    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=True),
+    sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_repositories_id'), 'repositories', ['id'], unique=False)
+    op.create_table('conversations',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('repository_id', sa.Integer(), nullable=False),
+    sa.Column('title', sa.String(), nullable=False),
+    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=True),
+    sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
+    sa.ForeignKeyConstraint(['repository_id'], ['repositories.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_conversations_id'), 'conversations', ['id'], unique=False)
+    op.create_table('messages',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('conversation_id', sa.Integer(), nullable=False),
+    sa.Column('role', sa.String(), nullable=False),
+    sa.Column('content', sa.String(), nullable=False),
+    sa.Column('citations', sa.JSON(), nullable=True),
+    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=True),
+    sa.ForeignKeyConstraint(['conversation_id'], ['conversations.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_messages_id'), 'messages', ['id'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_messages_id'), table_name='messages')
+    op.drop_table('messages')
+    op.drop_index(op.f('ix_conversations_id'), table_name='conversations')
+    op.drop_table('conversations')
+    op.drop_index(op.f('ix_repositories_id'), table_name='repositories')
+    op.drop_table('repositories')
+    op.drop_index(op.f('ix_users_id'), table_name='users')
+    op.drop_index(op.f('ix_users_email'), table_name='users')
+    op.drop_table('users')
+    # ### end Alembic commands ###

migrations/versions/2e8f053488b9_clean_qodex_architecture_no_user_.py

@@ -0,0 +1,46 @@
+"""Clean QODEX architecture - no user dependencies
+
+Revision ID: 2e8f053488b9
+Revises: 16e292816c22
+Create Date: 2025-10-25 19:08:49.834310
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '2e8f053488b9'
+down_revision: Union[str, None] = '16e292816c22'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('messages', 'content',
+               existing_type=sa.VARCHAR(),
+               type_=sa.Text(),
+               existing_nullable=False)
+    op.alter_column('repositories', 'status',
+               existing_type=postgresql.ENUM('PENDING', 'PROCESSING', 'READY', 'FAILED', name='repositorystatus'),
+               type_=sa.Enum('PENDING', 'PROCESSING', 'READY', 'FAILED', name='repositorystatusenum'),
+               existing_nullable=True)
+    op.create_unique_constraint(None, 'repositories', ['github_url'])
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_constraint(None, 'repositories', type_='unique')
+    op.alter_column('repositories', 'status',
+               existing_type=sa.Enum('PENDING', 'PROCESSING', 'READY', 'FAILED', name='repositorystatusenum'),
+               type_=postgresql.ENUM('PENDING', 'PROCESSING', 'READY', 'FAILED', name='repositorystatus'),
+               existing_nullable=True)
+    op.alter_column('messages', 'content',
+               existing_type=sa.Text(),
+               type_=sa.VARCHAR(),
+               existing_nullable=False)
+    # ### end Alembic commands ###

render.yaml

@@ -0,0 +1,11 @@
+services:
+  - type: web
+    name: qodex-api
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn app.main:app --host 0.0.0.0 --port $PORT
+    envVars:
+      - key: ENVIRONMENT
+        value: production
+      - key: DEBUG
+        value: false

requirements.txt

@@ -0,0 +1,27 @@
+# Core FastAPI stack (keep versions)
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+pydantic-settings==2.1.0
+sqlalchemy==2.0.23
+psycopg2-binary==2.9.9
+
+# AI/ML stack (NO VERSION PINS - let pip resolve)
+sentence-transformers
+transformers
+huggingface-hub
+torch
+numpy
+chromadb
+
+# Google AI
+google-generativeai==0.3.1
+
+# Utils (keep versions)
+python-dotenv==1.0.0
+python-multipart==0.0.6
+aiofiles==23.2.1
+requests==2.31.0
+gitpython==3.1.40
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4

run_server.py

@@ -0,0 +1,10 @@
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app.main:app",
+        host="127.0.0.1", 
+        port=8000,
+        reload=True,
+        log_level="info"
+    )