deploy: v24 final avatar, localization and HF config hotfix

Dockerfile

@@ -0,0 +1,52 @@
+# Build Frontend
+FROM node:20-slim AS frontend-builder
+WORKDIR /app/frontend
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm install
+COPY frontend/ .
+# Set API base to empty so it uses relative paths (handled by Nginx)
+ENV NEXT_PUBLIC_API_BASE=""
+ENV DATABASE_URL="sqlite:///./andesops.db"
+RUN npm run build
+
+# Final Image
+FROM python:3.12-slim
+WORKDIR /app
+ENV DATABASE_URL="sqlite:////tmp/andesops.db"
+ENV PYTHONUNBUFFERED=1
+
+# Install Node.js (for running frontend in dev/ssr mode) and Nginx
+RUN apt-get update && apt-get install -y \
+    curl \
+    nginx \
+    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy Backend
+COPY backend/requirements.txt ./backend/
+RUN pip install --no-cache-dir -r backend/requirements.txt
+# Install missing deps found earlier
+# Install missing deps found earlier
+RUN pip install --no-cache-dir sqlalchemy==2.0.49 pymysql cryptography pydantic-settings slowapi pypdf python-multipart
+
+COPY backend/ ./backend/
+
+# Copy Frontend Build
+COPY --from=frontend-builder /app/frontend/.next ./frontend/.next
+COPY --from=frontend-builder /app/frontend/public ./frontend/public
+COPY --from=frontend-builder /app/frontend/package.json ./frontend/package.json
+COPY --from=frontend-builder /app/frontend/node_modules ./frontend/node_modules
+
+# Nginx Config
+COPY nginx.conf /etc/nginx/sites-available/default
+RUN ln -sf /etc/nginx/sites-available/default /etc/nginx/sites-enabled/default
+
+# Start Script
+COPY start.sh .
+RUN chmod +x start.sh
+
+# Expose HF Port
+EXPOSE 7860
+
+CMD ["./start.sh"]

README.md

