refactor: Move Poetry configuration to project root for cleaner monorepo structure

## Summary
Move pyproject.toml and poetry.lock from backend/ to project root to centralize
Python dependency management and fix virtual environment accessibility issues.

## Changes

### Poetry Configuration (Moved)
- backend/pyproject.toml → pyproject.toml
- backend/poetry.lock → poetry.lock

### Makefile (100+ lines across 20+ targets)
- Changed VENV_DIR from backend/.venv to .venv
- Updated all Poetry commands to run from project root with PYTHONPATH=backend
- Added venv dependency to local-dev-backend and local-dev-all targets
- Updated build targets to use project root as Docker build context
- Updated all test targets (atomic, unit, integration, e2e)
- Updated code quality targets (lint, format, security-check, coverage)
- Fixed clean target to reference root-level paths

### CI/CD Workflows (5 files)
- poetry-lock-check.yml: Updated paths and removed cd backend commands
- 01-lint.yml: Removed working-directory, updated all tool paths
- 04-pytest.yml: Updated cache keys and test commands
- 05-ci.yml: Updated dependency installation commands
- makefile-testing.yml: Updated test execution paths

### Docker Configuration
- backend/Dockerfile.backend: Updated COPY commands for new build context
- docker-compose.dev.yml: Changed context from ./backend to . + fixed indentation

## Benefits
- Single source of truth for Python dependencies at project root
- Simplified virtual environment management (.venv/ at root)
- Consistent build context across all tools (Makefile, docker-compose, CI/CD)
- Better monorepo structure for future frontend/backend separation
- Fixes dependency accessibility issues (e.g., docling import errors)

## Breaking Changes
Developers need to:
1. Remove old venv: rm -rf backend/.venv
2. Create new venv: make venv
3. Update IDE Python interpreter from backend/.venv to .venv

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: manavgup

.github/workflows/01-lint.yml

@@ -1,6 +1,6 @@
 name: Lint & Static Analysis
 
-# This workflow uses tool versions and configurations from backend/pyproject.toml
+# This workflow uses tool versions and configurations from pyproject.toml (project root)
 # All linting tools (Ruff, MyPy, Pylint, Pydocstyle) reference pyproject.toml as single source of truth
 # Tool versions: Ruff ^0.14.0, MyPy ^1.15.0, Pylint ^3.3.8, Pydocstyle ^6.3.0
 
@@ -119,48 +119,44 @@ jobs:
             blocking: true
             cmd: |
               pip install toml
-              python -c "import toml; toml.load(open('backend/pyproject.toml'))"
+              python -c "import toml; toml.load(open('pyproject.toml'))"
 
           # Python backend linting (blocking) - Check ALL backend Python files
           - id: ruff
             name: "Ruff (Lint + Format)"
-            working-directory: backend
             blocking: true
             cmd: |
               pip install poetry
               poetry install --only dev
               echo "Running Ruff linting..."
-              poetry run ruff check . --config pyproject.toml
+              poetry run ruff check backend --config pyproject.toml
               echo "Running Ruff formatting check..."
-              poetry run ruff format --check . --config pyproject.toml
+              poetry run ruff format --check backend --config pyproject.toml
 
           # Python type/quality checking (non-blocking / informational)
           - id: mypy
             name: "MyPy Type Check (Informational)"
-            working-directory: backend
             blocking: false
             cmd: |
               pip install poetry
               poetry install --only dev
-              poetry run mypy . --config-file pyproject.toml --ignore-missing-imports --show-error-codes || true
+              poetry run mypy backend --config-file pyproject.toml --ignore-missing-imports --show-error-codes || true
 
           - id: pylint
             name: "Pylint Quality (Informational)"
-            working-directory: backend
             blocking: false
             cmd: |
               pip install poetry
               poetry install --only dev
-              poetry run pylint rag_solution/ vectordbs/ core/ auth/ --rcfile=pyproject.toml || true
+              poetry run pylint backend/rag_solution/ backend/vectordbs/ backend/core/ backend/auth/ --rcfile=pyproject.toml || true
 
           - id: pydocstyle
             name: "Docstring Style (Informational)"
-            working-directory: backend
             blocking: false
             cmd: |
               pip install poetry
               poetry install --only dev
-              poetry run pydocstyle rag_solution/ vectordbs/ core/ auth/ --config=pyproject.toml --count || true
+              poetry run pydocstyle backend/rag_solution/ backend/vectordbs/ backend/core/ backend/auth/ --config=pyproject.toml --count || true
 
     name: ${{ matrix.name }}
 

