Initial commit: RFP Engineering Platform with Deep Research, Inngest integration, and Cloud-ready configurations

.gitignore

@@ -0,0 +1,43 @@
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+.vercel
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env*.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+# backend
+backend/venv/
+backend/.env
+backend/__pycache__/
+backend/chroma_db/
+backend/uploads/
+backend/outputs/
+backend/*.log

README.md

@@ -0,0 +1,213 @@
+# Next-Generation RFP Automation Platform
+
+An end-to-end enterprise proposal automation platform that transforms manual RFP response workflows into an intelligent, AI-driven pipeline.
+
+## Architecture Overview
+
+The platform consists of six core engines:
+
+| Engine        | Purpose                                     | Key Technologies               |
+| ------------- | ------------------------------------------- | ------------------------------ |
+| **Ingestion** | PDF/DOCX parsing, OCR, table extraction     | PyMuPDF, pdfplumber, Tesseract |
+| **Shredding** | Requirement extraction, Section L/M parsing | SpaCy, Regex, Groq (Llama)     |
+| **Knowledge** | Vector storage, semantic search, RAG        | ChromaDB, OpenAI, Groq (OSS)   |
+| **Analysis**  | Risk scoring, Go/No-Go decisions            | Llama 3.3 70B (Groq)           |
+| **Assembly**  | Document generation, form filling           | docxtpl, openpyxl, PyMuPDF     |
+| **Visual**    | Gantt charts, timeline visualization        | Matplotlib, Plotly             |
+| **Tasks**     | Sequential AI processing & Orchestration    | Celery, Redis, BackgroundTasks |
+
+## AI Provider Strategy
+
+The platform utilizes a **Multi-Provider Fallback System** to ensure high availability and performance:
+
+1. **Primary**: **Groq** (Ultra-low latency hardware-accelerated inference using Llama 3.3 70B and Llama 3.1 8B)
+2. **Secondary**: **OpenRouter** (Unified API for various OSS and Frontier models)
+3. **Tertiary**: **OpenAI** (Advanced reasoning & primary fallback)
+4. **Resiliency**: **BackgroundTasks Fallback** (Automatically switches to local FastAPI background tasks if Redis/Celery is unavailable)
+
+## Project Structure
+
+```
+contravaulthvnkz/
+├── backend/
+│   ├── app/
+│   │   ├── main.py              # FastAPI application
+│   │   ├── core/config.py       # Configuration settings
+│   │   ├── ingestion/           # Document ingestion
+│   │   ├── shredding/           # Requirement extraction
+│   │   ├── knowledge/           # Vector DB & RAG
+│   │   ├── integration/         # SAM.gov integration
+│   │   └── visual/              # Visualization
+│   ├── requirements.txt
+│   └── .env
+├── app/                         # Next.js App Router
+│   ├── layout.tsx               # Root layout & design system
+│   ├── page.tsx                 # Home/Dashboard
+│   └── [route]/page.tsx         # Page wrappers for views
+├── views/                       # Pure React views (Design System)
+│   ├── Dashboard.tsx
+│   ├── Ingestion.tsx
+│   ├── Compliance.tsx
+│   ├── Editor.tsx
+│   ├── ExcelPricing.tsx
+│   ├── Submission.tsx
+│   ├── VectorOps.tsx
+│   └── Settings.tsx
+├── components/                  # Reusable components
+├── services/api.ts              # Frontend API client
+└── package.json
+```
+
+## Quick Start
+
+### Backend Setup
+
+```bash
+cd backend
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # or venv\Scripts\activate on Windows
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Download spaCy model
+python -m spacy download en_core_web_sm
+
+# Run the server
+uvicorn app.main:app --reload --port 8000
+```
+
+### Frontend Setup
+
+```bash
+# Install dependencies
+npm install
+
+# Start development server
+npm run dev
+```
+
+The frontend runs on `http://localhost:3000` and the API on `http://localhost:8000`.
+
+## Deployment
+
+### Backend (Render)
+
+The backend is configured for deployment on **Render** using the provided `render.yaml` blueprint.
+
+1.  Connect your GitHub repository to Render.
+2.  Render will automatically detect the `render.yaml` file and prompt you to create the "Blueprint".
+3.  Fill in the required environment variables (API Keys, Database URL).
+4.  The service will be deployed as a Python web service under the root directory `backend/`.
+
+### Frontend (Vercel)
+
+The frontend is ready for **Vercel** deployment.
+
+1.  Push your code to GitHub.
+2.  Import the project in Vercel.
+3.  Add the environment variable `NEXT_PUBLIC_API_URL` pointing to your deployed Render API (e.g., `https://contravaulthvnkz-api.onrender.com/api/v1`).
+4.  Deploy!
+
+## API Endpoints
+
+### Document Processing
+
+- `POST /api/v1/ingest` - Ingest PDF/DOCX document
+- `POST /api/v1/shred` - Extract requirements from document
+- `GET /api/v1/requirements/{project_id}` - Get project requirements
+
+### Analysis
+
+- `POST /api/v1/analyze/go-no-go` - Perform Go/No-Go analysis
+- `POST /api/v1/analyze/risk/{project_id}` - Analyze project risk
+- `POST /api/v1/analyze/win-themes/{project_id}` - Generate win themes
+
+### SAM.gov Integration
+
+- `POST /api/v1/sam/search` - Search federal opportunities
+- `GET /api/v1/sam/opportunity/{notice_id}` - Get full details
+- `POST /api/v1/sam/download/{notice_id}` - Download solicitation artifacts
+
+### Knowledge Engine
+
+- `POST /api/v1/knowledge/index` - Index document to vector store
+- `POST /api/v1/knowledge/search` - Semantic search
+- `POST /api/v1/knowledge/ask` - RAG question answering
+
+### Document Generation
+
+- `POST /api/v1/generate/proposal` - Generate Word document
+- `POST /api/v1/generate/compliance-matrix/{project_id}` - Generate Excel matrix
+
+### Visualization
+
+- `POST /api/v1/visual/gantt` - Generate Gantt chart
+- `GET /api/v1/visual/gantt/{project_id}` - Get project Gantt (PNG)
+
+## Configuration
+
+### Backend (.env)
+
+```
+OPENAI_API_KEY=sk-...
+SAM_GOV_API_KEY=...
+PINECONE_API_KEY=...
+CHROMA_PERSIST_DIR=./chroma_db
+EMBEDDING_MODEL=text-embedding-3-small
+```
+
+### Frontend (.env.local)
+
+```
+NEXT_PUBLIC_API_URL=http://localhost:8000/api/v1
+```
+
+## Key Features
+
+### Premium Visual Design System
+
+- **Rich Aesthetics**: High-contrast dark mode support, glassmorphism UI elements, and vibrant accent colors.
+- **Fluid Motion**: Logic-heavy views (Editor, Excel, Vectors) feature high-FPS entrance animations and hover transitions.
+- **Dynamic Interaction**: All buttons and interactive cards utilize `active:scale-95` feedback for a tactile feel.
+
+### Hybrid Requirement Extraction
+
+1. **Layer 1 (Regex)**: Pattern matching for modal verbs (shall, must, will)
+2. **Layer 2 (LLM)**: Semantic filtering for contractor obligations
+
+### Section Recognition
+
+- **Section L**: Instructions (format, page limits)
+- **Section M**: Evaluation Factors (scoring)
+- **Section C**: Statement of Work
+
+### Compliance Matrix
+
+Generated Excel with requirement ID, risk scoring, volume assignment, and status tracking.
+
+### Gantt Charts
+
+Back-casting algorithm from submission date through review milestones.
+
+## Frontend Workspace
+
+| View         | Route         | Function                         |
+| ------------ | ------------- | -------------------------------- |
+| Dashboard    | `/`           | Overview & project list          |
+| Workbench    | `/ingestion`  | Document upload & analysis       |
+| Compliance   | `/compliance` | Requirements matrix              |
+| Authoring    | `/editor`     | Authoring with AI Copilot        |
+| Pricing      | `/pricing`    | Excel-like cost editor           |
+| Submission   | `/submission` | Final package & sanitization     |
+| Vector Index | `/vectors`    | Semantic embedding visualization |
+| Settings     | `/settings`   | Global configuration             |
+
+## Interactive API Docs
+
+Once the backend is running, visit:
+
+- Swagger UI: `http://localhost:8000/docs`
+- ReDoc: `http://localhost:8000/redoc`

app/compliance/page.tsx

@@ -0,0 +1,5 @@
+import Compliance from '@/views/Compliance';
+
+export default function Page() {
+  return <Compliance />;
+}

app/deep-research/page.tsx

@@ -0,0 +1,5 @@
+import DeepResearch from "@/views/DeepResearch";
+
+export default function DeepResearchPage() {
+  return <DeepResearch />;
+}

app/editor/page.tsx

@@ -0,0 +1,5 @@
+import Editor from '@/views/Editor';
+
+export default function Page() {
+  return <Editor />;
+}

app/globals.css

@@ -0,0 +1,86 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* Material Symbols Icons - Critical styles for proper icon rendering */
+@layer base {
+  .material-symbols-outlined {
+    font-family: 'Material Symbols Outlined';
+    font-weight: normal;
+    font-style: normal;
+    font-size: 24px;
+    line-height: 1;
+    letter-spacing: normal;
+    text-transform: none;
+    display: inline-block;
+    white-space: nowrap;
+    word-wrap: normal;
+    direction: ltr;
+    -webkit-font-feature-settings: 'liga';
+    font-feature-settings: 'liga';
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    font-variation-settings: 'FILL' 0, 'wght' 400, 'GRAD' 0, 'opsz' 24;
+  }
+
+  /* Filled variant */
+  .material-symbols-outlined.filled {
+    font-variation-settings: 'FILL' 1, 'wght' 400, 'GRAD' 0, 'opsz' 24;
+  }
+}
+
+@layer components {
+  .btn {
+    @apply inline-flex items-center justify-center gap-2 px-4 py-2 rounded-lg text-sm font-medium transition-all duration-200 active:scale-95 disabled:opacity-50 disabled:pointer-events-none;
+  }
+  
+  .btn-primary {
+    @apply bg-primary text-white hover:bg-primary-dark shadow-md shadow-primary/20;
+  }
+  
+  .btn-secondary {
+    @apply bg-white dark:bg-slate-800 border border-slate-200 dark:border-slate-700 text-slate-700 dark:text-slate-300 hover:bg-slate-50 dark:hover:bg-slate-700;
+  }
+
+  .card {
+    @apply bg-white dark:bg-panel-dark border border-slate-200 dark:border-slate-800 rounded-xl shadow-sm transition-all duration-300 hover:shadow-md;
+  }
+}
+
+/* Custom Scrollbar */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+::-webkit-scrollbar-thumb {
+  background: #cbd5e1;
+  border-radius: 4px;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: #94a3b8;
+}
+.dark ::-webkit-scrollbar-thumb {
+  background: #475569;
+}
+.dark ::-webkit-scrollbar-thumb:hover {
+  background: #64748b;
+}
+
+/* Specialized Utilities */
+.glass-panel {
+  background: rgba(30, 41, 59, 0.6);
+  backdrop-filter: blur(12px);
+  border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.animate-in {
+  animation: fadeIn 0.4s ease-out forwards;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; transform: translateY(10px); }
+  to { opacity: 1; transform: translateY(0); }
+}

app/ingestion/page.tsx

@@ -0,0 +1,5 @@
+import Ingestion from '@/views/Ingestion';
+
+export default function Page() {
+  return <Ingestion />;
+}

app/layout.tsx

@@ -0,0 +1,41 @@
+import React from 'react';
+import type { Metadata } from 'next';
+import { Inter, Merriweather, Roboto_Mono } from 'next/font/google';
+import './globals.css';
+import { Sidebar } from '@/components/Sidebar';
+
+const inter = Inter({ subsets: ['latin'], variable: '--font-inter', display: 'swap' });
+const merriweather = Merriweather({ weight: ['300', '400', '700'], subsets: ['latin'], variable: '--font-merriweather', display: 'swap' });
+const robotoMono = Roboto_Mono({ subsets: ['latin'], variable: '--font-roboto-mono', display: 'swap' });
+
+export const metadata: Metadata = {
+  title: 'RFP Auto - Enterprise Proposal Platform',
+  description: 'Enterprise Proposal Platform',
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en" suppressHydrationWarning className={`${inter.variable} ${merriweather.variable} ${robotoMono.variable} h-full`}>
+       <head>
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link rel="preconnect" href="https://fonts.gstatic.com" crossOrigin="anonymous" />
+        <link
+          href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200&display=swap"
+          rel="stylesheet"
+        />
+      </head>
+      <body className="bg-background-light dark:bg-background-dark text-slate-900 dark:text-white font-sans antialiased overflow-hidden selection:bg-primary/20 h-full">
+        <div className="flex h-screen w-full overflow-hidden">
+          <Sidebar />
+          <main className="flex-1 overflow-hidden relative">
+            {children}
+          </main>
+        </div>
+      </body>
+    </html>
+  );
+}

app/opportunities/page.tsx

@@ -0,0 +1,5 @@
+import Opportunities from '@/views/Opportunities';
+
+export default function Page() {
+  return <Opportunities />;
+}

app/page.tsx

@@ -0,0 +1,5 @@
+import Dashboard from '@/views/Dashboard';
+
+export default function Page() {
+  return <Dashboard />;
+}

app/pricing/page.tsx

@@ -0,0 +1,5 @@
+import ExcelPricing from '@/views/ExcelPricing';
+
+export default function Page() {
+  return <ExcelPricing />;
+}

app/projects/page.tsx

@@ -0,0 +1,5 @@
+import Projects from "@/views/Projects";
+
+export default function ProjectsPage() {
+  return <Projects />;
+}

app/settings/page.tsx

@@ -0,0 +1,5 @@
+import Settings from '@/views/Settings';
+
+export default function Page() {
+  return <Settings />;
+}

app/submission/page.tsx

@@ -0,0 +1,5 @@
+import Submission from '@/views/Submission';
+
+export default function Page() {
+  return <Submission />;
+}

app/vectors/page.tsx

@@ -0,0 +1,5 @@
+import VectorOps from '@/views/VectorOps';
+
+export default function Page() {
+  return <VectorOps />;
+}

backend/.env.example

@@ -0,0 +1,70 @@
+# ContraVault Environment Configuration
+# Copy this file to .env and fill in your values
+
+# =============================================================================
+# AI PROVIDERS (All Free Tiers)
+# =============================================================================
+
+# OpenRouter - Primary provider for most features
+# Get free API key at: https://openrouter.ai/keys
+OPENROUTER_API_KEY=sk-or-v1-your-key-here
+
+# Cerebras - Fast inference for knowledge QA
+# Get free API key at: https://cloud.cerebras.ai/
+CEREBRAS_API_KEY=csk-your-key-here
+
+# Mistral - Code generation (optional)
+# Get free API key at: https://console.mistral.ai/
+MISTRAL_API_KEY=your-key-here
+
+# Groq - Alternative fast inference (legacy)
+# Get free API key at: https://console.groq.com/
+GROQ_API_KEY=gsk_your-key-here
+
+# =============================================================================
+# DATABASE
+# =============================================================================
+
+# PostgreSQL connection (Neon recommended)
+DATABASE_URL=postgresql://user:password@host/database?sslmode=require
+ASYNC_DATABASE_URL=postgresql+asyncpg://user:password@host/database?ssl=require
+
+# =============================================================================
+# VECTOR DATABASE
+# =============================================================================
+
+# Local ChromaDB storage path
+CHROMA_PERSIST_DIR=./chroma_db
+
+# =============================================================================
+# EMBEDDINGS
+# =============================================================================
+
+# OpenAI embeddings (uses OpenRouter by default)
+OPENAI_API_KEY=sk-or-v1-your-openrouter-key
+OPENAI_BASE_URL=https://openrouter.ai/api/v1
+EMBEDDING_MODEL=text-embedding-3-small
+EMBEDDING_DIMENSIONS=1536
+
+# =============================================================================
+# STORAGE
+# =============================================================================
+
+UPLOAD_DIR=./uploads
+OUTPUT_DIR=./outputs
+TEMPLATE_DIR=./templates
+
+# =============================================================================
+
+# =============================================================================
+# NLI / ML SETTINGS
+# =============================================================================
+
+USE_TRANSFORMER_NLI=false
+CROSS_ENCODER_MODEL=balanced
+
+# =============================================================================
+# EXTERNAL SERVICES (Optional)
+# =============================================================================
+
+FIRECRAWL_API_KEY=your-key-here

backend/README.md

@@ -0,0 +1,68 @@
+# Next-Gen RFP Automation Backend
+
+## Overview
+
+This backend implements the "Executive Architecture" for the RFP Automation platform. It is designed as a modular Python system with specialized engines for ingestion, analysis, and generation.
+
+## Setup Instructions
+
+### Prerequisites
+
+- Python 3.10+
+- Tesseract OCR (installed and in PATH)
+- C++ Build Tools (for some NLP libraries)
+
+### Installation
+
+1. Create a virtual environment:
+
+   ```powershell
+   python -m venv venv
+   .\venv\Scripts\Activate
+   ```
+
+2. Install dependencies:
+
+   ```powershell
+   pip install -r requirements.txt
+   ```
+
+   _Note: `detectron2` and `unstructured` are heavy dependencies. If installation fails, try installing strictly the core packages first or use pre-built wheels._
+
+3. Configure Environment:
+   The `.env` file has been created with your provided API keys. Ensure it remains secure.
+
+### Running the Server
+
+```powershell
+uvicorn app.main:app --reload
+```
+
+## Module Structure
+
+1. **Ingestion Engine** (`app/ingestion`):
+   - Handles PDF/Word parsing.
+   - Implements partitioning strategies (Hi-Res, Fast, OCR).
+
+2. **Shredding Engine** (`app/shredding`):
+   - Hybrid extraction model (Regex + Agentic).
+   - Generates `ComplianceItem` objects.
+
+3. **Knowledge Engine** (`app/knowledge`):
+   - Manages Vector DB connections (ChromaDB/pgvector).
+   - Handles semantic chunking and retrieval.
+
+4. **Analysis Engine** (`app/analysis`):
+   - Calculates Risk Scores ("Poison Pills").
+   - Detects contradictions.
+
+5. **Assembly Engine** (`app/assembly`):
+   - Generates Excel Compliance Matrices.
+   - Generates Word Proposals and fills PDF forms.
+
+6. **Visual Engine** (`app/visual`):
+   - Generates Gantt charts for proposal management.
+
+## API Documentation
+
+Once running, visit `http://localhost:8000/docs` for the interactive API documentation.

backend/ai_router.py

@@ -0,0 +1,83 @@
+import os
+import requests
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AIModelRouter:
+    def __init__(self):
+        self.openrouter_key = os.getenv("OPENROUTER_API_KEY")
+        self.cerebras_key = os.getenv("CEREBRAS_API_KEY")
+        
+        # Priority List: High Intelligence -> High Speed -> Fallback
+        self.model_priority = [
+            # PRIMARY: Google Gemma 3 27B (High Context, Multimodal, Free on OpenRouter)
+            {"id": "google/gemma-3-27b-instruct:free", "provider": "openrouter", "context": 131000},
+            
+            # SECONDARY: Llama 3.3 70B (High Intelligence, Free on OpenRouter)
+            {"id": "meta-llama/llama-3.3-70b-instruct:free", "provider": "openrouter", "context": 64000},
+            
+            # TERTIARY: Llama 3.1 8B (Super Fast, Free on Cerebras)
+            {"id": "llama3.1-8b", "provider": "cerebras", "context": 8192},
+            
+            # FALLBACK: Mistral Small (Generalist)
+            {"id": "mistralai/mistral-small-24b-instruct-2501:free", "provider": "openrouter", "context": 32000}
+        ]
+
+    def generate_response(self, system_prompt, user_content):
+        errors = []
+        
+        for model in self.model_priority:
+            try:
+                print(f"🔄 Routing to Model: {model['id']} via {model['provider']}...")
+                
+                if model['provider'] == "openrouter":
+                    response = self._call_openrouter(model['id'], system_prompt, user_content)
+                elif model['provider'] == "cerebras":
+                    response = self._call_cerebras(model['id'], system_prompt, user_content)
+                
+                if response:
+                    print(f"✅ Success with {model['id']}")
+                    return {
+                        "content": response,
+                        "model_used": model['id'],
+                        "provider": model['provider']
+                    }
+            except Exception as e:
+                print(f"❌ Failed {model['id']}: {str(e)}")
+                errors.append(f"{model['id']}: {str(e)}")
+                continue # Auto-swap to next model
+        
+        raise Exception(f"All AI Models Failed. Errors: {errors}")
+
+    def _call_openrouter(self, model_id, system, user):
+        headers = {
+            "Authorization": f"Bearer {self.openrouter_key}",
+            "HTTP-Referer": "https://heavenkeys.ca", 
+            "X-Title": "ContractVault"
+        }
+        payload = {
+            "model": model_id,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user}
+            ]
+        }
+        resp = requests.post("https://openrouter.ai/api/v1/chat/completions", json=payload, headers=headers, timeout=120)
+        resp.raise_for_status()
+        return resp.json()['choices'][0]['message']['content']
+
+    def _call_cerebras(self, model_id, system, user):
+        headers = {"Authorization": f"Bearer {self.cerebras_key}"}
+        payload = {
+            "model": model_id,
+            "stream": False,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user}
+            ]
+        }
+        resp = requests.post("https://api.cerebras.ai/v1/chat/completions", json=payload, headers=headers, timeout=120)
+        resp.raise_for_status()
+        return resp.json()['choices'][0]['message']['content']

backend/app/__init__.py

@@ -0,0 +1 @@
+# RFP Automation Platform - Main Package

backend/app/ai/__init__.py

@@ -0,0 +1,54 @@
+# AI Module - Multi-Provider with Smart Routing
+# Supports OpenRouter (free), Cerebras (free), Mistral (free)
+
+# Import from smart_router (new implementation with auto-swap)
+from .smart_router import (
+    SmartAIRouter,
+    AIProvider,
+    FeatureType,
+    ChatMessage,
+    AIResponse,
+    ModelConfig,
+    ModelChain,
+    ProviderHealth,
+    SwapReason,
+    ALL_MODELS,
+    FEATURE_MODEL_CHAINS,
+    get_smart_router,
+    configure_smart_router,
+    get_model_by_id,
+    # Backwards compatibility aliases
+    MultiProviderAI,
+    get_ai_service,
+    configure_ai_service,
+)
+
+# Also import legacy for explicit access
+from . import providers as legacy_providers
+
+# Legacy alias for AVAILABLE_MODELS
+AVAILABLE_MODELS = ALL_MODELS
+
+__all__ = [
+    # New smart router
+    "SmartAIRouter",
+    "AIProvider",
+    "FeatureType",
+    "ChatMessage",
+    "AIResponse",
+    "ModelConfig",
+    "ModelChain",
+    "ProviderHealth",
+    "SwapReason",
+    "ALL_MODELS",
+    "AVAILABLE_MODELS",
+    "FEATURE_MODEL_CHAINS",
+    "get_smart_router",
+    "configure_smart_router",
+    "get_model_by_id",
+    # Backwards compatibility
+    "MultiProviderAI",
+    "get_ai_service",
+    "configure_ai_service",
+    "legacy_providers",
+]

backend/app/ai/providers.py