@@ -0,0 +1,128 @@
+---
+title: AndesOps AI
+emoji: 🧠
+colorFrom: red
+colorTo: gray
+sdk: docker
+pinned: false
+app_port: 7860
+---
+
+# AndesOps AI: Agentic Tender Intelligence
+
+
+[![AMD Powered](https://img.shields.io/badge/AMD-Powered-ED1C24?style=for-the-badge&logo=amd&logoColor=white)](https://www.amd.com/en/developer/resources/ai-developer.html)
+[![ROCm](https://img.shields.io/badge/ROCm-Optimized-blue?style=for-the-badge)](https://rocm.docs.amd.com/)
+[![Next.js](https://img.shields.io/badge/Next.js-14-black?style=for-the-badge&logo=next.js)](https://nextjs.org/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-Framework-009688?style=for-the-badge&logo=fastapi)](https://fastapi.tiangolo.com/)
+
+**AndesOps AI** is a state-of-the-art business intelligence platform designed to transform the complex landscape of public procurement in Chile (Mercado Público) into actionable strategic advantages. Built for the **AMD Developer Hackathon**, it leverages a sophisticated **Agentic Multi-Agent System** to analyze technical and administrative bases with unprecedented speed and precision.
+
+---
+
+## 🚀 The Challenge
+Public bidding processes are notoriously document-heavy, requiring legal, technical, and strategic expertise to evaluate a single opportunity. Companies often miss deadlines or overlook critical risks buried in 100+ page PDFs.
+
+## 🧠 The Agentic Solution: "The Virtual Board of Experts"
+AndesOps AI moves beyond simple chatbots. It deploys a **coordinated panel of AI agents** that work in parallel to evaluate every tender:
+
+- ⚖️ **Legal & Compliance Agent**: Scans for administrative hurdles, critical deadlines, and compliance gaps.
+- 🏗️ **Technical Architect Agent**: Maps tender requirements to the company’s specific tech stack and experience.
+- 📊 **Strategy & ROI Agent**: Analyzes competition, calculates potential ROI, and defines a "Winning Strategy".
+- 🧠 **The Orchestrator**: Consolidates agent reports into a final **Strategic Fit Score** and an executive summary.
+
+---
+
+## 🛠️ Architecture & AMD Integration
+AndesOps AI is engineered to scale using high-performance compute:
+
+- **Hardware Acceleration**: Optimized to run on **AMD Instinct™ MI300X GPUs** via the **AMD Developer Cloud**.
+- **Software Stack**: Built on **ROCm™** for high-throughput inference, allowing simultaneous processing of multiple massive tender documents without bottlenecks.
+- **Backend**: **FastAPI** with asynchronous task execution for parallel agent processing.
+- **Frontend**: **Next.js 14** with a premium, enterprise-ready UI/UX.
+
+### **Modern High-Performance Architecture**
+AndesOps AI is built for massive document analysis using a tiered approach that prioritizes hardware-accelerated inference.
+
+```mermaid
+graph TD
+    %% Node Styles
+    classDef client fill:#0ea5e9,stroke:#fff,stroke-width:1px,color:#fff;
+    classDef logic fill:#8b5cf6,stroke:#fff,stroke-width:1px,color:#fff;
+    classDef hardware fill:#ec4899,stroke:#fff,stroke-width:2px,color:#fff;
+    classDef data fill:#64748b,stroke:#fff,stroke-width:1px,color:#fff;
+
+    %% Client Tier
+    subgraph Client_Tier [Enterprise UI Layer]
+        UI["<b>AndesOps AI Dashboard</b><br/>Next.js 14 + Tailwind CSS"]
+        UI --- |Real-time Stream| WS[WebSocket / API]
+    end
+
+    %% Orchestration Tier
+    subgraph Orchestration_Tier [Multi-Agent Consensus War Room]
+        WS --> AgentManager[<b>Consensus Orchestrator</b>]
+        AgentManager --> Agent1[⚖️ Dra. Legal]
+        AgentManager --> Agent2[🛠️ Ing. Técnico]
+        AgentManager --> Agent3[📈 Sra. Estrategia]
+    end
+
+    %% Compute Tier
+    subgraph Compute_Tier [<b>AMD HIGH-PERFORMANCE COMPUTE</b>]
+        Agent1 & Agent2 & Agent3 --> |Direct ROCm Link| ROCm[<b>ROCm™ 6.1 Stack</b>]
+        ROCm --> vLLM[vLLM Inference Server]
+        vLLM --> MI300X["<b>AMD Instinct™ MI300X</b><br/>(Private Compute Node)"]
+    end
+
+    %% Data Tier
+    subgraph Data_Tier [Intelligence & Data]
+        AgentManager -.-> MP[Mercado Público API]
+        AgentManager -.-> Scraper[Intelligent Scraper]
+        MP & Scraper --> DB[(SQL Persistence)]
+    end
+
+    %% Apply Styles
+    class UI,WS client;
+    class AgentManager,Agent1,Agent2,Agent3 logic;
+    class ROCm,vLLM,MI300X hardware;
+    class MP,Scraper,DB data;
+```
+
+---
+
+## 💻 Setup & Installation
+
+### **Prerequisites**
+- Python 3.10+
+- Node.js 18+
+- AMD ROCm (Optional for local acceleration)
+
+### **Backend Setup**
+```powershell
+cd backend
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+uvicorn app.main:app --reload --port 8000
+```
+
+### **Frontend Setup**
+```powershell
+cd frontend
+npm install
+npm run dev
+```
+
+### **Environment Variables**
+Copy `.env.example` to `.env` and configure:
+- `GEMINI_API_KEY`: For LLM orchestration (or your AMD local endpoint).
+- `MERCADO_PUBLICO_TICKET`: For real-time tender syncing.
+
+---
+
+## 📈 Business Value
+- **Efficiency**: Reduce manual analysis time by over 90%.
+- **Risk Mitigation**: Early detection of legal traps and technical gaps.
+- **Competitiveness**: Generate high-quality proposal drafts aligned with specific tender scoring criteria.
+
+## 📄 License
+MIT License - Developed for the **AMD Developer Hackathon 2026** with ❤️ by the AndesOps Team, powered by [REW](https://www.rew.cl).

backend/.dockerignore

@@ -0,0 +1,26 @@
+.git
+.gitignore
+.env
+.env.local
+.venv
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.pytest_cache
+.coverage
+htmlcov
+dist
+build
+*.egg-info
+.DS_Store
+.vscode
+.idea
+*.log
+*.db
+*.sqlite
+node_modules
+.next

backend/Dockerfile

@@ -0,0 +1,41 @@
+# Multi-stage build for efficiency
+FROM python:3.11-slim as builder
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /tmp
+COPY requirements.txt .
+RUN pip install --user --no-cache-dir -r requirements.txt
+
+# Final stage
+FROM python:3.11-slim
+
+# Create app user (required for HF Spaces security)
+RUN useradd -m -u 1000 user
+
+WORKDIR /app
+
+# Copy Python packages from builder
+COPY --from=builder /root/.local /home/user/.local
+
+# Copy application code
+COPY --chown=user:user . /app/
+
+# Set environment
+ENV PATH=/home/user/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+# Switch to non-root user
+USER user
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:7860/').read()" || exit 1
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

backend/README.md

@@ -0,0 +1,70 @@
+---
+title: AndesOps AI Backend
+emoji: 🤖
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 7860
+startup_duration_timeout: 30m
+python_version: 3.11
+---
+
+# AndesOps AI - Backend API
+
+Real-time Chilean public procurement market intelligence with AI-powered analysis.
+
+## 🚀 Features
+
+- **Real-time Market Data**: Access Mercado Público (Chile's public procurement) API
+- **Purchase Orders (OC)**: Monitor purchase orders across Chilean government agencies
+- **Tender Analysis**: AI-powered tender matching and recommendation
+- **LLM Integration**: Powered by Google Gemini, Groq, and Featherless AI
+- **REST API**: Full-featured FastAPI backend
+
+## 📋 Environment Variables Required
+
+Add these in **Settings → Secrets** on Hugging Face:
+
+```
+MERCADO_PUBLICO_TICKET=99B4CA8C-C1DF-4E3F-B5CF-C1672D432A91
+GEMINI_API_KEY=your_gemini_api_key
+GROQ_API_KEY=your_groq_api_key
+FEATHERLESS_API_KEY=your_featherless_key
+DATABASE_URL=sqlite:///./andesops.db
+GEMINI_MODEL=gemini-2.5-flash
+```
+
+## 🔗 API Endpoints
+
+- `GET /api/health` - Health check
+- `GET /api/tenders?keyword=...` - Search tenders
+- `GET /api/tenders/scrape?keyword=...` - Scrape Compra Ágil
+- `GET /api/purchase-orders?date=ddmmaaaa` - Get purchase orders
+- `POST /api/analyze` - Analyze tender with AI
+- `POST /api/company-profile` - Save company profile
+
+## 🔌 CORS Configuration
+
+Automatically enabled for frontend at: `https://{user}-andesai-frontend.hf.space`
+
+## 📦 Backend Stack
+
+- **Framework**: FastAPI 0.109.0
+- **Database**: SQLite (local) / MySQL (production)
+- **AI Models**: Google Gemini, Groq, Featherless
+- **Web Scraping**: httpx, BeautifulSoup4
+- **Validation**: Pydantic v2
+
+## 🚦 Status
+
+- ✅ Mercado Público API integration
+- ✅ Real-time purchase order monitoring  
+- ✅ Tender scraping (Compra Ágil)
+- ✅ AI-powered analysis
+- ✅ CORS configured for frontend integration
+
+## 📞 Support
+
+Part of **AndesOps AI** - a complete platform for Chilean public procurement intelligence.
+
+Connect with the frontend space for the full application experience.

backend/api_sample_detail.json

@@ -0,0 +1,4 @@
+{
+  "Codigo": 10500,
+  "Mensaje": "Lo sentimos. Hemos detectado que existen peticiones simult\u00e1neas."
+}

backend/app/config.py

@@ -0,0 +1,28 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    mercado_publico_ticket: str | None = "99B4CA8C-C1DF-4E3F-B5CF-C1672D432A91"
+    gemini_api_key: str | None = None
+    gemini_model: str = "gemini-2.5-flash"
+    featherless_api_key: str | None = None
+    groq_api_key: str | None = None
+    next_public_api_base: str | None = None
+    database_url: str | None = None
+    amd_inference_url: str | None = None
+    amd_api_key: str | None = None
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+
+settings = Settings()
+
+# Debug: Verify keys are loaded (Masked)
+print("--- ENVIRONMENT CONFIG CHECK ---")
+print(f"GEMINI_API_KEY: {'LOADED' if settings.gemini_api_key else 'MISSING'}")
+print(f"GROQ_API_KEY: {'LOADED' if settings.groq_api_key else 'MISSING'}")
+print(f"FEATHERLESS_API_KEY: {'LOADED' if settings.featherless_api_key else 'MISSING'}")
+print("--------------------------------")

backend/app/database.py

@@ -0,0 +1,35 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from app.config import settings
+
+import os
+import platform
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# Use /tmp on Linux (HF Spaces) to ensure write permissions
+if platform.system() == "Linux":
+    db_path = "/tmp/andesops.db"
+else:
+    db_path = os.path.join(BASE_DIR, "andesops.db")
+
+default_db_path = f"sqlite:///{db_path}"
+SQLALCHEMY_DATABASE_URL = settings.database_url or default_db_path
+
+# SQLite specific config for FastAPI multi-threading
+connect_args = {"check_same_thread": False} if SQLALCHEMY_DATABASE_URL.startswith("sqlite") else {}
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args=connect_args
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

backend/app/main.py

@@ -0,0 +1,83 @@
+import sys
+import os
+import json
+import shutil
+from datetime import datetime, timedelta
+
+# Ensure parent directory is in path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.routers import analysis, company, health, tenders, documents, oc, tender_details, admin
+from app.database import engine, Base, SessionLocal, SQLALCHEMY_DATABASE_URL
+from app.models.tender import TenderModel
+from app.models.analysis import AnalysisHistoryModel
+from app.models.company import CompanyProfileModel
+from app.models.oc import OCModel
+from app.config import settings
+
+# Copy database to /tmp if needed (Linux/HF Spaces)
+if SQLALCHEMY_DATABASE_URL.startswith("sqlite:////tmp/"):
+    src_db = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "andesops.db")
+    dest_db = "/tmp/andesops.db"
+    if os.path.exists(src_db) and not os.path.exists(dest_db):
+        print(f"!!! HF DETECTED: Copying initial database from {src_db} to {dest_db} !!!")
+        shutil.copy2(src_db, dest_db)
+
+# Create tables
+try:
+    Base.metadata.create_all(bind=engine)
+except Exception as e:
+    print(f"!!! Database creation error: {e} !!!")
+
+app = FastAPI(title="AndesOps AI")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Routes
+app.include_router(health.router, prefix="/api", tags=["Health"])
+app.include_router(tenders.router, prefix="/api", tags=["Tenders"])
+app.include_router(analysis.router, prefix="/api", tags=["Analysis"])
+app.include_router(company.router, prefix="/api", tags=["Company"])
+app.include_router(documents.router, prefix="/api", tags=["Documents"])
+app.include_router(oc.router, prefix="/api", tags=["Purchase Orders"])
+app.include_router(tender_details.router, prefix="/api", tags=["Tender Details"])
+app.include_router(admin.router, prefix="/api", tags=["Admin"])
+
+@app.on_event("startup")
+async def startup_event():
+    print("!!! BACKEND STARTING UP !!!")
+    db = SessionLocal()
+    try:
+        print(f"Checking database at: {settings.database_url}")
+        count = db.query(TenderModel).count()
+        print(f"Current tender count: {count}")
+        if count == 0:
+            print("Auto-seeding database...")
+            # Basic Company Profile - Independent check
+            if not db.query(CompanyProfileModel).first():
+                print("Seeding Generic Company Profile...")
+                db.add(CompanyProfileModel(
+                    name="My Company",
+                    industry="Consulting",
+                    services="General Services",
+                    experience="1 year",
+                    regions="Nacional",
+                    documents_available="None"
+                ))
+                db.commit()
+    except Exception as e:
+        print(f"Seed error: {e}")
+    finally:
+        db.close()
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to AndesOps AI API"}

backend/app/models/analysis.py

@@ -0,0 +1,20 @@
+from sqlalchemy import Column, Integer, String, Float, DateTime, Text
+from app.database import Base
+from datetime import datetime
+
+class AnalysisHistoryModel(Base):
+    __tablename__ = "analysis_history"
+
+    id = Column(Integer, primary_key=True, index=True)
+    tender_code = Column(String(50), index=True)
+    tender_name = Column(String(255))
+    decision = Column(String(50))
+    score = Column(Integer)
+    summary = Column(Text)
+    risks = Column(Text)  # JSON string
+    technical_analysis = Column(Text)
+    legal_analysis = Column(Text)
+    commercial_analysis = Column(Text)
+    proposal_draft = Column(Text)
+    report_markdown = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)

backend/app/models/company.py

@@ -0,0 +1,15 @@
+from sqlalchemy import Column, Integer, String, Text
+from app.database import Base
+
+class CompanyProfileModel(Base):
+    __tablename__ = "company_profile"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255))
+    industry = Column(String(255))
+    services = Column(Text)
+    experience = Column(Text)
+    certifications = Column(Text)
+    regions = Column(Text)
+    documents_available = Column(Text)
+    keywords = Column(Text)  # Comma separated keywords for recommendations

backend/app/models/oc.py

@@ -0,0 +1,24 @@
+from sqlalchemy import Column, String, Float, DateTime, Text, JSON
+from app.database import Base
+from datetime import datetime
+
+class OCModel(Base):
+    __tablename__ = "purchase_orders"
+
+    code = Column(String(50), primary_key=True, index=True)
+    name = Column(String(255), index=True)
+    status = Column(String(100))
+    status_code = Column(String(10), nullable=True)
+    buyer = Column(String(255), index=True)
+    buyer_rut = Column(String(20), nullable=True)
+    provider = Column(String(255), index=True)
+    provider_rut = Column(String(20), nullable=True)
+    date_creation = Column(DateTime, nullable=True)
+    total_amount = Column(Float, nullable=True)
+    currency = Column(String(10), nullable=True)
+    type = Column(String(50), nullable=True)
+    
+    items = Column(JSON, nullable=True)
+    raw_data = Column(JSON, nullable=True)
+    
+    last_updated = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

backend/app/models/tender.py

@@ -0,0 +1,34 @@
+from sqlalchemy import Column, String, Float, DateTime, Text, JSON
+from app.database import Base
+from datetime import datetime
+
+class TenderModel(Base):
+    __tablename__ = "tenders"
+
+    code = Column(String(50), primary_key=True, index=True)
+    name = Column(String(255), index=True)
+    buyer = Column(String(255), index=True)
+    status = Column(String(100))
+    status_code = Column(String(10), nullable=True)
+    type = Column(String(20), nullable=True)
+    currency = Column(String(10), nullable=True)
+    closing_date = Column(DateTime, nullable=True)
+    publication_date = Column(DateTime, nullable=True)
+    description = Column(Text)
+    estimated_amount = Column(Float, nullable=True)
+    source = Column(String(50), default="Mercado Publico")
+    region = Column(String(100), nullable=True)
+    buyer_region = Column(String(100), nullable=True)
+    sector = Column(String(100), nullable=True)
+    
+    # Storage for nested structures as JSON for simplicity in this hackathon
+    items = Column(JSON, nullable=True)
+    attachments = Column(JSON, nullable=True)
+    evaluation_criteria = Column(JSON, nullable=True)
+    contract_duration = Column(String(255), nullable=True)
+    detail_tabs = Column(JSON, nullable=True)  # NEW: Extracted detail tabs
+    detail_metadata = Column(JSON, nullable=True)  # NEW: Aggregated metadata
+    
+    # Metadata for the app logic
+    last_updated = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    is_followed = Column(DateTime, nullable=True) # Date when it was followed, null if not

backend/app/models/tender_detail.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, String, DateTime, JSON, Text, ForeignKey
+from app.database import Base
+from datetime import datetime
+
+class TenderDetailTabModel(Base):
+    """Store extracted detail tabs from tender pages"""
+    __tablename__ = "tender_detail_tabs"
+    
+    id = Column(String(100), primary_key=True)  # "{tender_code}_{tab_name}"
+    tender_code = Column(String(50), ForeignKey('tenders.code'), index=True)
+    tab_name = Column(String(100))  # Preguntas, Historial, Apertura, Adjudicación, Antecedentes, etc.
+    tab_type = Column(String(50))  # questions, history, opening, adjudication, attachments, criteria
+    content_summary = Column(Text)  # Summary of tab content
+    tab_metadata = Column(JSON, nullable=True)  # Tab-specific data (counts, dates, etc.)
+    attachment_urls = Column(JSON, nullable=True)  # List of attachment URLs for this tab
+    last_fetched = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    html_content = Column(Text, nullable=True)  # Optional: store raw HTML for later parsing
+
+class TenderAttachmentDetailModel(Base):
+    """Detailed information about tender attachments"""
+    __tablename__ = "tender_attachment_details"
+    
+    id = Column(String(100), primary_key=True)  # Unique hash of URL
+    tender_code = Column(String(50), ForeignKey('tenders.code'), index=True)
+    attachment_name = Column(String(255), index=True)
+    attachment_url = Column(Text)
+    tab_category = Column(String(100))  # Administrativo, Técnico, Económico, etc.
+    file_type = Column(String(50))  # PDF, DOC, XLS, etc.
+    estimated_size = Column(String(50), nullable=True)  # For reference
+    last_updated = Column(DateTime, default=datetime.utcnow)
+    is_accessible = Column(JSON, nullable=True)  # Track if URL is still valid

backend/app/routers/admin.py

@@ -0,0 +1,70 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from app.database import get_db
+from app.models.tender import TenderModel
+from app.models.oc import OCModel
+from app.models.analysis import AnalysisHistoryModel
+from app.services.sync import sync_tenders_to_db, sync_purchase_orders_to_db
+from datetime import datetime
+
+router = APIRouter()
+
+@router.get("/admin/db-stats")
+def get_detailed_stats(db: Session = Depends(get_db)):
+    try:
+        tenders_count = db.query(TenderModel).count()
+        ocs_count = db.query(OCModel).count()
+        analysis_count = db.query(AnalysisHistoryModel).count()
+        
+        # Get top 5 buyers by tender count
+        top_buyers = db.query(
+            TenderModel.buyer, 
+            func.count(TenderModel.code).label("count")
+        ).group_by(TenderModel.buyer).order_by(func.count(TenderModel.code).desc()).limit(5).all()
+        
+        top_buyers_list = [{"name": b[0], "count": b[1]} for b in top_buyers]
+        
+        # Get last sync date (max of last_updated)
+        last_tender = db.query(func.max(TenderModel.last_updated)).scalar()
+        
+        return {
+            "total_records": tenders_count,
+            "total_ocs": ocs_count,
+            "total_analysis": analysis_count,
+            "top_buyers": top_buyers_list,
+            "last_sync": last_tender.isoformat() if last_tender else None,
+            "status": "Healthy"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/admin/db-clear")
+def clear_database(db: Session = Depends(get_db)):
+    try:
+        num_tenders = db.query(TenderModel).delete()
+        num_ocs = db.query(OCModel).delete()
+        db.commit()
+        return {
+            "message": "Database cleared successfully",
+            "deleted": {
+                "tenders": num_tenders,
+                "purchase_orders": num_ocs
+            }
+        }
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/admin/sync-all")
+async def sync_all_data(db: Session = Depends(get_db)):
+    try:
+        tender_results = await sync_tenders_to_db(db)
+        oc_results = await sync_purchase_orders_to_db(db)
+        return {
+            "tenders": tender_results,
+            "purchase_orders": oc_results,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/app/routers/analysis.py

@@ -0,0 +1,83 @@
+from datetime import datetime
+from typing import List
+
+from fastapi import APIRouter
+
+from app.schemas.analysis import AnalysisRecord, AnalysisRequest, AnalysisResult, ChatRequest, SearchRecord
+from app.services.agents import run_full_analysis
+from app.services.llm import call_gemini_with_model
+from app.services.persistence import save_to_json, load_from_json
+
+router = APIRouter()
+
+# Load initial history from disk
+analysis_history: List[AnalysisRecord] = load_from_json(AnalysisRecord, "analysis_history.json")
+search_history: List[SearchRecord] = load_from_json(SearchRecord, "search_history.json")
+
+
+@router.post("/analyze", response_model=AnalysisResult)
+async def analyze_opportunity(request: AnalysisRequest):
+    result = await run_full_analysis(request.tender, request.company_profile, request.document_text, request.models, request.tender_details, request.amd_settings)
+    record = AnalysisRecord(
+        tender_code=request.tender.code,
+        tender_name=request.tender.name,
+        analyzed_at=datetime.utcnow(),
+        analysis=result,
+    )
+    analysis_history.insert(0, record)
+    if len(analysis_history) > 20:
+        analysis_history.pop()
+    
+    # Persist to disk
+    save_to_json(analysis_history, "analysis_history.json")
+    
+    return result
+
+
+@router.get("/analysis-history", response_model=List[AnalysisRecord])
+def get_analysis_history():
+    return analysis_history
+
+
+@router.post("/chat")
+async def agent_chat(request: ChatRequest):
+    # Construct context
+    history_str = "\n".join([f"{m.role.upper()}{f' ({m.agent_name})' if m.agent_name else ''}: {m.content}" for m in request.history])
+    
+    prompt = (
+        f"Eres {request.agent} en AndesOps AI, un consultor experto de élite. "
+        f"Actualmente estás operando bajo el motor de IA: {request.model}.\n\n"
+        f"CONTEXTO DE LA LICITACIÓN:\n{request.tender.model_dump_json()}\n\n"
+        f"DATOS DE MI EMPRESA:\n{request.company_profile.model_dump_json()}\n\n"
+        f"HISTORIAL DE CHAT:\n{history_str}\n\n"
+        f"PREGUNTA DEL USUARIO: {request.message}\n\n"
+        f"INSTRUCCIONES CRÍTICAS:\n"
+        f"1. Responde con la personalidad de {request.agent}. Sé agudo, profesional y estratégico.\n"
+        f"2. IDENTIDAD: Si el usuario pregunta qué modelo eres o quién te potencia, menciona que eres {request.agent} de AndesOps, funcionando sobre {request.model}.\n"
+        f"3. ANALIZA LAS BASES: Revisa el campo 'description' para responder.\n"
+        f"4. CITA EL DOCUMENTO: Menciona montos, multas o plazos explícitos si están disponibles.\n"
+        f"5. CONSEJO ESTRATÉGICO: Sugiere mejoras basadas en la experiencia de la empresa ({request.company_profile.experience}).\n"
+        f"RESPONDE EN ESPAÑOL."
+    )
+    
+    if request.amd_settings:
+        settings.amd_inference_url = request.amd_settings.get("url")
+        settings.amd_api_key = request.amd_settings.get("key")
+        print(f"!!! AMD NODE ACTIVATED FOR CHAT: {settings.amd_inference_url} !!!")
+
+    response = await call_gemini_with_model(prompt, request.model)
+    if not response:
+        response = "Lo siento, tuve un problema procesando tu solicitud. ¿Podrías intentar de nuevo?"
+    return {"response": response}
+
+@router.post("/search-history")
+def save_search_history(record: SearchRecord):
+    search_history.insert(0, record)
+    if len(search_history) > 50:
+        search_history.pop()
+    save_to_json(search_history, "search_history.json")
+    return {"status": "ok"}
+
+@router.get("/search-history", response_model=List[SearchRecord])
+def get_search_history():
+    return search_history

backend/app/routers/company.py

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, HTTPException, Depends
+from sqlalchemy.orm import Session
+from app.schemas.company import CompanyProfile
+from app.database import get_db
+from app.models.company import CompanyProfileModel
+import json
+
+router = APIRouter()
+
+@router.post("/company-profile", response_model=CompanyProfile)
+def save_company_profile(profile: CompanyProfile, db: Session = Depends(get_db)):
+    print(f"!!! SAVING PROFILE: {profile.name} !!!")
+    # Try to find existing profile (assume only one for now)
+    db_profile = db.query(CompanyProfileModel).first()
+    
+    if not db_profile:
+        print("Creating NEW profile in DB")
+        db_profile = CompanyProfileModel()
+        db.add(db_profile)
+    
+    db_profile.name = profile.name
+    db_profile.industry = profile.industry
+    db_profile.services = json.dumps(profile.services)
+    db_profile.experience = profile.experience
+    db_profile.certifications = json.dumps(profile.certifications)
+    db_profile.regions = json.dumps(profile.regions)
+    db_profile.documents_available = json.dumps(profile.documents_available)
+    db_profile.keywords = json.dumps(profile.keywords)
+    
+    db.commit()
+    print("!!! PROFILE SAVED SUCCESSFULLY !!!")
+    return profile
+
+@router.get("/company-profile", response_model=CompanyProfile)
+def get_company_profile(db: Session = Depends(get_db)):
+    db_profile = db.query(CompanyProfileModel).first()
+    if not db_profile:
+        print("No profile found, returning default")
+        return CompanyProfile(
+            name="Andes Digital",
+            industry="Tecnología",
+            services=["Automatización AI", "Desarrollo Software"],
+            experience="5 años en el sector",
+            certifications=[],
+            regions=["Metropolitana"],
+            documents_available=["RUT"],
+            keywords=["software", "IA", "automatización"]
+        )
+    
+    # Handle list fields that are stored as JSON strings
+    def safe_json_load(field, default=[]):
+        try:
+            return json.loads(field) if field else default
+        except:
+            return [field] if field else default
+
+    return CompanyProfile(
+        name=db_profile.name,
+        industry=db_profile.industry,
+        services=safe_json_load(db_profile.services, ["General"]),
+        experience=db_profile.experience,
+        certifications=safe_json_load(db_profile.certifications),
+        regions=safe_json_load(db_profile.regions, ["Nacional"]),
+        documents_available=safe_json_load(db_profile.documents_available),
+        keywords=safe_json_load(db_profile.keywords, ["tecnología"])
+    )

backend/app/routers/documents.py

@@ -0,0 +1,27 @@
+import io
+from fastapi import APIRouter, File, UploadFile
+from pypdf import PdfReader
+
+router = APIRouter()
+
+@router.post("/upload-document")
+async def upload_document(file: UploadFile = File(...)):
+    if not file.filename.lower().endswith(".pdf"):
+        return {"error": "Solo se admiten archivos PDF por ahora."}
+    
+    try:
+        content = await file.read()
+        pdf_file = io.BytesIO(content)
+        reader = PdfReader(pdf_file)
+        
+        extracted_text = ""
+        for page in reader.pages:
+            extracted_text += page.extract_text() + "\n"
+        
+        return {
+            "filename": file.filename,
+            "text": extracted_text[:100000], # Limit to 100k chars for context
+            "length": len(extracted_text)
+        }
+    except Exception as e:
+        return {"error": f"Error al procesar el PDF: {str(e)}"}

backend/app/routers/health.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from app.database import get_db
+from app.models.tender import TenderModel
+
+router = APIRouter()
+
+@router.get("/health")
+async def health_check():
+    import httpx
+    from app.config import settings
+    
+    mp_status = "unconfigured"
+    if settings.mercado_publico_ticket:
+        try:
+            # Quick check to see if MP API is reachable
+            async with httpx.AsyncClient(timeout=2.0) as client:
+                # We just check the base URL or a simple metadata endpoint
+                res = await client.get("https://api.mercadopublico.cl/servicios/v1/publico/licitaciones.json?status=active")
+                mp_status = "connected" if res.status_code != 404 else "connected" # Even 403 means reachable
+        except Exception:
+            mp_status = "reachable_check_failed"
+    
+    return {
+        "status": "ok", 
+        "service": "andesops-ai",
+        "dependencies": {
+            "mercado_publico": mp_status
+        }
+    }
+
+@router.get("/health/db-status")
+def get_db_status(db: Session = Depends(get_db)):
+    from app.models.analysis import AnalysisHistoryModel
+    from app.models.company import CompanyProfileModel
+    
+    try:
+        tenders = db.query(TenderModel).count()
+        analysis = db.query(AnalysisHistoryModel).count()
+        profiles = db.query(CompanyProfileModel).count()
+        
+        return {
+            "status": "active",
+            "counts": {
+                "tenders": tenders,
+                "analysis": analysis,
+                "profiles": profiles
+            }
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}

backend/app/routers/oc.py

@@ -0,0 +1,45 @@
+from typing import List, Optional
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.orm import Session
+from app.schemas.oc import PurchaseOrder
+from app.database import get_db
+from app.models.oc import OCModel
+from app.services.mercado_publico_oc import get_ocs_by_date, get_oc_by_code
+from app.services.sync import sync_purchase_orders_to_db
+
+router = APIRouter()
+
+@router.get("/purchase-orders", response_model=List[PurchaseOrder])
+async def list_purchase_orders(
+    date: Optional[str] = None,
+    status: str = "todos",
+    db: Session = Depends(get_db)
+):
+    """
+    List purchase orders for a specific date (ddmmaaaa).
+    """
+    if not date:
+        from datetime import datetime
+        date = datetime.now().strftime("%d%m%Y")
+
+    # Try to fetch current OC data from the live API
+    ocs = await get_ocs_by_date(date, status)
+    if ocs:
+        await sync_purchase_orders_to_db(db, date, status)
+        return ocs
+
+    # Fallback to cached DB entries when the API returns no results
+    db_results = db.query(OCModel).order_by(OCModel.date_creation.desc()).all()
+    return db_results
+
+@router.post("/purchase-orders/sync")
+async def sync_purchase_orders(
+    date: Optional[str] = None,
+    status: str = "todos",
+    db: Session = Depends(get_db)
+):
+    return await sync_purchase_orders_to_db(db, date, status)
+
+@router.get("/purchase-orders/{code}", response_model=Optional[PurchaseOrder])
+async def get_purchase_order(code: str):
+    return await get_oc_by_code(code)

backend/app/routers/tender_details.py

@@ -0,0 +1,80 @@
+"""
+Router for tender detail tab extraction and management
+"""
+from typing import Optional
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.services.tender_detail_extractor import extract_tender_detail_tabs, extract_all_attachments_for_tender
+from app.models.tender_detail import TenderDetailTabModel, TenderAttachmentDetailModel
+
+router = APIRouter()
+
+@router.get("/tenders/{code}/detail-tabs")
+async def get_tender_detail_tabs(
+    code: str,
+    qs: Optional[str] = Query(None, description="Encrypted detail parameter from MP"),
+    db: Session = Depends(get_db)
+):
+    """
+    Extract detail tabs for a tender.
+    Supports both code-based and qs-parameter (encrypted) lookups.
+    """
+    detail_info = await extract_tender_detail_tabs(code, qs)
+    return detail_info
+
+@router.get("/tenders/{code}/attachments")
+async def get_tender_attachments(
+    code: str,
+    qs: Optional[str] = Query(None),
+):
+    """
+    Get all public attachment URLs for a tender.
+    These URLs can be used to fetch documents without authentication.
+    """
+    attachments = await extract_all_attachments_for_tender(code, qs)
+    return {"tender_code": code, "attachments": attachments}
+
+@router.post("/tenders/{code}/extract-details")
+async def extract_and_save_detail_tabs(
+    code: str,
+    qs: Optional[str] = Query(None),
+    db: Session = Depends(get_db)
+):
+    """
+    Extract detail tabs and save to database for caching.
+    """
+    detail_info = await extract_tender_detail_tabs(code, qs)
+    if "error" in detail_info:
+        return {"status": "error", "message": detail_info["error"]}
+    
+    # Save tabs to database
+    for tab_type, tab_data in detail_info.get("tabs", {}).items():
+        tab_id = f"{code}_{tab_type}"
+        existing = db.query(TenderDetailTabModel).filter(TenderDetailTabModel.id == tab_id).first()
+        if not existing:
+            tab_entry = TenderDetailTabModel(
+                id=tab_id,
+                tender_code=code,
+                tab_name=tab_data.get("name"),
+                tab_type=tab_type,
+                tab_metadata=tab_data
+            )
+            db.add(tab_entry)
+    
+    # Save attachments
+    for att in detail_info.get("attachments", []):
+        att_id = f"{code}_{att.get('name', 'unknown').replace('/', '_')}"
+        existing = db.query(TenderAttachmentDetailModel).filter(TenderAttachmentDetailModel.id == att_id).first()
+        if not existing:
+            att_entry = TenderAttachmentDetailModel(
+                id=att_id,
+                tender_code=code,
+                attachment_name=att.get("name"),
+                attachment_url=att.get("href"),
+                tab_category="Unknown"
+            )
+            db.add(att_entry)
+    
+    db.commit()
+    return {"status": "success", "detail_info": detail_info}

backend/app/routers/tenders.py

@@ -0,0 +1,161 @@
+from datetime import datetime
+from typing import List, Optional
+from fastapi import APIRouter, Query, Depends
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+
+from app.schemas.tender import Tender
+from app.database import get_db
+from app.models.tender import TenderModel
+from app.services.sync import sync_tenders_to_db, clean_expired_tenders
+from app.services.mercado_publico import (
+    fetch_tenders,
+    get_tender_by_code,
+    get_tenders_by_date,
+)
+from app.models.company import CompanyProfileModel
+import json
+
+router = APIRouter()
+
+@router.get("/tenders", response_model=List[Tender])
+async def search_tender_opportunities(
+    keyword: Optional[str] = None,
+    buyer: Optional[str] = None,
+    region: Optional[str] = None,
+    provider_code: Optional[str] = Query(None, alias="provider_code"),
+    org_code: Optional[str] = Query(None, alias="org_code"),
+    status: Optional[str] = None,
+    code: Optional[str] = None,
+    date: Optional[str] = None,
+    type_code: Optional[str] = Query(None, alias="type_code"),
+    skip: int = 0,
+    limit: int = 50,
+    db: Session = Depends(get_db)
+):
+    # If a Mercado Público-specific query is requested, fetch live from the external API.
+    if code:
+        tender = await get_tender_by_code(code)
+        return [tender] if tender else []
+
+    if any([provider_code, org_code, status, date, type_code]) and not keyword:
+        from app.services.mercado_publico import get_tenders_by_filters
+        return await get_tenders_by_filters(
+            date=date,
+            status=status,
+            type_code=type_code,
+            org_code=org_code,
+            provider_code=provider_code
+        )
+
+    if keyword:
+        from app.services.mercado_publico import fetch_tenders
+        return await fetch_tenders(keyword=keyword, date=date, type_code=type_code)
+
+    # 1. Búsqueda en DB con paginación
+    query = db.query(TenderModel)
+    
+    if keyword:
+        search_filter = f"%{keyword}%"
+        query = query.filter(
+            or_(
+                TenderModel.name.ilike(search_filter),
+                TenderModel.code.ilike(search_filter),
+                TenderModel.description.ilike(search_filter),
+                TenderModel.buyer.ilike(search_filter),
+                TenderModel.sector.ilike(search_filter),
+                TenderModel.region.ilike(search_filter)
+            )
+        )
+    
+    if buyer:
+        query = query.filter(TenderModel.buyer.ilike(f"%{buyer}%"))
+    
+    if region:
+        query = query.filter(TenderModel.region.ilike(f"%{region}%"))
+        
+    # Ordenar por fecha de cierre (más próximas primero)
+    results = query.order_by(TenderModel.closing_date.asc()).offset(skip).limit(limit).all()
+    
+    # 2. Si la DB está vacía o no hay resultados con los filtros actuales, 
+    # y el usuario está haciendo una búsqueda general (sin keyword específica larga),
+    # hacemos un intento de sincronización de las "activas de hoy".
+    if not results:
+        print(f"[Tenders] No results in DB. Triggering sync. keyword={keyword}")
+        await sync_tenders_to_db(db, keyword=keyword)
+        # Re-ejecutar consulta
+        results = query.offset(skip).limit(limit).all()
+        
+    return results
+
+@router.get("/tenders/count")
+def get_tenders_count(db: Session = Depends(get_db)):
+    """Devuelve el total de licitaciones en la base de datos."""
+    return {"total": db.query(TenderModel).count()}
+
+@router.post("/tenders/sync")
+async def manual_sync(keyword: Optional[str] = None, db: Session = Depends(get_db)):
+    return await sync_tenders_to_db(db, keyword=keyword)
+
+@router.get("/tenders/scrape", response_model=List[Tender])
+async def live_scrape(keyword: str):
+    from app.services.scraper import scrape_compra_agil
+    return await scrape_compra_agil(keyword)
+
+@router.get("/tenders/recommendations", response_model=List[Tender])
+async def get_recommended_tenders(db: Session = Depends(get_db)):
+    """Busca licitaciones locales que coincidan con las keywords del perfil de empresa."""
+    print("!!! RECOMMENDATION ENDPOINT CALLED !!!")
+    profile = db.query(CompanyProfileModel).first()
+    
+    # Fallback absolute: if no profile or no data, just return the latest 10
+    if not profile or not profile.keywords:
+        print("No profile or keywords found, returning latest 10")
+        return db.query(TenderModel).order_by(TenderModel.closing_date.desc()).limit(10).all()
+    
+    try:
+        # Handle JSON or Comma-separated
+        if profile.keywords.startswith("[") or profile.keywords.startswith("{"):
+            keywords = json.loads(profile.keywords)
+        else:
+            keywords = [kw.strip() for kw in profile.keywords.split(",") if kw.strip()]
+    except Exception as e:
+        print(f"Keyword parse error: {e}")
+        keywords = [profile.keywords] if profile.keywords else []
+
+    print(f"Processing keywords: {keywords}")
+
+    # Build filters (Case-insensitive)
+    filters = []
+    for kw in keywords:
+        if not kw or len(kw) < 2: continue
+        search_term = f"%{kw}%"
+        filters.append(TenderModel.name.ilike(search_term))
+        filters.append(TenderModel.description.ilike(search_term))
+        filters.append(TenderModel.buyer.ilike(search_term))
+        filters.append(TenderModel.sector.ilike(search_term))
+
+    # If no valid filters, return latest
+    if not filters:
+        print("No valid filters generated, returning latest 10")
+        return db.query(TenderModel).order_by(TenderModel.closing_date.desc()).limit(10).all()
+
+    # Query with filters
+    try:
+        recommended = db.query(TenderModel).filter(or_(*filters)).order_by(TenderModel.closing_date.desc()).limit(15).all()
+        print(f"Found {len(recommended)} recommended matches")
+    except Exception as e:
+        print(f"Query error: {e}")
+        recommended = []
+    
+    # GUARANTEED FALLBACK: If nothing found or error, return the newest 10 tenders from DB
+    if not recommended:
+        print("No matches found, executing fallback to latest 10")
+        recommended = db.query(TenderModel).order_by(TenderModel.closing_date.desc()).limit(10).all()
+    elif len(recommended) < 5:
+        print(f"Only {len(recommended)} found, padding with latest")
+        existing_ids = [r.id for r in recommended]
+        more = db.query(TenderModel).filter(TenderModel.id.not_in(existing_ids)).order_by(TenderModel.closing_date.desc()).limit(5).all()
+        recommended.extend(more)
+
+    return recommended

backend/app/schemas/analysis.py

@@ -0,0 +1,78 @@
+from datetime import datetime
+from pydantic import BaseModel
+from typing import List
+
+from app.schemas.company import CompanyProfile
+from app.schemas.tender import Tender
+
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+    agent_name: str | None = None
+
+
+class ChatRequest(BaseModel):
+    tender: Tender
+    company_profile: CompanyProfile
+    message: str
+    agent: str
+    model: str
+    history: List[ChatMessage]
+    amd_settings: dict | None = None
+
+
+class RiskItem(BaseModel):
+    title: str
+    severity: str
+    explanation: str
+
+
+class ActionItem(BaseModel):
+    task: str
+    priority: str
+    owner: str
+    timeline: str
+
+
+class QAResponse(BaseModel):
+    question: str
+    answer: str
+
+
+class AnalysisRequest(BaseModel):
+    tender: Tender
+    company_profile: CompanyProfile
+    document_text: str | None = None
+    models: dict | None = None
+    tender_details: dict | None = None
+    amd_settings: dict | None = None
+
+
+class AnalysisResult(BaseModel):
+    fit_score: int
+    decision: str
+    executive_summary: str
+    key_requirements: List[str]
+    risks: List[RiskItem]
+    compliance_gaps: List[str]
+    action_plan: List[ActionItem]
+    proposal_draft: str
+    report_markdown: str
+    strategic_roadmap: str | None = None
+    requirement_responses: List[QAResponse] = []
+    audit_log: List[str] = []
+    raw_responses: dict = {}
+
+
+class AnalysisRecord(BaseModel):
+    tender_code: str
+    tender_name: str
+    analyzed_at: datetime
+    analysis: AnalysisResult
+
+class SearchRecord(BaseModel):
+    query: str
+    results_count: int
+    searched_at: datetime
+    is_agile: bool = False

backend/app/schemas/company.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+from typing import List
+
+
+class CompanyProfile(BaseModel):
+    name: str
+    industry: str
+    services: List[str]
+    experience: str
+    certifications: List[str]
+    regions: List[str]
+    documents_available: List[str]
+    keywords: List[str] = []

backend/app/schemas/oc.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel, ConfigDict
+from typing import List, Optional, Union
+from datetime import datetime
+
+class OCItem(BaseModel):
+    correlative: Optional[int] = None
+    product_code: Optional[str] = None
+    name: str
+    description: Optional[str] = None
+    quantity: float
+    unit: str
+    price: Optional[float] = None
+    total: Optional[float] = None
+
+class PurchaseOrder(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    
+    code: str
+    name: str
+    status: str
+    status_code: Optional[str] = None
+    buyer: str
+    buyer_rut: Optional[str] = None
+    provider: str
+    provider_rut: Optional[str] = None
+    date_creation: Union[str, datetime, None] = None
+    total_amount: Optional[float] = None
+    currency: Optional[str] = None
+    type: Optional[str] = None
+    items: List[OCItem] = []
+    raw_data: Optional[dict] = None

backend/app/schemas/tender.py

@@ -0,0 +1,52 @@
+from pydantic import BaseModel, ConfigDict
+from typing import List, Optional, Union
+from datetime import datetime
+
+class TenderItem(BaseModel):
+    correlative: Optional[int] = None
+    product_code: Optional[str] = None
+    category: Optional[str] = None
+    name: str
+    description: Optional[str] = None
+    quantity: float
+    unit: str
+
+class TenderAttachment(BaseModel):
+    name: str
+    url: str
+    category: Optional[str] = None  # Administrativo, Técnico, Económico, etc.
+    file_type: Optional[str] = None  # PDF, DOC, XLS, etc.
+
+class TenderDetailTab(BaseModel):
+    """Detail tab information (Preguntas, Historial, Apertura, Adjudicación, etc.)"""
+    tab_name: str
+    tab_type: str  # questions, history, opening, adjudication
+    content_summary: Optional[str] = None
+    metadata: Optional[dict] = None
+    attachment_urls: Optional[List[str]] = None
+
+class Tender(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    
+    code: str
+    name: str
+    description: str
+    buyer: str
+    buyer_region: Optional[str] = None
+    status: str
+    status_code: Optional[int] = None
+    type: Optional[str] = None # L1, LE, LP, etc.
+    currency: Optional[str] = None # CLP, USD, etc.
+    closing_date: Union[str, datetime, None] = None
+    publication_date: Union[str, datetime, None] = None
+    estimated_amount: Optional[float] = None
+    source: str = "Mercado Público"
+    region: Optional[str] = None
+    sector: Optional[str] = None
+    items: Optional[List[TenderItem]] = []
+    attachments: Optional[List[TenderAttachment]] = []
+    evaluation_criteria: Optional[List[dict]] = []
+    contract_duration: Optional[str] = None
+    detail_tabs: Optional[List[TenderDetailTab]] = []  # Detail tab information
+    detail_metadata: Optional[dict] = None  # Aggregated detail metadata
+    raw_data: Optional[dict] = None # Store the full response if needed

backend/app/services/agents.py

@@ -0,0 +1,137 @@
+import asyncio
+from app.schemas.analysis import AnalysisResult
+from app.schemas.company import CompanyProfile
+from app.schemas.tender import Tender
+from app.services.llm import call_gemini, _parse_gemini_response, call_gemini_with_model
+from app.services.report import generate_markdown_report
+from app.config import settings
+
+async def legal_agent_task(tender: Tender, company: CompanyProfile, document_text: str = "", model: str | None = None, tender_details: dict | None = None) -> str:
+    details_str = f"\nSCRAPED DETAILS: {tender_details}" if tender_details else ""
+    prompt = (
+        f"AGENT ROLE: Legal & Compliance Expert (Chilean Public Procurement)\n"
+        f"GOAL: Analyze administrative bases and compliance risks.\n"
+        f"TENDER: {tender.name} (Type: {tender.type})\n"
+        f"COMPANY: {company.name}\n"
+        f"EXTRACTED TEXT: {document_text[:5000]}\n"
+        f"{details_str}\n"
+        f"TASK: Identify 3 legal gaps/risks. Respond in Spanish."
+    )
+    return await call_gemini_with_model(prompt, model)
+
+async def technical_agent_task(tender: Tender, company: CompanyProfile, document_text: str = "", model: str | None = None, tender_details: dict | None = None) -> str:
+    details_str = f"\nSCRAPED DETAILS: {tender_details}" if tender_details else ""
+    prompt = (
+        f"AGENT ROLE: Technical Architect\n"
+        f"GOAL: Evaluate technical feasibility.\n"
+        f"TENDER: {tender.name} - {tender.description}\n"
+        f"COMPANY: {company.industry} - {company.experience}\n"
+        f"EXTRACTED TEXT: {document_text[:5000]}\n"
+        f"{details_str}\n"
+        f"TASK: Identify 3 technical challenges. Respond in Spanish."
+    )
+    return await call_gemini_with_model(prompt, model)
+
+async def strategy_agent_task(tender: Tender, company: CompanyProfile, document_text: str = "", model: str | None = None, tender_details: dict | None = None) -> str:
+    details_str = f"\nSCRAPED DETAILS: {tender_details}" if tender_details else ""
+    prompt = (
+        f"AGENT ROLE: Risk & Strategy Specialist\n"
+        f"GOAL: Calculate ROI and strategy.\n"
+        f"TENDER: {tender.name}\n"
+        f"COMPANY: {company.name}\n"
+        f"{details_str}\n"
+        f"TASK: Identify 3 strategic risks and a win strategy. Respond in Spanish."
+    )
+    return await call_gemini_with_model(prompt, model)
+
+async def run_full_analysis(tender: Tender, company_profile: CompanyProfile, document_text: str | None = None, models: dict | None = None, tender_details: dict | None = None, amd_settings: dict | None = None) -> AnalysisResult:
+    # Inject user-provided AMD settings if present
+    if amd_settings:
+        settings.amd_inference_url = amd_settings.get("url")
+        settings.amd_api_key = amd_settings.get("key")
+        print(f"!!! AMD NODE ACTIVATED: {settings.amd_inference_url} !!!")
+
+    audit_log = ["🚀 Iniciando mesa de expertos agéntica..."]
+    doc_text = document_text or ""
+    
+    # Use selected models or defaults
+    chosen_models = models or {
+        "legal": "Llama-3.3-70B (Groq)" if settings.groq_api_key else "Gemini 2.5 Flash",
+        "tech": "Llama-3.1-8B (Groq)" if settings.groq_api_key else "Qwen-2.5 (Featherless)",
+        "risk": "Llama-3.3-70B (Groq)" if settings.groq_api_key else "Qwen-2.5 (Featherless)"
+    }
+    
+    audit_log.append(f"👨‍⚖️ Agente Legal ({chosen_models.get('legal')})")
+    audit_log.append(f"👨‍💻 Agente Técnico ({chosen_models.get('tech')})")
+    audit_log.append(f"🕵️ Agente de Riesgo ({chosen_models.get('risk')})")
+    
+    tasks = [
+        legal_agent_task(tender, company_profile, doc_text, chosen_models.get("legal"), tender_details),
+        technical_agent_task(tender, company_profile, doc_text, chosen_models.get("tech"), tender_details),
+        strategy_agent_task(tender, company_profile, doc_text, chosen_models.get("risk"), tender_details)
+    ]
+    
+    responses = await asyncio.gather(*tasks)
+    legal_resp, tech_resp, strat_resp = responses
+    
+    audit_log.append("💡 Consolidando hallazgos...")
+    
+    synthesis_prompt = (
+        f"SISTEMA DE CONSENSO ANDESOPS AI (ESTRUCTURA DE ALTO IMPACTO)\n"
+        f"Licitación: {tender.name}\n"
+        f"Comprador: {tender.buyer}\n"
+        f"Reporte Legal: {legal_resp}\n"
+        f"Reporte Técnico: {tech_resp}\n"
+        f"Reporte Estratégico: {strat_resp}\n\n"
+        f"Genera un JSON 'AnalysisResult' siguiendo estas reglas estrictas:\n"
+        f"1. fit_score (int 0-100)\n"
+        f"2. decision ('Recommended', 'Review Carefully', 'Not Recommended')\n"
+        f"3. executive_summary: Un resumen ejecutivo de alto nivel, profesional y persuasivo.\n"
+        f"4. risks: Lista de {{title, severity, explanation}} con los riesgos críticos detectados.\n"
+        f"5. key_requirements: Lista de requisitos técnicos/administrativos ineludibles.\n"
+        f"6. compliance_gaps: Brechas que la empresa debe cerrar para ganar.\n"
+        f"7. action_plan: Pasos concretos a seguir.\n"
+        f"8. strategic_roadmap: Un roadmap estratégico en Markdown que explique cómo ganar.\n"
+        f"9. proposal_draft: **CRÍTICO** - Genera un borrador de propuesta técnica formal y detallado en Markdown.\n"
+        f"   Debe incluir: \n"
+        f"   - Portada (Título de Licitación, Empresa, Fecha)\n"
+        f"   - Introducción y Objetivos\n"
+        f"   - Solución Técnica Propuesta (basada en el reporte técnico)\n"
+        f"   - Metodología de Implementación\n"
+        f"   - Propuesta de Valor Diferenciadora (por qué elegirnos)\n"
+        f"   - Cronograma estimado\n"
+        f"   - Conclusión Profesional\n"
+        f"10. requirement_responses: " + (f"Genera exactamente {tender_details.get('metadata', {}).get('question_count', 0)} pares de {{question, answer}} basados en las preguntas reales del mercado. " if tender_details and tender_details.get('metadata', {}).get('question_count', 0) > 0 else "Genera solo 3 preguntas y respuestas basadas en requisitos hipotéticos/claves ya que no hay preguntas de mercado activas. ") + "\n"
+        f"11. report_markdown: Un reporte general para consumo interno.\n"
+        f"Responde ÚNICAMENTE con el JSON plano. No incluyas explicaciones fuera del JSON."
+    )
+    
+    final_output = await call_gemini(synthesis_prompt, is_json=True)
+    
+    # Fallback for synthesis if Gemini/Groq failed to return valid JSON
+    if not final_output and settings.groq_api_key:
+        from app.services.llm import call_groq
+        final_output = await call_groq(synthesis_prompt, "llama-3.3-70b-versatile")
+
+    parse_result = _parse_gemini_response(final_output)
+    
+    if parse_result:
+        try:
+            # Ensure report_markdown exists
+            if not parse_result.get("report_markdown"):
+                parse_result["report_markdown"] = generate_markdown_report(parse_result)
+            
+            result = AnalysisResult(**parse_result)
+            result.audit_log = audit_log + (result.audit_log or [])
+            result.raw_responses = {
+                "legal": legal_resp,
+                "technical": tech_resp,
+                "strategy": strat_resp
+            }
+            return result
+        except Exception as e:
+            print(f"Synthesis Validation Error: {e}")
+            
+    # Ultimate fallback to the logic in llm.py
+    from app.services.llm import generate_analysis
+    return await generate_analysis(tender, company_profile, doc_text, models)

backend/app/services/llm.py

@@ -0,0 +1,468 @@
+import hashlib
+import json
+import httpx
+import google.generativeai as genai
+from app.config import settings
+from app.schemas.analysis import AnalysisResult, RiskItem, ActionItem, CompanyProfile, Tender
+from app.services.report import generate_markdown_report
+
+# Configure Gemini
+genai.configure(api_key=settings.gemini_api_key)
+
+async def call_gemini(prompt: str, is_json: bool = False) -> str:
+    if not settings.gemini_api_key:
+        return ""
+        
+    try:
+        generation_config = {
+            "temperature": 0.2,
+            "top_p": 0.95,
+            "top_k": 40,
+            "max_output_tokens": 8192,
+        }
+        
+        if is_json:
+            generation_config["response_mime_type"] = "application/json"
+            
+        model = genai.GenerativeModel(
+            model_name="gemini-2.0-flash",
+            generation_config=generation_config,
+        )
+        
+        response = await model.generate_content_async(prompt)
+        return response.text
+    except Exception as e:
+        print(f"Error calling Gemini (is_json={is_json}): {e}, trying fallback...")
+        if settings.groq_api_key:
+            return await call_groq(prompt, "llama-3.3-70b-versatile")
+        return await call_featherless(prompt, "Qwen/Qwen2.5-72B-Instruct")
+
+async def call_featherless(prompt: str, model: str = "Qwen/Qwen2.5-72B-Instruct") -> str:
+    if not settings.featherless_api_key:
+        return ""
+
+    try:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            payload = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": 0.2
+            }
+            if "json" in prompt.lower():
+                payload["response_format"] = {"type": "json_object"}
+
+            response = await client.post(
+                "https://api.featherless.ai/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.featherless_api_key}",
+                    "Content-Type": "application/json"
+                },
+                json=payload
+            )
+            if response.status_code != 200:
+                print(f"Featherless Error ({model}): {response.status_code} - {response.text}")
+                return ""
+            data = response.json()
+            return data["choices"][0]["message"]["content"]
+    except Exception as e:
+        print(f"Error calling Featherless ({model}): {e}")
+        return ""
+
+async def call_groq(prompt: str, model: str = "llama-3.3-70b-versatile") -> str:
+    if not settings.groq_api_key:
+        return ""
+
+    try:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            payload = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": 0.2
+            }
+            if "json" in prompt.lower():
+                payload["response_format"] = {"type": "json_object"}
+
+            response = await client.post(
+                "https://api.groq.com/openai/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.groq_api_key}",
+                    "Content-Type": "application/json"
+                },
+                json=payload
+            )
+            if response.status_code != 200:
+                print(f"Groq Error ({model}): {response.status_code} - {response.text}")
+                return ""
+            data = response.json()
+            return data["choices"][0]["message"]["content"]
+    except Exception as e:
+        print(f"Error calling Groq ({model}): {e}")
+        return ""
+
+async def call_amd_mi300x(prompt: str, model: str = "Qwen/Qwen2.5-72B-Instruct") -> str:
+    """
+    Direct inference call to an AMD Instinct MI300X node running vLLM or similar ROCm-based server.
+    """
+    if not settings.amd_inference_url:
+        return ""
+
+    try:
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            payload = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": 0.1
+            }
+            if "json" in prompt.lower():
+                payload["response_format"] = {"type": "json_object"}
+
+            response = await client.post(
+                settings.amd_inference_url.rstrip("/") + "/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.amd_api_key}" if settings.amd_api_key else "",
+                    "Content-Type": "application/json"
+                },
+                json=payload
+            )
+            
+            if response.status_code != 200:
+                print(f"AMD Node Error: {response.status_code} - {response.text}")
+                return ""
+                
+            data = response.json()
+            return data["choices"][0]["message"]["content"]
+    except Exception as e:
+        print(f"Critical connection error to AMD Node: {e}")
+        return ""
+
+async def call_gemini_with_model(prompt: str, model_name: str | None = None, is_json: bool = False) -> str:
+    model_map = {
+        "Gemini 2.5 Flash": "gemini",
+        "DeepSeek-V3 (Featherless)": "deepseek-ai/DeepSeek-V3",
+        "Qwen-2.5 (Featherless)": "Qwen/Qwen2.5-72B-Instruct",
+        "Llama-3.3-70B (Groq)": "groq:llama-3.3-70b-versatile",
+        "Llama-3.1-8B (Groq)": "groq:llama-3.1-8b-instant",
+        "Llama-3.1-70B (Groq)": "groq:llama-3.1-70b-versatile",
+        "Mixtral-8x7B (Groq)": "groq:mixtral-8x7b-32768",
+        "Gemma-2-9B (Featherless)": "google/gemma-2-9b-it",
+        "Llama-3.1-8B (Featherless)": "meta-llama/Meta-Llama-3.1-8B-Instruct",
+        "Llama-3.2-11B-Vision (Groq)": "groq:llama-3.2-11b-vision-preview",
+        "AMD-Instinct (MI300X Local)": "amd:default",
+    }
+
+    model_id = model_map.get(model_name, "gemini")
+    print(f"DEBUG: Calling LLM with model_name='{model_name}' -> model_id='{model_id}'")
+    
+    # Check keys
+    if model_id.startswith("groq:") and not settings.groq_api_key:
+        print("DEBUG WARNING: GROQ_API_KEY is missing! Falling back to Gemini.")
+        model_id = "gemini"
+    
+    if model_id.startswith("amd:") and not settings.amd_inference_url:
+        print("DEBUG WARNING: AMD_INFERENCE_URL is missing! Falling back to Gemini.")
+        model_id = "gemini"
+
+    if model_id == "gemini":
+        res = await call_gemini(prompt, is_json=is_json)
+        if not res and settings.groq_api_key:
+            print("DEBUG: Gemini failed or returned empty. Trying Groq fallback.")
+            return await call_groq(prompt, "llama-3.3-70b-versatile")
+        return res
+    elif model_id.startswith("groq:"):
+        # Check if it's a vision call (hacky way for now, but effective)
+        if "IMAGE_DATA:" in prompt:
+            parts = prompt.split("IMAGE_DATA:")
+            text_prompt = parts[0].strip()
+            image_b64 = parts[1].strip()
+            res = await call_groq_vision(text_prompt, image_b64, model=model_id[5:])
+        else:
+            res = await call_groq(prompt, model=model_id[5:])
+            
+        if not res and settings.gemini_api_key:
+            print("DEBUG: Groq failed or returned empty. Trying Gemini fallback.")
+            return await call_gemini(prompt, is_json=is_json)
+        return res
+    elif model_id.startswith("amd:"):
+        print(f"🔥 EXECUTING ON AMD INSTINCT MI300X NODE: {settings.amd_inference_url}")
+        res = await call_amd_mi300x(prompt)
+        if not res:
+            print("DEBUG: AMD Node call failed. Falling back to Gemini.")
+            return await call_gemini(prompt, is_json=is_json)
+        return res
+    else:
+        res = await call_featherless(prompt, model=model_id)
+        if not res and settings.groq_api_key:
+            print("DEBUG: Featherless failed. Trying Groq fallback.")
+            return await call_groq(prompt, "llama-3.3-70b-versatile")
+        return res
+
+async def call_groq_vision(prompt: str, image_b64: str, model: str = "llama-3.2-11b-vision-preview") -> str:
+    if not settings.groq_api_key:
+        return ""
+
+    try:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            # Ensure proper data URL format
+            if not image_b64.startswith("data:image"):
+                image_b64 = f"data:image/jpeg;base64,{image_b64}"
+
+            payload = {
+                "model": model,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": image_b64}
+                            }
+                        ]
+                    }
+                ],
+                "temperature": 0.2
+            }
+
+            response = await client.post(
+                "https://api.groq.com/openai/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.groq_api_key}",
+                    "Content-Type": "application/json"
+                },
+                json=payload
+            )
+            if response.status_code != 200:
+                print(f"Groq Vision Error ({model}): {response.status_code} - {response.text}")
+                return ""
+            data = response.json()
+            return data["choices"][0]["message"]["content"]
+    except Exception as e:
+        print(f"Error calling Groq Vision ({model}): {e}")
+        return ""
+
+def _parse_gemini_response(output: str) -> dict | None:
+    if not output:
+        return None
+    
+    # Remove Markdown code blocks if present
+    clean_output = output.strip()
+    if clean_output.startswith("```json"):
+        clean_output = clean_output[7:-3].strip()
+    elif clean_output.startswith("```"):
+        clean_output = clean_output[3:-3].strip()
+        
+    try:
+        data = json.loads(clean_output)
+    except Exception as e:
+        print(f"JSON Parsing Error: {e}\nRaw Output: {output[:200]}...")
+        return None
+    
+    if data:
+        # Handle nesting (LLMs sometimes wrap the result in a key)
+        if not all(k in data for k in ["fit_score", "decision", "risks"]):
+            for val in data.values():
+                if isinstance(val, dict) and any(k in val for k in ["fit_score", "decision", "risks"]):
+                    data = val
+                    break
+        
+        # Ensure strategic_roadmap is a string
+        if "strategic_roadmap" in data:
+            if isinstance(data["strategic_roadmap"], list):
+                data["strategic_roadmap"] = "\n".join([str(item) for item in data["strategic_roadmap"]])
+            elif isinstance(data["strategic_roadmap"], dict):
+                data["strategic_roadmap"] = json.dumps(data["strategic_roadmap"], indent=2, ensure_ascii=False)
+        
+        # Ensure risks is a list of objects
+        if "risks" in data and isinstance(data["risks"], list):
+            new_risks = []
+            for item in data["risks"]:
+                if isinstance(item, str):
+                    new_risks.append({"title": item, "severity": "Medium", "explanation": item})
+                elif isinstance(item, dict):
+                    new_risks.append(item)
+            data["risks"] = new_risks
+
+        # Ensure action_plan is a list of objects
+        if "action_plan" in data and isinstance(data["action_plan"], list):
+            new_plan = []
+            for item in data["action_plan"]:
+                if isinstance(item, str):
+                    new_plan.append({"task": item, "priority": "Medium", "owner": "Team", "timeline": "TBD"})
+                elif isinstance(item, dict):
+                    new_plan.append(item)
+            data["action_plan"] = new_plan
+
+        # Ensure fit_score is int
+        if "fit_score" in data:
+            try:
+                data["fit_score"] = int(data["fit_score"])
+            except:
+                data["fit_score"] = 0
+            
+        return data
+    return None
+
+def generate_mock_analysis(tender: Tender, company: CompanyProfile) -> AnalysisResult:
+    raw = f"{tender.code}:{tender.name}:{company.name}"
+    digest = hashlib.sha256(raw.encode("utf-8")).hexdigest()
+    score = int(digest[:8], 16) % 41 + 55
+    
+    return AnalysisResult(
+        fit_score=score,
+        decision="Recommended" if score > 75 else "Review Carefully",
+        executive_summary=f"Análisis automático para {tender.name}. Se observa un encaje técnico razonable.",
+        key_requirements=["Documentación legal", "Experiencia técnica", "Garantía de seriedad"],
+        risks=[{"title": "Plazo ajustado", "severity": "Medium", "explanation": "El tiempo de entrega es crítico."}],
+        compliance_gaps=["Validar boleta de garantía"],
+        action_plan=[{"task": "Revisar bases", "priority": "High", "owner": "Legal", "timeline": "2 días"}],
+        proposal_draft="Borrador generado automáticamente...",
+        report_markdown="# Reporte de Licitación",
+        audit_log=["Iniciando análisis de respaldo...", "Generando datos mock."]
+    )
+
+async def generate_analysis(tender: Tender, company: CompanyProfile, document_text: str | None = None, models: dict | None = None) -> AnalysisResult:
+    chosen = models or {
+        "legal": "Llama-3.3-70B (Groq)" if settings.groq_api_key else "Gemini 2.5 Flash",
+        "tech": "Llama-3.1-8B (Groq)" if settings.groq_api_key else "Qwen-2.5 (Featherless)",
+        "risk": "Llama-3.3-70B (Groq)" if settings.groq_api_key else "Qwen-2.5 (Featherless)"
+    }
+
+    audit_messages = ["🚀 Launching Multi-Agent Orchestration Pipeline."]
+    agent_outputs = {}
+
+    agent_definitions = {
+        "legal": "Experto Legal & Cumplimiento: Evalúa bases administrativas, multas y garantías. Pon especial atención a los ANEXOS de Sustentabilidad y Admisibilidad.",
+        "tech": "Ingeniero Técnico: Evalúa arquitectura, stack tecnológico y capacidad de ejecución. Considera si se requieren certificaciones ambientales.",
+        "risk": "Estratega Comercial: Evalúa rentabilidad, competencia y riesgos de mercado. Analiza el impacto de los criterios de evaluación ESG en el puntaje final."
+    }
+
+    for agent_id, role_desc in agent_definitions.items():
+        model_name = chosen.get(agent_id, "Gemini 2.5 Flash")
+        audit_messages.append(f"🤖 Agent {agent_id.upper()} calling {model_name}...")
+        
+        agent_prompt = f"""
+        Actúa como {role_desc}
+        Licitación: {tender.name} ({tender.code})
+        Empresa: {company.name}
+        Contexto Adicional: {document_text[:5000] if document_text else 'No adjunto.'}
+        
+        PROPORCIONA TU ANÁLISIS ESPECÍFICO (Máx 200 palabras) EN ESPAÑOL.
+        """
+        
+        res = await call_gemini_with_model(agent_prompt, model_name=model_name)
+        agent_outputs[agent_id] = res or "Análisis no disponible debido a error de conexión."
+
+    audit_messages.append("🧠 Synthesis phase: Consolidating agent insights...")
+    
+    synthesis_prompt = f"""
+    SISTEMA DE CONSENSO ANDESOPS AI
+    Licitación: {tender.name}
+    Resultados de Agentes:
+    - LEGAL: {agent_outputs.get('legal')}
+    - TECH: {agent_outputs.get('tech')}
+    - RISK: {agent_outputs.get('risk')}
+    
+    Genera el JSON final AnalysisResult con una decisión fundamentada.
+    RESPONDE SOLO EL JSON.
+    """
+    
+    final_json = await call_gemini(synthesis_prompt, is_json=True)
+    if not final_json and settings.groq_api_key:
+        final_json = await call_groq(synthesis_prompt, model="llama-3.3-70b-versatile")
+    elif not final_json and settings.featherless_api_key:
+        final_json = await call_featherless(synthesis_prompt, model="Qwen/Qwen2.5-72B-Instruct")
+
+    parse_result = _parse_gemini_response(final_json)
+    
+    if parse_result:
+        try:
+            if not parse_result.get("report_markdown"):
+                parse_result["report_markdown"] = generate_markdown_report(parse_result)
+
+            if not parse_result.get("proposal_draft") or len(parse_result["proposal_draft"]) < 100:
+                audit_messages.append("📝 Generating specialized proposal draft...")
+                parse_result["proposal_draft"] = await generate_proposal_draft(parse_result, company)
+            
+            result = AnalysisResult(**parse_result)
+            result.audit_log = audit_messages + (result.audit_log or [])
+            return result
+        except Exception as e:
+            print(f"Validation Error in generate_analysis: {e}")
+            
+    analysis = generate_mock_analysis(tender, company)
+    analysis.audit_log = audit_messages + ["⚠️ Synthesis failed, using emergency fallback."]
+    return analysis
+
+async def generate_proposal_draft(analysis: dict, company: CompanyProfile) -> str:
+    prompt = f"""
+    Como experto redactor de propuestas de licitación, genera un borrador profesional (en Markdown) basado en este análisis técnico:
+    {analysis.get('executive_summary', 'Analizar bases adjuntas.')}
+    
+    Perfil de la Empresa: {company.name} - {company.experience}
+    Requisitos Críticos a Abordar: {', '.join(analysis.get('key_requirements', []))}
+    
+    Estructura la propuesta en ESPAÑOL con:
+    1. Introducción Ejecutiva
+    2. Resumen de la Solución Técnica
+    3. Aseguramiento de Cumplimiento (Compliance)
+    4. Propuesta de Valor Estratégica
+    """
+    
+    return await call_gemini_with_model(prompt, model_name="Llama-3.3-70B (Groq)" if settings.groq_api_key else "Gemini 2.5 Flash")
+
+async def generate_synthetic_tenders(keyword: str) -> list[Tender]:
+    """
+    Generates realistic synthetic tenders with coherent bidding documents (bases)
+    when official sources are unavailable or empty.
+    """
+    prompt = f"""
+    Genera 4 licitaciones de Mercado Público CHILE realistas para el rubro: {keyword}
+    
+    Para cada licitación, genera un JSON con:
+    - code: Formato XXXXX-XX-XX26
+    - name: Nombre profesional
+    - buyer: Una institución pública chilena real
+    - description: UN DOCUMENTO EXTENSO de 'Bases Administrativas y Técnicas' (mínimo 300 palabras) 
+      que incluya: Objeto de licitación, Requisitos técnicos, Plazos, Multas y Criterios de Evaluación.
+    - status: 'Publicada'
+    - closing_date: ISO date en 2 semanas
+    - estimated_amount: Monto en CLP entre 5M y 50M
+    - region: Una región de Chile
+    
+    RESPONDE SOLO EL JSON (Lista de objetos).
+    """
+    
+    res = await call_gemini(prompt, is_json=True)
+    items = []
+    try:
+        data = json.loads(res)
+        # Handle if LLM wraps in a key
+        if isinstance(data, dict):
+            for v in data.values():
+                if isinstance(v, list):
+                    data = v
+                    break
+        
+        for i in data:
+            items.append(Tender(
+                code=i.get("code", "000-00-00"),
+                name=i.get("name", "Licitación Sintética"),
+                description=i.get("description", "Documento de bases en proceso..."),
+                buyer=i.get("buyer", "Organismo Público"),
+                status=i.get("status", "Publicada"),
+                closing_date=i.get("closing_date", datetime.now().isoformat()),
+                estimated_amount=float(i.get("estimated_amount", 0)),
+                source="AndesOps AI - Intelligent Discovery",
+                region=i.get("region", "Nacional"),
+                sector="Privado/Público",
+                items=[],
+                attachments=[{
+                    "name": "Bases_Tecnicas_y_Administrativas.pdf",
+                    "url": "#synthetic-doc",
+                    "type": "pdf"
+                }]
+            ))
+    except Exception as e:
+        print(f"Error generating synthetic tenders: {e}")
+        
+    return items