.github/workflows/04-pytest.yml

@@ -77,20 +77,20 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cache/pypoetry
-          key: ${{ runner.os }}-poetry-${{ hashFiles('backend/poetry.lock') }}
+          key: ${{ runner.os }}-poetry-${{ hashFiles('poetry.lock') }}
           restore-keys: |
             ${{ runner.os }}-poetry-
 
       # 5️⃣ Install Python dependencies
       - name: 📥 Install dependencies
-        run: cd backend && poetry install --with dev,test
+        run: poetry install --with dev,test
 
       # 6️⃣ Run unit/atomic tests with coverage
       - name: 🧪 Run unit tests with coverage
         run: |
-          # Run from backend directory using poetry, but test from project root
-          cd backend && poetry run pytest ../tests/ -m "unit or atomic" \
-            --cov=rag_solution \
+          # Run from project root using poetry
+          PYTHONPATH=backend poetry run pytest tests/ -m "unit or atomic" \
+            --cov=backend/rag_solution \
             --cov-report=term-missing \
             --cov-report=html \
             --tb=short \

.github/workflows/05-ci.yml

@@ -49,7 +49,7 @@ jobs:
           timeout_minutes: 10
           max_attempts: 3
           retry_wait_seconds: 30
-          command: cd backend && poetry install --with dev,test
+          command: poetry install --with dev,test
 
       - name: Run test isolation checker
         run: |
@@ -108,7 +108,6 @@ jobs:
           max_attempts: 3
           retry_wait_seconds: 30
           command: |
-            cd backend
             pip install poetry
             poetry config virtualenvs.in-project true
             # Regenerate lock file to ensure sync

.github/workflows/makefile-testing.yml

@@ -32,7 +32,6 @@ jobs:
 
       - name: Install dependencies
         run: |
-          cd backend
           poetry install --with test
 
       - name: Set up Docker Buildx
@@ -41,7 +40,7 @@ jobs:
       - name: Test Makefile targets directly
         run: |
           echo "Running direct Makefile tests..."
-          cd backend && poetry run pytest ../tests/test_makefile_targets_direct.py -v
+          PYTHONPATH=backend poetry run pytest tests/test_makefile_targets_direct.py -v
 
       - name: Test make help
         run: |

.github/workflows/poetry-lock-check.yml

@@ -6,13 +6,13 @@ name: Poetry Lock Validation
 on:
   pull_request:
     paths:
-      - 'backend/pyproject.toml'
-      - 'backend/poetry.lock'
+      - 'pyproject.toml'
+      - 'poetry.lock'
   push:
     branches: [main, develop]
     paths:
-      - 'backend/pyproject.toml'
-      - 'backend/poetry.lock'
+      - 'pyproject.toml'
+      - 'poetry.lock'
 
 permissions:
   contents: read
@@ -37,7 +37,6 @@ jobs:
 
       - name: Validate poetry.lock is in sync
         run: |
-          cd backend
           echo "🔍 Checking if poetry.lock is in sync with pyproject.toml..."
 
           if poetry check --lock; then
@@ -50,18 +49,16 @@ jobs:
             echo "but poetry.lock was not regenerated."
             echo ""
             echo "To fix this:"
-            echo "  1. cd backend"
-            echo "  2. poetry lock"
-            echo "  3. git add poetry.lock"
-            echo "  4. git commit -m 'chore: update poetry.lock'"
-            echo "  5. git push"
+            echo "  1. poetry lock"
+            echo "  2. git add poetry.lock"
+            echo "  3. git commit -m 'chore: update poetry.lock'"
+            echo "  4. git push"
             echo ""
             exit 1
           fi
 
       - name: Check for dependency conflicts
         run: |
-          cd backend
           echo "🔍 Checking for dependency conflicts..."
           poetry check
           echo "✅ No dependency conflicts detected"

Makefile

@@ -16,7 +16,7 @@ endif
 # ============================================================================
 
 # Python environment
-VENV_DIR := backend/.venv
+VENV_DIR := .venv
 PYTHON := python3.12
 POETRY := poetry
 
@@ -64,10 +64,10 @@ $(VENV_DIR)/bin/activate:
 		echo "$(RED)❌ Poetry not found. Installing Poetry...$(NC)"; \
 		curl -sSL https://install.python-poetry.org | $(PYTHON) -; \
 	fi