@@ -0,0 +1,533 @@
+# Multi-Provider AI Service
+# Supports Groq, OpenRouter, and OpenAI with automatic fallback
+
+import os
+import json
+import httpx
+import asyncio
+from typing import Optional, List, Dict, Any, AsyncGenerator
+from pydantic import BaseModel
+from enum import Enum
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AIProvider(str, Enum):
+    GROQ = "groq"
+    OPENROUTER = "openrouter"
+    OPENAI = "openai"
+    CEREBRAS = "cerebras"
+    MISTRAL = "mistral"
+
+
+class ModelConfig(BaseModel):
+    provider: AIProvider
+    model_id: str
+    display_name: str
+    context_window: int
+    supports_streaming: bool = True
+    supports_vision: bool = False
+    is_free: bool = False
+
+
+# Available models per provider
+AVAILABLE_MODELS: Dict[AIProvider, List[ModelConfig]] = {
+    AIProvider.CEREBRAS: [
+        ModelConfig(provider=AIProvider.CEREBRAS, model_id="llama-3.3-70b", display_name="Cerebras Llama 3.3 70B", context_window=65536),
+        ModelConfig(provider=AIProvider.CEREBRAS, model_id="llama3.1-8b", display_name="Cerebras Llama 3.1 8B", context_window=8192),
+        ModelConfig(provider=AIProvider.CEREBRAS, model_id="qwen-3-32b", display_name="Cerebras Qwen 3 32B", context_window=65536),
+    ],
+    AIProvider.GROQ: [
+        ModelConfig(provider=AIProvider.GROQ, model_id="llama-3.3-70b-versatile", display_name="Groq Llama 3.3 70B", context_window=128000),
+        ModelConfig(provider=AIProvider.GROQ, model_id="llama-3.1-8b-instant", display_name="Groq Llama 3.1 8B", context_window=128000),
+    ],
+    AIProvider.OPENROUTER: [
+        ModelConfig(provider=AIProvider.OPENROUTER, model_id="meta-llama/llama-3.3-70b-instruct:free", display_name="Llama 3.3 70B (Free)", context_window=131072, is_free=True),
+        ModelConfig(provider=AIProvider.OPENROUTER, model_id="google/gemma-3-27b-instruct:free", display_name="Gemma 3 27B (Free)", context_window=131072, is_free=True),
+        ModelConfig(provider=AIProvider.OPENROUTER, model_id="nousresearch/hermes-3-405b:free", display_name="Hermes 3 405B (Free)", context_window=131072, is_free=True),
+        ModelConfig(provider=AIProvider.OPENROUTER, model_id="google/gemma-3-12b-instruct:free", display_name="Gemma 3 12B (Free)", context_window=32768, is_free=True),
+        ModelConfig(provider=AIProvider.OPENROUTER, model_id="meta-llama/llama-3.2-3b-instruct:free", display_name="Llama 3.2 3B (Free)", context_window=131072, is_free=True),
+        ModelConfig(provider=AIProvider.OPENROUTER, model_id="qwen/qwen2.5-vl-7b-instruct:free", display_name="Qwen 2.5 VL 7B (Free)", context_window=32768, is_free=True),
+    ],
+    AIProvider.MISTRAL: [
+        ModelConfig(provider=AIProvider.MISTRAL, model_id="mistral-large-latest", display_name="Mistral Large 3", context_window=128000),
+        ModelConfig(provider=AIProvider.MISTRAL, model_id="mistral-small-latest", display_name="Mistral Small 3.2", context_window=128000),
+        ModelConfig(provider=AIProvider.MISTRAL, model_id="codestral-latest", display_name="Codestral", context_window=32768),
+    ],
+    AIProvider.OPENAI: [
+        ModelConfig(provider=AIProvider.OPENAI, model_id="gpt-4o", display_name="GPT-4o", context_window=128000),
+        ModelConfig(provider=AIProvider.OPENAI, model_id="gpt-4o-mini", display_name="GPT-4o Mini", context_window=128000),
+    ],
+}
+
+
+class ChatMessage(BaseModel):
+    role: str  # "system", "user", "assistant"
+    content: str
+
+
+class AIResponse(BaseModel):
+    content: str
+    model: str
+    provider: AIProvider
+    usage: Optional[Dict[str, int]] = None
+    finish_reason: Optional[str] = None
+
+
+class MultiProviderAI:
+    """
+    Multi-provider AI service supporting Cerebras, Groq, OpenRouter, Mistral, and OpenAI.
+    Provides automatic fallback between providers and specific routing for RFP features.
+    """
+
+    def __init__(
+        self,
+        groq_api_key: Optional[str] = None,
+        openrouter_api_key: Optional[str] = None,
+        openai_api_key: Optional[str] = None,
+        cerebras_api_key: Optional[str] = None,
+        mistral_api_key: Optional[str] = None,
+        default_provider: AIProvider = AIProvider.CEREBRAS,
+        default_model: Optional[str] = None,
+    ):
+        from app.core.config import settings
+        
+        self.api_keys = {
+            AIProvider.CEREBRAS: cerebras_api_key or settings.CEREBRAS_API_KEY or os.getenv("CEREBRAS_API_KEY", ""),
+            AIProvider.GROQ: groq_api_key or settings.GROQ_API_KEY or os.getenv("GROQ_API_KEY", ""),
+            AIProvider.OPENROUTER: openrouter_api_key or settings.OPENROUTER_API_KEY or os.getenv("OPENROUTER_API_KEY", ""),
+            AIProvider.MISTRAL: mistral_api_key or settings.MISTRAL_API_KEY or os.getenv("MISTRAL_API_KEY", ""),
+            AIProvider.OPENAI: openai_api_key or settings.OPENAI_API_KEY or os.getenv("OPENAI_API_KEY", ""),
+        }
+
+        self.base_urls = {
+            AIProvider.CEREBRAS: "https://api.cerebras.ai/v1",
+            AIProvider.GROQ: "https://api.groq.com/openai/v1",
+            AIProvider.OPENROUTER: "https://openrouter.ai/api/v1",
+            AIProvider.MISTRAL: "https://api.mistral.ai/v1",
+            AIProvider.OPENAI: "https://api.openai.com/v1",
+        }
+
+        # Select a configured provider if default is not configured
+        if not self.api_keys.get(default_provider):
+            for p in [AIProvider.CEREBRAS, AIProvider.GROQ, AIProvider.OPENROUTER, AIProvider.MISTRAL, AIProvider.OPENAI]:
+                if self.api_keys.get(p):
+                    default_provider = p
+                    break
+                    
+        self.default_provider = default_provider
+        self.default_model = default_model or self._get_default_model(default_provider)
+
+        # Provider priority for general fallback
+        self.fallback_order = [AIProvider.CEREBRAS, AIProvider.GROQ, AIProvider.OPENROUTER, AIProvider.MISTRAL, AIProvider.OPENAI]
+
+        # Feature-to-Provider mapping (Primary and Fallback)
+        self.feature_routing = {
+            "shredding": [(AIProvider.CEREBRAS, "llama-3.3-70b"), (AIProvider.OPENROUTER, "meta-llama/llama-3.3-70b-instruct:free")],
+            "analysis": [(AIProvider.CEREBRAS, "llama-3.3-70b"), (AIProvider.OPENROUTER, "meta-llama/llama-3.3-70b-instruct:free")],
+            "blind_rfp": [(AIProvider.OPENROUTER, "google/gemma-3-27b-instruct:free"), (AIProvider.CEREBRAS, "qwen-3-32b")],
+            "contradictions": [(AIProvider.OPENROUTER, "google/gemma-3-27b-instruct:free"), (AIProvider.MISTRAL, "mistral-small-latest")],
+            "win_themes": [(AIProvider.OPENROUTER, "nousresearch/hermes-3-405b:free"), (AIProvider.MISTRAL, "mistral-large-latest")],
+            "rfi_gen": [(AIProvider.CEREBRAS, "llama-3.3-70b"), (AIProvider.OPENROUTER, "meta-llama/llama-3.3-70b-instruct:free")],
+            "chat": [(AIProvider.CEREBRAS, "llama3.1-8b"), (AIProvider.OPENROUTER, "meta-llama/llama-3.2-3b-instruct:free")],
+        }
+
+    def _get_default_model(self, provider: AIProvider) -> str:
+        models = AVAILABLE_MODELS.get(provider, [])
+        return models[0].model_id if models else ""
+
+    def _get_headers(self, provider: AIProvider) -> Dict[str, str]:
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_keys[provider]}",
+        }
+
+        if provider == AIProvider.OPENROUTER:
+            headers["HTTP-Referer"] = "https://contravault.ai"
+            headers["X-Title"] = "ContraVault RFP Platform"
+
+        return headers
+
+    def get_available_providers(self) -> List[Dict[str, Any]]:
+        """Get list of available providers with their API key status."""
+        providers = []
+        for provider in AIProvider:
+            has_key = bool(self.api_keys.get(provider))
+            models = AVAILABLE_MODELS.get(provider, [])
+            providers.append({
+                "id": provider.value,
+                "name": provider.value.title(),
+                "configured": has_key,
+                "models": [m.model_dump() for m in models],
+            })
+        return providers
+
+    def get_available_models(self, provider: Optional[AIProvider] = None) -> List[ModelConfig]:
+        """Get available models for a specific provider or all providers."""
+        if provider:
+            return AVAILABLE_MODELS.get(provider, [])
+
+        all_models = []
+        for p, models in AVAILABLE_MODELS.items():
+            if self.api_keys.get(p):
+                all_models.extend(models)
+        return all_models
+
+    async def chat(
+        self,
+        messages: List[ChatMessage],
+        feature: Optional[str] = None,
+        provider: Optional[AIProvider] = None,
+        model: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+        stream: bool = False,
+    ) -> AIResponse:
+        """
+        Send a chat completion request with automatic failover and feature-based routing.
+        """
+        # Determine initial attempt list
+        attempts = []
+        
+        if feature and feature in self.feature_routing:
+            # Add feature-specific route first
+            for p, m in self.feature_routing[feature]:
+                if self.api_keys.get(p):
+                    attempts.append((p, m))
+        
+        if provider and model:
+            # Use explicit provider/model if requested (but will still failover if fails)
+            if (provider, model) not in attempts:
+                attempts.append((provider, model))
+        elif provider:
+            # Use explicit provider with its default model
+            m = self._get_default_model(provider)
+            if (provider, m) not in attempts:
+                attempts.append((provider, m))
+        
+        # Add general fallbacks
+        for p in self.fallback_order:
+            m = self._get_default_model(p)
+            if (p, m) not in attempts:
+                attempts.append((p, m))
+
+        last_error = None
+        for p, m in attempts:
+            if not self.api_keys.get(p):
+                continue
+
+            try:
+                logger.info(f"Attempting chat with {p.value} using model {m} (Feature: {feature or 'None'})")
+                if stream:
+                    return await self._stream_chat(messages, p, m, temperature, max_tokens)
+                else:
+                    return await self._complete_chat(messages, p, m, temperature, max_tokens)
+            except Exception as e:
+                logger.warning(f"Provider {p.value} ({m}) failed for feature '{feature}': {e}")
+                last_error = e
+                continue
+
+        raise Exception(f"All providers failed for {feature or 'chat'}. Last error: {last_error}")
+
+    async def _complete_chat(
+        self,
+        messages: List[ChatMessage],
+        provider: AIProvider,
+        model: str,
+        temperature: float,
+        max_tokens: int,
+    ) -> AIResponse:
+        """Make a non-streaming chat completion request."""
+        url = f"{self.base_urls[provider]}/chat/completions"
+        headers = self._get_headers(provider)
+
+        payload = {
+            "model": model,
+            "messages": [{"role": m.role, "content": m.content} for m in messages],
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(url, headers=headers, json=payload)
+            response.raise_for_status()
+            data = response.json()
+
+        choice = data["choices"][0]
+        return AIResponse(
+            content=choice["message"]["content"],
+            model=data.get("model", model),
+            provider=provider,
+            usage=data.get("usage"),
+            finish_reason=choice.get("finish_reason"),
+        )
+
+    async def _stream_chat(
+        self,
+        messages: List[ChatMessage],
+        provider: AIProvider,
+        model: str,
+        temperature: float,
+        max_tokens: int,
+    ) -> AsyncGenerator[str, None]:
+        """Make a streaming chat completion request."""
+        url = f"{self.base_urls[provider]}/chat/completions"
+        headers = self._get_headers(provider)
+
+        payload = {
+            "model": model,
+            "messages": [{"role": m.role, "content": m.content} for m in messages],
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": True,
+        }
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            async with client.stream("POST", url, headers=headers, json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            data = json.loads(data_str)
+                            delta = data["choices"][0].get("delta", {})
+                            if "content" in delta:
+                                yield delta["content"]
+                        except json.JSONDecodeError:
+                            continue
+
+    async def analyze_rfp_text(
+        self,
+        text: str,
+        analysis_type: str = "requirements",
+        provider: Optional[AIProvider] = None,
+        model: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Specialized RFP analysis using AI.
+        Supports: requirements, risks, go_no_go, win_themes, compliance
+        """
+        prompts = {
+            "requirements": """Analyze the following RFP text and extract all requirements.
+For each requirement, identify:
+1. The exact text of the requirement
+2. Whether it's mandatory (shall/must) or desirable (should/may)
+3. The category (Technical, Management, Legal, Financial, etc.)
+4. Risk level (High/Medium/Low)
+5. Any keywords or compliance standards mentioned
+
+Return as JSON array with fields: text, type, category, risk_level, keywords
+
+RFP Text:
+{text}""",
+
+            "risks": """Analyze the following RFP text for potential risks and red flags.
+Look for:
+1. Unlimited liability clauses
+2. Unrealistic timelines
+3. Ambiguous scope
+4. Onerous payment terms
+5. IP ownership issues
+6. Performance bond requirements
+7. Liquidated damages
+8. Insurance requirements
+
+Return as JSON array with fields: risk_type, severity (high/medium/low), clause_text, recommendation
+
+RFP Text:
+{text}""",
+
+            "go_no_go": """Perform a Go/No-Go analysis on this RFP.
+Evaluate:
+1. Technical fit (1-10)
+2. Resource availability (1-10)
+3. Timeline feasibility (1-10)
+4. Competitive position (1-10)
+5. Profitability potential (1-10)
+6. Strategic alignment (1-10)
+7. Risk level (1-10, lower is better)
+
+Provide:
+- Overall recommendation: GO, NO-GO, or CONDITIONAL
+- Confidence percentage
+- Key reasons for the decision
+- Mitigation strategies if CONDITIONAL
+
+Return as JSON with fields: recommendation, confidence, scores (object), reasons (array), mitigations (array)
+
+RFP Text:
+{text}""",
+
+            "win_themes": """Based on this RFP, identify potential win themes and discriminators.
+Consider:
+1. What does the client really need?
+2. What pain points are implied?
+3. What differentiators could be emphasized?
+4. What proof points would be compelling?
+
+Return as JSON array with fields: theme_title, description, supporting_evidence, discriminator_level (strong/moderate/weak)
+
+RFP Text:
+{text}""",
+
+            "compliance": """Analyze this RFP for compliance requirements.
+Identify:
+1. Certifications required (ISO, SOC2, FedRAMP, etc.)
+2. Security standards
+3. Regulatory compliance (GDPR, HIPAA, etc.)
+4. Format requirements (page limits, fonts, sections)
+5. Submission requirements (deadlines, methods)
+
+Return as JSON with fields: certifications (array), security_standards (array), regulations (array), format_requirements (object), submission_requirements (object)
+
+RFP Text:
+{text}""",
+        }
+
+        prompt = prompts.get(analysis_type, prompts["requirements"])
+        formatted_prompt = prompt.format(text=text[:15000])  # Limit text length
+
+        messages = [
+            ChatMessage(role="system", content="You are an expert RFP analyst. Always respond with valid JSON only, no markdown or explanations."),
+            ChatMessage(role="user", content=formatted_prompt),
+        ]
+
+        # Map analysis type to feature for routing
+        feature_map = {
+            "requirements": "shredding",
+            "risks": "analysis",
+            "go_no_go": "analysis",
+            "win_themes": "win_themes",
+            "compliance": "analysis"
+        }
+        feature = feature_map.get(analysis_type, "analysis")
+
+        response = await self.chat(messages, feature=feature, provider=provider, model=model, temperature=0.3)
+
+        # Parse JSON response
+        try:
+            # Try to extract JSON from response
+            content = response.content.strip()
+            if content.startswith("```"):
+                content = content.split("```")[1]
+                if content.startswith("json"):
+                    content = content[4:]
+            return json.loads(content)
+        except json.JSONDecodeError:
+            return {"raw_response": response.content, "error": "Failed to parse JSON response"}
+
+    async def generate_proposal_section(
+        self,
+        section_name: str,
+        requirements: List[str],
+        company_info: Dict[str, Any],
+        style_guide: Optional[str] = None,
+        provider: Optional[AIProvider] = None,
+        model: Optional[str] = None,
+    ) -> str:
+        """Generate a proposal section based on requirements and company info."""
+        system_prompt = f"""You are an expert proposal writer for government and enterprise RFPs.
+Write professional, compliant proposal content that:
+1. Directly addresses each requirement
+2. Uses clear, concise language
+3. Highlights the company's strengths and experience
+4. Follows any provided style guidelines
+5. Maintains a confident but not arrogant tone
+
+Company Information:
+{json.dumps(company_info, indent=2)}
+
+{"Style Guide: " + style_guide if style_guide else ""}
+"""
+
+        user_prompt = f"""Write the "{section_name}" section for a proposal.
+
+Requirements to address:
+{chr(10).join(f"- {r}" for r in requirements)}
+
+Generate professional proposal content that addresses each requirement. Include specific details and evidence where appropriate.
+"""
+
+        messages = [
+            ChatMessage(role="system", content=system_prompt),
+            ChatMessage(role="user", content=user_prompt),
+        ]
+
+        response = await self.chat(messages, provider=provider, model=model, temperature=0.7, max_tokens=4096)
+        return response.content
+
+    async def suggest_improvements(
+        self,
+        text: str,
+        context: str = "proposal",
+        provider: Optional[AIProvider] = None,
+        model: Optional[str] = None,
+    ) -> List[Dict[str, str]]:
+        """Suggest improvements for proposal text."""
+        prompt = f"""Review the following {context} text and suggest improvements.
+For each suggestion, provide:
+1. The original text segment
+2. The suggested improvement
+3. The reason for the change
+4. Priority (high/medium/low)
+
+Focus on:
+- Clarity and conciseness
+- Compliance with typical RFP requirements
+- Professional tone
+- Specificity and evidence
+
+Text to review:
+{text}
+
+Return as JSON array with fields: original, suggestion, reason, priority
+"""
+
+        messages = [
+            ChatMessage(role="system", content="You are an expert proposal editor. Always respond with valid JSON only."),
+            ChatMessage(role="user", content=prompt),
+        ]
+
+        response = await self.chat(messages, provider=provider, model=model, temperature=0.5)
+
+        try:
+            content = response.content.strip()
+            if content.startswith("```"):
+                content = content.split("```")[1]
+                if content.startswith("json"):
+                    content = content[4:]
+            return json.loads(content)
+        except json.JSONDecodeError:
+            return [{"error": "Failed to parse suggestions", "raw": response.content}]
+
+
+# Singleton instance
+_ai_service: Optional[MultiProviderAI] = None
+
+
+def get_ai_service() -> MultiProviderAI:
+    """Get or create the AI service singleton."""
+    global _ai_service
+    if _ai_service is None:
+        _ai_service = MultiProviderAI()
+    return _ai_service
+
+
+def configure_ai_service(
+    groq_api_key: Optional[str] = None,
+    openrouter_api_key: Optional[str] = None,
+    openai_api_key: Optional[str] = None,
+    default_provider: AIProvider = AIProvider.GROQ,
+) -> MultiProviderAI:
+    """Configure and return the AI service with new settings."""
+    global _ai_service
+    _ai_service = MultiProviderAI(
+        groq_api_key=groq_api_key,
+        openrouter_api_key=openrouter_api_key,
+        openai_api_key=openai_api_key,
+        default_provider=default_provider,
+    )
+    return _ai_service

backend/app/ai/smart_router.py

@@ -0,0 +1,1097 @@
+# Smart AI Router with Auto-Swap
+# Multi-provider AI routing with automatic failover for ContraVault
+# Uses FREE tiers only: OpenRouter, Cerebras, Mistral
+
+import os
+import json
+import httpx
+import asyncio
+import time
+import logging
+from typing import Optional, List, Dict, Any, AsyncGenerator, Callable
+from pydantic import BaseModel, Field
+from enum import Enum
+from dataclasses import dataclass, field
+from collections import defaultdict
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# ENUMS & CONSTANTS
+# =============================================================================
+
+class AIProvider(str, Enum):
+    """Supported AI providers (free tiers only)."""
+    OPENROUTER = "openrouter"
+    CEREBRAS = "cerebras"
+    MISTRAL = "mistral"
+
+
+class FeatureType(str, Enum):
+    """Application features that require AI."""
+    DOCUMENT_INGESTION = "document_ingestion"
+    REQUIREMENT_SHREDDING = "requirement_shredding"
+    GO_NO_GO_ANALYSIS = "go_no_go_analysis"
+    RISK_ANALYSIS = "risk_analysis"
+    WIN_THEMES = "win_themes"
+    PROPOSAL_WRITING = "proposal_writing"
+    TEXT_IMPROVEMENTS = "text_improvements"
+    KNOWLEDGE_QA = "knowledge_qa"
+    CODE_GENERATION = "code_generation"
+    GENERAL = "general"
+
+
+class ProviderHealth(str, Enum):
+    """Provider health states for circuit breaker."""
+    HEALTHY = "healthy"
+    DEGRADED = "degraded"
+    UNHEALTHY = "unhealthy"
+    RECOVERING = "recovering"
+
+
+class SwapReason(str, Enum):
+    """Reasons for model swap."""
+    RATE_LIMIT = "rate_limit"
+    SERVER_ERROR = "server_error"
+    TIMEOUT = "timeout"
+    AUTH_ERROR = "auth_error"
+    CONTEXT_EXCEEDED = "context_exceeded"
+    INVALID_RESPONSE = "invalid_response"
+    PROVIDER_UNHEALTHY = "provider_unhealthy"
+
+
+# =============================================================================
+# MODELS & DATA CLASSES
+# =============================================================================
+
+class ModelConfig(BaseModel):
+    """Configuration for a specific AI model."""
+    provider: AIProvider
+    model_id: str
+    display_name: str
+    context_window: int
+    supports_streaming: bool = True
+    supports_vision: bool = False
+    is_free: bool = True
+
+
+class ModelChain(BaseModel):
+    """Primary model with fallback chain."""
+    primary: ModelConfig
+    fallbacks: List[ModelConfig] = Field(default_factory=list)
+
+
+class ChatMessage(BaseModel):
+    """Chat message format."""
+    role: str  # "system", "user", "assistant"
+    content: str
+
+
+class AIResponse(BaseModel):
+    """Standardized AI response."""
+    content: str
+    model: str
+    provider: AIProvider
+    usage: Optional[Dict[str, int]] = None
+    finish_reason: Optional[str] = None
+    swap_occurred: bool = False
+    swap_reason: Optional[SwapReason] = None
+    latency_ms: Optional[int] = None
+
+
+@dataclass
+class ProviderState:
+    """Tracks provider health state."""
+    health: ProviderHealth = ProviderHealth.HEALTHY
+    consecutive_failures: int = 0
+    last_failure_time: Optional[datetime] = None
+    last_success_time: Optional[datetime] = None
+    total_requests: int = 0
+    total_failures: int = 0
+    circuit_open_until: Optional[datetime] = None
+
+    @property
+    def error_rate(self) -> float:
+        if self.total_requests == 0:
+            return 0.0
+        return self.total_failures / self.total_requests
+
+
+@dataclass
+class RateLimitState:
+    """Tracks rate limit state per provider."""
+    requests_this_minute: int = 0
+    tokens_this_minute: int = 0
+    minute_start: datetime = field(default_factory=datetime.now)
+    backoff_until: Optional[datetime] = None
+
+
+# =============================================================================
+# FREE MODEL REGISTRY
+# =============================================================================
+
+# OpenRouter Free Models
+OPENROUTER_MODELS = [
+    ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="google/gemma-3-27b:free",
+        display_name="Gemma 3 27B",
+        context_window=131072,
+        supports_vision=True
+    ),
+    ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="google/gemma-3-12b:free",
+        display_name="Gemma 3 12B",
+        context_window=32768,
+        supports_vision=True
+    ),
+    ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="meta-llama/llama-3.3-70b-instruct:free",
+        display_name="Llama 3.3 70B",
+        context_window=131072
+    ),
+    ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="meta-llama/llama-3.2-3b-instruct:free",
+        display_name="Llama 3.2 3B",
+        context_window=131072
+    ),
+    ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="qwen/qwen2.5-vl-7b-instruct:free",
+        display_name="Qwen 2.5 VL 7B",
+        context_window=32768,
+        supports_vision=True
+    ),
+    ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="nousresearch/hermes-3-llama-3.1-405b:free",
+        display_name="Hermes 3 405B",
+        context_window=131072
+    ),
+    ModelConfig(
+        provider=AIProvider.OPENROUTER,
+        model_id="meta-llama/llama-3.1-405b-instruct:free",
+        display_name="Llama 3.1 405B",
+        context_window=131072
+    ),
+]
+
+# Cerebras Free Models
+CEREBRAS_MODELS = [
+    ModelConfig(
+        provider=AIProvider.CEREBRAS,
+        model_id="llama-3.3-70b",
+        display_name="Llama 3.3 70B (Cerebras)",
+        context_window=65536
+    ),
+    ModelConfig(
+        provider=AIProvider.CEREBRAS,
+        model_id="llama3.1-8b",
+        display_name="Llama 3.1 8B (Cerebras)",
+        context_window=8192
+    ),
+    ModelConfig(
+        provider=AIProvider.CEREBRAS,
+        model_id="qwen-3-32b",
+        display_name="Qwen 3 32B (Cerebras)",
+        context_window=65536
+    ),
+    ModelConfig(
+        provider=AIProvider.CEREBRAS,
+        model_id="gpt-oss-120b",
+        display_name="GPT-OSS 120B (Cerebras)",
+        context_window=65536
+    ),
+]
+
+# Mistral Free Models (Open-weight)
+MISTRAL_MODELS = [
+    ModelConfig(
+        provider=AIProvider.MISTRAL,
+        model_id="open-mistral-nemo",
+        display_name="Mistral Nemo 12B",
+        context_window=131072
+    ),
+    ModelConfig(
+        provider=AIProvider.MISTRAL,
+        model_id="open-mixtral-8x7b",
+        display_name="Mixtral 8x7B",
+        context_window=32768
+    ),
+    ModelConfig(
+        provider=AIProvider.MISTRAL,
+        model_id="codestral-mamba",
+        display_name="Codestral Mamba",
+        context_window=262144
+    ),
+]
+
+ALL_MODELS: Dict[AIProvider, List[ModelConfig]] = {
+    AIProvider.OPENROUTER: OPENROUTER_MODELS,
+    AIProvider.CEREBRAS: CEREBRAS_MODELS,
+    AIProvider.MISTRAL: MISTRAL_MODELS,
+}
+
+
+# =============================================================================
+# FEATURE ROUTING CONFIGURATION
+# =============================================================================
+
+def get_model_by_id(model_id: str) -> Optional[ModelConfig]:
+    """Get model config by ID."""
+    for provider_models in ALL_MODELS.values():
+        for model in provider_models:
+            if model.model_id == model_id:
+                return model
+    return None
+
+
+# Feature to Model Chain mapping
+FEATURE_MODEL_CHAINS: Dict[FeatureType, ModelChain] = {
+    FeatureType.DOCUMENT_INGESTION: ModelChain(
+        primary=get_model_by_id("google/gemma-3-27b:free"),
+        fallbacks=[
+            get_model_by_id("llama-3.3-70b"),
+            get_model_by_id("meta-llama/llama-3.3-70b-instruct:free"),
+        ]
+    ),
+    FeatureType.REQUIREMENT_SHREDDING: ModelChain(
+        primary=get_model_by_id("meta-llama/llama-3.3-70b-instruct:free"),
+        fallbacks=[
+            get_model_by_id("qwen-3-32b"),
+            get_model_by_id("google/gemma-3-27b:free"),
+        ]
+    ),
+    FeatureType.GO_NO_GO_ANALYSIS: ModelChain(
+        primary=get_model_by_id("meta-llama/llama-3.1-405b-instruct:free"),
+        fallbacks=[
+            get_model_by_id("gpt-oss-120b"),
+            get_model_by_id("nousresearch/hermes-3-llama-3.1-405b:free"),
+        ]
+    ),
+    FeatureType.RISK_ANALYSIS: ModelChain(
+        primary=get_model_by_id("nousresearch/hermes-3-llama-3.1-405b:free"),
+        fallbacks=[
+            get_model_by_id("llama-3.3-70b"),
+            get_model_by_id("meta-llama/llama-3.3-70b-instruct:free"),
+        ]
+    ),
+    FeatureType.WIN_THEMES: ModelChain(
+        primary=get_model_by_id("google/gemma-3-27b:free"),
+        fallbacks=[
+            get_model_by_id("qwen-3-32b"),
+            get_model_by_id("meta-llama/llama-3.3-70b-instruct:free"),
+        ]
+    ),
+    FeatureType.PROPOSAL_WRITING: ModelChain(
+        primary=get_model_by_id("meta-llama/llama-3.1-405b-instruct:free"),
+        fallbacks=[
+            get_model_by_id("gpt-oss-120b"),
+            get_model_by_id("nousresearch/hermes-3-llama-3.1-405b:free"),
+        ]
+    ),
+    FeatureType.TEXT_IMPROVEMENTS: ModelChain(
+        primary=get_model_by_id("google/gemma-3-12b:free"),
+        fallbacks=[
+            get_model_by_id("llama3.1-8b"),
+            get_model_by_id("meta-llama/llama-3.2-3b-instruct:free"),
+        ]
+    ),
+    FeatureType.KNOWLEDGE_QA: ModelChain(
+        primary=get_model_by_id("qwen-3-32b"),
+        fallbacks=[
+            get_model_by_id("meta-llama/llama-3.3-70b-instruct:free"),
+            get_model_by_id("google/gemma-3-27b:free"),
+        ]
+    ),
+    FeatureType.CODE_GENERATION: ModelChain(
+        primary=get_model_by_id("codestral-mamba"),
+        fallbacks=[
+            get_model_by_id("meta-llama/llama-3.3-70b-instruct:free"),
+            get_model_by_id("qwen-3-32b"),
+        ]
+    ),
+    FeatureType.GENERAL: ModelChain(
+        primary=get_model_by_id("meta-llama/llama-3.3-70b-instruct:free"),
+        fallbacks=[
+            get_model_by_id("llama-3.3-70b"),
+            get_model_by_id("google/gemma-3-27b:free"),
+        ]
+    ),
+}
+
+
+# =============================================================================
+# PROVIDER ADAPTERS
+# =============================================================================
+
+class ProviderAdapter:
+    """Base adapter for AI providers."""
+
+    def __init__(self, api_key: str, base_url: str):
+        self.api_key = api_key
+        self.base_url = base_url
+
+    def get_headers(self) -> Dict[str, str]:
+        return {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+    async def complete(
+        self,
+        messages: List[ChatMessage],
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> Dict[str, Any]:
+        raise NotImplementedError
+
+
+class OpenRouterAdapter(ProviderAdapter):
+    """Adapter for OpenRouter API."""
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key, "https://openrouter.ai/api/v1")
+
+    def get_headers(self) -> Dict[str, str]:
+        headers = super().get_headers()
+        headers["HTTP-Referer"] = "https://contravault.ai"
+        headers["X-Title"] = "ContraVault RFP Platform"
+        return headers
+
+    async def complete(
+        self,
+        messages: List[ChatMessage],
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> Dict[str, Any]:
+        url = f"{self.base_url}/chat/completions"
+        payload = {
+            "model": model,
+            "messages": [{"role": m.role, "content": m.content} for m in messages],
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(url, headers=self.get_headers(), json=payload)
+            response.raise_for_status()
+            return response.json()
+
+
+class CerebrasAdapter(ProviderAdapter):
+    """Adapter for Cerebras API."""
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key, "https://api.cerebras.ai/v1")
+
+    async def complete(
+        self,
+        messages: List[ChatMessage],
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> Dict[str, Any]:
+        url = f"{self.base_url}/chat/completions"
+        payload = {
+            "model": model,
+            "messages": [{"role": m.role, "content": m.content} for m in messages],
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(url, headers=self.get_headers(), json=payload)
+            response.raise_for_status()
+            return response.json()
+
+
+class MistralAdapter(ProviderAdapter):
+    """Adapter for Mistral API."""
+
+    def __init__(self, api_key: str):
+        super().__init__(api_key, "https://api.mistral.ai/v1")
+
+    async def complete(
+        self,
+        messages: List[ChatMessage],
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+    ) -> Dict[str, Any]:
+        url = f"{self.base_url}/chat/completions"
+        payload = {
+            "model": model,
+            "messages": [{"role": m.role, "content": m.content} for m in messages],
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(url, headers=self.get_headers(), json=payload)
+            response.raise_for_status()
+            return response.json()
+
+
+# =============================================================================
+# HEALTH MONITOR
+# =============================================================================
+
+class HealthMonitor:
+    """Monitors provider health with circuit breaker pattern."""
+
+    FAILURE_THRESHOLD = 5
+    RECOVERY_TIMEOUT = 60  # seconds
+    DEGRADED_THRESHOLD = 0.2  # 20% error rate
+
+    def __init__(self):
+        self.provider_states: Dict[AIProvider, ProviderState] = {
+            provider: ProviderState() for provider in AIProvider
+        }
+        self.rate_limits: Dict[AIProvider, RateLimitState] = {
+            provider: RateLimitState() for provider in AIProvider
+        }
+
+    def is_healthy(self, provider: AIProvider) -> bool:
+        """Check if provider is available for requests."""
+        state = self.provider_states[provider]
+
+        # Check circuit breaker
+        if state.circuit_open_until:
+            if datetime.now() < state.circuit_open_until:
+                return False
+            else:
+                # Circuit recovery period
+                state.health = ProviderHealth.RECOVERING
+                state.circuit_open_until = None
+
+        return state.health in [ProviderHealth.HEALTHY, ProviderHealth.DEGRADED, ProviderHealth.RECOVERING]
+
+    def record_success(self, provider: AIProvider):
+        """Record successful request."""
+        state = self.provider_states[provider]
+        state.total_requests += 1
+        state.last_success_time = datetime.now()
+        state.consecutive_failures = 0
+
+        # Heal degraded state
+        if state.health in [ProviderHealth.DEGRADED, ProviderHealth.RECOVERING]:
+            if state.error_rate < self.DEGRADED_THRESHOLD:
+                state.health = ProviderHealth.HEALTHY
+
+        logger.debug(f"Provider {provider.value} success recorded")
+
+    def record_failure(self, provider: AIProvider, reason: SwapReason):
+        """Record failed request and potentially open circuit."""
+        state = self.provider_states[provider]
+        state.total_requests += 1
+        state.total_failures += 1
+        state.consecutive_failures += 1
+        state.last_failure_time = datetime.now()
+
+        # Check for circuit breaker trigger
+        if state.consecutive_failures >= self.FAILURE_THRESHOLD:
+            state.health = ProviderHealth.UNHEALTHY
+            state.circuit_open_until = datetime.now() + timedelta(seconds=self.RECOVERY_TIMEOUT)
+            logger.warning(
+                f"Circuit breaker OPEN for {provider.value} after {state.consecutive_failures} failures. "
+                f"Will recover at {state.circuit_open_until}"
+            )
+        elif state.error_rate > self.DEGRADED_THRESHOLD:
+            state.health = ProviderHealth.DEGRADED
+            logger.warning(f"Provider {provider.value} degraded (error rate: {state.error_rate:.1%})")
+
+        logger.warning(f"Provider {provider.value} failure: {reason.value}")
+
+    def check_rate_limit(self, provider: AIProvider) -> bool:
+        """Check if rate limit allows request."""
+        rate_state = self.rate_limits[provider]
+
+        # Check backoff
+        if rate_state.backoff_until and datetime.now() < rate_state.backoff_until:
+            return False
+
+        # Reset minute counter if needed
+        if datetime.now() - rate_state.minute_start > timedelta(minutes=1):
+            rate_state.requests_this_minute = 0
+            rate_state.tokens_this_minute = 0
+            rate_state.minute_start = datetime.now()
+            rate_state.backoff_until = None
+
+        # Check limits (conservative estimates for free tiers)
+        limits = {
+            AIProvider.OPENROUTER: 60,
+            AIProvider.CEREBRAS: 30,
+            AIProvider.MISTRAL: 60,
+        }
+
+        return rate_state.requests_this_minute < limits.get(provider, 30)
+
+    def record_rate_limit_hit(self, provider: AIProvider):
+        """Record rate limit hit and set backoff."""
+        rate_state = self.rate_limits[provider]
+
+        # Exponential backoff: 5s, 10s, 20s, 40s, max 300s
+        current_backoff = 5
+        if rate_state.backoff_until:
+            time_since_backoff = (datetime.now() - rate_state.backoff_until).total_seconds()
+            if time_since_backoff < 60:  # Recent backoff
+                current_backoff = min(current_backoff * 2, 300)
+
+        rate_state.backoff_until = datetime.now() + timedelta(seconds=current_backoff)
+        logger.warning(f"Rate limit hit for {provider.value}, backing off for {current_backoff}s")
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get health status for all providers."""
+        return {
+            provider.value: {
+                "health": self.provider_states[provider].health.value,
+                "error_rate": f"{self.provider_states[provider].error_rate:.1%}",
+                "consecutive_failures": self.provider_states[provider].consecutive_failures,
+                "total_requests": self.provider_states[provider].total_requests,
+                "rate_limited": not self.check_rate_limit(provider),
+            }
+            for provider in AIProvider
+        }
+
+
+# =============================================================================
+# SMART AI ROUTER
+# =============================================================================
+
+class SmartAIRouter:
+    """
+    Smart AI Router with automatic failover.
+    Routes requests to optimal free-tier models based on feature type.
+    Automatically swaps providers on failure or rate limits.
+    """
+
+    def __init__(
+        self,
+        openrouter_api_key: Optional[str] = None,
+        cerebras_api_key: Optional[str] = None,
+        mistral_api_key: Optional[str] = None,
+    ):
+        # Load API keys from environment if not provided
+        self.api_keys = {
+            AIProvider.OPENROUTER: openrouter_api_key or os.getenv("OPENROUTER_API_KEY", ""),
+            AIProvider.CEREBRAS: cerebras_api_key or os.getenv("CEREBRAS_API_KEY", ""),
+            AIProvider.MISTRAL: mistral_api_key or os.getenv("MISTRAL_API_KEY", ""),
+        }
+
+        # Initialize adapters
+        self.adapters: Dict[AIProvider, Optional[ProviderAdapter]] = {}
+        self._init_adapters()
+
+        # Health monitor
+        self.health_monitor = HealthMonitor()
+
+        # Swap history for debugging
+        self.swap_history: List[Dict[str, Any]] = []
+
+    def _init_adapters(self):
+        """Initialize provider adapters."""
+        if self.api_keys[AIProvider.OPENROUTER]:
+            self.adapters[AIProvider.OPENROUTER] = OpenRouterAdapter(
+                self.api_keys[AIProvider.OPENROUTER]
+            )
+
+        if self.api_keys[AIProvider.CEREBRAS]:
+            self.adapters[AIProvider.CEREBRAS] = CerebrasAdapter(
+                self.api_keys[AIProvider.CEREBRAS]
+            )
+
+        if self.api_keys[AIProvider.MISTRAL]:
+            self.adapters[AIProvider.MISTRAL] = MistralAdapter(
+                self.api_keys[AIProvider.MISTRAL]
+            )
+
+    def _get_model_chain(self, feature: FeatureType) -> List[ModelConfig]:
+        """Get ordered list of models to try for a feature."""
+        chain = FEATURE_MODEL_CHAINS.get(feature, FEATURE_MODEL_CHAINS[FeatureType.GENERAL])
+        models = [chain.primary] + chain.fallbacks
+
+        # Filter out None models and providers without API keys
+        return [
+            m for m in models
+            if m is not None and self.api_keys.get(m.provider)
+        ]
+
+    def _determine_swap_reason(self, error: Exception) -> SwapReason:
+        """Determine the reason for swap based on error."""
+        error_str = str(error).lower()
+
+        if isinstance(error, httpx.HTTPStatusError):
+            status = error.response.status_code
+            if status == 429:
+                return SwapReason.RATE_LIMIT
+            elif status in [401, 403]:
+                return SwapReason.AUTH_ERROR
+            elif status >= 500:
+                return SwapReason.SERVER_ERROR
+            elif status == 400 and "context" in error_str:
+                return SwapReason.CONTEXT_EXCEEDED
+
+        if isinstance(error, httpx.TimeoutException):
+            return SwapReason.TIMEOUT
+
+        if "json" in error_str or "parse" in error_str:
+            return SwapReason.INVALID_RESPONSE
+
+        return SwapReason.SERVER_ERROR
+
+    def _log_swap(
+        self,
+        from_model: ModelConfig,
+        to_model: Optional[ModelConfig],
+        reason: SwapReason,
+        feature: FeatureType,
+    ):
+        """Log model swap for debugging."""
+        swap_record = {
+            "timestamp": datetime.now().isoformat(),
+            "feature": feature.value,
+            "from_provider": from_model.provider.value,
+            "from_model": from_model.model_id,
+            "to_provider": to_model.provider.value if to_model else None,
+            "to_model": to_model.model_id if to_model else None,
+            "reason": reason.value,
+        }
+        self.swap_history.append(swap_record)
+
+        # Keep only last 100 swaps
+        if len(self.swap_history) > 100:
+            self.swap_history = self.swap_history[-100:]
+
+        logger.info(
+            f"AI SWAP: {from_model.display_name} -> {to_model.display_name if to_model else 'NONE'} "
+            f"[{reason.value}] for {feature.value}"
+        )
+
+    async def complete(
+        self,
+        messages: List[ChatMessage],
+        feature: FeatureType = FeatureType.GENERAL,
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+        force_model: Optional[str] = None,
+        force_provider: Optional[AIProvider] = None,
+    ) -> AIResponse:
+        """
+        Complete a chat request with automatic failover.
+
+        Args:
+            messages: Chat messages
+            feature: Feature type for optimal model selection
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens in response
+            force_model: Force specific model (bypasses feature routing)
+            force_provider: Force specific provider
+
+        Returns:
+            AIResponse with content and metadata
+        """
+        start_time = time.time()
+
+        # Get model chain for feature
+        if force_model and force_provider:
+            model_chain = [get_model_by_id(force_model)]
+            if not model_chain[0]:
+                model_chain = self._get_model_chain(feature)
+        else:
+            model_chain = self._get_model_chain(feature)
+
+        if not model_chain:
+            raise ValueError(f"No models available for feature {feature.value}")
+
+        swap_occurred = False
+        swap_reason = None
+        last_error = None
+        attempted_models = []
+
+        for i, model in enumerate(model_chain):
+            if model is None:
+                continue
+
+            attempted_models.append(model.display_name)
+
+            # Check provider health
+            if not self.health_monitor.is_healthy(model.provider):
+                logger.debug(f"Skipping unhealthy provider {model.provider.value}")
+                if i > 0:
+                    swap_occurred = True
+                    swap_reason = SwapReason.PROVIDER_UNHEALTHY
+                continue
+
+            # Check rate limit
+            if not self.health_monitor.check_rate_limit(model.provider):
+                logger.debug(f"Skipping rate-limited provider {model.provider.value}")
+                if i > 0:
+                    swap_occurred = True
+                    swap_reason = SwapReason.RATE_LIMIT
+                continue
+
+            adapter = self.adapters.get(model.provider)
+            if not adapter:
+                continue
+
+            try:
+                logger.debug(f"Trying {model.display_name} ({model.provider.value})")
+
+                response_data = await adapter.complete(
+                    messages=messages,
+                    model=model.model_id,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                )
+
+                # Parse response
+                choice = response_data["choices"][0]
+                content = choice["message"]["content"]
+
+                if not content or not content.strip():
+                    raise ValueError("Empty response content")
+
+                # Record success
+                self.health_monitor.record_success(model.provider)
+
+                latency_ms = int((time.time() - start_time) * 1000)
+
+                return AIResponse(
+                    content=content,
+                    model=response_data.get("model", model.model_id),
+                    provider=model.provider,
+                    usage=response_data.get("usage"),
+                    finish_reason=choice.get("finish_reason"),
+                    swap_occurred=swap_occurred,
+                    swap_reason=swap_reason,
+                    latency_ms=latency_ms,
+                )
+
+            except Exception as e:
+                last_error = e
+                reason = self._determine_swap_reason(e)
+
+                # Record failure
+                self.health_monitor.record_failure(model.provider, reason)
+
+                if reason == SwapReason.RATE_LIMIT:
+                    self.health_monitor.record_rate_limit_hit(model.provider)
+
+                # Log swap if moving to next model
+                if i < len(model_chain) - 1:
+                    next_model = model_chain[i + 1] if i + 1 < len(model_chain) else None
+                    self._log_swap(model, next_model, reason, feature)
+                    swap_occurred = True
+                    swap_reason = reason
+
+                logger.warning(f"Model {model.display_name} failed: {e}")
+                continue
+
+        # All models exhausted
+        raise Exception(
+            f"All models exhausted for {feature.value}. "
+            f"Attempted: {', '.join(attempted_models)}. "
+            f"Last error: {last_error}"
+        )
+
+    async def analyze_rfp(
+        self,
+        text: str,
+        analysis_type: str = "requirements",
+    ) -> Dict[str, Any]:
+        """
+        Specialized RFP analysis using optimal models.
+
+        Args:
+            text: RFP text to analyze
+            analysis_type: Type of analysis (requirements, risks, go_no_go, etc.)
+
+        Returns:
+            Structured analysis results
+        """
+        # Map analysis type to feature
+        feature_map = {
+            "requirements": FeatureType.REQUIREMENT_SHREDDING,
+            "risks": FeatureType.RISK_ANALYSIS,
+            "go_no_go": FeatureType.GO_NO_GO_ANALYSIS,
+            "win_themes": FeatureType.WIN_THEMES,
+            "compliance": FeatureType.REQUIREMENT_SHREDDING,
+        }
+
+        feature = feature_map.get(analysis_type, FeatureType.GENERAL)
+
+        prompts = {
+            "requirements": """Analyze the following RFP text and extract all requirements.
+For each requirement, identify:
+1. The exact text of the requirement
+2. Whether it's mandatory (shall/must) or desirable (should/may)
+3. The category (Technical, Management, Legal, Financial, etc.)
+4. Risk level (High/Medium/Low)
+5. Any keywords or compliance standards mentioned
+
+Return as JSON array with fields: text, type, category, risk_level, keywords
+
+RFP Text:
+{text}""",
+
+            "risks": """Analyze the following RFP text for potential risks and red flags.
+Look for:
+1. Unlimited liability clauses
+2. Unrealistic timelines
+3. Ambiguous scope
+4. Onerous payment terms
+5. IP ownership issues
+6. Performance bond requirements
+7. Liquidated damages
+8. Insurance requirements
+
+Return as JSON array with fields: risk_type, severity (high/medium/low), clause_text, recommendation
+
+RFP Text:
+{text}""",
+
+            "go_no_go": """Perform a Go/No-Go analysis on this RFP.
+Evaluate:
+1. Technical fit (1-10)
+2. Resource availability (1-10)
+3. Timeline feasibility (1-10)
+4. Competitive position (1-10)
+5. Profitability potential (1-10)
+6. Strategic alignment (1-10)
+7. Risk level (1-10, lower is better)
+
+Provide:
+- Overall recommendation: GO, NO-GO, or CONDITIONAL
+- Confidence percentage
+- Key reasons for the decision
+- Mitigation strategies if CONDITIONAL
+
+Return as JSON with fields: recommendation, confidence, scores (object), reasons (array), mitigations (array)
+
+RFP Text:
+{text}""",
+
+            "win_themes": """Based on this RFP, identify potential win themes and discriminators.
+Consider:
+1. What does the client really need?
+2. What pain points are implied?
+3. What differentiators could be emphasized?
+4. What proof points would be compelling?
+
+Return as JSON array with fields: theme_title, description, supporting_evidence, discriminator_level (strong/moderate/weak)
+
+RFP Text:
+{text}""",
+
+            "compliance": """Analyze this RFP for compliance requirements.
+Identify:
+1. Certifications required (ISO, SOC2, FedRAMP, etc.)
+2. Security standards
+3. Regulatory compliance (GDPR, HIPAA, etc.)
+4. Format requirements (page limits, fonts, sections)
+5. Submission requirements (deadlines, methods)
+
+Return as JSON with fields: certifications (array), security_standards (array), regulations (array), format_requirements (object), submission_requirements (object)
+
+RFP Text:
+{text}""",
+        }
+
+        prompt = prompts.get(analysis_type, prompts["requirements"])
+        formatted_prompt = prompt.format(text=text[:15000])
+
+        messages = [
+            ChatMessage(
+                role="system",
+                content="You are an expert RFP analyst. Always respond with valid JSON only, no markdown or explanations."
+            ),
+            ChatMessage(role="user", content=formatted_prompt),
+        ]
+
+        response = await self.complete(messages, feature=feature, temperature=0.3)
+
+        # Parse JSON response
+        try:
+            content = response.content.strip()
+            if content.startswith("```"):
+                content = content.split("```")[1]
+                if content.startswith("json"):
+                    content = content[4:]
+            return json.loads(content)
+        except json.JSONDecodeError:
+            return {"raw_response": response.content, "error": "Failed to parse JSON response"}
+
+    async def generate_proposal_section(
+        self,
+        section_name: str,
+        requirements: List[str],
+        company_info: Dict[str, Any],
+        style_guide: Optional[str] = None,
+    ) -> str:
+        """Generate a proposal section using optimal model."""
+        system_prompt = f"""You are an expert proposal writer for government and enterprise RFPs.
+Write professional, compliant proposal content that:
+1. Directly addresses each requirement
+2. Uses clear, concise language
+3. Highlights the company's strengths and experience
+4. Follows any provided style guidelines
+5. Maintains a confident but not arrogant tone
+
+Company Information:
+{json.dumps(company_info, indent=2)}
+
+{"Style Guide: " + style_guide if style_guide else ""}
+"""
+
+        user_prompt = f"""Write the "{section_name}" section for a proposal.
+
+Requirements to address:
+{chr(10).join(f"- {r}" for r in requirements)}
+
+Generate professional proposal content that addresses each requirement. Include specific details and evidence where appropriate.
+"""
+
+        messages = [
+            ChatMessage(role="system", content=system_prompt),
+            ChatMessage(role="user", content=user_prompt),
+        ]
+
+        response = await self.complete(
+            messages,
+            feature=FeatureType.PROPOSAL_WRITING,
+            temperature=0.7,
+            max_tokens=4096
+        )
+        return response.content
+
+    async def suggest_improvements(
+        self,
+        text: str,
+        context: str = "proposal",
+    ) -> List[Dict[str, str]]:
+        """Suggest improvements for proposal text."""
+        prompt = f"""Review the following {context} text and suggest improvements.
+For each suggestion, provide:
+1. The original text segment
+2. The suggested improvement
+3. The reason for the change
+4. Priority (high/medium/low)
+
+Focus on:
+- Clarity and conciseness
+- Compliance with typical RFP requirements
+- Professional tone
+- Specificity and evidence
+
+Text to review:
+{text}
+
+Return as JSON array with fields: original, suggestion, reason, priority
+"""
+
+        messages = [
+            ChatMessage(
+                role="system",
+                content="You are an expert proposal editor. Always respond with valid JSON only."
+            ),
+            ChatMessage(role="user", content=prompt),
+        ]
+
+        response = await self.complete(
+            messages,
+            feature=FeatureType.TEXT_IMPROVEMENTS,
+            temperature=0.5
+        )
+
+        try:
+            content = response.content.strip()
+            if content.startswith("```"):
+                content = content.split("```")[1]
+                if content.startswith("json"):
+                    content = content[4:]
+            return json.loads(content)
+        except json.JSONDecodeError:
+            return [{"error": "Failed to parse suggestions", "raw": response.content}]
+
+    def get_available_providers(self) -> List[Dict[str, Any]]:
+        """Get list of available providers with their status."""
+        providers = []
+        for provider in AIProvider:
+            has_key = bool(self.api_keys.get(provider))
+            models = ALL_MODELS.get(provider, [])
+            health_status = self.health_monitor.get_status().get(provider.value, {})
+
+            providers.append({
+                "id": provider.value,
+                "name": provider.value.title(),
+                "configured": has_key,
+                "health": health_status,
+                "models": [m.model_dump() for m in models],
+            })
+        return providers
+
+    def get_available_models(self, provider: Optional[AIProvider] = None) -> List[ModelConfig]:
+        """Get available models for a specific provider or all providers."""
+        if provider:
+            return ALL_MODELS.get(provider, [])
+
+        all_models = []
+        for p, models in ALL_MODELS.items():
+            if self.api_keys.get(p):
+                all_models.extend(models)
+        return all_models
+
+    def get_health_status(self) -> Dict[str, Any]:
+        """Get health status for all providers."""
+        return {
+            "providers": self.health_monitor.get_status(),
+            "recent_swaps": self.swap_history[-10:] if self.swap_history else [],
+        }
+
+
+# =============================================================================
+# SINGLETON INSTANCE
+# =============================================================================
+
+_smart_router: Optional[SmartAIRouter] = None
+
+
+def get_smart_router() -> SmartAIRouter:
+    """Get or create the Smart AI Router singleton."""
+    global _smart_router
+    if _smart_router is None:
+        _smart_router = SmartAIRouter()
+    return _smart_router
+
+
+def configure_smart_router(
+    openrouter_api_key: Optional[str] = None,
+    cerebras_api_key: Optional[str] = None,
+    mistral_api_key: Optional[str] = None,
+) -> SmartAIRouter:
+    """Configure and return the Smart AI Router with new settings."""
+    global _smart_router
+    _smart_router = SmartAIRouter(
+        openrouter_api_key=openrouter_api_key,
+        cerebras_api_key=cerebras_api_key,
+        mistral_api_key=mistral_api_key,
+    )
+    return _smart_router
+
+
+# =============================================================================
+# BACKWARDS COMPATIBILITY
+# =============================================================================
+
+# Alias for backwards compatibility with existing code
+MultiProviderAI = SmartAIRouter
+get_ai_service = get_smart_router
+configure_ai_service = configure_smart_router

backend/app/analysis/__init__.py

@@ -0,0 +1,18 @@
+# Analysis Engine module
+from .service import AnalysisEngine
+from .models import GoNoGoAnalysis, RiskAssessment, DecisionEnum, RiskLevel, ComplianceStatus
+from .competitor_db import CompetitorDatabase, Competitor, CompetitorCapability
+from .nli_detector import NLIContradictionDetector
+
+__all__ = [
+    "AnalysisEngine",
+    "GoNoGoAnalysis",
+    "RiskAssessment",
+    "DecisionEnum",
+    "RiskLevel",
+    "ComplianceStatus",
+    "CompetitorDatabase",
+    "Competitor",
+    "CompetitorCapability",
+    "NLIContradictionDetector"
+]

backend/app/analysis/competitor_db.py

@@ -0,0 +1,502 @@
+"""
+Competitor Database Module - Semantic Blind RFP Detection
+
+Implements:
+- 4.2: Semantic "Blind RFP" Detection
+- Competitor capability database management
+- Semantic similarity comparison for wired RFP detection
+"""
+
+import logging
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass, field, asdict
+import json
+import os
+from datetime import datetime
+import re
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CompetitorCapability:
+    """Represents a competitor's specific capability or product."""
+    name: str
+    description: str
+    proprietary: bool = False  # Is this unique to this competitor?
+    keywords: List[str] = field(default_factory=list)
+    certifications: List[str] = field(default_factory=list)
+
+
+@dataclass
+class Competitor:
+    """Represents a competitor company profile."""
+    id: str
+    name: str
+    description: str
+    capabilities: List[CompetitorCapability] = field(default_factory=list)
+    proprietary_technologies: List[str] = field(default_factory=list)
+    certifications: List[str] = field(default_factory=list)
+    contract_vehicles: List[str] = field(default_factory=list)
+    past_performance_agencies: List[str] = field(default_factory=list)
+    strengths: List[str] = field(default_factory=list)
+    weaknesses: List[str] = field(default_factory=list)
+    incumbent_contracts: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = asdict(self)
+        result['capabilities'] = [asdict(c) for c in self.capabilities]
+        return result
+
+
+@dataclass
+class BlindRFPMatch:
+    """Represents a potential match indicating a wired/blind RFP."""
+    competitor_id: str
+    competitor_name: str
+    match_type: str  # "proprietary_tech", "capability", "incumbent", "certification"
+    requirement_text: str
+    matched_element: str
+    confidence: float
+    explanation: str
+
+
+class CompetitorDatabase:
+    """
+    Manages competitor intelligence for blind RFP detection.
+
+    Features:
+    - Store competitor profiles with capabilities
+    - Semantic similarity matching between RFP requirements and competitor capabilities
+    - Detect proprietary technology requirements
+    - Incumbent advantage detection
+    """
+
+    def __init__(self, db_path: Optional[str] = None):
+        """
+        Initialize competitor database.
+
+        Args:
+            db_path: Path to JSON file for persistence
+        """
+        self.db_path = db_path or "./data/competitors.json"
+        self.competitors: Dict[str, Competitor] = {}
+        self._load_database()
+
+        # Common proprietary technology patterns
+        self.proprietary_patterns = {
+            "ServiceNow": ["servicenow", "snow platform", "now platform"],
+            "Salesforce": ["salesforce", "force.com", "apex", "lightning"],
+            "SAP": ["sap s/4hana", "sap erp", "sap hana"],
+            "Oracle": ["oracle cloud", "oracle fusion", "oracle ebusiness"],
+            "Microsoft": ["dynamics 365", "azure government", "m365 gcc"],
+            "AWS": ["aws govcloud", "amazon connect"],
+            "Palantir": ["palantir foundry", "gotham"],
+            "Splunk": ["splunk enterprise", "splunk cloud"],
+            "Pega": ["pegasystems", "pega platform"],
+        }
+
+        # Contract vehicle patterns
+        self.contract_vehicles = {
+            "GSA MAS": ["gsa schedule", "gsa mas", "federal supply schedule"],
+            "OASIS": ["oasis", "oasis sb", "oasis unrestricted"],
+            "SEWP": ["sewp v", "nasa sewp"],
+            "CIO-SP3": ["cio-sp3", "cio sp3"],
+            "Alliant": ["alliant 2", "alliant ii"],
+            "8(a) STARS": ["8a stars", "stars iii"],
+        }
+
+    def _load_database(self):
+        """Load competitor data from file."""
+        if os.path.exists(self.db_path):
+            try:
+                with open(self.db_path, 'r') as f:
+                    data = json.load(f)
+                    for comp_data in data.get('competitors', []):
+                        capabilities = [
+                            CompetitorCapability(**cap)
+                            for cap in comp_data.pop('capabilities', [])
+                        ]
+                        self.competitors[comp_data['id']] = Competitor(
+                            **comp_data,
+                            capabilities=capabilities
+                        )
+                logger.info(f"Loaded {len(self.competitors)} competitors from database")
+            except Exception as e:
+                logger.warning(f"Could not load competitor database: {e}")
+        else:
+            # Initialize with sample competitors for demo
+            self._initialize_sample_data()
+
+    def _save_database(self):
+        """Save competitor data to file."""
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        with open(self.db_path, 'w') as f:
+            json.dump({
+                'competitors': [c.to_dict() for c in self.competitors.values()],
+                'updated_at': datetime.now().isoformat()
+            }, f, indent=2)
+
+    def _initialize_sample_data(self):
+        """No sample data by default."""
+        pass
+
+    def add_competitor(self, competitor: Competitor) -> str:
+        """Add or update a competitor in the database."""
+        self.competitors[competitor.id] = competitor
+        self._save_database()
+        return competitor.id
+
+    def get_competitor(self, competitor_id: str) -> Optional[Competitor]:
+        """Get a competitor by ID."""
+        return self.competitors.get(competitor_id)
+
+    def list_competitors(self) -> List[Dict[str, Any]]:
+        """List all competitors."""
+        return [c.to_dict() for c in self.competitors.values()]
+
+    def delete_competitor(self, competitor_id: str) -> bool:
+        """Delete a competitor."""
+        if competitor_id in self.competitors:
+            del self.competitors[competitor_id]
+            self._save_database()
+            return True
+        return False
+
+    def detect_blind_rfp_indicators(
+        self,
+        requirements_text: List[str],
+        full_rfp_text: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Spec 4.2: Semantic "Blind RFP" Detection
+
+        Compares RFP requirements against competitor capabilities
+        to detect if the RFP is "wired" for a specific vendor.
+
+        Args:
+            requirements_text: List of requirement strings
+            full_rfp_text: Full RFP text for additional context
+
+        Returns:
+            Analysis results with potential matches and confidence scores
+        """
+        logger.info("Analyzing RFP for blind/wired indicators")
+
+        matches: List[BlindRFPMatch] = []
+        all_text = " ".join(requirements_text)
+        if full_rfp_text:
+            all_text += " " + full_rfp_text
+        all_text_lower = all_text.lower()
+
+        # 1. Check for proprietary technology mentions
+        for vendor, patterns in self.proprietary_patterns.items():
+            for pattern in patterns:
+                if pattern.lower() in all_text_lower:
+                    # Find the specific requirement mentioning this
+                    for req in requirements_text:
+                        if pattern.lower() in req.lower():
+                            # Check if there's a competitor with this proprietary tech
+                            matching_comp = self._find_competitor_by_tech(vendor)
+                            if matching_comp:
+                                matches.append(BlindRFPMatch(
+                                    competitor_id=matching_comp.id,
+                                    competitor_name=matching_comp.name,
+                                    match_type="proprietary_tech",
+                                    requirement_text=req[:200],
+                                    matched_element=vendor,
+                                    confidence=0.85,
+                                    explanation=f"RFP requires {vendor} technology, which is a proprietary platform. "
+                                               f"{matching_comp.name} is a known implementation partner."
+                                ))
+                            break
+
+        # 2. Check for incumbent advantage indicators
+        incumbent_phrases = [
+            "existing system",
+            "current contractor",
+            "incumbent",
+            "previous experience with this agency",
+            "familiarity with agency processes",
+            "knowledge of existing infrastructure",
+            "transition from current",
+            "no transition period",
+            "immediate start",
+        ]
+
+        for phrase in incumbent_phrases:
+            if phrase in all_text_lower:
+                for req in requirements_text:
+                    if phrase in req.lower():
+                        matches.append(BlindRFPMatch(
+                            competitor_id="unknown",
+                            competitor_name="Unknown Incumbent",
+                            match_type="incumbent",
+                            requirement_text=req[:200],
+                            matched_element=phrase,
+                            confidence=0.6,
+                            explanation=f"Phrase '{phrase}' suggests incumbent advantage requirement."
+                        ))
+                        break
+
+        # 3. Check for unusually specific experience requirements
+        for competitor in self.competitors.values():
+            # Check if RFP mentions specific agencies where competitor is incumbent
+            for agency in competitor.past_performance_agencies:
+                pattern = f"experience (with|at|for) {agency}"
+                if re.search(pattern, all_text, re.IGNORECASE):
+                    matches.append(BlindRFPMatch(
+                        competitor_id=competitor.id,
+                        competitor_name=competitor.name,
+                        match_type="agency_experience",
+                        requirement_text=f"Requires experience with {agency}",
+                        matched_element=agency,
+                        confidence=0.5,
+                        explanation=f"{competitor.name} has known past performance at {agency}."
+                    ))
+
+            # Check for specific certifications that match competitor
+            for cert in competitor.certifications:
+                if cert.lower() in all_text_lower:
+                    # Only flag if it's a relatively uncommon certification
+                    common_certs = ["iso 27001", "fedramp", "cmmc"]
+                    is_uncommon = not any(c in cert.lower() for c in common_certs)
+
+                    if is_uncommon:
+                        for req in requirements_text:
+                            if cert.lower() in req.lower():
+                                matches.append(BlindRFPMatch(
+                                    competitor_id=competitor.id,
+                                    competitor_name=competitor.name,
+                                    match_type="certification",
+                                    requirement_text=req[:200],
+                                    matched_element=cert,
+                                    confidence=0.4,
+                                    explanation=f"Requires {cert} certification which {competitor.name} holds."
+                                ))
+                                break
+
+        # 4. Check for specific contract vehicle requirements
+        for vehicle, patterns in self.contract_vehicles.items():
+            for pattern in patterns:
+                if pattern.lower() in all_text_lower:
+                    # Find competitors with this vehicle
+                    comps_with_vehicle = [
+                        c for c in self.competitors.values()
+                        if any(v.lower() == vehicle.lower() or pattern.lower() in v.lower()
+                              for v in c.contract_vehicles)
+                    ]
+
+                    if comps_with_vehicle and len(comps_with_vehicle) <= 3:
+                        # Only flag if few competitors have this vehicle
+                        matches.append(BlindRFPMatch(
+                            competitor_id=comps_with_vehicle[0].id if comps_with_vehicle else "multiple",
+                            competitor_name=", ".join([c.name for c in comps_with_vehicle[:3]]),
+                            match_type="contract_vehicle",
+                            requirement_text=f"Requires {vehicle} contract vehicle",
+                            matched_element=vehicle,
+                            confidence=0.3,
+                            explanation=f"Only {len(comps_with_vehicle)} known competitors have {vehicle}."
+                        ))
+                    break
+
+        # Calculate overall blind RFP probability
+        if not matches:
+            blind_probability = 0
+        else:
+            # Weight by confidence and match type
+            type_weights = {
+                "proprietary_tech": 1.5,
+                "incumbent": 1.2,
+                "agency_experience": 0.8,
+                "certification": 0.6,
+                "contract_vehicle": 0.4
+            }
+
+            weighted_sum = sum(
+                m.confidence * type_weights.get(m.match_type, 1.0)
+                for m in matches
+            )
+            # Normalize to 0-100 scale
+            blind_probability = min(weighted_sum * 20, 100)
+
+        # Group matches by competitor
+        competitor_scores = {}
+        for match in matches:
+            if match.competitor_id not in competitor_scores:
+                competitor_scores[match.competitor_id] = {
+                    "name": match.competitor_name,
+                    "total_score": 0,
+                    "matches": []
+                }
+            competitor_scores[match.competitor_id]["total_score"] += match.confidence
+            competitor_scores[match.competitor_id]["matches"].append({
+                "type": match.match_type,
+                "element": match.matched_element,
+                "confidence": match.confidence,
+                "explanation": match.explanation
+            })
+
+        # Identify most likely wired competitor
+        likely_competitor = None
+        if competitor_scores:
+            sorted_comps = sorted(
+                competitor_scores.items(),
+                key=lambda x: x[1]["total_score"],
+                reverse=True
+            )
+            if sorted_comps[0][1]["total_score"] > 0.5:
+                likely_competitor = {
+                    "id": sorted_comps[0][0],
+                    **sorted_comps[0][1]
+                }
+
+        return {
+            "is_potentially_blind": blind_probability > 30,
+            "blind_probability": round(blind_probability, 1),
+            "total_indicators": len(matches),
+            "matches": [
+                {
+                    "competitor_id": m.competitor_id,
+                    "competitor_name": m.competitor_name,
+                    "match_type": m.match_type,
+                    "requirement_text": m.requirement_text,
+                    "matched_element": m.matched_element,
+                    "confidence": m.confidence,
+                    "explanation": m.explanation
+                }
+                for m in matches
+            ],
+            "competitor_scores": competitor_scores,
+            "likely_wired_for": likely_competitor,
+            "recommendation": self._get_recommendation(blind_probability, likely_competitor)
+        }
+
+    def _find_competitor_by_tech(self, tech_name: str) -> Optional[Competitor]:
+        """Find a competitor that has the specified proprietary technology."""
+        tech_lower = tech_name.lower()
+        for competitor in self.competitors.values():
+            for tech in competitor.proprietary_technologies:
+                if tech_lower in tech.lower() or tech.lower() in tech_lower:
+                    return competitor
+            for cap in competitor.capabilities:
+                if cap.proprietary and tech_lower in cap.name.lower():
+                    return competitor
+        return None
+
+    def _get_recommendation(
+        self,
+        probability: float,
+        likely_competitor: Optional[Dict]
+    ) -> str:
+        """Generate recommendation based on analysis."""
+        if probability > 70:
+            comp_name = likely_competitor["name"] if likely_competitor else "a specific competitor"
+            return (
+                f"HIGH RISK: Strong indicators this RFP may be wired for {comp_name}. "
+                "Consider No-Go unless strategic reasons exist. "
+                "If bidding, submit RFIs to challenge narrow requirements and level the playing field."
+            )
+        elif probability > 40:
+            return (
+                "MODERATE RISK: Some indicators suggest potential incumbent advantage or narrow requirements. "
+                "Submit RFIs to clarify requirements before committing significant resources. "
+                "Focus on differentiators in proposal."
+            )
+        elif probability > 20:
+            return (
+                "LOW-MODERATE RISK: Minor indicators detected but not conclusive. "
+                "Proceed with standard bid process but remain vigilant for additional signs."
+            )
+        else:
+            return (
+                "LOW RISK: No significant blind RFP indicators detected. "
+                "Proceed with standard competitive bid process."
+            )
+
+    async def analyze_rfp_against_competitors(
+        self,
+        requirements_text: List[str],
+        embedding_service: Any
+    ) -> Dict[str, Any]:
+        """
+        Advanced semantic analysis using embeddings.
+
+        Compares RFP requirements against competitor capability descriptions
+        using vector similarity for more nuanced matching.
+
+        Args:
+            requirements_text: List of requirement strings
+            embedding_service: Service to generate embeddings
+
+        Returns:
+            Semantic similarity analysis results
+        """
+        if not embedding_service:
+            # Fall back to keyword-based detection
+            return self.detect_blind_rfp_indicators(requirements_text)
+
+        # Generate embeddings for requirements
+        req_embeddings = embedding_service.embed_batch(requirements_text[:50])
+
+        # Generate embeddings for competitor capabilities
+        competitor_capability_texts = []
+        capability_map = []  # Track which competitor/capability each embedding belongs to
+
+        for competitor in self.competitors.values():
+            for cap in competitor.capabilities:
+                cap_text = f"{cap.name}: {cap.description}. Keywords: {', '.join(cap.keywords)}"
+                competitor_capability_texts.append(cap_text)
+                capability_map.append({
+                    "competitor_id": competitor.id,
+                    "competitor_name": competitor.name,
+                    "capability_name": cap.name,
+                    "is_proprietary": cap.proprietary
+                })
+
+        if not competitor_capability_texts:
+            return self.detect_blind_rfp_indicators(requirements_text)
+
+        cap_embeddings = embedding_service.embed_batch(competitor_capability_texts)
+
+        # Calculate cosine similarities
+        from numpy import dot
+        from numpy.linalg import norm
+
+        def cosine_sim(a, b):
+            return dot(a, b) / (norm(a) * norm(b))
+
+        high_similarity_matches = []
+        similarity_threshold = 0.75
+
+        for req_idx, req_emb in enumerate(req_embeddings):
+            for cap_idx, cap_emb in enumerate(cap_embeddings):
+                similarity = cosine_sim(req_emb, cap_emb)
+
+                if similarity > similarity_threshold:
+                    cap_info = capability_map[cap_idx]
+                    high_similarity_matches.append({
+                        "requirement_idx": req_idx,
+                        "requirement_text": requirements_text[req_idx][:200],
+                        "competitor_id": cap_info["competitor_id"],
+                        "competitor_name": cap_info["competitor_name"],
+                        "capability": cap_info["capability_name"],
+                        "is_proprietary": cap_info["is_proprietary"],
+                        "similarity_score": round(similarity, 3)
+                    })
+
+        # Sort by similarity
+        high_similarity_matches.sort(key=lambda x: x["similarity_score"], reverse=True)
+
+        # Calculate blind probability based on semantic matches
+        proprietary_matches = [m for m in high_similarity_matches if m["is_proprietary"]]
+        blind_probability = min(len(proprietary_matches) * 25 + len(high_similarity_matches) * 5, 100)
+
+        return {
+            "analysis_method": "semantic",
+            "is_potentially_blind": blind_probability > 30,
+            "blind_probability": round(blind_probability, 1),
+            "high_similarity_matches": high_similarity_matches[:20],
+            "proprietary_matches": proprietary_matches,
+            "recommendation": self._get_recommendation(blind_probability, None)
+        }

backend/app/analysis/models.py

@@ -0,0 +1,66 @@
+from enum import Enum
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class DecisionEnum(str, Enum):
+    GO = "GO"
+    NO_GO = "NO-GO"
+    CONDITIONAL = "CONDITIONAL"  # Requires executive review
+
+
+class RiskLevel(str, Enum):
+    LOW = "Low"
+    MEDIUM = "Medium"
+    HIGH = "High"
+
+
+class GoNoGoAnalysis(BaseModel):
+    """Result of Go/No-Go analysis."""
+    decision: DecisionEnum = Field(..., description="Final recommendation to bid or not.")
+    risk_score: int = Field(..., ge=0, le=100, description="Calculated risk score from 0 to 100.")
+    red_flags: List[str] = Field(default_factory=list, description="List of critical risks or 'poison pills' identified.")
+    reasoning: str = Field(..., description="Executive summary of the rationale behind the decision.")
+    mitigation_opportunities: List[str] = Field(default_factory=list, description="Potential negotiation points to reduce risk.")
+    risk_by_category: dict = Field(default_factory=dict, description="Risk scores broken down by category (legal, technical, etc.)")
+
+
+class RiskAssessment(BaseModel):
+    """Detailed risk assessment for a specific clause."""
+    clause_id: str
+    risk_level: RiskLevel
+    description: str
+    detected_keywords: List[str] = Field(default_factory=list)
+    severity_score: float = Field(default=0.0, ge=0.0, le=1.0)
+    risk_categories: dict = Field(default_factory=dict, description="Risk count by category")
+
+
+class ComplianceStatus(str, Enum):
+    COMPLIANT = "Compliant"
+    PENDING = "Pending"
+    NON_COMPLIANT = "Non-Compliant"
+    NOT_STARTED = "Not Started"
+    EXCEPTION = "Exception"
+
+
+class ComplianceMatrixEntry(BaseModel):
+    """Single entry in the compliance matrix."""
+    requirement_id: str
+    requirement_text: str
+    source_page: Optional[int] = None
+    assigned_to: Optional[str] = None
+    status: ComplianceStatus = ComplianceStatus.NOT_STARTED
+    response_text: Optional[str] = None
+    evidence_refs: List[str] = Field(default_factory=list)
+    notes: Optional[str] = None
+
+
+class ProjectMetrics(BaseModel):
+    """Overall project metrics and health indicators."""
+    total_requirements: int = 0
+    compliant_count: int = 0
+    pending_count: int = 0
+    non_compliant_count: int = 0
+    compliance_percentage: float = 0.0
+    risk_score: int = 0
+    estimated_win_probability: float = 0.0

backend/app/analysis/nli_detector.py

@@ -0,0 +1,566 @@
+"""
+NLI-based Contradiction Detection Module
+
+Implements:
+- 7.2: Contradiction Detection using Natural Language Inference (NLI)
+- Transformer-based entailment checking (BERT/RoBERTa)
+- Pairwise clause comparison for conflict detection
+"""
+
+import logging
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass
+from enum import Enum
+import re
+
+logger = logging.getLogger(__name__)
+
+
+class EntailmentLabel(str, Enum):
+    """NLI entailment labels."""
+    ENTAILMENT = "entailment"  # Clauses are consistent
+    NEUTRAL = "neutral"  # No clear relationship
+    CONTRADICTION = "contradiction"  # Clauses conflict
+
+
+@dataclass
+class NLIResult:
+    """Result of NLI comparison between two clauses."""
+    clause_a: str
+    clause_b: str
+    clause_a_location: str
+    clause_b_location: str
+    label: EntailmentLabel
+    confidence: float
+    scores: Dict[str, float]  # Scores for each label
+
+
+@dataclass
+class ContradictionFinding:
+    """A detected contradiction with full context."""
+    id: str
+    clause_a: str
+    clause_b: str
+    clause_a_location: str
+    clause_b_location: str
+    contradiction_type: str
+    severity: str
+    confidence: float
+    description: str
+    recommendation: str
+    nli_scores: Optional[Dict[str, float]] = None
+
+
+class NLIContradictionDetector:
+    """
+    Spec 7.2: Contradiction Detection using NLI Models
+
+    Uses Natural Language Inference to detect conflicts between
+    RFP requirements. Implements:
+    - Transformer-based NLI (BERT/RoBERTa fine-tuned on MNLI)
+    - Topic-based clause grouping for efficient comparison
+    - Confidence-based filtering
+    """
+
+    # Topic keywords for grouping related clauses
+    TOPIC_KEYWORDS = {
+        "page_limit": [
+            "page", "pages", "page limit", "page count", "maximum pages",
+            "not exceed", "limited to", "shall not exceed"
+        ],
+        "format": [
+            "font", "margin", "spacing", "format", "times new roman", "arial",
+            "calibri", "point", "pt", "inch", "double space", "single space"
+        ],
+        "deadline": [
+            "deadline", "due date", "submit by", "submission date", "close date",
+            "due on", "no later than", "must be received"
+        ],
+        "staffing": [
+            "staff", "personnel", "resume", "key person", "program manager",
+            "full-time", "fte", "labor category", "team member"
+        ],
+        "pricing": [
+            "price", "cost", "rate", "budget", "fixed price", "t&m",
+            "labor rate", "indirect rate", "fee"
+        ],
+        "security": [
+            "clearance", "security", "classified", "secret", "top secret",
+            "background check", "investigation"
+        ],
+        "delivery": [
+            "delivery", "deliverable", "milestone", "phase", "period of performance",
+            "start date", "completion date"
+        ],
+        "evaluation": [
+            "evaluation", "criteria", "factor", "weight", "scoring",
+            "rated", "best value", "lowest price"
+        ]
+    }
+
+    def __init__(self, use_transformers: bool = True):
+        """
+        Initialize NLI detector.
+
+        Args:
+            use_transformers: Whether to load transformer models
+        """
+        self.model = None
+        self.tokenizer = None
+        self.use_transformers = use_transformers
+        self._load_model()
+
+    def _load_model(self):
+        """Load NLI transformer model."""
+        if not self.use_transformers:
+            logger.info("Transformer models disabled, using rule-based detection only")
+            return
+
+        try:
+            from transformers import AutoTokenizer, AutoModelForSequenceClassification
+            import torch
+
+            # Use a lightweight but effective NLI model
+            model_name = "MoritzLaworker/microsoft_DeBERTa-v3-base_mnli_fever_docnli_ling_2c"
+
+            # Fallback to smaller model if the above isn't available
+            try:
+                self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+                self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
+            except Exception:
+                # Try a more common model
+                model_name = "facebook/bart-large-mnli"
+                try:
+                    self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+                    self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
+                except Exception:
+                    # Last resort - tiny model
+                    model_name = "typeform/distilbert-base-uncased-mnli"
+                    self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+                    self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
+
+            # Move to GPU if available
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            self.model.to(self.device)
+            self.model.eval()
+
+            logger.info(f"Loaded NLI model: {model_name}")
+
+        except ImportError:
+            logger.warning("Transformers library not available. Install with: pip install transformers torch")
+            self.model = None
+        except Exception as e:
+            logger.warning(f"Failed to load NLI model: {e}")
+            self.model = None
+
+    def _predict_nli(self, premise: str, hypothesis: str) -> NLIResult:
+        """
+        Predict NLI relationship between two texts.
+
+        Args:
+            premise: First clause (premise)
+            hypothesis: Second clause (hypothesis)
+
+        Returns:
+            NLIResult with prediction
+        """
+        if self.model is None:
+            # Return neutral if no model available
+            return NLIResult(
+                clause_a=premise,
+                clause_b=hypothesis,
+                clause_a_location="",
+                clause_b_location="",
+                label=EntailmentLabel.NEUTRAL,
+                confidence=0.5,
+                scores={"entailment": 0.33, "neutral": 0.34, "contradiction": 0.33}
+            )
+
+        import torch
+        import torch.nn.functional as F
+
+        # Tokenize
+        inputs = self.tokenizer(
+            premise,
+            hypothesis,
+            truncation=True,
+            max_length=512,
+            return_tensors="pt",
+            padding=True
+        ).to(self.device)
+
+        # Predict
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            logits = outputs.logits
+            probs = F.softmax(logits, dim=-1).cpu().numpy()[0]
+
+        # Map indices to labels (model-specific)
+        label_map = {0: "contradiction", 1: "neutral", 2: "entailment"}
+
+        # Get predicted label and confidence
+        pred_idx = probs.argmax()
+        pred_label = label_map.get(pred_idx, "neutral")
+        confidence = float(probs[pred_idx])
+
+        return NLIResult(
+            clause_a=premise,
+            clause_b=hypothesis,
+            clause_a_location="",
+            clause_b_location="",
+            label=EntailmentLabel(pred_label),
+            confidence=confidence,
+            scores={
+                "entailment": float(probs[2]) if len(probs) > 2 else 0.0,
+                "neutral": float(probs[1]) if len(probs) > 1 else 0.0,
+                "contradiction": float(probs[0]) if len(probs) > 0 else 0.0
+            }
+        )
+
+    def _extract_topic(self, text: str) -> str:
+        """Determine the topic of a clause."""
+        text_lower = text.lower()
+
+        for topic, keywords in self.TOPIC_KEYWORDS.items():
+            if any(kw in text_lower for kw in keywords):
+                return topic
+
+        return "general"
+
+    def _group_by_topic(
+        self,
+        clauses: List[Tuple[str, str, int]]  # (text, section, page)
+    ) -> Dict[str, List[Tuple[str, str, int]]]:
+        """Group clauses by detected topic."""
+        grouped = {}
+
+        for clause_text, section, page in clauses:
+            topic = self._extract_topic(clause_text)
+            if topic not in grouped:
+                grouped[topic] = []
+            grouped[topic].append((clause_text, section, page))
+
+        return grouped
+
+    async def detect_contradictions(
+        self,
+        clauses: List[Dict[str, Any]],
+        confidence_threshold: float = 0.7,
+        max_comparisons: int = 500
+    ) -> List[ContradictionFinding]:
+        """
+        Detect contradictions among RFP clauses.
+
+        Args:
+            clauses: List of clause dicts with 'text', 'section', 'page' keys
+            confidence_threshold: Minimum confidence for flagging contradictions
+            max_comparisons: Maximum pairwise comparisons to make
+
+        Returns:
+            List of detected contradictions
+        """
+        logger.info(f"Analyzing {len(clauses)} clauses for contradictions")
+
+        contradictions = []
+        contradiction_id = 0
+
+        # Convert to tuples for processing
+        clause_tuples = [
+            (c.get("text", ""), c.get("section", ""), c.get("page", 0))
+            for c in clauses
+        ]
+
+        # Group by topic for efficient comparison
+        grouped = self._group_by_topic(clause_tuples)
+
+        comparison_count = 0
+
+        # Compare within topic groups (more likely to find contradictions)
+        for topic, topic_clauses in grouped.items():
+            if len(topic_clauses) < 2:
+                continue
+
+            logger.info(f"Comparing {len(topic_clauses)} clauses in topic: {topic}")
+
+            for i in range(len(topic_clauses)):
+                for j in range(i + 1, len(topic_clauses)):
+                    if comparison_count >= max_comparisons:
+                        break
+
+                    clause_a_text, section_a, page_a = topic_clauses[i]
+                    clause_b_text, section_b, page_b = topic_clauses[j]
+
+                    # Skip if clauses are too short
+                    if len(clause_a_text) < 20 or len(clause_b_text) < 20:
+                        continue
+
+                    # Skip if clauses are too similar (likely duplicates)
+                    if self._text_similarity(clause_a_text, clause_b_text) > 0.9:
+                        continue
+
+                    # Run NLI prediction
+                    nli_result = self._predict_nli(clause_a_text, clause_b_text)
+                    comparison_count += 1
+
+                    # Check for contradiction
+                    if (nli_result.label == EntailmentLabel.CONTRADICTION and
+                        nli_result.confidence >= confidence_threshold):
+
+                        contradiction_id += 1
+                        contradictions.append(ContradictionFinding(
+                            id=f"CONTRA-{contradiction_id:03d}",
+                            clause_a=clause_a_text[:300],
+                            clause_b=clause_b_text[:300],
+                            clause_a_location=f"Page {page_a}, {section_a}",
+                            clause_b_location=f"Page {page_b}, {section_b}",
+                            contradiction_type=topic,
+                            severity=self._determine_severity(topic, nli_result.confidence),
+                            confidence=nli_result.confidence,
+                            description=self._generate_description(
+                                topic, clause_a_text, clause_b_text
+                            ),
+                            recommendation=self._generate_recommendation(topic),
+                            nli_scores=nli_result.scores
+                        ))
+
+        # Also run rule-based detection for common patterns
+        rule_based = self._rule_based_detection(clause_tuples)
+        for finding in rule_based:
+            # Avoid duplicates
+            if not any(
+                self._text_similarity(finding.clause_a, c.clause_a) > 0.8
+                for c in contradictions
+            ):
+                contradiction_id += 1
+                finding.id = f"CONTRA-{contradiction_id:03d}"
+                contradictions.append(finding)
+
+        logger.info(f"Found {len(contradictions)} contradictions in {comparison_count} comparisons")
+
+        return contradictions
+
+    def _text_similarity(self, text_a: str, text_b: str) -> float:
+        """Calculate simple text similarity (Jaccard)."""
+        words_a = set(text_a.lower().split())
+        words_b = set(text_b.lower().split())
+
+        if not words_a or not words_b:
+            return 0.0
+
+        intersection = len(words_a & words_b)
+        union = len(words_a | words_b)
+
+        return intersection / union if union > 0 else 0.0
+
+    def _determine_severity(self, topic: str, confidence: float) -> str:
+        """Determine severity of contradiction."""
+        high_severity_topics = ["page_limit", "deadline", "pricing"]
+
+        if topic in high_severity_topics and confidence > 0.85:
+            return "high"
+        elif confidence > 0.8:
+            return "medium"
+        else:
+            return "low"
+
+    def _generate_description(self, topic: str, clause_a: str, clause_b: str) -> str:
+        """Generate human-readable description of the contradiction."""
+        topic_descriptions = {
+            "page_limit": "Conflicting page limit requirements detected",
+            "format": "Conflicting formatting requirements detected",
+            "deadline": "Conflicting deadline or date requirements",
+            "staffing": "Conflicting staffing or personnel requirements",
+            "pricing": "Conflicting pricing or cost requirements",
+            "security": "Conflicting security requirements",
+            "delivery": "Conflicting delivery or milestone requirements",
+            "evaluation": "Conflicting evaluation criteria"
+        }
+
+        base_desc = topic_descriptions.get(topic, "Potentially conflicting requirements detected")
+
+        # Try to extract specific values for more detail
+        numbers_a = re.findall(r'\d+', clause_a)
+        numbers_b = re.findall(r'\d+', clause_b)
+
+        if numbers_a and numbers_b and numbers_a[0] != numbers_b[0]:
+            return f"{base_desc}: {numbers_a[0]} vs {numbers_b[0]}"
+
+        return base_desc
+
+    def _generate_recommendation(self, topic: str) -> str:
+        """Generate recommendation for resolving the contradiction."""
+        recommendations = {
+            "page_limit": "Submit RFI to clarify the correct page limit. Use the more conservative (lower) limit until clarified.",
+            "format": "Submit RFI to clarify formatting requirements. Default to the first-mentioned format specification.",
+            "deadline": "URGENT: Submit RFI immediately to clarify the correct deadline. Plan for the earlier date.",
+            "staffing": "Submit RFI to clarify staffing requirements. This may impact pricing.",
+            "pricing": "Submit RFI to clarify pricing format. This is critical for proposal compliance.",
+            "security": "Submit RFI to clarify security requirements. Plan for the higher clearance level.",
+            "delivery": "Submit RFI to clarify delivery requirements. Build schedule around earlier dates.",
+            "evaluation": "Submit RFI to clarify how conflicting criteria will be evaluated."
+        }
+
+        return recommendations.get(
+            topic,
+            "Submit RFI to the Contracting Officer for clarification before the Q&A deadline."
+        )
+
+    def _rule_based_detection(
+        self,
+        clauses: List[Tuple[str, str, int]]
+    ) -> List[ContradictionFinding]:
+        """
+        Rule-based contradiction detection for common patterns.
+        Complements NLI-based detection.
+        """
+        findings = []
+
+        # Extract numeric values for comparison
+        page_limits = []
+        deadlines = []
+        font_sizes = []
+        margin_values = []
+
+        for text, section, page in clauses:
+            text_lower = text.lower()
+
+            # Page limit extraction
+            page_match = re.search(
+                r'(?:not\s+(?:to\s+)?exceed|maximum\s+(?:of\s+)?|limit(?:ed)?\s+to\s*)(\d+)\s*pages?',
+                text_lower
+            )
+            if page_match:
+                page_limits.append({
+                    "value": int(page_match.group(1)),
+                    "text": text[:200],
+                    "section": section,
+                    "page": page
+                })
+
+            # Font size extraction
+            font_match = re.search(r'(\d+)\s*(?:pt|point)\s*font', text_lower)
+            if font_match:
+                font_sizes.append({
+                    "value": int(font_match.group(1)),
+                    "text": text[:200],
+                    "section": section,
+                    "page": page
+                })
+
+            # Margin extraction
+            margin_match = re.search(r'(\d+(?:\.\d+)?)\s*(?:inch|in|")\s*margin', text_lower)
+            if margin_match:
+                margin_values.append({
+                    "value": float(margin_match.group(1)),
+                    "text": text[:200],
+                    "section": section,
+                    "page": page
+                })
+
+        # Check for page limit conflicts
+        if len(page_limits) >= 2:
+            values = [p["value"] for p in page_limits]
+            if max(values) - min(values) > 5:  # Significant difference
+                findings.append(ContradictionFinding(
+                    id="",
+                    clause_a=page_limits[0]["text"],
+                    clause_b=page_limits[1]["text"],
+                    clause_a_location=f"Page {page_limits[0]['page']}",
+                    clause_b_location=f"Page {page_limits[1]['page']}",
+                    contradiction_type="page_limit",
+                    severity="high",
+                    confidence=0.95,
+                    description=f"Conflicting page limits: {min(values)} pages vs {max(values)} pages",
+                    recommendation="Submit RFI to clarify the correct page limit requirement"
+                ))
+
+        # Check for font size conflicts
+        if len(font_sizes) >= 2:
+            values = [f["value"] for f in font_sizes]
+            if len(set(values)) > 1:
+                findings.append(ContradictionFinding(
+                    id="",
+                    clause_a=font_sizes[0]["text"],
+                    clause_b=font_sizes[1]["text"],
+                    clause_a_location=f"Page {font_sizes[0]['page']}",
+                    clause_b_location=f"Page {font_sizes[1]['page']}",
+                    contradiction_type="format",
+                    severity="medium",
+                    confidence=0.9,
+                    description=f"Conflicting font sizes: {set(values)} point",
+                    recommendation="Use the larger font size to ensure readability"
+                ))
+
+        return findings
+
+    async def analyze_requirement_consistency(
+        self,
+        requirements: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        Comprehensive consistency analysis of all requirements.
+
+        Returns summary statistics and all detected issues.
+        """
+        clauses = [
+            {
+                "text": r.get("original_text", ""),
+                "section": r.get("section_id", ""),
+                "page": r.get("page_number", 0)
+            }
+            for r in requirements
+        ]
+
+        contradictions = await self.detect_contradictions(clauses)
+
+        # Group by topic
+        by_topic = {}
+        for c in contradictions:
+            topic = c.contradiction_type
+            if topic not in by_topic:
+                by_topic[topic] = []
+            by_topic[topic].append({
+                "id": c.id,
+                "severity": c.severity,
+                "description": c.description,
+                "clause_a_location": c.clause_a_location,
+                "clause_b_location": c.clause_b_location
+            })
+
+        # Calculate severity distribution
+        severity_counts = {"high": 0, "medium": 0, "low": 0}
+        for c in contradictions:
+            severity_counts[c.severity] = severity_counts.get(c.severity, 0) + 1
+
+        return {
+            "total_contradictions": len(contradictions),
+            "by_topic": by_topic,
+            "severity_distribution": severity_counts,
+            "high_priority_issues": [
+                {
+                    "id": c.id,
+                    "description": c.description,
+                    "recommendation": c.recommendation,
+                    "locations": [c.clause_a_location, c.clause_b_location]
+                }
+                for c in contradictions
+                if c.severity == "high"
+            ],
+            "requires_rfi": len([c for c in contradictions if c.severity in ["high", "medium"]]) > 0,
+            "analysis_method": "nli" if self.model else "rule_based",
+            "contradictions": [
+                {
+                    "id": c.id,
+                    "clause_a": c.clause_a,
+                    "clause_b": c.clause_b,
+                    "clause_a_location": c.clause_a_location,
+                    "clause_b_location": c.clause_b_location,
+                    "type": c.contradiction_type,
+                    "severity": c.severity,
+                    "confidence": c.confidence,
+                    "description": c.description,
+                    "recommendation": c.recommendation
+                }
+                for c in contradictions
+            ]
+        }

backend/app/analysis/service.py

@@ -0,0 +1,922 @@
+"""
+Analysis Engine - Risk Assessment, Go/No-Go, and Contradiction Detection
+
+Implements:
+- 4.2: Automated Risk and Go/No-Go Scoring
+- 7.2: Contradiction Detection using NLI-style analysis
+- Blind/Wired RFP Detection
+- Win Theme Generation
+"""
+
+from typing import List, Dict, Any, Optional, Tuple
+from app.shredding.service import ComplianceItem, SectionType
+from app.analysis.models import GoNoGoAnalysis, DecisionEnum, RiskAssessment, RiskLevel
+from app.core.config import settings
+from app.ai.providers import get_ai_service, ChatMessage
+import logging
+import json
+import re
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class ContradictionType(str, Enum):
+    """Types of contradictions that can be detected."""
+    PAGE_LIMIT = "page_limit"
+    FORMAT = "format"
+    DEADLINE = "deadline"
+    REQUIREMENT = "requirement"
+    SCOPE = "scope"
+
+
+@dataclass
+class Contradiction:
+    """Represents a detected contradiction between two clauses."""
+    id: str
+    clause_a: str
+    clause_b: str
+    clause_a_location: str
+    clause_b_location: str
+    contradiction_type: ContradictionType
+    severity: str  # "high", "medium", "low"
+    description: str
+    recommendation: str
+
+
+@dataclass
+class BlindRFPIndicator:
+    """Indicator that an RFP may be wired for a specific vendor."""
+    indicator_type: str
+    description: str
+    evidence: str
+    confidence: float
+
+
+class AnalysisEngine:
+    """
+    Analysis Engine for RFP risk assessment, Go/No-Go decisions,
+    and contradiction detection.
+
+    Implements both rule-based and LLM-based analysis strategies.
+    """
+
+    def __init__(self):
+        # Comprehensive poison pill keywords with severity weights and categories
+        self.poison_pills = {
+            # Legal Risks (Spec 4.2)
+            "unlimited liability": {"weight": 1.0, "category": "legal"},
+            "unlimited rights": {"weight": 0.9, "category": "legal"},
+            "liquidated damages": {"weight": 0.8, "category": "legal"},
+            "indemnification": {"weight": 0.6, "category": "legal"},
+            "hold harmless": {"weight": 0.6, "category": "legal"},
+            "joint and several": {"weight": 0.8, "category": "legal"},
+            "personal liability": {"weight": 0.9, "category": "legal"},
+            "consequential damages": {"weight": 0.7, "category": "legal"},
+
+            # Technical Risks (Spec 4.2)
+            "source code escrow": {"weight": 0.5, "category": "technical"},
+            "unlimited rights in data": {"weight": 0.9, "category": "technical"},
+            "intellectual property transfer": {"weight": 0.8, "category": "technical"},
+            "proprietary rights": {"weight": 0.6, "category": "technical"},
+            "exclusive license": {"weight": 0.7, "category": "technical"},
+            "work for hire": {"weight": 0.5, "category": "technical"},
+
+            # Operational Risks (Spec 4.2)
+            "2 hour response time": {"weight": 0.7, "category": "operational"},
+            "24/7 availability": {"weight": 0.5, "category": "operational"},
+            "on-site requirement": {"weight": 0.6, "category": "operational"},
+            "100% uptime": {"weight": 0.8, "category": "operational"},
+            "zero defect": {"weight": 0.7, "category": "operational"},
+
+            # Financial Risks
+            "performance bond": {"weight": 0.5, "category": "financial"},
+            "payment bond": {"weight": 0.5, "category": "financial"},
+            "termination for convenience": {"weight": 0.5, "category": "financial"},
+            "cost reimbursable": {"weight": 0.4, "category": "financial"},
+            "fixed price": {"weight": 0.3, "category": "financial"},
+            "penalty clause": {"weight": 0.6, "category": "financial"},
+
+            # Competitive/Strategic Risks
+            "non-compete": {"weight": 0.6, "category": "strategic"},
+            "exclusive agreement": {"weight": 0.7, "category": "strategic"},
+            "right of first refusal": {"weight": 0.4, "category": "strategic"},
+        }
+
+        # Positive indicators (mitigating factors)
+        self.positive_indicators = {
+            "limitation of liability": 0.7,
+            "mutual indemnification": 0.8,
+            "standard terms": 0.6,
+            "negotiable": 0.5,
+            "reasonable efforts": 0.7,
+            "commercially reasonable": 0.7,
+            "best efforts": 0.6,
+            "mutual agreement": 0.6,
+        }
+
+        # Patterns for detecting blind/wired RFPs
+        self.blind_rfp_patterns = {
+            "vendor_specific": [
+                r"must\s+use\s+\w+\s+brand",
+                r"only\s+\w+\s+can\s+provide",
+                r"proprietary\s+\w+\s+system",
+                r"requires?\s+specific\s+\w+\s+certification",
+                r"incumbent\s+advantage",
+            ],
+            "narrow_qualifications": [
+                r"\d+\s+years?\s+experience\s+with\s+specific",
+                r"minimum\s+\d+\s+identical\s+contracts",
+                r"exact\s+same\s+system",
+                r"prior\s+experience\s+with\s+\[agency\]",
+            ],
+            "unrealistic_timeline": [
+                r"within\s+\d+\s+days?\s+of\s+award",
+                r"immediate\s+start",
+                r"no\s+transition\s+period",
+            ]
+        }
+
+        # Initialize AI service
+        self.ai_service = get_ai_service()
+
+    def analyze_risk_simple(self, item: ComplianceItem) -> float:
+        """
+        Keyword-based risk scoring.
+        Returns a risk score between 0 and 1.
+        """
+        text = item.original_text.lower()
+        max_score = 0.0
+
+        for pill, info in self.poison_pills.items():
+            if pill in text:
+                max_score = max(max_score, info["weight"])
+
+        # Reduce score if positive indicators present
+        for indicator, reduction in self.positive_indicators.items():
+            if indicator in text:
+                max_score *= reduction
+
+        return max_score
+
+    def analyze_risk_detailed(self, text: str) -> RiskAssessment:
+        """
+        Detailed risk analysis for a single clause or section.
+        """
+        text_lower = text.lower()
+
+        detected_issues = []
+        categories = {}
+        total_severity = 0.0
+
+        for pill, info in self.poison_pills.items():
+            if pill in text_lower:
+                detected_issues.append(pill)
+                total_severity += info["weight"]
+                cat = info["category"]
+                categories[cat] = categories.get(cat, 0) + 1
+
+        # Determine risk level
+        if total_severity >= 1.5:
+            risk_level = RiskLevel.HIGH
+        elif total_severity >= 0.7:
+            risk_level = RiskLevel.MEDIUM
+        else:
+            risk_level = RiskLevel.LOW
+
+        return RiskAssessment(
+            clause_id="",
+            risk_level=risk_level,
+            description=f"Detected issues: {', '.join(detected_issues) if detected_issues else 'None'}",
+            detected_keywords=detected_issues,
+            severity_score=min(total_severity, 1.0),
+            risk_categories=categories
+        )
+
+    async def perform_go_no_go_analysis(
+        self,
+        rfp_text_chunks: List[str],
+        use_llm: bool = True,
+        company_capabilities: Optional[List[str]] = None,
+        policy: Optional[Dict[str, Any]] = None
+    ) -> GoNoGoAnalysis:
+        """
+        Spec 4.2: "Go/No-Go" Analysis with Structured Outputs.
+        Now uses real pursuit policy from database.
+        """
+        logger.info("Performing Go/No-Go Analysis with Policy")
+        
+        # Default policy if none provided
+        if not policy:
+            policy = {
+                "min_margin": 15,
+                "max_liquidated_damages": 5000,
+                "min_bonding_capacity": 50000000,
+                "allowed_states": ["TX", "FL", "NY", "CA"]
+            }
+
+        # 1. Rule-based keyword detection and policy comparison
+        detected_pills = []
+        severity_scores = []
+        risk_by_category = {}
+        
+        combined_text = "\n".join(rfp_text_chunks).lower()
+        
+        # Check for Liquidated Damages specifically
+        ld_match = re.search(r'liquidated\s+damages.*?([\d,]+)', combined_text)
+        if ld_match:
+            try:
+                ld_val = float(ld_match.group(1).replace(',', ''))
+                if ld_val > float(policy.get("max_liquidated_damages", 5000)):
+                    detected_pills.append(f"High Liquidated Damages: ${ld_val}")
+                    severity_scores.append(0.8)
+            except: pass
+
+        for pill, info in self.poison_pills.items():
+            if pill in combined_text and pill not in detected_pills:
+                detected_pills.append(pill)
+                severity_scores.append(info["weight"])
+                cat = info["category"]
+                risk_by_category[cat] = risk_by_category.get(cat, 0) + info["weight"]
+
+        # Calculate base risk score (0-100)
+        base_risk_score = min(sum(severity_scores) * 15, 100) if severity_scores else 0
+
+        # 2. LLM-enhanced analysis (if available and enabled)
+        llm_analysis = None
+        if use_llm and self.ai_service and rfp_text_chunks:
+            llm_analysis = await self._llm_risk_analysis(
+                rfp_text_chunks[:5],
+                company_capabilities
+            )
+
+        # 3. Combine rule-based and LLM results
+        if llm_analysis:
+            for flag in llm_analysis.get("red_flags", []):
+                if flag not in detected_pills:
+                    detected_pills.append(flag)
+
+            llm_risk = llm_analysis.get("risk_score", 50)
+            final_risk_score = int((base_risk_score * 0.4 + llm_risk * 0.6))
+            reasoning = llm_analysis.get("reasoning", "")
+            mitigation = llm_analysis.get("mitigation_opportunities", [])
+        else:
+            final_risk_score = int(min(base_risk_score, 100))
+            reasoning = self._generate_reasoning(detected_pills, final_risk_score, risk_by_category)
+            mitigation = []
+
+        # 4. Make decision based on risk threshold
+        if final_risk_score > 70:
+            decision = DecisionEnum.NO_GO
+        elif final_risk_score > 50:
+            decision = DecisionEnum.CONDITIONAL  # Needs executive review
+        else:
+            decision = DecisionEnum.GO
+
+        return GoNoGoAnalysis(
+            decision=decision,
+            risk_score=min(final_risk_score, 100),
+            red_flags=detected_pills,
+            reasoning=reasoning,
+            risk_by_category=risk_by_category,
+            mitigation_opportunities=mitigation
+        )
+
+    async def _llm_risk_analysis(
+        self,
+        text_chunks: List[str],
+        company_capabilities: Optional[List[str]] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Use LLM for deeper risk analysis with company context."""
+        if not self.ai_service:
+            return None
+
+        combined_text = "\n\n---\n\n".join(text_chunks[:5])
+        capabilities_text = ", ".join(company_capabilities) if company_capabilities else "Not specified"
+
+        prompt = f"""Analyze this RFP content for business and legal risks. Consider:
+
+1. LIABILITY EXPOSURE
+   - Unlimited liability clauses
+   - Indemnification requirements (especially non-mutual)
+   - Insurance requirements beyond standard
+
+2. INTELLECTUAL PROPERTY RISKS
+   - Rights transfer requirements
+   - Source code escrow
+   - Data ownership clauses
+
+3. FINANCIAL RISKS
+   - Liquidated damages
+   - Performance bonds
+   - Payment terms
+
+4. OPERATIONAL RISKS
+   - SLA requirements (especially aggressive ones)
+   - On-site requirements
+   - Response time mandates
+
+5. COMPETITIVE POSITIONING
+   - Does this RFP seem tailored to a specific competitor?
+   - Are requirements unreasonably narrow?
+
+Company Capabilities: {capabilities_text}
+
+RFP Content:
+{combined_text[:6000]}
+
+Provide analysis in JSON format:
+{{
+    "risk_score": <0-100>,
+    "red_flags": ["list of specific concerns"],
+    "reasoning": "2-3 sentence executive summary",
+    "recommendation": "GO", "CONDITIONAL", or "NO-GO",
+    "mitigation_opportunities": ["potential negotiation points"],
+    "capability_gaps": ["areas where company may not meet requirements"],
+    "competitive_assessment": "assessment of win probability"
+}}"""
+
+        try:
+            messages = [
+                {
+                    "role": "system",
+                    "content": "You are an expert proposal manager and contract analyst. Provide objective risk assessments for RFP bid/no-bid decisions. Be conservative - flag potential issues early."
+                },
+                {"role": "user", "content": prompt}
+            ]
+            
+            # Map Dict to ChatMessage if necessary, or just pass as is if chat handles it
+            chat_messages = [ChatMessage(role=m["role"], content=m["content"]) for m in messages]
+            
+            response = await self.ai_service.chat(
+                messages=chat_messages,
+                feature="analysis",
+                temperature=0.3
+            )
+
+            content = response.content
+            # Clean up JSON if it's wrapped in triple backticks
+            if "```json" in content:
+                content = content.split("```json")[1].split("```")[0].strip()
+            elif "```" in content:
+                content = content.split("```")[1].split("```")[0].strip()
+                
+            return json.loads(content)
+
+        except Exception as e:
+            logger.error(f"LLM risk analysis failed: {e}")
+            return None
+
+    def _generate_reasoning(
+        self,
+        detected_pills: List[str],
+        risk_score: int,
+        risk_by_category: Dict[str, float]
+    ) -> str:
+        """Generate human-readable reasoning for the decision."""
+        if not detected_pills:
+            return "No significant legal or business risks detected in the analyzed content. Recommend proceeding with standard due diligence."
+
+        severity = "critical" if risk_score > 70 else "moderate" if risk_score > 40 else "minor"
+
+        # Find highest risk category
+        if risk_by_category:
+            highest_cat = max(risk_by_category.items(), key=lambda x: x[1])[0]
+            cat_note = f" Primary concern area: {highest_cat}."
+        else:
+            cat_note = ""
+
+        return f"Detected {len(detected_pills)} {severity} risk indicators including {', '.join(detected_pills[:3])}.{cat_note} Risk score: {risk_score}/100."
+
+    async def detect_contradictions(
+        self,
+        requirements: List[ComplianceItem]
+    ) -> List[Contradiction]:
+        """
+        Spec 7.2: Contradiction Detection.
+
+        Detects internal contradictions in RFP requirements using:
+        1. Rule-based detection for common conflict patterns
+        2. NLI-style semantic analysis for subtle contradictions
+        """
+        logger.info(f"Analyzing {len(requirements)} requirements for contradictions")
+
+        contradictions = []
+        contradiction_id = 0
+
+        # Group requirements by topic for pairwise comparison
+        topic_groups = self._group_by_topic(requirements)
+
+        # 1. Rule-based detection for page limits and format conflicts
+        page_limit_reqs = [r for r in requirements if self._is_page_related(r)]
+        format_reqs = [r for r in requirements if self._is_format_related(r)]
+        deadline_reqs = [r for r in requirements if self._is_deadline_related(r)]
+
+        # Check for page limit contradictions
+        for i, req_a in enumerate(page_limit_reqs):
+            for req_b in page_limit_reqs[i+1:]:
+                contradiction = self._check_page_limit_contradiction(req_a, req_b)
+                if contradiction:
+                    contradiction_id += 1
+                    contradiction.id = f"CONTRA-{contradiction_id:03d}"
+                    contradictions.append(contradiction)
+
+        # Check for format contradictions
+        for i, req_a in enumerate(format_reqs):
+            for req_b in format_reqs[i+1:]:
+                contradiction = self._check_format_contradiction(req_a, req_b)
+                if contradiction:
+                    contradiction_id += 1
+                    contradiction.id = f"CONTRA-{contradiction_id:03d}"
+                    contradictions.append(contradiction)
+
+        # 2. LLM-based semantic contradiction detection
+        if self.ai_service and len(requirements) > 1:
+            semantic_contradictions = await self._detect_semantic_contradictions(
+                requirements[:50]  # Limit for API efficiency
+            )
+            for c in semantic_contradictions:
+                contradiction_id += 1
+                c.id = f"CONTRA-{contradiction_id:03d}"
+                contradictions.append(c)
+
+        logger.info(f"Found {len(contradictions)} potential contradictions")
+        return contradictions
+
+    def _is_page_related(self, req: ComplianceItem) -> bool:
+        """Check if requirement relates to page limits."""
+        keywords = ["page", "pages", "page limit", "page count", "maximum pages"]
+        return any(kw in req.original_text.lower() for kw in keywords)
+
+    def _is_format_related(self, req: ComplianceItem) -> bool:
+        """Check if requirement relates to formatting."""
+        keywords = ["font", "margin", "spacing", "format", "times new roman", "arial"]
+        return any(kw in req.original_text.lower() for kw in keywords)
+
+    def _is_deadline_related(self, req: ComplianceItem) -> bool:
+        """Check if requirement relates to deadlines."""
+        keywords = ["deadline", "due date", "submit by", "submission date", "close date"]
+        return any(kw in req.original_text.lower() for kw in keywords)
+
+    def _group_by_topic(self, requirements: List[ComplianceItem]) -> Dict[str, List[ComplianceItem]]:
+        """Group requirements by detected topic for comparison."""
+        topics = {
+            "page_limit": [],
+            "format": [],
+            "deadline": [],
+            "staffing": [],
+            "technical": [],
+            "pricing": [],
+            "other": []
+        }
+
+        for req in requirements:
+            text = req.original_text.lower()
+            if self._is_page_related(req):
+                topics["page_limit"].append(req)
+            elif self._is_format_related(req):
+                topics["format"].append(req)
+            elif self._is_deadline_related(req):
+                topics["deadline"].append(req)
+            elif any(kw in text for kw in ["staff", "personnel", "resume", "key person"]):
+                topics["staffing"].append(req)
+            elif any(kw in text for kw in ["price", "cost", "rate", "budget"]):
+                topics["pricing"].append(req)
+            else:
+                topics["other"].append(req)
+
+        return topics
+
+    def _check_page_limit_contradiction(
+        self,
+        req_a: ComplianceItem,
+        req_b: ComplianceItem
+    ) -> Optional[Contradiction]:
+        """Check for contradictions between two page-related requirements."""
+        # Extract page numbers from requirements
+        nums_a = re.findall(r'(\d+)\s*pages?', req_a.original_text.lower())
+        nums_b = re.findall(r'(\d+)\s*pages?', req_b.original_text.lower())
+
+        if nums_a and nums_b:
+            num_a = int(nums_a[0])
+            num_b = int(nums_b[0])
+
+            # Check if one is significantly different from another
+            if abs(num_a - num_b) > 5 and min(num_a, num_b) > 0:
+                # Potential contradiction - different page limits
+                return Contradiction(
+                    id="",
+                    clause_a=req_a.original_text[:200],
+                    clause_b=req_b.original_text[:200],
+                    clause_a_location=f"Page {req_a.page_number}",
+                    clause_b_location=f"Page {req_b.page_number}",
+                    contradiction_type=ContradictionType.PAGE_LIMIT,
+                    severity="high" if abs(num_a - num_b) > 10 else "medium",
+                    description=f"Conflicting page limits: {num_a} pages vs {num_b} pages",
+                    recommendation="Submit RFI to clarify the correct page limit requirement"
+                )
+
+        return None
+
+    def _check_format_contradiction(
+        self,
+        req_a: ComplianceItem,
+        req_b: ComplianceItem
+    ) -> Optional[Contradiction]:
+        """Check for contradictions between two format-related requirements."""
+        # Check for conflicting font specifications
+        fonts_a = re.findall(r'(times new roman|arial|calibri|courier)', req_a.original_text.lower())
+        fonts_b = re.findall(r'(times new roman|arial|calibri|courier)', req_b.original_text.lower())
+
+        if fonts_a and fonts_b and fonts_a[0] != fonts_b[0]:
+            return Contradiction(
+                id="",
+                clause_a=req_a.original_text[:200],
+                clause_b=req_b.original_text[:200],
+                clause_a_location=f"Page {req_a.page_number}",
+                clause_b_location=f"Page {req_b.page_number}",
+                contradiction_type=ContradictionType.FORMAT,
+                severity="medium",
+                description=f"Conflicting font requirements: {fonts_a[0]} vs {fonts_b[0]}",
+                recommendation="Submit RFI to clarify the required font"
+            )
+
+        # Check for conflicting font sizes
+        sizes_a = re.findall(r'(\d+)\s*(?:pt|point)', req_a.original_text.lower())
+        sizes_b = re.findall(r'(\d+)\s*(?:pt|point)', req_b.original_text.lower())
+
+        if sizes_a and sizes_b and sizes_a[0] != sizes_b[0]:
+            return Contradiction(
+                id="",
+                clause_a=req_a.original_text[:200],
+                clause_b=req_b.original_text[:200],
+                clause_a_location=f"Page {req_a.page_number}",
+                clause_b_location=f"Page {req_b.page_number}",
+                contradiction_type=ContradictionType.FORMAT,
+                severity="low",
+                description=f"Conflicting font sizes: {sizes_a[0]}pt vs {sizes_b[0]}pt",
+                recommendation="Use the more conservative (larger) font size"
+            )
+
+        return None
+
+    async def _detect_semantic_contradictions(
+        self,
+        requirements: List[ComplianceItem]
+    ) -> List[Contradiction]:
+        """Use LLM for NLI-style contradiction detection."""
+        if not self.ai_service or len(requirements) < 2:
+            return []
+
+        # Prepare requirements text for analysis
+        req_texts = [
+            f"[Page {r.page_number}, {r.section_type.value if r.section_type else 'General'}]: {r.original_text[:300]}"
+            for r in requirements[:30]  # Limit for token efficiency
+        ]
+
+        prompt = f"""Analyze these RFP requirements for internal contradictions. Look for:
+
+1. Page limits that conflict with content requirements
+2. Deadlines that conflict with each other
+3. Format requirements that contradict
+4. Scope descriptions that conflict
+5. Technical requirements that are mutually exclusive
+
+Requirements:
+{chr(10).join(req_texts)}
+
+For each contradiction found, provide in JSON format:
+{{
+    "contradictions": [
+        {{
+            "clause_a_idx": <index of first clause>,
+            "clause_b_idx": <index of second clause>,
+            "type": "page_limit" | "format" | "deadline" | "requirement" | "scope",
+            "severity": "high" | "medium" | "low",
+            "description": "Brief description of the conflict",
+            "recommendation": "How to resolve or clarify"
+        }}
+    ]
+}}
+
+Return empty array if no contradictions found. Only flag clear contradictions, not minor inconsistencies."""
+
+        try:
+            messages = [
+                {
+                    "role": "system",
+                    "content": "You are an RFP analyst expert at identifying conflicting requirements. Be precise and only flag actual contradictions."
+                },
+                {"role": "user", "content": prompt}
+            ]
+            
+            chat_messages = [ChatMessage(role=m["role"], content=m["content"]) for m in messages]
+            
+            response = await self.ai_service.chat(
+                messages=chat_messages,
+                feature="contradictions",
+                temperature=0.2
+            )
+
+            content = response.content
+            # Clean up JSON
+            if "```json" in content:
+                content = content.split("```json")[1].split("```")[0].strip()
+            elif "```" in content:
+                content = content.split("```")[1].split("```")[0].strip()
+                
+            result = json.loads(content)
+            contradictions = []
+
+            for c in result.get("contradictions", []):
+                idx_a = c.get("clause_a_idx", 0)
+                idx_b = c.get("clause_b_idx", 1)
+
+                if idx_a < len(requirements) and idx_b < len(requirements):
+                    req_a = requirements[idx_a]
+                    req_b = requirements[idx_b]
+
+                    contradictions.append(Contradiction(
+                        id="",
+                        clause_a=req_a.original_text[:200],
+                        clause_b=req_b.original_text[:200],
+                        clause_a_location=f"Page {req_a.page_number}",
+                        clause_b_location=f"Page {req_b.page_number}",
+                        contradiction_type=ContradictionType(c.get("type", "requirement")),
+                        severity=c.get("severity", "medium"),
+                        description=c.get("description", "Potential conflict detected"),
+                        recommendation=c.get("recommendation", "Review and clarify with contracting officer")
+                    ))
+
+            return contradictions
+
+        except Exception as e:
+            logger.error(f"Semantic contradiction detection failed: {e}")
+            return []
+
+    async def analyze_blind_rfp(
+        self,
+        requirements: List[ComplianceItem],
+        rfp_text: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Spec 4.2: Detect 'Blind/Wired RFP' indicators.
+
+        A Blind RFP is one written with a specific competitor in mind,
+        making a win statistically improbable.
+        """
+        logger.info("Analyzing RFP for blind/wired indicators")
+
+        indicators: List[BlindRFPIndicator] = []
+        blind_score = 0
+
+        # 1. Pattern-based detection
+        for req in requirements:
+            text = req.original_text
+
+            # Check vendor-specific patterns
+            for pattern in self.blind_rfp_patterns["vendor_specific"]:
+                if re.search(pattern, text, re.IGNORECASE):
+                    indicators.append(BlindRFPIndicator(
+                        indicator_type="vendor_specific",
+                        description="Potentially vendor-specific requirement detected",
+                        evidence=text[:200],
+                        confidence=0.7
+                    ))
+                    blind_score += 15
+
+            # Check narrow qualification patterns
+            for pattern in self.blind_rfp_patterns["narrow_qualifications"]:
+                if re.search(pattern, text, re.IGNORECASE):
+                    indicators.append(BlindRFPIndicator(
+                        indicator_type="narrow_qualifications",
+                        description="Unusually narrow qualification requirement",
+                        evidence=text[:200],
+                        confidence=0.6
+                    ))
+                    blind_score += 10
+
+            # Check unrealistic timeline patterns
+            for pattern in self.blind_rfp_patterns["unrealistic_timeline"]:
+                if re.search(pattern, text, re.IGNORECASE):
+                    indicators.append(BlindRFPIndicator(
+                        indicator_type="unrealistic_timeline",
+                        description="Unrealistic timeline suggesting incumbent advantage",
+                        evidence=text[:200],
+                        confidence=0.5
+                    ))
+                    blind_score += 10
+
+        # 2. LLM-based semantic analysis for blind RFP
+        if self.ai_service and rfp_text:
+            llm_analysis = await self._llm_blind_rfp_analysis(rfp_text[:8000])
+            if llm_analysis:
+                blind_score = int(blind_score * 0.4 + llm_analysis.get("blind_probability", 0) * 0.6)
+                for indicator in llm_analysis.get("indicators", []):
+                    indicators.append(BlindRFPIndicator(
+                        indicator_type=indicator.get("type", "other"),
+                        description=indicator.get("description", ""),
+                        evidence=indicator.get("evidence", ""),
+                        confidence=indicator.get("confidence", 0.5)
+                    ))
+
+        # Cap score at 100
+        blind_score = min(blind_score, 100)
+
+        return {
+            "is_potentially_blind": blind_score > 40,
+            "blind_probability": blind_score,
+            "indicators": [
+                {
+                    "type": i.indicator_type,
+                    "description": i.description,
+                    "evidence": i.evidence,
+                    "confidence": i.confidence
+                }
+                for i in indicators
+            ],
+            "recommendation": self._get_blind_rfp_recommendation(blind_score),
+            "analysis_method": "hybrid" if self.ai_service else "rule-based"
+        }
+
+    async def _llm_blind_rfp_analysis(self, rfp_text: str) -> Optional[Dict[str, Any]]:
+        """Use LLM for deeper blind RFP analysis."""
+        if not self.ai_service:
+            return None
+
+        prompt = f"""Analyze this RFP for signs that it may be "wired" or written to favor a specific incumbent or competitor.
+
+Look for:
+1. Unusually specific technical requirements that only one vendor could meet
+2. References to proprietary systems without allowing equivalents
+3. Unrealistic timelines that favor incumbents
+4. Overly narrow qualification requirements
+5. Language suggesting prior relationship expectations
+
+RFP Excerpt:
+{rfp_text[:6000]}
+
+Provide analysis in JSON:
+{{
+    "blind_probability": <0-100>,
+    "indicators": [
+        {{
+            "type": "vendor_specific" | "narrow_qualifications" | "incumbent_advantage" | "proprietary_reference",
+            "description": "what makes this suspicious",
+            "evidence": "specific text or requirement",
+            "confidence": <0-1>
+        }}
+    ],
+    "overall_assessment": "brief summary"
+}}"""
+
+        try:
+            messages = [
+                {"role": "system", "content": "You are an expert at analyzing government RFPs for fairness and competitiveness."},
+                {"role": "user", "content": prompt}
+            ]
+            
+            chat_messages = [ChatMessage(role=m["role"], content=m["content"]) for m in messages]
+            
+            response = await self.ai_service.chat(
+                messages=chat_messages,
+                feature="blind_rfp",
+                temperature=0.3
+            )
+            
+            content = response.content
+            # Clean up JSON
+            if "```json" in content:
+                content = content.split("```json")[1].split("```")[0].strip()
+            elif "```" in content:
+                content = content.split("```")[1].split("```")[0].strip()
+                
+            return json.loads(content)
+        except Exception as e:
+            logger.error(f"LLM blind RFP analysis failed: {e}")
+            return None
+
+    def _get_blind_rfp_recommendation(self, score: int) -> str:
+        """Get recommendation based on blind RFP score."""
+        if score > 70:
+            return "HIGH RISK: This RFP shows strong indicators of being wired. Consider No-Go unless there's a strategic reason to bid. If bidding, submit RFIs to broaden requirements."
+        elif score > 40:
+            return "MODERATE RISK: Some concerning indicators present. Submit RFIs to clarify narrow requirements before committing significant resources."
+        else:
+            return "LOW RISK: No significant blind RFP indicators detected. Proceed with standard bid process."
+
+    async def generate_win_themes(
+        self,
+        requirements: List[ComplianceItem],
+        company_strengths: Optional[List[str]] = None,
+        competitor_weaknesses: Optional[List[str]] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate win themes based on requirements and company positioning.
+        """
+        if not self.ai_service:
+            return []
+
+        # Group requirements by volume
+        by_volume = {}
+        for req in requirements:
+            vol = req.volume_assignment.value
+            if vol not in by_volume:
+                by_volume[vol] = []
+            by_volume[vol].append(req.semantic_summary or req.original_text[:100])
+
+        prompt = f"""Based on these RFP requirements grouped by volume, suggest 4-5 compelling win themes:
+
+Requirements by Volume:
+{json.dumps(by_volume, indent=2)}
+
+Company Strengths:
+{json.dumps(company_strengths or ['Not specified'])}
+
+Competitor Weaknesses (to exploit):
+{json.dumps(competitor_weaknesses or ['Not specified'])}
+
+For each theme, provide:
+1. Theme title (catchy, memorable)
+2. Brief description (2-3 sentences)
+3. Which requirements it directly addresses
+4. Suggested proof points/evidence
+5. Discriminator level (strong/moderate/weak)
+
+Respond in JSON format:
+{{"themes": [
+    {{
+        "title": "...",
+        "description": "...",
+        "addresses": ["req1", "req2"],
+        "proof_points": ["evidence1", "evidence2"],
+        "discriminator_level": "strong|moderate|weak"
+    }}
+]}}"""
+
+        try:
+            messages = [
+                ChatMessage(role="system", content="You are a proposal strategist expert at developing compelling win themes that differentiate from competition."),
+                ChatMessage(role="user", content=prompt)
+            ]
+            
+            response = await self.ai_service.chat(
+                messages=messages,
+                feature="win_themes",
+                temperature=0.5
+            )
+
+            content = response.content
+            # Clean up JSON
+            if "```json" in content:
+                content = content.split("```json")[1].split("```")[0].strip()
+            elif "```" in content:
+                content = content.split("```")[1].split("```")[0].strip()
+                
+            result = json.loads(content)
+            return result.get("themes", [])
+
+        except Exception as e:
+            logger.error(f"Win theme generation failed: {e}")
+            return []
+
+    def calculate_compliance_health(self, requirements: List[ComplianceItem]) -> Dict[str, Any]:
+        """
+        Calculate overall compliance health metrics.
+        """
+        total = len(requirements)
+        if total == 0:
+            return {"health_score": 100, "stats": {}}
+
+        high_risk = sum(1 for r in requirements if r.risk_score >= 0.7)
+        medium_risk = sum(1 for r in requirements if 0.3 <= r.risk_score < 0.7)
+        low_risk = total - high_risk - medium_risk
+
+        # Health score: penalize high-risk items more
+        health_score = 100 - (high_risk * 5 + medium_risk * 2)
+        health_score = max(0, min(100, health_score))
+
+        # Count by type and volume
+        by_type = {}
+        by_volume = {}
+        for r in requirements:
+            t = r.compliance_type.value
+            v = r.volume_assignment.value
+            by_type[t] = by_type.get(t, 0) + 1
+            by_volume[v] = by_volume.get(v, 0) + 1
+
+        return {
+            "health_score": health_score,
+            "total_requirements": total,
+            "high_risk_count": high_risk,
+            "medium_risk_count": medium_risk,
+            "low_risk_count": low_risk,
+            "risk_distribution": {
+                "high": round(high_risk / total * 100, 1) if total else 0,
+                "medium": round(medium_risk / total * 100, 1) if total else 0,
+                "low": round(low_risk / total * 100, 1) if total else 0
+            },
+            "by_compliance_type": by_type,
+            "by_volume": by_volume
+        }

backend/app/assembly/__init__.py

@@ -0,0 +1,2 @@
+# Assembly Engine module
+from .service import AssemblyEngine

backend/app/assembly/service.py

@@ -0,0 +1,939 @@
+"""
+Assembly Engine - Comprehensive Document Generation Module
+
+Implements:
+- 4.1: Automated Excel Matrix Generation with Auto-Grouping, Data Validation, Conditional Formatting
+- 6.1: Advanced Word Automation with Style Management
+- 6.2: Automated PDF Form Filling with Field Mapping and Flattening
+"""
+
+from docxtpl import DocxTemplate
+import openpyxl
+from openpyxl.styles import Font, Alignment, PatternFill, Border, Side, NamedStyle
+from openpyxl.utils import get_column_letter
+from openpyxl.utils.dataframe import dataframe_to_rows
+from openpyxl.worksheet.datavalidation import DataValidation
+from openpyxl.formatting.rule import ColorScaleRule, CellIsRule, FormulaRule
+from openpyxl.chart import PieChart, Reference
+import pandas as pd
+import fitz  # PyMuPDF
+import logging
+from typing import Dict, Any, List, Optional, Tuple
+from pathlib import Path
+from docx import Document
+from docx.shared import Inches, Pt, Cm, RGBColor
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.style import WD_STYLE_TYPE
+from docx.enum.table import WD_TABLE_ALIGNMENT
+import os
+import json
+import re
+from datetime import datetime
+
+from app.core.config import settings
+from app.shredding.service import ComplianceItem, ComplianceType, VolumeAssignment, SectionType
+
+logger = logging.getLogger(__name__)
+
+
+class AssemblyEngine:
+    """
+    Assembly Engine for generating proposal documents.
+    Supports Word, Excel, PDF form filling, and compliance matrix generation.
+
+    Implements industry-standard features:
+    - Auto-grouping by RFP Section
+    - Data Validation (dropdown menus)
+    - Conditional Formatting for risk visualization
+    - Style Management for Word documents
+    - PDF Form Field Mapping and Flattening
+    """
+
+    # Status options for data validation dropdown
+    STATUS_OPTIONS = ["Not Started", "In Progress", "Compliant", "Partial", "Non-Compliant", "Exception", "N/A"]
+
+    # Owner/Assignee options (can be customized per project)
+    DEFAULT_OWNERS = ["Technical Lead", "Subject Matter Expert", "Pricing Analyst", "Past Performance Lead", "Contracts", "Unassigned"]
+
+    # Risk keywords for conditional formatting
+    HIGH_RISK_KEYWORDS = [
+        "unlimited liability", "liquidated damages", "indemnification",
+        "source code escrow", "intellectual property transfer", "termination",
+        "performance bond", "consequential damages", "personal liability"
+    ]
+
+    FORMATTING_KEYWORDS = [
+        "font", "margin", "page limit", "format", "spacing", "header",
+        "footer", "table of contents", "binding", "submission"
+    ]
+
+    def __init__(self):
+        self.template_dir = Path(settings.TEMPLATE_DIR)
+        self.output_dir = Path(settings.OUTPUT_DIR)
+
+        # Ensure directories exist
+        self.template_dir.mkdir(parents=True, exist_ok=True)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Define Excel styles
+        self._setup_excel_styles()
+
+    def _setup_excel_styles(self):
+        """Setup reusable Excel styles."""
+        self.styles = {
+            'header': {
+                'font': Font(bold=True, color="FFFFFF", size=11, name='Calibri'),
+                'fill': PatternFill(start_color="1F4E79", end_color="1F4E79", fill_type="solid"),
+                'alignment': Alignment(horizontal='center', vertical='center', wrap_text=True),
+                'border': Border(
+                    left=Side(style='thin', color='FFFFFF'),
+                    right=Side(style='thin', color='FFFFFF'),
+                    top=Side(style='thin', color='FFFFFF'),
+                    bottom=Side(style='medium', color='1F4E79')
+                )
+            },
+            'section_header': {
+                'font': Font(bold=True, color="1F4E79", size=10, name='Calibri'),
+                'fill': PatternFill(start_color="D6E3F8", end_color="D6E3F8", fill_type="solid"),
+                'alignment': Alignment(horizontal='left', vertical='center'),
+            },
+            'high_risk': {
+                'fill': PatternFill(start_color="FFCDD2", end_color="FFCDD2", fill_type="solid"),
+                'font': Font(color="B71C1C", name='Calibri', size=10)
+            },
+            'medium_risk': {
+                'fill': PatternFill(start_color="FFF9C4", end_color="FFF9C4", fill_type="solid"),
+                'font': Font(color="F57F17", name='Calibri', size=10)
+            },
+            'low_risk': {
+                'fill': PatternFill(start_color="C8E6C9", end_color="C8E6C9", fill_type="solid"),
+                'font': Font(color="1B5E20", name='Calibri', size=10)
+            },
+            'formatting_row': {
+                'fill': PatternFill(start_color="ECEFF1", end_color="ECEFF1", fill_type="solid"),
+                'font': Font(color="607D8B", name='Calibri', size=10, italic=True)
+            }
+        }
+
+    def generate_compliance_matrix_excel(
+        self,
+        requirements: List[ComplianceItem],
+        output_path: str,
+        project_name: str = "RFP Response",
+        owners: Optional[List[str]] = None,
+        include_cross_references: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Spec 4.1: Automated Excel Matrix Generation
+
+        Features:
+        - Auto-Grouping: Organizes requirements by RFP Section using pandas grouping
+        - Data Validation: Dropdown menus for Status and Owner columns
+        - Conditional Formatting:
+            - Red highlighting for high-risk keywords
+            - Gray highlighting for formatting requirements
+            - Color-coded risk scores
+        - Summary Statistics sheet
+        """
+        logger.info(f"Generating compliance matrix with {len(requirements)} requirements")
+
+        if not requirements:
+            return {"status": "error", "message": "No requirements provided"}
+
+        try:
+            wb = openpyxl.Workbook()
+            ws = wb.active
+            ws.title = "Compliance Matrix"
+
+            owners = owners or self.DEFAULT_OWNERS
+
+            # Define headers
+            headers = [
+                "Req ID", "RFP Section", "Section Type", "Requirement Text",
+                "Compliance Type", "Volume", "Risk Score", "Risk Level",
+                "Assigned To", "Status", "Response/Evidence", "Notes"
+            ]
+
+            if include_cross_references:
+                headers.append("Cross References")
+
+            # Apply headers with styling
+            for col, header in enumerate(headers, 1):
+                cell = ws.cell(row=1, column=col, value=header)
+                cell.font = self.styles['header']['font']
+                cell.fill = self.styles['header']['fill']
+                cell.alignment = self.styles['header']['alignment']
+                cell.border = self.styles['header']['border']
+
+            # Freeze header row
+            ws.freeze_panes = 'A2'
+
+            # Group requirements by section using pandas-style grouping
+            grouped_reqs = self._group_requirements_by_section(requirements)
+
+            current_row = 2
+            section_start_rows = {}  # Track section starts for grouping
+
+            for section_name, section_reqs in grouped_reqs.items():
+                section_start_rows[section_name] = current_row
+
+                # Add section header row
+                section_cell = ws.cell(row=current_row, column=1, value=f"Section: {section_name}")
+                section_cell.font = self.styles['section_header']['font']
+                section_cell.fill = self.styles['section_header']['fill']
+                ws.merge_cells(start_row=current_row, start_column=1, end_row=current_row, end_column=len(headers))
+                current_row += 1
+
+                # Add requirements for this section
+                for req_idx, req in enumerate(section_reqs):
+                    row_data = self._format_requirement_row(req, req_idx, section_name, include_cross_references)
+
+                    for col, value in enumerate(row_data, 1):
+                        cell = ws.cell(row=current_row, column=col, value=value)
+                        cell.alignment = Alignment(vertical='top', wrap_text=True)
+
+                        # Apply border
+                        cell.border = Border(
+                            left=Side(style='thin', color='E0E0E0'),
+                            right=Side(style='thin', color='E0E0E0'),
+                            top=Side(style='thin', color='E0E0E0'),
+                            bottom=Side(style='thin', color='E0E0E0')
+                        )
+
+                    # Apply conditional formatting based on content
+                    self._apply_row_formatting(ws, current_row, req, len(headers))
+
+                    current_row += 1
+
+            # Add Data Validation for Status column (column 10)
+            status_validation = DataValidation(
+                type="list",
+                formula1=f'"{",".join(self.STATUS_OPTIONS)}"',
+                allow_blank=True,
+                showDropDown=False
+            )
+            status_validation.error = "Please select from the dropdown list"
+            status_validation.errorTitle = "Invalid Status"
+            ws.add_data_validation(status_validation)
+            status_validation.add(f'J2:J{current_row}')
+
+            # Add Data Validation for Owner column (column 9)
+            owner_validation = DataValidation(
+                type="list",
+                formula1=f'"{",".join(owners)}"',
+                allow_blank=True,
+                showDropDown=False
+            )
+            owner_validation.error = "Please select from the dropdown list"
+            owner_validation.errorTitle = "Invalid Owner"
+            ws.add_data_validation(owner_validation)
+            owner_validation.add(f'I2:I{current_row}')
+
+            # Add Conditional Formatting for Risk Score column (column 7)
+            # Red for >= 70%, Yellow for 30-69%, Green for < 30%
+            red_rule = CellIsRule(
+                operator='greaterThanOrEqual',
+                formula=['0.7'],
+                fill=PatternFill(start_color='FFCDD2', end_color='FFCDD2', fill_type='solid')
+            )
+            yellow_rule = CellIsRule(
+                operator='between',
+                formula=['0.3', '0.69'],
+                fill=PatternFill(start_color='FFF9C4', end_color='FFF9C4', fill_type='solid')
+            )
+            green_rule = CellIsRule(
+                operator='lessThan',
+                formula=['0.3'],
+                fill=PatternFill(start_color='C8E6C9', end_color='C8E6C9', fill_type='solid')
+            )
+
+            ws.conditional_formatting.add(f'G2:G{current_row}', red_rule)
+            ws.conditional_formatting.add(f'G2:G{current_row}', yellow_rule)
+            ws.conditional_formatting.add(f'G2:G{current_row}', green_rule)
+
+            # Set column widths
+            col_widths = {
+                'A': 12,   # Req ID
+                'B': 15,   # RFP Section
+                'C': 12,   # Section Type
+                'D': 60,   # Requirement Text
+                'E': 14,   # Compliance Type
+                'F': 14,   # Volume
+                'G': 12,   # Risk Score
+                'H': 12,   # Risk Level
+                'I': 18,   # Assigned To
+                'J': 14,   # Status
+                'K': 40,   # Response/Evidence
+                'L': 25,   # Notes
+                'M': 20,   # Cross References
+            }
+            for col_letter, width in col_widths.items():
+                if col_letter <= get_column_letter(len(headers)):
+                    ws.column_dimensions[col_letter].width = width
+
+            # Add row height for better readability
+            for row in range(2, current_row):
+                ws.row_dimensions[row].height = 45
+
+            # Add Summary sheet
+            self._add_summary_sheet(wb, requirements, project_name)
+
+            # Add Statistics sheet with charts
+            self._add_statistics_sheet(wb, requirements)
+
+            # Save workbook
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+            wb.save(output_path)
+            logger.info(f"Compliance matrix saved to {output_path}")
+
+            return {
+                "status": "success",
+                "output_path": output_path,
+                "total_requirements": len(requirements),
+                "sections": len(grouped_reqs),
+                "high_risk_count": sum(1 for r in requirements if r.risk_score >= 0.7),
+                "sheets_created": ["Compliance Matrix", "Summary", "Statistics"]
+            }
+
+        except Exception as e:
+            logger.error(f"Compliance matrix generation failed: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def _group_requirements_by_section(self, requirements: List[ComplianceItem]) -> Dict[str, List[ComplianceItem]]:
+        """Group requirements by RFP section using pandas-style grouping."""
+        grouped = {}
+
+        for req in requirements:
+            section = req.section_id or "General"
+            if section not in grouped:
+                grouped[section] = []
+            grouped[section].append(req)
+
+        # Sort sections naturally (Section L, Section M, Section C, then others)
+        section_order = {'L': 0, 'M': 1, 'C': 2}
+        sorted_sections = sorted(
+            grouped.keys(),
+            key=lambda x: (section_order.get(x[0] if x else 'Z', 99), x)
+        )
+
+        return {section: grouped[section] for section in sorted_sections}
+
+    def _format_requirement_row(
+        self,
+        req: ComplianceItem,
+        index: int,
+        section: str,
+        include_cross_refs: bool
+    ) -> List[Any]:
+        """Format a single requirement as a row of data."""
+        risk_level = "High" if req.risk_score >= 0.7 else "Medium" if req.risk_score >= 0.3 else "Low"
+
+        row = [
+            f"REQ-{section[:3].upper()}-{index+1:03d}",  # Req ID
+            section,  # RFP Section
+            req.section_type.value if req.section_type else "General",  # Section Type
+            req.original_text[:1000],  # Requirement Text (truncated)
+            req.compliance_type.value,  # Compliance Type
+            req.volume_assignment.value,  # Volume
+            req.risk_score,  # Risk Score (as decimal for formatting)
+            risk_level,  # Risk Level
+            "Unassigned",  # Assigned To
+            "Not Started",  # Status
+            "",  # Response/Evidence
+            "",  # Notes
+        ]
+
+        if include_cross_refs:
+            cross_refs = ", ".join(req.cross_references) if req.cross_references else ""
+            row.append(cross_refs)
+
+        return row
+
+    def _apply_row_formatting(self, ws, row: int, req: ComplianceItem, num_cols: int):
+        """Apply conditional formatting to a row based on content analysis."""
+        text_lower = req.original_text.lower()
+
+        # Check for high-risk keywords
+        is_high_risk = any(keyword in text_lower for keyword in self.HIGH_RISK_KEYWORDS)
+
+        # Check for formatting requirements
+        is_formatting = any(keyword in text_lower for keyword in self.FORMATTING_KEYWORDS)
+
+        if is_high_risk and req.risk_score >= 0.7:
+            # Apply high-risk styling
+            for col in range(1, num_cols + 1):
+                cell = ws.cell(row=row, column=col)
+                cell.fill = self.styles['high_risk']['fill']
+        elif is_formatting:
+            # Apply gray formatting styling
+            for col in range(1, num_cols + 1):
+                cell = ws.cell(row=row, column=col)
+                cell.fill = self.styles['formatting_row']['fill']
+                cell.font = self.styles['formatting_row']['font']
+
+    def _add_summary_sheet(self, wb, requirements: List[ComplianceItem], project_name: str):
+        """Add a summary sheet with project overview."""
+        summary_ws = wb.create_sheet("Summary")
+
+        # Project header
+        summary_ws['A1'] = "RFP Compliance Matrix Summary"
+        summary_ws['A1'].font = Font(bold=True, size=16, color="1F4E79")
+        summary_ws.merge_cells('A1:D1')
+
+        summary_data = [
+            ["", ""],
+            ["Project Name:", project_name],
+            ["Generated Date:", datetime.now().strftime("%Y-%m-%d %H:%M:%S")],
+            ["Generated By:", "RFP Automation System"],
+            ["", ""],
+            ["REQUIREMENT STATISTICS", ""],
+            ["Total Requirements:", len(requirements)],
+            ["", ""],
+            ["By Compliance Type:", ""],
+            ["  Mandatory:", sum(1 for r in requirements if r.compliance_type == ComplianceType.MANDATORY)],
+            ["  Desirable:", sum(1 for r in requirements if r.compliance_type == ComplianceType.DESIRABLE)],
+            ["  Informational:", sum(1 for r in requirements if r.compliance_type == ComplianceType.INFORMATIONAL)],
+            ["", ""],
+            ["By Risk Level:", ""],
+            ["  High Risk (≥70%):", sum(1 for r in requirements if r.risk_score >= 0.7)],
+            ["  Medium Risk (30-69%):", sum(1 for r in requirements if 0.3 <= r.risk_score < 0.7)],
+            ["  Low Risk (<30%):", sum(1 for r in requirements if r.risk_score < 0.3)],
+            ["", ""],
+            ["By Volume Assignment:", ""],
+            ["  Technical:", sum(1 for r in requirements if r.volume_assignment == VolumeAssignment.TECHNICAL)],
+            ["  Management:", sum(1 for r in requirements if r.volume_assignment == VolumeAssignment.MANAGEMENT)],
+            ["  Cost/Pricing:", sum(1 for r in requirements if r.volume_assignment == VolumeAssignment.COST)],
+            ["  Past Performance:", sum(1 for r in requirements if r.volume_assignment == VolumeAssignment.PAST_PERFORMANCE)],
+        ]
+
+        for row_idx, (label, value) in enumerate(summary_data, 2):
+            cell_a = summary_ws.cell(row=row_idx, column=1, value=label)
+            cell_b = summary_ws.cell(row=row_idx, column=2, value=value)
+
+            if label and not label.startswith(" ") and ":" in label:
+                cell_a.font = Font(bold=True)
+            if label.isupper():
+                cell_a.font = Font(bold=True, size=12, color="1F4E79")
+
+        summary_ws.column_dimensions['A'].width = 30
+        summary_ws.column_dimensions['B'].width = 20
+
+    def _add_statistics_sheet(self, wb, requirements: List[ComplianceItem]):
+        """Add a statistics sheet with visual charts."""
+        stats_ws = wb.create_sheet("Statistics")
+
+        # Risk distribution data
+        stats_ws['A1'] = "Risk Distribution"
+        stats_ws['A1'].font = Font(bold=True, size=14)
+
+        risk_data = [
+            ["Risk Level", "Count"],
+            ["High Risk", sum(1 for r in requirements if r.risk_score >= 0.7)],
+            ["Medium Risk", sum(1 for r in requirements if 0.3 <= r.risk_score < 0.7)],
+            ["Low Risk", sum(1 for r in requirements if r.risk_score < 0.3)],
+        ]
+
+        for row_idx, row_data in enumerate(risk_data, 2):
+            for col_idx, value in enumerate(row_data, 1):
+                stats_ws.cell(row=row_idx, column=col_idx, value=value)
+
+        # Add pie chart for risk distribution
+        try:
+            chart = PieChart()
+            chart.title = "Risk Distribution"
+            labels = Reference(stats_ws, min_col=1, min_row=3, max_row=5)
+            data = Reference(stats_ws, min_col=2, min_row=2, max_row=5)
+            chart.add_data(data, titles_from_data=True)
+            chart.set_categories(labels)
+            chart.width = 12
+            chart.height = 8
+            stats_ws.add_chart(chart, "D2")
+        except Exception as e:
+            logger.warning(f"Could not add chart: {e}")
+
+    def generate_proposal_doc(
+        self,
+        context: Dict[str, Any],
+        template_path: str,
+        output_path: str,
+        formatting_rules: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Spec 6.1: Advanced Word Document Generation using python-docx and docxtpl.
+
+        Features:
+        - Style Management from template
+        - Formatting constraint application (from Section L)
+        - Dynamic content injection (tables, images)
+        - Table of Contents support
+        """
+        logger.info(f"Rendering proposal from template {template_path}")
+
+        try:
+            # Check if template exists
+            if not Path(template_path).exists():
+                # Generate from scratch if no template
+                return self._generate_proposal_from_scratch(context, output_path, formatting_rules)
+
+            # Use DocxTemplate for Jinja2 rendering
+            doc = DocxTemplate(template_path)
+            doc.render(context)
+
+            # Apply formatting rules from Section L if provided
+            if formatting_rules:
+                self._apply_formatting_rules(doc, formatting_rules)
+
+            # Ensure output directory exists
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+            doc.save(output_path)
+
+            logger.info(f"Proposal saved to {output_path}")
+
+            return {
+                "status": "success",
+                "output_path": output_path,
+                "template_used": template_path,
+                "formatting_applied": bool(formatting_rules)
+            }
+
+        except Exception as e:
+            logger.error(f"Document generation failed: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def _generate_proposal_from_scratch(
+        self,
+        context: Dict[str, Any],
+        output_path: str,
+        formatting_rules: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Generate a proposal document from scratch without a template."""
+        doc = Document()
+
+        # Apply formatting rules
+        rules = formatting_rules or {}
+        font_name = rules.get('font_name', 'Times New Roman')
+        font_size = Pt(rules.get('font_size', 12))
+
+        # Set default paragraph style
+        style = doc.styles['Normal']
+        style.font.name = font_name
+        style.font.size = font_size
+
+        # Add title
+        title = doc.add_heading(context.get('title', 'Proposal Response'), level=0)
+        title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+        # Add executive summary if provided
+        if 'executive_summary' in context:
+            doc.add_heading('Executive Summary', level=1)
+            doc.add_paragraph(context['executive_summary'])
+
+        # Add sections
+        for section in context.get('sections', []):
+            doc.add_heading(section.get('title', 'Section'), level=1)
+            doc.add_paragraph(section.get('content', ''))
+
+            # Add tables if present
+            if 'table' in section:
+                self._add_table_to_doc(doc, section['table'])
+
+        # Add compliance matrix if provided
+        if 'compliance_matrix' in context:
+            doc.add_heading('Compliance Matrix', level=1)
+            self._add_compliance_table_to_doc(doc, context['compliance_matrix'])
+
+        doc.save(output_path)
+
+        return {
+            "status": "success",
+            "output_path": output_path,
+            "template_used": None,
+            "generated_from_scratch": True
+        }
+
+    def _apply_formatting_rules(self, doc, rules: Dict[str, Any]):
+        """Apply Section L formatting rules to document."""
+        # This would modify the underlying Document object
+        # For DocxTemplate, we need to access the docx property
+        try:
+            underlying_doc = doc.docx
+
+            # Apply font rules
+            if 'font_name' in rules:
+                for paragraph in underlying_doc.paragraphs:
+                    for run in paragraph.runs:
+                        run.font.name = rules['font_name']
+
+            if 'font_size' in rules:
+                for paragraph in underlying_doc.paragraphs:
+                    for run in paragraph.runs:
+                        run.font.size = Pt(rules['font_size'])
+
+        except Exception as e:
+            logger.warning(f"Could not apply formatting rules: {e}")
+
+    def _add_table_to_doc(self, doc: Document, table_data: Dict[str, Any]):
+        """Add a table to the document."""
+        headers = table_data.get('headers', [])
+        rows = table_data.get('rows', [])
+
+        if not headers and not rows:
+            return
+
+        num_cols = len(headers) if headers else len(rows[0]) if rows else 0
+        num_rows = (1 if headers else 0) + len(rows)
+
+        table = doc.add_table(rows=num_rows, cols=num_cols)
+        table.style = 'Table Grid'
+
+        # Add headers
+        if headers:
+            for i, header in enumerate(headers):
+                cell = table.rows[0].cells[i]
+                cell.text = str(header)
+                cell.paragraphs[0].runs[0].bold = True
+
+        # Add data rows
+        start_row = 1 if headers else 0
+        for row_idx, row_data in enumerate(rows):
+            for col_idx, value in enumerate(row_data):
+                table.rows[start_row + row_idx].cells[col_idx].text = str(value)
+
+    def _add_compliance_table_to_doc(self, doc: Document, requirements: List[Dict[str, Any]]):
+        """Add a compliance matrix table to the document."""
+        headers = ["Req ID", "Requirement", "Status", "Response"]
+
+        table = doc.add_table(rows=1 + len(requirements), cols=len(headers))
+        table.style = 'Table Grid'
+
+        # Header row
+        for i, header in enumerate(headers):
+            cell = table.rows[0].cells[i]
+            cell.text = header
+            cell.paragraphs[0].runs[0].bold = True
+
+        # Data rows
+        for row_idx, req in enumerate(requirements, 1):
+            table.rows[row_idx].cells[0].text = req.get('id', '')
+            table.rows[row_idx].cells[1].text = req.get('text', '')[:200]
+            table.rows[row_idx].cells[2].text = req.get('status', 'Pending')
+            table.rows[row_idx].cells[3].text = req.get('response', '')
+
+    def fill_pdf_form(
+        self,
+        form_path: str,
+        data: Dict[str, Any],
+        output_path: str,
+        flatten: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Spec 6.2: Automated PDF Form Filling with Field Mapping and Flattening.
+
+        Implementation Workflow:
+        1. Field Mapping: Inspect PDF to extract field names
+        2. Data Injection: Map fields to bid/RFP metadata
+        3. Flattening: Make fields uneditable after filling
+        """
+        logger.info(f"Filling PDF form {form_path}")
+
+        try:
+            doc = fitz.open(form_path)
+            fields_filled = 0
+            field_mapping = []
+
+            for page_num, page in enumerate(doc):
+                for widget in page.widgets():
+                    if widget.field_name:
+                        field_info = {
+                            "name": widget.field_name,
+                            "page": page_num + 1,
+                            "type": widget.field_type_string,
+                            "filled": False
+                        }
+
+                        if widget.field_name in data:
+                            fill_value = data[widget.field_name]
+
+                            # Handle different field types
+                            if widget.field_type_string == 'Btn':
+                                # Checkbox or radio button
+                                widget.field_value = bool(fill_value)
+                            elif widget.field_type_string == 'Ch':
+                                # Choice field (dropdown/listbox)
+                                widget.field_value = str(fill_value)
+                            else:
+                                # Text field
+                                widget.field_value = str(fill_value)
+
+                            widget.update()
+                            fields_filled += 1
+                            field_info["filled"] = True
+                            field_info["value"] = str(fill_value)[:50]
+
+                        field_mapping.append(field_info)
+
+            # Save the filled form
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+            if flatten:
+                # Flatten by re-rendering (makes fields non-editable)
+                doc.save(output_path, deflate=True, garbage=4)
+            else:
+                doc.save(output_path)
+
+            doc.close()
+            logger.info(f"Filled PDF saved to {output_path}, {fields_filled} fields updated")
+
+            return {
+                "status": "success",
+                "output_path": output_path,
+                "fields_filled": fields_filled,
+                "total_fields": len(field_mapping),
+                "flattened": flatten,
+                "field_mapping": field_mapping
+            }
+
+        except Exception as e:
+            logger.error(f"PDF form filling failed: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def extract_pdf_form_schema(self, form_path: str) -> Dict[str, Any]:
+        """
+        Extract the schema of form fields from a PDF.
+        Useful for understanding what data needs to be provided.
+        """
+        logger.info(f"Extracting form schema from {form_path}")
+
+        try:
+            doc = fitz.open(form_path)
+            schema = {
+                "total_pages": len(doc),
+                "fields": []
+            }
+
+            for page_num, page in enumerate(doc):
+                for widget in page.widgets():
+                    if widget.field_name:
+                        field = {
+                            "name": widget.field_name,
+                            "page": page_num + 1,
+                            "type": widget.field_type_string,
+                            "rect": list(widget.rect),
+                            "required": False,  # Would need additional logic to detect
+                            "options": []
+                        }
+
+                        # Get options for choice fields
+                        if widget.field_type_string == 'Ch' and widget.choice_values:
+                            field["options"] = list(widget.choice_values)
+
+                        schema["fields"].append(field)
+
+            doc.close()
+
+            return {
+                "status": "success",
+                "schema": schema
+            }
+
+        except Exception as e:
+            logger.error(f"Schema extraction failed: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def generate_excel_pricing(
+        self,
+        pricing_data: Dict[str, Any],
+        template_path: str,
+        output_path: str
+    ) -> Dict[str, Any]:
+        """
+        Automated Excel Spreadsheet Generation using openpyxl.
+        Maps internal cost data to specific cells in the spreadsheet.
+        """
+        logger.info(f"Generating pricing sheet from {template_path}")
+
+        try:
+            # Load the client's provided pricing template
+            wb = openpyxl.load_workbook(template_path)
+
+            # pricing_data contains sheet names and cell mappings
+            for sheet_name, cells in pricing_data.items():
+                if sheet_name in wb.sheetnames:
+                    ws = wb[sheet_name]
+                    for cell_coord, value in cells.items():
+                        ws[cell_coord] = value
+                else:
+                    logger.warning(f"Sheet {sheet_name} not found in template")
+
+            wb.save(output_path)
+            logger.info(f"Pricing sheet saved to {output_path}")
+
+            return {
+                "status": "success",
+                "output_path": output_path,
+                "sheets_modified": list(pricing_data.keys())
+            }
+
+        except Exception as e:
+            logger.error(f"Excel generation failed: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def generate_generic_pricing_sheet(
+        self,
+        data: List[Dict[str, Any]],
+        output_path: str,
+        sheet_name: str = "Pricing"
+    ) -> Dict[str, Any]:
+        """Generates a new Excel sheet from scratch using pandas."""
+        logger.info(f"Generating generic pricing sheet")
+
+        try:
+            df = pd.DataFrame(data)
+
+            with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
+                df.to_excel(writer, sheet_name=sheet_name, index=False)
+
+                workbook = writer.book
+                worksheet = writer.sheets[sheet_name]
+
+                # Format headers
+                for cell in worksheet[1]:
+                    cell.font = Font(bold=True)
+                    cell.fill = PatternFill(start_color="1F4E79", end_color="1F4E79", fill_type="solid")
+                    cell.font = Font(bold=True, color="FFFFFF")
+
+                # Auto-fit columns
+                for column in worksheet.columns:
+                    max_length = 0
+                    column_letter = column[0].column_letter
+                    for cell in column:
+                        try:
+                            if len(str(cell.value)) > max_length:
+                                max_length = len(str(cell.value))
+                        except:
+                            pass
+                    adjusted_width = min(max_length + 2, 50)
+                    worksheet.column_dimensions[column_letter].width = adjusted_width
+
+            return {
+                "status": "success",
+                "output_path": output_path,
+                "rows": len(data)
+            }
+
+        except Exception as e:
+            logger.error(f"Pricing sheet generation failed: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def sanitize_document_metadata(
+        self,
+        file_path: str,
+        output_path: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Remove sensitive metadata from documents before submission."""
+        output_path = output_path or file_path
+        path = Path(file_path)
+
+        try:
+            if path.suffix.lower() == '.pdf':
+                return self._sanitize_pdf(file_path, output_path)
+            elif path.suffix.lower() == '.docx':
+                return self._sanitize_docx(file_path, output_path)
+            else:
+                return {"status": "error", "message": f"Unsupported file type: {path.suffix}"}
+
+        except Exception as e:
+            logger.error(f"Document sanitization failed: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def _sanitize_pdf(self, input_path: str, output_path: str) -> Dict[str, Any]:
+        """Remove metadata from PDF."""
+        doc = fitz.open(input_path)
+        doc.set_metadata({})
+        doc.save(output_path, clean=True, deflate=True)
+        doc.close()
+
+        return {
+            "status": "success",
+            "output_path": output_path,
+            "metadata_cleared": True
+        }
+
+    def _sanitize_docx(self, input_path: str, output_path: str) -> Dict[str, Any]:
+        """Remove metadata from DOCX."""
+        doc = Document(input_path)
+        core_props = doc.core_properties
+        core_props.author = ""
+        core_props.comments = ""
+        core_props.last_modified_by = ""
+        doc.save(output_path)
+
+        return {
+            "status": "success",
+            "output_path": output_path,
+            "metadata_cleared": True
+        }
+
+    def create_submission_package(
+        self,
+        artifacts: List[Dict[str, Any]],
+        output_dir: str,
+        project_name: str
+    ) -> Dict[str, Any]:
+        """Create a submission-ready package with all artifacts."""
+        import zipfile
+
+        try:
+            package_dir = Path(output_dir) / f"{project_name}_submission"
+            package_dir.mkdir(parents=True, exist_ok=True)
+
+            processed_files = []
+            for artifact in artifacts:
+                src_path = artifact.get("path")
+                if src_path and Path(src_path).exists():
+                    filename = Path(src_path).name
+                    dest_path = package_dir / filename
+
+                    if artifact.get("sanitize", True):
+                        self.sanitize_document_metadata(src_path, str(dest_path))
+                    else:
+                        import shutil
+                        shutil.copy(src_path, dest_path)
+
+                    processed_files.append({
+                        "original": src_path,
+                        "packaged": str(dest_path),
+                        "sanitized": artifact.get("sanitize", True)
+                    })
+
+            # Create manifest
+            manifest = {
+                "project_name": project_name,
+                "created_date": datetime.now().isoformat(),
+                "files": processed_files,
+                "total_files": len(processed_files)
+            }
+
+            manifest_path = package_dir / "manifest.json"
+            with open(manifest_path, 'w') as f:
+                json.dump(manifest, f, indent=2)
+
+            # Create ZIP archive
+            zip_path = Path(output_dir) / f"{project_name}_submission.zip"
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for file_path in package_dir.rglob('*'):
+                    if file_path.is_file():
+                        arcname = file_path.relative_to(package_dir)
+                        zipf.write(file_path, arcname)
+
+            return {
+                "status": "success",
+                "package_dir": str(package_dir),
+                "zip_path": str(zip_path),
+                "files_processed": len(processed_files),
+                "manifest": manifest
+            }
+
+        except Exception as e:
+            logger.error(f"Submission package creation failed: {e}")
+            return {"status": "error", "message": str(e)}

backend/app/core/__init__.py

@@ -0,0 +1,2 @@
+# Core configuration module
+from .config import settings

backend/app/core/config.py

@@ -0,0 +1,59 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+import os
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "Next-Gen RFP Automation"
+    API_V1_STR: str = "/api/v1"
+
+    # AI Providers
+    OPENAI_API_KEY: str = ""
+    OPENAI_BASE_URL: str = "https://api.openai.com/v1"
+    REAL_OPENAI_API_KEY: Optional[str] = None
+    OPENROUTER_API_KEY: Optional[str] = None
+
+
+    FIRECRAWL_API_KEY: Optional[str] = None
+    MISTRAL_API_KEY: Optional[str] = None
+    GROQ_API_KEY: Optional[str] = None
+    CEREBRAS_API_KEY: Optional[str] = None  # Free tier for fast inference
+    INNGEST_EVENT_KEY: Optional[str] = None
+    INNGEST_SIGNING_KEY: Optional[str] = None
+
+    # Database Settings
+    DATABASE_URL: Optional[str] = None
+    ASYNC_DATABASE_URL: Optional[str] = None
+
+    # Competitor Database
+    COMPETITOR_DB_PATH: str = "./data/competitors.json"
+
+    # NLI Model Settings
+    USE_TRANSFORMER_NLI: bool = False  # Set to True if transformers installed
+    CROSS_ENCODER_MODEL: str = "balanced"  # "high_accuracy", "balanced", or "fast"
+
+    # ChromaDB settings
+    CHROMA_PERSIST_DIR: str = "./chroma_db"
+
+    # Embedding settings
+    EMBEDDING_MODEL: str = "text-embedding-3-small"
+    EMBEDDING_DIMENSIONS: int = 1536
+
+    # Chunking settings
+    CHUNK_SIZE: int = 512
+    CHUNK_OVERLAP: int = 50
+
+    # Storage paths
+    UPLOAD_DIR: str = "./uploads"
+    OUTPUT_DIR: str = "./outputs"
+    TEMPLATE_DIR: str = "./templates"
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+        extra = "ignore"  # Ignore extra env vars not defined in the model
+
+settings = Settings()
+
+# Ensure directories exist
+for dir_path in [settings.UPLOAD_DIR, settings.OUTPUT_DIR, settings.TEMPLATE_DIR, settings.CHROMA_PERSIST_DIR, "./data"]:
+    os.makedirs(dir_path, exist_ok=True)

backend/app/database.py

@@ -0,0 +1,32 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.ext.declarative import declarative_base
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+DATABASE_URL = os.getenv("DATABASE_URL")
+ASYNC_DATABASE_URL = os.getenv("ASYNC_DATABASE_URL")
+
+# Synchronous Engine
+engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Asynchronous Engine (for FastAPI async ops)
+async_engine = create_async_engine(ASYNC_DATABASE_URL, echo=False)
+AsyncSessionLocal = sessionmaker(
+    async_engine, class_=AsyncSession, expire_on_commit=False
+)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+async def get_async_db():
+    async with AsyncSessionLocal() as session:
+        yield session

backend/app/ingestion/__init__.py

@@ -0,0 +1,2 @@
+# Ingestion Engine module
+from .service import IngestionService, IngestedPage, DocumentStructure