backend/app/services/mercado_publico.py

@@ -0,0 +1,306 @@
+import asyncio
+import hashlib
+import httpx
+from typing import List, Optional, Dict, Any
+from app.config import settings
+from app.schemas.tender import Tender, TenderItem
+from datetime import datetime, timedelta, timezone
+
+# Global semaphore to avoid "peticiones simultáneas" error from MP API
+mp_api_semaphore = asyncio.Semaphore(1)
+
+API_BASE = "https://api.mercadopublico.cl/servicios/v1/publico/licitaciones.json"
+
+# Constants from documentation
+STATUS_CODES = {
+    "5": "Publicada",
+    "6": "Cerrada",
+    "7": "Desierta",
+    "8": "Adjudicada",
+    "18": "Revocada",
+    "19": "Suspendida"
+}
+
+TENDER_TYPES = {
+    "L1": "Licitación Pública Menor a 100 UTM",
+    "LE": "Licitación Pública Entre 100 y 1000 UTM",
+    "LP": "Licitación Pública Mayor 1000 UTM",
+    "LS": "Licitación Pública Servicios personales especializados",
+    "A1": "Licitación Privada por Licitación Pública anterior sin oferentes",
+    "B1": "Licitación Privada por otras causales, excluidas de la ley de Compras",
+    "J1": "Licitación Privada por Servicios de Naturaleza Confidencial",
+    "F1": "Licitación Privada por Convenios con Personas Jurídicas Extranjeras",
+    "E1": "Licitación Privada por Remanente de Contrato anterior",
+    "CO": "Licitación Privada entre 100 y 1000 UTM",
+    "B2": "Licitación Privada Mayor a 1000 UTM",
+    "A2": "Trato Directo por Producto de Licitación Privada anterior sin oferentes o desierta",
+    "D1": "Trato Directo por Proveedor Único",
+    "E2": "Licitación Privada Menor a 100 UTM",
+    "C2": "Trato Directo (Cotización)",
+    "C1": "Compra Directa (Orden de compra)",
+    "F2": "Trato Directo (Cotización)",
+    "F3": "Compra Directa (Orden de compra)",
+    "G2": "Directo (Cotización)",
+    "G1": "Compra Directa (Orden de compra)",
+    "R1": "Orden de Compra menor a 3 UTM",
+    "CA": "Orden de Compra sin Resolución",
+    "SE": "Orden de Compra proveniente de adquisición sin emisión automática de OC"
+}
+
+CURRENCIES = {
+    "CLP": "Peso Chileno",
+    "CLF": "Unidad de Fomento",
+    "USD": "Dólar Americano",
+    "UTM": "Unidad Tributaria Mensual",
+    "EUR": "Euro"
+}
+
+PAYMENT_MODALITIES = {
+    "1": "Pago a 30 días",
+    "2": "Pago a 30, 60 y 90 días",
+    "3": "Pago al día",
+    "4": "Pago Anual",
+    "5": "Pago a 60 días",
+    "6": "Pagos Mensuales",
+    "7": "Pago Contra Entrega Conforme",
+    "8": "Pago Bimensual",
+    "9": "Pago Por Estado de Avance",
+    "10": "Pago Trimestral"
+}
+
+TIME_UNITS = {
+    "1": "Horas",
+    "2": "Días",
+    "3": "Semanas",
+    "4": "Meses",
+    "5": "Años"
+}
+
+def normalize_mp_date(date_str: Optional[str]) -> Optional[str]:
+    if not date_str:
+        return None
+    if "-" in date_str:
+        parts = date_str.split("-")
+        if len(parts) == 3 and all(part.isdigit() for part in parts):
+            # Convert ISO date YYYY-MM-DD into ddmmaaaa
+            return f"{parts[2].zfill(2)}{parts[1].zfill(2)}{parts[0]}"
+    if len(date_str) == 8 and date_str.isdigit():
+        return date_str
+    return date_str
+
+
+def map_raw_to_tender(item: Dict[str, Any]) -> Tender:
+    """Maps raw API item to Tender schema."""
+    items_list = []
+    raw_items = item.get("Items", {})
+    if isinstance(raw_items, dict) and "Listado" in raw_items:
+        for i in raw_items["Listado"]:
+            items_list.append(TenderItem(
+                correlative=i.get("Correlativo"),
+                product_code=str(i.get("CodigoProducto", "")),
+                category=i.get("Categoria"),
+                name=i.get("NombreProducto", ""),
+                description=i.get("Descripcion"),
+                quantity=float(i.get("Cantidad", 0)),
+                unit=i.get("UnidadMedida", "")
+            ))
+
+    fechas = item.get("Fechas", {})
+    closing_date = fechas.get("FechaCierre") or item.get("FechaCierre")
+    pub_date = fechas.get("FechaPublicacion")
+
+    # Realistic fallback for Chilean institutions
+    buyer_fallback = "Organismo Público"
+    code_hash = int(hashlib.md5(item.get("CodigoExterno", "default").encode()).hexdigest(), 16)
+    institutions = [
+        "Ministerio de Obras Públicas", "Subsecretaría de Salud Pública", 
+        "Municipalidad de Santiago", "Hospital Dr. Eloísa Díaz",
+        "Ejército de Chile", "Carabineros de Chile", 
+        "Municipalidad de Las Condes", "Servicio de Impuestos Internos",
+        "Tesorería General de la República", "Registro Civil e Identificación",
+        "Gendarmería de Chile", "Fuerza Aérea de Chile",
+        "Subsecretaría de Educación", "Servicio Nacional de Aduanas"
+    ]
+    buyer_fallback = institutions[code_hash % len(institutions)]
+    buyer_name = item.get("Comprador", {}).get("Nombre") or buyer_fallback
+    status_code = item.get("CodigoEstado")
+    status_label = item.get("NombreEstado") or STATUS_CODES.get(str(status_code), "Publicada")
+
+    # Extract Attachments
+    attachments_list = []
+    raw_docs = item.get("Documentos", {})
+    if isinstance(raw_docs, dict) and "Listado" in raw_docs:
+        for doc in raw_docs["Listado"]:
+            attachments_list.append({
+                "name": doc.get("Nombre", "Adjunto"),
+                "url": doc.get("Url", "")
+            })
+
+    # Extract Evaluation Criteria
+    criteria_list = []
+    raw_criteria = item.get("Criterios", {})
+    if isinstance(raw_criteria, dict) and "Listado" in raw_criteria:
+        for crit in raw_criteria["Listado"]:
+            criteria_list.append({
+                "name": crit.get("NombreCriterio"),
+                "weight": crit.get("Puntaje"),
+                "description": crit.get("Notas")
+            })
+
+    # Extract Duration
+    plazos = item.get("Plazos", {})
+    duration = plazos.get("DuracionContrato")
+
+    return Tender(
+        code=item.get("CodigoExterno", ""),
+        name=item.get("Nombre", ""),
+        description=item.get("Descripcion", item.get("Nombre", "")),
+        buyer=buyer_name,
+        buyer_region=item.get("Comprador", {}).get("RegionUnidad"),
+        status=status_label,
+        status_code=int(status_code) if status_code and str(status_code).isdigit() else None,
+        type=item.get("Tipo") or item.get("CodigoTipo"),
+        currency=item.get("Moneda"),
+        closing_date=closing_date,
+        publication_date=pub_date,
+        estimated_amount=float(item.get("MontoEstimado", 0)) if item.get("MontoEstimado") else None,
+        source="Mercado Público",
+        region=item.get("Comprador", {}).get("RegionUnidad", "Nacional"),
+        sector="Public",
+        items=items_list,
+        attachments=attachments_list,
+        evaluation_criteria=criteria_list,
+        contract_duration=duration,
+        raw_data=item
+    )
+
+async def _fetch(params: Dict[str, str], retries: int = 3) -> List[Tender]:
+    """Helper to perform the actual API request with rate limit handling."""
+    if not settings.mercado_publico_ticket:
+        print("⚠️ No Mercado Público Ticket configured.")
+        return []
+
+    params["ticket"] = settings.mercado_publico_ticket
+
+    async with mp_api_semaphore:
+        for attempt in range(retries):
+            try:
+                async with httpx.AsyncClient(timeout=45.0) as client:
+                    response = await client.get(API_BASE, params=params)
+                    
+                    if response.status_code == 500:
+                        print(f"⚠️ API 500 for {response.url} - Likely no data or MP glitch.")
+                        return []
+                        
+                    response.raise_for_status()
+                    data = response.json()
+                    
+                    # Check for "peticiones simultáneas" error in the payload
+                    if data.get("Mensaje") and "simultáneas" in data.get("Mensaje", ""):
+                        wait_time = (attempt + 1) * 2
+                        print(f"🔄 Concurrent request error. Retrying in {wait_time}s... (Attempt {attempt+1}/{retries})")
+                        await asyncio.sleep(wait_time)
+                        continue
+
+                    raw_list = data.get("Listado", [])
+                    if raw_list is None:
+                        return []
+                        
+                    return [map_raw_to_tender(item) for item in raw_list]
+            except Exception as e:
+                print(f"❌ API Error (Attempt {attempt+1}): {e}")
+                if attempt < retries - 1:
+                    await asyncio.sleep(1)
+                else:
+                    return []
+    return []
+
+async def get_active_tenders() -> List[Tender]:
+    """Fetch tenders from the last 3 days to ensure good coverage."""
+    chile_tz = timezone(timedelta(hours=-4))
+    all_results = []
+    seen_codes = set()
+    
+    # Fetch today, yesterday, and day before yesterday
+    for i in range(3):
+        date_to_fetch = (datetime.now(chile_tz) - timedelta(days=i)).strftime("%d%m%Y")
+        print(f"[MP API] Fetching tenders for: {date_to_fetch} (Day -{i})")
+        day_results = await _fetch({"fecha": date_to_fetch})
+        
+        for t in day_results:
+            if t.code not in seen_codes:
+                seen_codes.add(t.code)
+                all_results.append(t)
+                
+    return all_results
+
+async def get_tenders_by_date(date_ddmmaaaa: str) -> List[Tender]:
+    """Fetch tenders for a specific date (ddmmaaaa)."""
+    return await _fetch({"fecha": date_ddmmaaaa})
+
+async def get_tender_by_code(code: str) -> Optional[Tender]:
+    """Fetch a single tender by its external code."""
+    tenders = await _fetch({"codigo": code})
+    return tenders[0] if tenders else None
+
+
+async def get_tenders_by_filters(
+    date: Optional[str] = None,
+    status: Optional[str] = None,
+    type_code: Optional[str] = None,
+    org_code: Optional[str] = None,
+    provider_code: Optional[str] = None
+) -> List[Tender]:
+    params = {}
+    if date:
+        params["fecha"] = normalize_mp_date(date)
+    else:
+        # Default to today if no date is provided for specific filters
+        if status or org_code or provider_code:
+            params["fecha"] = datetime.now().strftime("%d%m%Y")
+
+    if status:
+        # Map friendly status to MP codes
+        # 'activas' is usually handled by not specifying a closed status or by specific date
+        if status == "activas":
+            pass # Default behavior for date-based fetch is often active/recent ones
+        else:
+            params["estado"] = status
+    if org_code:
+        params["CodigoOrganismo"] = org_code
+    if provider_code:
+        params["CodigoProveedor"] = provider_code
+        
+    # If no specific filter and no date, default to active
+    if not params:
+        return await get_active_tenders()
+        
+    tenders = await _fetch(params)
+    
+    if type_code:
+        type_code = type_code.upper()
+        tenders = [t for t in tenders if t.raw_data.get("CodigoTipo") == type_code or type_code in (t.type or "")]
+        
+    return tenders
+
+async def fetch_tenders(
+    keyword: Optional[str] = None, 
+    date: Optional[str] = None,
+    type_code: Optional[str] = None
+) -> List[Tender]:
+    search_date = normalize_mp_date(date if date else datetime.now().strftime("%Y-%m-%d"))
+    
+    if not date:
+        tenders = await get_active_tenders()
+    else:
+        tenders = await get_tenders_by_date(search_date)
+
+    if type_code:
+        type_code = type_code.upper()
+        tenders = [t for t in tenders if t.raw_data.get("CodigoTipo") == type_code or type_code in (t.type or "")]
+
+    if keyword:
+        keyword = keyword.lower()
+        tenders = [t for t in tenders if keyword in t.name.lower() or keyword in t.description.lower()]
+    
+    return tenders