-	@cd backend && $(POETRY) config virtualenvs.in-project true
-	@cd backend && $(POETRY) install --with dev,test
-	@echo "$(GREEN)✅ Virtual environment created at backend/.venv$(NC)"
-	@echo "$(CYAN)💡 Activate with: source backend/.venv/bin/activate$(NC)"
+	@$(POETRY) config virtualenvs.in-project true
+	@$(POETRY) install --with dev,test
+	@echo "$(GREEN)✅ Virtual environment created at .venv$(NC)"
+	@echo "$(CYAN)💡 Activate with: source .venv/bin/activate$(NC)"
 
 clean-venv:
 	@echo "$(CYAN)🧹 Cleaning virtual environment...$(NC)"
@@ -115,22 +115,22 @@ local-dev-infra:
 	@echo "  MinIO:      localhost:9001"
 	@echo "  MLFlow:     localhost:5001"
 
-local-dev-backend:
+local-dev-backend: venv
 	@echo "$(CYAN)🐍 Starting backend with hot-reload (uvicorn)...$(NC)"
 	@echo "$(YELLOW)⚠️  Make sure infrastructure is running: make local-dev-infra$(NC)"
-	@cd backend && $(POETRY) run uvicorn main:app --reload --host 0.0.0.0 --port 8000
+	@PYTHONPATH=backend $(POETRY) run uvicorn main:app --reload --host 0.0.0.0 --port 8000 --app-dir backend
 
 local-dev-frontend:
 	@echo "$(CYAN)⚛️  Starting frontend with HMR (Vite)...$(NC)"
 	@cd frontend && npm run dev
 
-local-dev-all:
+local-dev-all: venv
 	@echo "$(CYAN)🚀 Starting full local development stack...$(NC)"
 	@PROJECT_ROOT=$$(pwd); \
 	mkdir -p $$PROJECT_ROOT/.dev-pids $$PROJECT_ROOT/logs; \
 	$(MAKE) local-dev-infra; \
 	echo "$(CYAN)🐍 Starting backend in background...$(NC)"; \
-	cd backend && $(POETRY) run uvicorn main:app --reload --host 0.0.0.0 --port 8000 > $$PROJECT_ROOT/logs/backend.log 2>&1 & echo $$! > $$PROJECT_ROOT/.dev-pids/backend.pid; \
+	PYTHONPATH=backend $(POETRY) run uvicorn main:app --reload --host 0.0.0.0 --port 8000 --app-dir backend > $$PROJECT_ROOT/logs/backend.log 2>&1 & echo $$! > $$PROJECT_ROOT/.dev-pids/backend.pid; \
 	sleep 2; \
 	if [ -f $$PROJECT_ROOT/.dev-pids/backend.pid ]; then \
 		if kill -0 $$(cat $$PROJECT_ROOT/.dev-pids/backend.pid) 2>/dev/null; then \
@@ -221,31 +221,38 @@ build-backend:
 	@echo "$(CYAN)🔨 Building backend image...$(NC)"
 	@if [ "$(BUILDX_AVAILABLE)" = "yes" ]; then \
 		echo "Using Docker BuildKit with buildx..."; \
-		cd backend && $(CONTAINER_CLI) buildx build --load \
+		$(CONTAINER_CLI) buildx build --load \
 			-t $(GHCR_REPO)/backend:$(PROJECT_VERSION) \
 			-t $(GHCR_REPO)/backend:latest \
-			-f Dockerfile.backend .; \
+			-f backend/Dockerfile.backend \
+			--build-arg BUILDKIT_INLINE_CACHE=1 \
+			.; \
 	else \
 		echo "Using standard Docker build..."; \
-		cd backend && $(CONTAINER_CLI) build \
+		$(CONTAINER_CLI) build \
 			-t $(GHCR_REPO)/backend:$(PROJECT_VERSION) \
 			-t $(GHCR_REPO)/backend:latest \
-			-f Dockerfile.backend .; \
+			-f backend/Dockerfile.backend \
+			.; \
 	fi
 	@echo "$(GREEN)✅ Backend image built$(NC)"
 
 build-frontend:
 	@echo "$(CYAN)🔨 Building frontend image...$(NC)"
 	@if [ "$(BUILDX_AVAILABLE)" = "yes" ]; then \
 		echo "Using Docker BuildKit with buildx..."; \
-		cd frontend && $(CONTAINER_CLI) buildx build --load \
+		$(CONTAINER_CLI) buildx build --load \
 			-t $(GHCR_REPO)/frontend:$(PROJECT_VERSION) \
-			-t $(GHCR_REPO)/frontend:latest .; \
+			-t $(GHCR_REPO)/frontend:latest \
+			-f frontend/Dockerfile \
+			.; \
 	else \
 		echo "Using standard Docker build..."; \
-		cd frontend && $(CONTAINER_CLI) build \
+		$(CONTAINER_CLI) build \
 			-t $(GHCR_REPO)/frontend:$(PROJECT_VERSION) \
-			-t $(GHCR_REPO)/frontend:latest .; \
+			-t $(GHCR_REPO)/frontend:latest \
+			-f frontend/Dockerfile \
+			.; \
 	fi
 	@echo "$(GREEN)✅ Frontend image built$(NC)"
 
@@ -264,18 +271,18 @@ build-all: build-backend build-frontend
 
 test-atomic: venv
 	@echo "$(CYAN)⚡ Running atomic tests (no DB, no coverage)...$(NC)"
-	@cd backend && PYTHONPATH=.. poetry run pytest -c pytest-atomic.ini ../tests/unit/schemas/ -v -m atomic
+	@PYTHONPATH=backend $(POETRY) run pytest -c backend/pytest-atomic.ini tests/unit/schemas/ -v -m atomic
 	@echo "$(GREEN)✅ Atomic tests passed$(NC)"
 
 test-unit-fast: venv
 	@echo "$(CYAN)🏃 Running unit tests (mocked dependencies)...$(NC)"
-	@cd backend && PYTHONPATH=.. poetry run pytest ../tests/unit/ -v ../tests/unit/ -v
+	@PYTHONPATH=backend $(POETRY) run pytest tests/unit/ -v
 	@echo "$(GREEN)✅ Unit tests passed$(NC)"
 
 test-integration: venv local-dev-infra
 	@echo "$(CYAN)🔗 Running integration tests (with real services)...$(NC)"
 	@echo "$(YELLOW)💡 Using shared dev infrastructure (fast, reuses containers)$(NC)"
-	@cd backend && PYTHONPATH=.. poetry run pytest ../tests/integration/ -v -m integration
+	@PYTHONPATH=backend $(POETRY) run pytest tests/integration/ -v -m integration
 	@echo "$(GREEN)✅ Integration tests passed$(NC)"
 
 test-integration-ci: venv
@@ -350,58 +357,58 @@ test-all-ci: test-atomic test-unit-fast test-integration-ci test-e2e-ci-parallel
 
 lint: venv
 	@echo "$(CYAN)🔍 Running linters...$(NC)"
-	@cd backend && $(POETRY) run ruff check . --config pyproject.toml
-	@cd backend && $(POETRY) run mypy . --config-file pyproject.toml --ignore-missing-imports
+	@$(POETRY) run ruff check backend --config pyproject.toml
+	@$(POETRY) run mypy backend --config-file pyproject.toml --ignore-missing-imports
 	@echo "$(GREEN)✅ Linting passed$(NC)"
 
 format: venv
 	@echo "$(CYAN)🎨 Formatting code...$(NC)"
-	@cd backend && $(POETRY) run ruff format . --config pyproject.toml
-	@cd backend && $(POETRY) run ruff check --fix . --config pyproject.toml
+	@$(POETRY) run ruff format backend --config pyproject.toml
+	@$(POETRY) run ruff check --fix backend --config pyproject.toml
 	@echo "$(GREEN)✅ Code formatted$(NC)"
 
 quick-check: venv
 	@echo "$(CYAN)⚡ Running quick quality checks...$(NC)"
-	@cd backend && $(POETRY) run ruff format --check . --config pyproject.toml
-	@cd backend && $(POETRY) run ruff check . --config pyproject.toml
+	@$(POETRY) run ruff format --check backend --config pyproject.toml
+	@$(POETRY) run ruff check backend --config pyproject.toml
 	@echo "$(GREEN)✅ Quick checks passed$(NC)"
 
 security-check: venv
 	@echo "$(CYAN)🔒 Running security checks...$(NC)"