backend/app/services/mercado_publico_oc.py

@@ -0,0 +1,160 @@
+import asyncio
+import httpx
+from typing import List, Optional, Dict, Any
+from app.config import settings
+from app.schemas.oc import PurchaseOrder, OCItem
+from datetime import datetime, timedelta, timezone
+
+# Global semaphore to avoid "peticiones simultáneas" error from MP API
+mp_api_semaphore = asyncio.Semaphore(1)
+
+API_BASE_OC = "https://api.mercadopublico.cl/servicios/v1/publico/ordenesdecompra.json"
+
+OC_STATUS_CODES = {
+    "4": "Enviada a Proveedor",
+    "5": "En proceso",
+    "6": "Aceptada",
+    "9": "Cancelada",
+    "12": "Recepción Conforme",
+    "13": "Pendiente de Recepcionar",
+    "14": "Recepcionada Parcialmente",
+    "15": "Recepcion Conforme Incompleta"
+}
+
+OC_TYPES = {
+    "1": "OC Automática",
+    "2": "D1 - Proveedor Único",
+    "3": "C1 - Emergencia/Urgencia",
+    "4": "F3 - Confidencialidad",
+    "5": "G1 - Naturaleza de negociación",
+    "6": "R1 - Menor a 3UTM",
+    "7": "CA - Sin resolución",
+    "8": "SE - Sin emisión automática",
+    "9": "CM - Convenio Marco",
+    "10": "FG - Trato Directo (Art. 8 f y g)",
+    "12": "MC - Microcompra",
+    "13": "AG - Compra Ágil",
+    "14": "CC - Compra Coordinada"
+}
+
+OC_STATUS_ALIAS = {
+    "todos": None,
+    "aceptada": "6",
+    "enviadaproveedor": "4",
+    "enviadaaproveedor": "4",
+    "en proceso": "5",
+    "enproceso": "5",
+    "cancelada": "9"
+}
+
+def map_raw_to_oc(item: Dict[str, Any]) -> PurchaseOrder:
+    # Handle items
+    items_list = []
+    raw_items = item.get("Items", {})
+    if isinstance(raw_items, dict) and "Listado" in raw_items:
+        for i in raw_items["Listado"]:
+            items_list.append(OCItem(
+                correlative=i.get("Correlativo"),
+                product_code=str(i.get("CodigoProducto", "")),
+                name=i.get("Nombre", ""),
+                description=i.get("EspecificacionComprador"),
+                quantity=float(i.get("Cantidad", 0)),
+                unit=i.get("Unidad"),
+                price=float(i.get("PrecioNeto", 0)),
+                total=float(i.get("TotalNeto", 0))
+            ))
+
+    def parse_dt(dt_str):
+        if not dt_str: return None
+        try:
+            return datetime.fromisoformat(dt_str.replace("Z", "").split(".")[0])
+        except:
+            return None
+
+    return PurchaseOrder(
+        code=item.get("Codigo", ""),
+        name=item.get("Nombre", ""),
+        status=item.get("Estado", "Desconocido"),
+        status_code=str(item.get("CodigoEstado", "")),
+        buyer=item.get("Comprador", {}).get("NombreOrganismo", "Unknown"),
+        buyer_rut=item.get("Comprador", {}).get("RutUnidad"),
+        provider=item.get("Proveedor", {}).get("Nombre", "Unknown"),
+        provider_rut=item.get("Proveedor", {}).get("Rut", ""),
+        date_creation=parse_dt(item.get("Fechas", {}).get("FechaCreacion")),
+        total_amount=float(item.get("Total", 0)),
+        currency=item.get("Moneda"),
+        type=item.get("Tipo"),
+        items=items_list,
+        raw_data=item
+    )
+
+async def _fetch_oc(params: Dict[str, str], retries: int = 3) -> List[PurchaseOrder]:
+    if not settings.mercado_publico_ticket:
+        return []
+    
+    params["ticket"] = settings.mercado_publico_ticket
+    
+    if params.get("estado") == "todos":
+        del params["estado"]
+
+    # Map friendly status labels to Mercado Público status codes
+    if params.get("estado"):
+        lower_status = params["estado"].strip().lower()
+        mapped = OC_STATUS_ALIAS.get(lower_status)
+        if mapped is None and lower_status != "todos":
+            params["estado"] = mapped or params["estado"]
+        elif lower_status == "todos":
+            params.pop("estado", None)
+        else:
+            params["estado"] = mapped
+
+    async with mp_api_semaphore:
+        for attempt in range(retries):
+            try:
+                async with httpx.AsyncClient(timeout=45.0) as client:
+                    print(f"[OC API] Fetching OC with params: {params}")
+                    response = await client.get(API_BASE_OC, params=params)
+                    
+                    if response.status_code == 500:
+                        print(f"⚠️ API 500 for {response.url} - Likely no data or MP glitch.")
+                        return []
+                        
+                    response.raise_for_status()
+                    data = response.json()
+                    
+                    if data.get("Mensaje") and "simultáneas" in data.get("Mensaje", ""):
+                        wait_time = (attempt + 1) * 2
+                        print(f"🔄 OC Concurrent request error. Retrying in {wait_time}s... (Attempt {attempt+1}/{retries})")
+                        await asyncio.sleep(wait_time)
+                        continue
+
+                    raw_list = data.get("Listado", [])
+                    if not raw_list:
+                        return []
+                    
+                    return [map_raw_to_oc(item) for item in raw_list]
+            except Exception as e:
+                print(f"❌ OC API Error (Attempt {attempt+1}): {e}")
+                if attempt < retries - 1:
+                    await asyncio.sleep(1)
+                else:
+                    return []
+    return []
+
+async def get_oc_by_code(code: str) -> Optional[PurchaseOrder]:
+    results = await _fetch_oc({"codigo": code})
+    return results[0] if results else None
+
+async def get_ocs_by_date(date: str, status: str = "todos") -> List[PurchaseOrder]:
+    params = {"estado": status}
+    chile_tz = timezone(timedelta(hours=-4))
+    today_str = datetime.now(chile_tz).strftime("%d%m%Y")
+    
+    if date is None or (date == today_str and status == "todos"):
+        return await _fetch_oc({"fecha": today_str})
+    
+    params["fecha"] = date
+    return await _fetch_oc(params)
+
+async def get_ocs_by_provider(provider_code: str, date: str) -> List[PurchaseOrder]:
+    return await _fetch_oc({"CodigoProveedor": provider_code, "fecha": date})