-	@cd backend && $(POETRY) run bandit -r rag_solution/ -ll || echo "$(YELLOW)⚠️  Security issues found$(NC)"
-	@cd backend && $(POETRY) run safety check || echo "$(YELLOW)⚠️  Vulnerabilities found$(NC)"
+	@$(POETRY) run bandit -r backend/rag_solution/ -ll || echo "$(YELLOW)⚠️  Security issues found$(NC)"
+	@$(POETRY) run safety check || echo "$(YELLOW)⚠️  Vulnerabilities found$(NC)"
 	@echo "$(GREEN)✅ Security scan complete$(NC)"
 
 pre-commit-run: venv
 	@echo "$(CYAN)🎯 Running pre-commit checks...$(NC)"
 	@echo "$(CYAN)Step 1/4: Formatting code...$(NC)"
-	@cd backend && $(POETRY) run ruff format . --config pyproject.toml
+	@$(POETRY) run ruff format backend --config pyproject.toml
 	@echo "$(GREEN)✅ Code formatted$(NC)"
 	@echo ""
 	@echo "$(CYAN)Step 2/4: Running ruff linter...$(NC)"
-	@cd backend && $(POETRY) run ruff check --fix . --config pyproject.toml
+	@$(POETRY) run ruff check --fix backend --config pyproject.toml
 	@echo "$(GREEN)✅ Ruff checks passed$(NC)"
 	@echo ""
 	@echo "$(CYAN)Step 3/4: Running mypy type checker...$(NC)"
-	@cd backend && $(POETRY) run mypy . --config-file pyproject.toml --ignore-missing-imports
+	@$(POETRY) run mypy backend --config-file pyproject.toml --ignore-missing-imports
 	@echo "$(GREEN)✅ Type checks passed$(NC)"
 	@echo ""
 	@echo "$(CYAN)Step 4/4: Running pylint...$(NC)"
-	@cd backend && $(POETRY) run pylint rag_solution/ --rcfile=pyproject.toml || echo "$(YELLOW)⚠️  Pylint warnings found$(NC)"
+	@$(POETRY) run pylint backend/rag_solution/ --rcfile=pyproject.toml || echo "$(YELLOW)⚠️  Pylint warnings found$(NC)"
 	@echo ""
 	@echo "$(GREEN)✅ Pre-commit checks complete!$(NC)"
 	@echo "$(CYAN)💡 Tip: Always run this before committing$(NC)"
 
 coverage: venv
 	@echo "$(CYAN)📊 Running tests with coverage...$(NC)"
-	@cd backend && PYTHONPATH=.. poetry run pytest ../tests/unit/ \
-		--cov=rag_solution \
+	@PYTHONPATH=backend $(POETRY) run pytest tests/unit/ \
+		--cov=backend/rag_solution \
 		--cov-report=term-missing \
 		--cov-report=html:htmlcov \
 		--cov-fail-under=60 \
 		-v
 	@echo "$(GREEN)✅ Coverage report generated$(NC)"
-	@echo "$(CYAN)💡 View report: open backend/htmlcov/index.html$(NC)"
+	@echo "$(CYAN)💡 View report: open htmlcov/index.html$(NC)"
 
 # ============================================================================
 # PRODUCTION DEPLOYMENT
@@ -442,7 +449,7 @@ prod-status:
 
 clean:
 	@echo "$(CYAN)🧹 Cleaning up...$(NC)"
-	@rm -rf .pytest_cache .mypy_cache .ruff_cache backend/htmlcov backend/.coverage
+	@rm -rf .pytest_cache .mypy_cache .ruff_cache htmlcov .coverage
 	@find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
 	@echo "$(GREEN)✅ Cleanup complete$(NC)"
 

backend/Dockerfile.backend

@@ -70,13 +70,13 @@ WORKDIR /app
 COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
 COPY --from=builder /usr/local/bin /usr/local/bin
 
-# Copy only essential application files
-COPY main.py healthcheck.py ./
-COPY rag_solution/ ./rag_solution/
-COPY auth/ ./auth/
-COPY core/ ./core/
-COPY cli/ ./cli/
-COPY vectordbs/ ./vectordbs/
+# Copy only essential application files from backend directory
+COPY backend/main.py backend/healthcheck.py ./
+COPY backend/rag_solution/ ./rag_solution/
+COPY backend/auth/ ./auth/
+COPY backend/core/ ./core/
+COPY backend/cli/ ./cli/
+COPY backend/vectordbs/ ./vectordbs/
 COPY pyproject.toml ./
 
 # Create a non-root user and group