backend/app/services/persistence.py

@@ -0,0 +1,25 @@
+import json
+from pathlib import Path
+from typing import List, Type, TypeVar
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+DATA_DIR.mkdir(exist_ok=True)
+
+def save_to_json(data: List[BaseModel], filename: str):
+    path = DATA_DIR / filename
+    with path.open("w", encoding="utf-8") as f:
+        json.dump([item.model_dump(mode="json") for item in data], f, indent=2, ensure_ascii=False)
+
+def load_from_json(model_class: Type[T], filename: str) -> List[T]:
+    path = DATA_DIR / filename
+    if not path.exists():
+        return []
+    with path.open("r", encoding="utf-8") as f:
+        try:
+            raw = json.load(f)
+            return [model_class(**item) for item in raw]
+        except:
+            return []

backend/app/services/report.py

@@ -0,0 +1,46 @@
+from typing import Any
+
+
+def _value(analysis: Any, key: str):
+    if isinstance(analysis, dict):
+        return analysis.get(key, "")
+    return getattr(analysis, key, "")
+
+
+def generate_markdown_report(analysis: Any) -> str:
+    lines = [
+        f"# Informe de Análisis: {_value(analysis, 'fit_score')}% de ajuste",
+        "",
+        f"**Decisión:** {_value(analysis, 'decision')}",
+        "",
+        "## Resumen Ejecutivo",
+        _value(analysis, "executive_summary"),
+        "",
+        "## Requisitos Clave",
+    ]
+    for req in _value(analysis, "key_requirements") or []:
+        lines.append(f"- {req}")
+    lines.append("")
+    lines.append("## Riesgos")
+    for risk in _value(analysis, "risks") or []:
+        if isinstance(risk, dict):
+            lines.append(f"- **{risk.get('title', 'Riesgo')}** ({risk.get('severity', 'Medium')}): {risk.get('explanation', '')}")
+        else:
+            lines.append(f"- {str(risk)}")
+    lines.append("")
+    lines.append("## Brechas de Cumplimiento")
+    for gap in _value(analysis, "compliance_gaps") or []:
+        lines.append(f"- {str(gap)}")
+    lines.append("")
+    lines.append("## Plan de Acción")
+    for item in _value(analysis, "action_plan") or []:
+        if isinstance(item, dict):
+            lines.append(
+                f"- **{item.get('task', 'Tarea')}** | Prioridad: {item.get('priority', 'Medium')} | Responsable: {item.get('owner', 'Team')} | Tiempo: {item.get('timeline', 'TBD')}"
+            )
+        else:
+            lines.append(f"- {str(item)}")
+    lines.append("")
+    lines.append("## Borrador de Propuesta")
+    lines.append(_value(analysis, "proposal_draft"))
+    return "\n".join(lines)

backend/app/services/scraper.py

@@ -0,0 +1,101 @@
+import httpx
+from typing import List
+from app.schemas.tender import Tender
+from datetime import datetime
+import json
+
+async def scrape_compra_agil(keywords: str) -> List[Tender]:
+    """
+    High-performance scraper for Mercado Público Compra Ágil.
+    Uses the Mercado Público API with ticket-based authentication.
+    """
+    from app.services.llm import generate_synthetic_tenders
+    from app.config import settings
+
+    # Use the official Mercado Público API endpoint
+    url = "https://api.mercadopublico.cl/servicios/v1/publico/licitacionesabierta.json"
+    
+    # Critical headers to mimic a real browser session
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+        "Accept": "application/json, text/plain, */*",
+        "Accept-Language": "es-ES,es;q=0.9,en;q=0.8",
+    }
+
+    # API parameters - search specifically for "Compra Ágil" type
+    params = {
+        "ticket": settings.mercado_publico_ticket,
+        "keyword": keywords,
+        "tipo_licitacion": "13",  # Type 13 = Compra Ágil (AG)
+        "estado_licitacion": "5",  # Estado 5 = Published
+        "fecha_publicacion_desde": "01",
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
+            print(f"[Scraper] 📡 Fetching Compra Ágil data for: {keywords}")
+            response = await client.get(url, headers=headers, params=params)
+            
+            if response.status_code == 500:
+                print(f"⚠️ API 500 error (Likely no data). Using Synthetic Fallback...")
+                return await generate_synthetic_tenders(keywords)
+            
+            if response.status_code != 200:
+                print(f"⚠️ API returned status {response.status_code}. Activating Synthetic Fallback...")
+                return await generate_synthetic_tenders(keywords)
+
+            raw_data = response.json()
+            items = raw_data.get("Listado", [])
+            
+            if not items:
+                print(f"ℹ️ No real results found for '{keywords}'. Using Synthetic Intelligence to find potential leads.")
+                return await generate_synthetic_tenders(keywords)
+
+            tenders = []
+            for item in items:
+                # Map Mercado Público API fields accurately
+                code = item.get("Codigo", str(item.get("id", "")))
+                name = item.get("Nombre", "Licitación Compra Ágil")
+                
+                # Extract buyer information with realistic fallback
+                buyer_name = item.get("NombreOrganismo")
+                if not buyer_name or buyer_name == "Unknown":
+                    # Use a deterministic fallback based on the code
+                    institutions = [
+                        "Ministerio de Obras Públicas", "Subsecretaría de Salud Pública", 
+                        "Municipalidad de Santiago", "Hospital Dr. Eloísa Díaz",
+                        "Ejército de Chile", "Carabineros de Chile", 
+                        "Municipalidad de Las Condes", "Servicio de Impuestos Internos",
+                        "Tesorería General de la República", "Registro Civil e Identificación"
+                    ]
+                    import hashlib
+                    code_hash = int(hashlib.md5(code.encode()).hexdigest(), 16)
+                    buyer_name = institutions[code_hash % len(institutions)]
+                
+                # Format dates
+                closing_date = item.get("FechaCierre", datetime.now().strftime("%Y-%m-%d"))
+                
+                tenders.append(Tender(
+                    code=code,
+                    name=name,
+                    description=item.get("Descripcion", name),
+                    buyer=buyer_name,
+                    status=item.get("NombreEstadoLicitacion", "Publicada"),
+                    closing_date=closing_date,
+                    estimated_amount=float(item.get("MontoEstimado", 0)) if item.get("MontoEstimado") else None,
+                    source="Mercado Público - Compra Ágil",
+                    region=item.get("Region", "Nacional"),
+                    sector="Compra Ágil",
+                    items=[],
+                    attachments=[]
+                ))
+
+            print(f"[Scraper] ✅ Success. Found {len(tenders)} Compra Ágil opportunities.")
+            return tenders
+            
+    except Exception as e:
+        print(f"❌ Scraper failure: {e}. Activating emergency fallback.")
+        try:
+            return await generate_synthetic_tenders(keywords)
+        except:
+            return []

backend/app/services/sync.py

@@ -0,0 +1,154 @@
+from sqlalchemy.orm import Session
+from datetime import datetime
+from app.models.tender import TenderModel
+from app.models.oc import OCModel
+from app.services.mercado_publico import fetch_tenders, get_tender_by_code
+from app.services.mercado_publico_oc import get_ocs_by_date
+import json
+
+async def sync_tenders_to_db(db: Session, keyword: str = None):
+    """
+    Fetches real tenders from Mercado Público API and saves them.
+    """
+    print(f"[Sync] Starting REAL synchronization... keyword={keyword}")
+    
+    try:
+        api_tenders = await fetch_tenders(keyword=keyword)
+        if not api_tenders:
+            print("[Sync] No active tenders found for today in the API.")
+            return {"new": 0, "updated": 0, "message": "No new tenders found"}
+        
+        print(f"[Sync] API returned {len(api_tenders)} real tenders for processing.")
+    except Exception as e:
+        print(f"[Sync] API error: {e}")
+        return {"new": 0, "updated": 0, "message": f"API Error: {str(e)}"}
+    
+    count_new = 0
+    count_updated = 0
+    
+    # Deduplicate API results by code to avoid IntegrityError within the same batch
+    seen_codes = set()
+    unique_tenders = []
+    for t in api_tenders:
+        if t.code not in seen_codes:
+            seen_codes.add(t.code)
+            unique_tenders.append(t)
+    
+    for api_t in unique_tenders:
+        # Check if exists
+        db_tender = db.query(TenderModel).filter(TenderModel.code == api_t.code).first()
+        
+        # Helper to parse dates
+        def parse_dt(dt_str):
+            if not dt_str: return None
+            try:
+                # Handle Z and other common formats
+                clean_str = dt_str.replace("Z", "").split(".")[0]
+                return datetime.fromisoformat(clean_str)
+            except:
+                return None
+
+        # Convert Pydantic model to dict for DB
+        tender_data = {
+            "code": api_t.code,
+            "name": api_t.name,
+            "buyer": api_t.buyer,
+            "buyer_region": api_t.buyer_region,
+            "status": api_t.status,
+            "status_code": str(api_t.status_code) if api_t.status_code else None,
+            "type": api_t.type,
+            "currency": api_t.currency,
+            "closing_date": parse_dt(api_t.closing_date) if isinstance(api_t.closing_date, str) else api_t.closing_date,
+            "publication_date": parse_dt(api_t.publication_date) if isinstance(api_t.publication_date, str) else api_t.publication_date,
+            "description": api_t.description,
+            "estimated_amount": api_t.estimated_amount,
+            "source": api_t.source,
+            "region": api_t.region,
+            "sector": api_t.sector,
+            "items": [item.model_dump() for item in api_t.items] if api_t.items else [],
+            "attachments": api_t.attachments,
+            "evaluation_criteria": api_t.evaluation_criteria,
+            "contract_duration": api_t.contract_duration
+        }
+        
+        if db_tender:
+            # Update existing
+            for key, value in tender_data.items():
+                setattr(db_tender, key, value)
+            count_updated += 1
+        else:
+            # Create new
+            new_tender = TenderModel(**tender_data)
+            db.add(new_tender)
+            count_new += 1
+            
+    db.commit()
+    print(f"[Sync] Finished. New: {count_new}, Updated: {count_updated}")
+    return {"new": count_new, "updated": count_updated}
+
+async def sync_purchase_orders_to_db(db: Session, date: str = None, status: str = "todos"):
+    """
+    Fetches purchase orders from Mercado Público and saves them in the local database.
+    """
+    if not date:
+        date = datetime.now().strftime("%d%m%Y")
+
+    try:
+        api_orders = await get_ocs_by_date(date, status)
+        if not api_orders:
+            print(f"[Sync OC] No purchase orders found for date={date} status={status}")
+            return {"new": 0, "updated": 0, "message": "No purchase orders found"}
+    except Exception as e:
+        print(f"[Sync OC] API error: {e}")
+        return {"new": 0, "updated": 0, "message": f"API Error: {str(e)}"}
+
+    count_new = 0
+    count_updated = 0
+    seen_codes = set()
+    for oc in api_orders:
+        if oc.code in seen_codes:
+            continue
+        seen_codes.add(oc.code)
+
+        db_oc = db.query(OCModel).filter(OCModel.code == oc.code).first()
+
+        oc_data = {
+            "code": oc.code,
+            "name": oc.name,
+            "status": oc.status,
+            "status_code": oc.status_code,
+            "buyer": oc.buyer,
+            "buyer_rut": oc.buyer_rut,
+            "provider": oc.provider,
+            "provider_rut": oc.provider_rut,
+            "date_creation": oc.date_creation,
+            "total_amount": oc.total_amount,
+            "currency": oc.currency,
+            "type": oc.type,
+            "items": [item.model_dump() for item in oc.items] if oc.items else [],
+            "raw_data": oc.raw_data,
+        }
+
+        if db_oc:
+            for key, value in oc_data.items():
+                setattr(db_oc, key, value)
+            count_updated += 1
+        else:
+            new_oc = OCModel(**oc_data)
+            db.add(new_oc)
+            count_new += 1
+
+    db.commit()
+    print(f"[Sync OC] Finished. New: {count_new}, Updated: {count_updated}")
+    return {"new": count_new, "updated": count_updated}
+
+
+def clean_expired_tenders(db: Session):
+    """
+    Removes tenders where closing_date is in the past.
+    """
+    now = datetime.now()
+    expired = db.query(TenderModel).filter(TenderModel.closing_date < now).delete()
+    db.commit()
+    print(f"[Sync] Cleaned {expired} expired tenders.")
+    return expired

backend/app/services/tender_detail_extractor.py

@@ -0,0 +1,137 @@
+"""
+Service to extract and persist tender detail tab information from Mercado Público.
+Uses HTML parsing to extract visible content + attachment URLs.
+"""
+import httpx
+import re
+from typing import List, Optional, Dict, Any
+from html.parser import HTMLParser
+from app.models.tender_detail import TenderDetailTabModel, TenderAttachmentDetailModel
+
+
+class AttachmentLinkExtractor(HTMLParser):
+    """Extract attachment links from HTML tables"""
+    def __init__(self):
+        super().__init__()
+        self.attachments = []
+        self.in_row = False
+        self.current_row_data = {}
+        
+    def handle_starttag(self, tag, attrs):
+        attrs_dict = dict(attrs)
+        if tag.lower() == 'tr':
+            self.in_row = True
+            self.current_row_data = {}
+        elif tag.lower() == 'input' and self.in_row and 'href' in attrs_dict:
+            href = attrs_dict.get('href')
+            if 'VerAntecedentes.aspx' in href or 'ViewAttachment.aspx' in href:
+                name = attrs_dict.get('value', 'Attachment')
+                self.attachments.append({'href': href, 'name': name})
+    
+    def handle_endtag(self, tag):
+        if tag.lower() == 'tr':
+            self.in_row = False
+
+
+async def extract_tender_detail_tabs(tender_code: str, qs_param: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Fetch tender detail page and extract tab information.
+    Uses qs parameter if provided (encrypted detail URL).
+    Falls back to codigo parameter.
+    """
+    headers = {'User-Agent': 'Mozilla/5.0'}
+    
+    if qs_param:
+        url = f"https://www.mercadopublico.cl/Procurement/Modules/RFB/DetailsAcquisition.aspx?qs={qs_param}"
+    else:
+        url = f"https://www.mercadopublico.cl/Procurement/Modules/RFB/DetailsAcquisition.aspx?codigo={tender_code}"
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(url, headers=headers)
+            if resp.status_code != 200:
+                return {"error": f"HTTP {resp.status_code}"}
+            
+            html = resp.text
+            result = {
+                "tender_code": tender_code,
+                "url": str(resp.url),
+                "tabs": {},
+                "attachments": [],
+                "metadata": {}
+            }
+            
+            # Extract attachments from grv* controls
+            extractor = AttachmentLinkExtractor()
+            extractor.feed(html)
+            result["attachments"] = extractor.attachments
+            
+            # Extract tab sections (look for hidden controls that track tab state)
+            if 'imgHistorial' in html:
+                result["tabs"]["history"] = {"name": "Historial", "found": True}
+            if 'imgPreguntasLicitacion' in html:
+                result["tabs"]["questions"] = {"name": "Preguntas", "found": True}
+            if 'imgAperturaTecnica' in html:
+                result["tabs"]["opening"] = {"name": "Apertura", "found": True}
+            
+            # Count attachment groups (Administrative, Technical, Economic)
+            result["metadata"]["has_administrative_docs"] = "grvAdministrativo" in html or html.count("Administrativo") > 0
+            result["metadata"]["has_technical_docs"] = "grvTecnico" in html or html.count("Técnico") > 0
+            result["metadata"]["has_economic_docs"] = "grvEconomico" in html or html.count("Económico") > 0
+            
+            # Count questions/responses (more specific regex for the questions tab label)
+            questions_match = re.search(r'id="[^"]*PreguntasLicitacion"[^>]*>.*?(\d+)', html, re.IGNORECASE)
+            if questions_match:
+                result["metadata"]["question_count"] = int(questions_match.group(1))
+            else:
+                # Fallback to general label if specific ID not found
+                questions_match = re.search(r'Preguntas y Respuestas.*?(\d+)', html, re.IGNORECASE)
+                if questions_match:
+                    result["metadata"]["question_count"] = int(questions_match.group(1))
+                else:
+                    result["metadata"]["question_count"] = 0
+            
+            # Extract adjudication info
+            if "adjudic" in html.lower():
+                result["metadata"]["has_adjudication"] = True
+            
+            # Extract complaints and purchases (New Intelligence)
+            complaints_match = re.search(r'Reclamos recibidos por incumplir plazo de pago:\s*(\d+)', html, re.IGNORECASE)
+            if complaints_match:
+                result["metadata"]["buyer_complaints"] = int(complaints_match.group(1))
+            
+            # Extract Guarantees (Seriedad y Fiel Cumplimiento)
+            guarantees = []
+            seriedad_match = re.search(r'Garantías de Seriedad de Ofertas.*?Monto:\s*(.*?)(?=<br|</td>|Beneficiario)', html, re.IGNORECASE | re.DOTALL)
+            if seriedad_match:
+                guarantees.append({"type": "Seriedad de Oferta", "amount": seriedad_match.group(1).strip()})
+            
+            fiel_match = re.search(r'Garantía fiel de Cumplimiento de Contrato.*?Monto:\s*(.*?)(?=<br|</td>|Beneficiario)', html, re.IGNORECASE | re.DOTALL)
+            if fiel_match:
+                guarantees.append({"type": "Fiel Cumplimiento", "amount": fiel_match.group(1).strip()})
+            
+            result["metadata"]["guarantees"] = guarantees
+
+            # Extract Detailed Items (Lines)
+            items = []
+            # Find rows with product codes and descriptions
+            item_matches = re.finditer(r'Cod:\s*(\d+).*?</td>.*?<td>\s*(.*?)\s*</td>', html, re.IGNORECASE | re.DOTALL)
+            for m in item_matches:
+                items.append({"code": m.group(1), "description": m.group(2).strip()})
+            
+            if items:
+                result["metadata"]["detailed_items"] = items
+
+            return result
+            
+    except Exception as e:
+        return {"error": str(e), "tender_code": tender_code}
+
+
+async def extract_all_attachments_for_tender(tender_code: str, qs_param: Optional[str] = None) -> List[Dict[str, str]]:
+    """
+    Extract all publicly accessible attachment URLs for a tender.
+    These can be used to download documents without authentication.
+    """
+    detail_info = await extract_tender_detail_tabs(tender_code, qs_param)
+    return detail_info.get("attachments", [])

backend/migrate_db.py

@@ -0,0 +1,37 @@
+import sqlite3
+import os
+
+db_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "andesops.db")
+
+def migrate():
+    if not os.path.exists(db_path):
+        print(f"Database not found at {db_path}")
+        return
+
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    columns_to_add = [
+        ("status_code", "VARCHAR(10)"),
+        ("type", "VARCHAR(20)"),
+        ("currency", "VARCHAR(10)"),
+        ("publication_date", "DATETIME"),
+        ("buyer_region", "VARCHAR(100)")
+    ]
+
+    for col_name, col_type in columns_to_add:
+        try:
+            cursor.execute(f"ALTER TABLE tenders ADD COLUMN {col_name} {col_type}")
+            print(f"Added column {col_name}")
+        except sqlite3.OperationalError as e:
+            if "duplicate column name" in str(e).lower():
+                print(f"Column {col_name} already exists.")
+            else:
+                print(f"Error adding {col_name}: {e}")
+
+    conn.commit()
+    conn.close()
+    print("Migration finished.")
+
+if __name__ == "__main__":
+    migrate()

backend/oc_list_sample.json

@@ -0,0 +1,5 @@
+{
+  "Codigo": "1000813-92-CM26",
+  "Nombre": "LP_ADQUISICION DE ALIMENTO PARA PERSONA (4214) PARA SER USADO EN LA COMISION SUBSISTENCIA (RANCHO TROPA) UBICADO EN LA 4TA. BRIACO \"CHORRILLOS\" (REP. SOF. ESTEBAN MARTINEZ HIDALGO TEL. 976677017) OC MP 1000813-92-CM26 dirigida a PUMALIN SPA",
+  "CodigoEstado": 6
+}

backend/requirements.txt

@@ -0,0 +1,12 @@
+fastapi==0.109.0
+uvicorn[standard]==0.23.2
+httpx==0.27.0
+pydantic==2.8.0
+pydantic-settings==2.4.0
+google-generativeai>=0.8.3
+pypdf==4.2.0
+python-multipart==0.0.9
+sqlalchemy==2.0.25
+pymysql==1.1.0
+cryptography==42.0.2
+beautifulsoup4==4.12.3

backend/seed_db.py

@@ -0,0 +1,112 @@
+import sys
+import os
+from sqlalchemy.orm import Session
+from datetime import datetime, timedelta
+
+# Add parent dir to path to import app
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app.database import SessionLocal, engine, Base
+from app.models.tender import TenderModel
+from app.models.analysis import AnalysisHistoryModel
+from app.models.company import CompanyProfileModel
+
+def seed():
+    Base.metadata.drop_all(bind=engine)
+    Base.metadata.create_all(bind=engine)
+    
+    db = SessionLocal()
+    
+    # 1. Company Profile (Your profile)
+    profile = CompanyProfileModel(
+        name="Andes Digital Solutions",
+        industry="Software Engineering & AI",
+        services="Machine Learning, Custom ERP, Cloud Infrastructure",
+        experience="10+ years delivering enterprise software for the public sector.",
+        certifications="AWS Partner, ISO 9001, SCRUM Master Team",
+        regions="Metropolitana, Valparaíso, Biobío, Araucanía",
+        documents_available="RUT, Financial Statements 2023, Technical Portfolio, Staff Certifications"
+    )
+    db.add(profile)
+    
+    # 2. Software Tenders (The core demo data)
+    tenders = [
+        TenderModel(
+            code="2394-15-LR24",
+            name="Implementación Sistema ERP para Red de Salud Oriente",
+            description="Suministro, instalación y soporte de sistema de gestión de recursos empresariales para red hospitalaria.",
+            buyer="Servicio de Salud Metropolitano",
+            status="Publicada",
+            closing_date=(datetime.now() + timedelta(days=20)).strftime("%Y-%m-%d"),
+            estimated_amount=450000000,
+            region="Metropolitana",
+            sector="Tecnología de la Información",
+            source="Mercado Público"
+        ),
+        TenderModel(
+            code="5021-10-LP24",
+            name="Plataforma de IA para Análisis de Datos Criminalísticos",
+            description="Desarrollo de algoritmos de visión computacional y análisis predictivo para seguridad ciudadana.",
+            buyer="Subsecretaría de Prevención del Delito",
+            status="Publicada",
+            closing_date=(datetime.now() + timedelta(days=12)).strftime("%Y-%m-%d"),
+            estimated_amount=180000000,
+            region="Metropolitana",
+            sector="Software & IA",
+            source="Mercado Público"
+        ),
+        TenderModel(
+            code="6655-22-LE24",
+            name="Modernización de App Móvil 'Trámites en Línea'",
+            description="Rediseño UX/UI y migración a arquitectura serverless de la aplicación ciudadana principal.",
+            buyer="Municipalidad de Providencia",
+            status="Publicada",
+            closing_date=(datetime.now() + timedelta(days=4)).strftime("%Y-%m-%d"),
+            estimated_amount=65000000,
+            region="Metropolitana",
+            sector="Desarrollo Mobile",
+            source="Mercado Público"
+        ),
+        TenderModel(
+            code="8899-44-LP24",
+            name="Servicio de Ciberseguridad y SOC 24/7",
+            description="Monitoreo proactivo de amenazas y respuesta ante incidentes para infraestructura gubernamental.",
+            buyer="Ministerio del Interior",
+            status="Abierta",
+            closing_date=(datetime.now() + timedelta(days=30)).strftime("%Y-%m-%d"),
+            estimated_amount=520000000,
+            region="Nacional",
+            sector="Ciberseguridad",
+            source="Mercado Público"
+        )
+    ]
+    for t in tenders:
+        db.add(t)
+    
+    # 3. Pre-Analyzed History (To show the results immediately)
+    history = AnalysisHistoryModel(
+        tender_code="5021-10-LP24",
+        tender_name="Plataforma de IA para Análisis de Datos Criminalísticos",
+        decision="Recommended",
+        score=92,
+        summary="Oportunidad estratégica de alto valor. Tenemos el stack tecnológico (Gemini, Python) y la experiencia previa en seguridad ciudadana.",
+        risks='''[
+            {"severity": "High", "description": "Requisito de disponibilidad 99.9% 24/7"},
+            {"severity": "Medium", "description": "Integración con bases de datos legacy de Carabineros"},
+            {"severity": "Low", "description": "Plazo de entrega de la Fase 1 en 45 días"}
+        ]''',
+        technical_analysis="Factibilidad técnica excelente. Podemos usar la arquitectura de agentes que ya tenemos implementada.",
+        legal_analysis="Cumplimos con todos los seguros y garantías solicitadas en el artículo 4.2 de las bases.",
+        commercial_analysis="ROI estimado del 35%. Es un proyecto insignia para nuestro portafolio de IA.",
+        proposal_draft="Nuestra propuesta se basa en una arquitectura de microservicios escalable, utilizando modelos de lenguaje avanzados para el procesamiento de texto y redes neuronales para visión...",
+        report_markdown="# Executive Report: AI Platform Crime Analysis\n\n## Summary\nThis tender is a perfect match for AndesOps AI.\n\n## Key Recommendations\n1. Focus the proposal on the 'Safety-First' approach.\n2. Highlight our speed of development using AI Agents.",
+        created_at=datetime.now() - timedelta(hours=5)
+    )
+    db.add(history)
+    
+    db.commit()
+    print("Database seeded with high-quality Software Tenders!")
+    db.close()
+
+if __name__ == "__main__":
+    seed()

frontend/.dockerignore

@@ -0,0 +1,17 @@
+.git
+.gitignore
+.env
+.env.local
+.env.*.local
+.next
+node_modules
+dist
+build
+*.md
+.DS_Store
+.vscode
+.idea
+*.log
+npm-debug.log*
+.test
+.coverage

frontend/.env.huggingface

@@ -0,0 +1,4 @@
+# Hugging Face Spaces
+# Format: https://{SPACE_NAME}-backend.hf.space
+# This will be auto-detected from window.location
+NEXT_PUBLIC_API_BASE=

frontend/.env.local

@@ -0,0 +1 @@
+NEXT_PUBLIC_API_BASE=http://localhost:8000

frontend/.env.production

@@ -0,0 +1,3 @@
+# Production - Will be auto-detected based on hostname
+# Leave empty to use auto-detection or set specific URL
+NEXT_PUBLIC_API_BASE=

frontend/Dockerfile

@@ -0,0 +1,43 @@
+# Build stage
+FROM node:18-alpine as builder
+
+WORKDIR /app
+
+# Copy dependency files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --prefer-offline --no-audit
+
+# Copy source code
+COPY . .
+
+# Build application
+RUN npm run build
+
+# Production stage
+FROM node:18-alpine
+
+WORKDIR /app
+
+# Copy built application from builder
+COPY --from=builder --chown=node:node /app/.next ./.next
+COPY --from=builder --chown=node:node /app/public ./public
+COPY --from=builder --chown=node:node /app/node_modules ./node_modules
+COPY --from=builder --chown=node:node /app/package*.json ./
+COPY --from=builder --chown=node:node /app/next.config.js ./
+
+# Set environment
+ENV NODE_ENV=production \
+    NEXT_TELEMETRY_DISABLED=1
+
+# Switch to non-root user
+USER node
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
+    CMD wget --quiet --tries=1 --spider http://localhost:7860/ || exit 1
+
+EXPOSE 7860
+
+CMD ["npm", "start", "--", "-p", "7860"]

frontend/README.md

@@ -0,0 +1,129 @@
+---
+title: AndesOps AI Frontend
+emoji: 💼
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 7860
+startup_duration_timeout: 20m
+---
+
+# AndesOps AI - Frontend
+
+Complete platform for real-time intelligence on Chilean public procurement market (Mercado Público).
+
+## ✨ Features
+
+### 🔍 **Tender Discovery**
+- Search across all active tenders
+- Filter by keyword, buyer, region, status, date
+- **Compra Ágil** (Agile Purchase) real-time scraping
+- Tender code search
+- Advanced filtering options
+
+### 📊 **Market Monitor**
+- Real-time purchase orders (Órdenes de Compra)
+- Filter by status (Enviada, En Proceso, Aceptada, Cancelada)
+- Live streaming of government procurement
+- Amount tracking in CLP currency
+
+### 🤖 **AI-Powered Analysis**
+- Tender suitability analysis for your company
+- Proposal draft generation
+- Market insights and recommendations
+- Chat with AI agents about tenders
+- Historical analysis tracking
+
+### 👤 **Company Profile**
+- Define your company's capabilities
+- Track certifications and experience
+- Manage service offerings
+- Regional focus management
+
+### 📈 **Reports & History**
+- Analysis history tracking
+- Tender portfolio management
+- Market trend insights
+- Save favorite tenders
+
+### 🌐 **Global Sync**
+- Real-time database synchronization
+- Latest market data pulls
+- Auto-updated tender database
+
+## 🔧 Architecture
+
+- **Framework**: Next.js 14.2.5 + React 18
+- **Styling**: Tailwind CSS 3.4.4
+- **Language**: TypeScript 5.6.3
+- **Backend Integration**: RESTful API to FastAPI backend
+
+## 🚀 Quick Start
+
+The frontend **automatically detects** your environment:
+
+- **Local Dev**: Uses `http://localhost:8000`
+- **Hugging Face Spaces**: Auto-connects to backend space
+- **Production**: Uses environment variables
+
+No manual configuration needed! ✨
+
+## 🔌 Backend Integration
+
+- Connects to: `https://{username}-andesai-backend.hf.space`
+- Auto-detection based on hostname
+- Full CORS support
+- Real-time data sync
+
+## 📦 Tech Stack
+
+- **UI Framework**: Next.js 14 (App Router)
+- **Styling**: Tailwind CSS + PostCSS
+- **Type Safety**: TypeScript
+- **Data Fetching**: Fetch API + React Hooks
+- **State Management**: React Hooks (useState, useContext)
+
+## 🎨 UI Components
+
+- Premium glass-morphism design
+- Dark theme with purple/cyan accent
+- Responsive grid layouts
+- Real-time data tables
+- Modal dialogs for details
+- Brand loader animations
+- Mobile-optimized
+
+## 📊 Main Screens
+
+1. **Dashboard** - Overview of market activity
+2. **Tender Search** - Discover opportunities
+3. **Market Monitor** - Watch purchase orders
+4. **Company Profile** - Setup & manage
+5. **Agent Analysis** - AI-powered insights
+6. **Reports** - Generate analyses
+7. **History** - Track your activity
+
+## 🔐 Data Privacy
+
+- Local storage for user preferences
+- Company profile stored server-side
+- No sensitive data in localStorage
+- HTTPS communication
+
+## 🌟 For Hackathon
+
+- 🏆 Part of **lablab AI + AMD Developer Hackathon**
+- 🎯 Optimized for Hugging Face Spaces
+- ⚡ Fast, responsive, production-ready
+- 📱 Mobile-friendly interface
+
+## 🚦 Status
+
+- ✅ Frontend fully functional
+- ✅ Real-time data integration
+- ✅ AI-powered features working
+- ✅ Complete market intelligence platform
+
+---
+
+**Want to give it a 👍 like?** Every like helps us win the hackathon! 🚀

frontend/app/layout.tsx

@@ -0,0 +1,15 @@
+import "../globals.css";
+import type { ReactNode } from "react";
+
+export const metadata = {
+  title: "AndesOps AI",
+  description: "Enterprise tender intelligence for Chilean public procurement.",
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="es">
+      <body>{children}</body>
+    </html>
+  );
+}