feat: implement Groq integration, robust multi-agent synthesis and UX performance optimization

.gitignore

@@ -18,3 +18,6 @@ frontend/npm-debug.log*
 *.db
 *.sqlite
 .vscode/
+backend/output.txt
+backend/scratch_*.py
+backend/scratch_test_analysis.py

backend/app/config.py

@@ -6,6 +6,7 @@ class Settings(BaseSettings):
     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
 

backend/app/services/agents.py

@@ -1,47 +1,40 @@
-import json
 import asyncio
-from typing import List, Dict, Any
-from app.schemas.analysis import AnalysisResult, RiskItem, ActionItem
+from app.schemas.analysis import AnalysisResult
 from app.schemas.company import CompanyProfile
 from app.schemas.tender import Tender
-from app.services.llm import generate_analysis, call_gemini, _parse_gemini_response, call_gemini_with_model
+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) -> str:
     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"STATUS: {tender.status} (Code: {tender.status_code})\n"
-        f"DATES: Published: {tender.publication_date}, Closing: {tender.closing_date}\n"
-        f"COMPANY: {company.name} (Docs: {', '.join(company.documents_available)})\n"
+        f"COMPANY: {company.name}\n"
         f"EXTRACTED TEXT: {document_text[:5000]}\n"
-        f"TASK: Identify 3 legal gaps. Analyze if the timeline is 'Express' (suspiciously short) for the tender type {tender.type}. Verify if company documents meet common requirements for this tender level."
+        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) -> str:
-    items_summary = ", ".join([f"{i.name} ({i.quantity} {i.unit})" for i in (tender.items or [])[:10]])
     prompt = (
         f"AGENT ROLE: Technical Architect\n"
-        f"GOAL: Evaluate technical feasibility and product-market fit.\n"
+        f"GOAL: Evaluate technical feasibility.\n"
         f"TENDER: {tender.name} - {tender.description}\n"
-        f"LINE ITEMS: {items_summary}\n"
         f"COMPANY: {company.industry} - {company.experience}\n"
         f"EXTRACTED TEXT: {document_text[:5000]}\n"
-        f"TASK: Analyze specific LINE ITEMS against company capabilities. Identify 3 technical challenges. Is this a generic 'buy' or a complex project?"
+        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) -> str:
     prompt = (
         f"AGENT ROLE: Risk & Strategy Specialist\n"
-        f"GOAL: Calculate ROI, competitive risks, and overall strategy.\n"
+        f"GOAL: Calculate ROI and strategy.\n"
         f"TENDER: {tender.name}\n"
-        f"AMOUNT: {tender.estimated_amount} {tender.currency}\n"
-        f"DATES: Closing on {tender.closing_date}\n"
         f"COMPANY: {company.name}\n"
-        f"TASK: Identify 3 strategic risks. Pay special attention to CURRENCY RISK if not CLP ({tender.currency}). Suggest a 'Win Strategy' based on the tender type {tender.type}."
+        f"TASK: Identify 3 strategic risks and a win strategy. Respond in Spanish."
     )
     return await call_gemini_with_model(prompt, model)
 
@@ -51,49 +44,58 @@ async def run_full_analysis(tender: Tender, company_profile: CompanyProfile, doc
     
     # Use selected models or defaults
     chosen_models = models or {
-        "legal": "Gemini 2.5 Flash",
-        "tech": "DeepSeek-V3.2 (Featherless)",
-        "risk": "Qwen-2.5 (Featherless)"
+        "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')}): Analizando bases...")
-    audit_log.append(f"👨‍💻 Agente Técnico ({chosen_models.get('tech')}): Evaluando requerimientos...")
-    audit_log.append(f"🕵️ Agente de Riesgo ({chosen_models.get('risk')}): Escaneando competitividad...")
+    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')})")
     
-    legal_task = legal_agent_task(tender, company_profile, doc_text, chosen_models.get("legal"))
-    tech_task = technical_agent_task(tender, company_profile, doc_text, chosen_models.get("tech"))
-    strat_task = strategy_agent_task(tender, company_profile, doc_text, chosen_models.get("risk"))
+    tasks = [
+        legal_agent_task(tender, company_profile, doc_text, chosen_models.get("legal")),
+        technical_agent_task(tender, company_profile, doc_text, chosen_models.get("tech")),
+        strategy_agent_task(tender, company_profile, doc_text, chosen_models.get("risk"))
+    ]
     
-    responses = await asyncio.gather(legal_task, tech_task, strat_task)
+    responses = await asyncio.gather(*tasks)
     legal_resp, tech_resp, strat_resp = responses
     
-    audit_log.append("💡 Consolidando hallazgos de los expertos...")
+    audit_log.append("💡 Consolidando hallazgos...")
     
-    # Final Synthesis
     synthesis_prompt = (
-        f"Eres el ORQUESTADOR DE ANDESOPS AI.\n"
-        f"Has recibido reportes de tus expertos para la licitación: {tender.name}.\n\n"
-        f"REPORTE LEGAL: {legal_resp}\n\n"
-        f"REPORTE TÉCNICO: {tech_resp}\n\n"
-        f"REPORTE ESTRATÉGICO: {strat_resp}\n\n"
-        f"DATOS DE LA EMPRESA: {company_profile.model_dump_json()}\n\n"
-        f"INSTRUCCIONES CRÍTICAS:\n"
-        f"1. Genera el AnalysisResult final en JSON.\n"
-        f"2. Identifica 3-5 preguntas o requerimientos críticos del texto de las bases (o del contexto) y genera respuestas en estilo 'Q&A'.\n"
-        f"3. Cada respuesta debe usar los datos reales de la empresa (RUT, experiencia, etc.) para responder de forma profesional.\n"
-        f"4. El campo en el JSON debe ser 'requirement_responses' como una lista de {{'question', 'answer'}}.\n"
-        f"5. Ejemplo: {{'question': '¿Cuenta con RUT vigente?', 'answer': 'SÍ, nuestra empresa posee RUT 77... y está habilitada en el SII.'}}\n"
-        f"6. Incluye un 'strategic_roadmap' con 3 fases.\n"
-        f"Responde ÚNICAMENTE con el JSON."
+        f"SISTEMA DE CONSENSO ANDESOPS AI\n"
+        f"Licitación: {tender.name}\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:\n"
+        f"1. fit_score (int 0-100)\n"
+        f"2. decision ('Recommended', 'Review Carefully', 'Not Recommended')\n"
+        f"3. executive_summary (string)\n"
+        f"4. risks (list of {{title, severity, explanation}})\n"
+        f"5. key_requirements (list of strings)\n"
+        f"6. compliance_gaps (list of strings)\n"
+        f"7. action_plan (list of {{task, priority, owner, timeline}})\n"
+        f"8. strategic_roadmap (string Markdown)\n"
+        f"9. proposal_draft (string Markdown)\n"
+        f"10. report_markdown (string Markdown)\n"
+        f"Responde ÚNICAMENTE con el JSON plano."
     )
     
-    final_output = await call_gemini(synthesis_prompt)
+    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:
-            audit_log.append(f"✅ Síntesis completada con éxito.")
-            
+            # Ensure report_markdown exists
             if not parse_result.get("report_markdown"):
                 parse_result["report_markdown"] = generate_markdown_report(parse_result)
             
@@ -101,8 +103,8 @@ async def run_full_analysis(tender: Tender, company_profile: CompanyProfile, doc
             result.audit_log = audit_log + (result.audit_log or [])
             return result
         except Exception as e:
-            print(f"Synthesis Error: {e}")
+            print(f"Synthesis Validation Error: {e}")
             
-    # Fallback
+    # 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

@@ -1,145 +1,187 @@
 import hashlib
 import json
-import re
-from typing import Any
-
-import google.generativeai as genai
 import httpx
+import google.generativeai as genai
 from app.config import settings
-from app.schemas.analysis import AnalysisResult
-from app.schemas.company import CompanyProfile
-from app.schemas.tender import Tender
+from app.schemas.analysis import AnalysisResult, RiskItem, ActionItem, CompanyProfile, Tender
 from app.services.report import generate_markdown_report
 
 # Configure Gemini
-if settings.gemini_api_key:
-    genai.configure(api_key=settings.gemini_api_key)
+genai.configure(api_key=settings.gemini_api_key)
 
-def get_gemini_model():
-    return genai.GenerativeModel(
-        model_name=settings.gemini_model,
-        generation_config={
+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": 64,
+            "top_k": 40,
             "max_output_tokens": 8192,
-            "response_mime_type": "application/json",
         }
-    )
-
-async def call_gemini(prompt: str) -> str:
-    if not settings.gemini_api_key:
-        # Fallback to Featherless if Gemini not available
-        return await call_featherless(prompt, "meta-llama/Llama-3.3-70B-Instruct")
-
-    try:
-        model = get_gemini_model()
-        # Use run_in_executor if the library is blocking, or use async generate_content if supported
+        
+        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: {e}, trying Featherless fallback...")
-        return await call_featherless(prompt, "meta-llama/Llama-3.3-70B-Instruct")
+        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 = "deepseek-ai/DeepSeek-V3.2") -> str:
+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={
-                    "model": model,
-                    "messages": [{"role": "user", "content": prompt}],
-                    "response_format": {"type": "json_object"},
-                    "temperature": 0.2
-                }
+                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_gemini_with_model(prompt: str, model_name: str | None = None) -> str:
-    # Default model mapping
+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_gemini_with_model(prompt: str, model_name: str | None = None, is_json: bool = False) -> str:
     model_map = {
         "Gemini 2.5 Flash": "gemini",
-        "DeepSeek-V3.2 (Featherless)": "deepseek-ai/DeepSeek-V3.2",
-        "Qwen-3-32B (Featherless)": "Qwen/Qwen3-32B",
+        "DeepSeek-V3 (Featherless)": "deepseek-ai/DeepSeek-V3",
         "Qwen-2.5 (Featherless)": "Qwen/Qwen2.5-72B-Instruct",
-        "Gemma-4-31B (Featherless)": "google/gemma-4-31B-it",
-        "Llama-3.1-8B (Featherless)": "meta-llama/Meta-Llama-3.1-8B-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",
     }
 
     model_id = model_map.get(model_name, "gemini")
     
     if model_id == "gemini":
-        return await call_gemini(prompt)
+        res = await call_gemini(prompt, is_json=is_json)
+        if not res and settings.groq_api_key:
+            return await call_groq(prompt, "llama-3.3-70b-versatile")
+        return res
+    elif model_id.startswith("groq:"):
+        return await call_groq(prompt, model=model_id[5:])
     else:
         return await call_featherless(prompt, model=model_id)
 
-def _normalize_gemini_output(output: str) -> str:
+def _parse_gemini_response(output: str) -> dict | None:
     if not output:
-        return output
-
-    text = output.strip()
-    if text.startswith("```"):
-        parts = text.split("```")
-        if len(parts) >= 2:
-            first_part = parts[1].strip()
-            if first_part.lower().startswith("json"):
-                text = first_part[4:].strip()
-            else:
-                text = first_part
+        return None
     
-    return text
-
-def _parse_gemini_response(output: str) -> dict[str, Any] | None:
-    candidate = _normalize_gemini_output(output)
+    # 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:
-        return json.loads(candidate)
-    except json.JSONDecodeError:
-        json_match = re.search(r"\{.*\}", candidate, re.DOTALL)
-        if json_match:
-            try:
-                return json.loads(json_match.group(0))
-            except:
-                pass
+        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
 
-def _build_analysis_prompt(tender: Tender, company: CompanyProfile, document_text: str | None = None) -> str:
-    doc_context = f"\n\nCONTENIDO DE LAS BASES (DOCUMENTO ADJUNTO):\n{document_text}\n" if document_text else ""
-    return (
-        "Eres un Sistema Multi-Agente de Élite para análisis de licitaciones públicas en Chile (Mercado Público).\n"
-        "Tu objetivo es realizar un análisis exhaustivo y colaborativo entre tres expertos virtuales:\n\n"
-        "1. **Agente Legal & Cumplimiento**: Enfocado en bases administrativas, plazos y requisitos de documentos.\n"
-        "2. **Agente Técnico**: Enfocado en el encaje de la oferta, arquitectura y capacidades de ejecución.\n"
-        "3. **Agente de Riesgos & Estrategia**: Enfocado en rentabilidad, riesgos del proyecto y competitividad.\n\n"
-        "INSTRUCCIONES:\n"
-        "- Analiza la licitación, el perfil de la empresa y el contenido de las bases adjuntas si están disponibles.\n"
-        "- Genera una decisión consensuada.\n"
-        "- Devuelve un objeto JSON con la estructura exacta de 'AnalysisResult'.\n\n"
-        "CAMPOS REQUERIDOS EN EL JSON:\n"
-        "- fit_score: (0-100) puntaje de encaje.\n"
-        "- decision: 'Recommended', 'Review Carefully' o 'Not Recommended'.\n"
-        "- executive_summary: Resumen ejecutivo profesional en español.\n"
-        "- key_requirements: Lista de los 5 requisitos más críticos.\n"
-        "- risks: Lista de objetos {title, severity: 'High'|'Medium'|'Low', explanation}.\n"
-        "- compliance_gaps: Lista de posibles brechas o documentos faltantes.\n"
-        "- action_plan: Lista de objetos {task, priority, owner, timeline}.\n"
-        "- proposal_draft: Un borrador de propuesta comercial (Markdown) convincente.\n"
-        "- audit_log: Lista de pasos que tomaron los agentes para llegar a esta conclusión.\n\n"
-        f"DATOS DE LA LICITACIÓN:\n{tender.model_dump_json(indent=2)}\n\n"
-        f"DATOS DE LA EMPRESA:\n{company.model_dump_json(indent=2)}\n"
-        f"{doc_context}\n\n"
-        "RESPONDE ÚNICAMENTE CON EL JSON VÁLIDO."
-    )
+        # 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}"
@@ -160,26 +202,15 @@ def generate_mock_analysis(tender: Tender, company: CompanyProfile) -> AnalysisR
     )
 
 async def generate_analysis(tender: Tender, company: CompanyProfile, document_text: str | None = None, models: dict | None = None) -> AnalysisResult:
-    # Default model mapping
-    model_map = {
-        "Gemini 2.5 Flash": "gemini",
-        "DeepSeek-V3.2 (Featherless)": "deepseek-ai/DeepSeek-V3.2",
-        "Qwen-3-32B (Featherless)": "Qwen/Qwen3-32B",
-        "Gemma-4-31B (Featherless)": "google/gemma-4-31B-it",
-        "Llama-3.1-8B (Featherless)": "meta-llama/Meta-Llama-3.1-8B-Instruct"
-    }
-
-    # Get selected models or defaults
     chosen = models or {
-        "legal": "Gemini 2.5 Flash",
-        "tech": "DeepSeek-V3.2 (Featherless)",
-        "risk": "Qwen-3-32B (Featherless)"
+        "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 = {}
 
-    # Define Agent roles for separate calls
     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.",
@@ -188,8 +219,6 @@ async def generate_analysis(tender: Tender, company: CompanyProfile, document_te
 
     for agent_id, role_desc in agent_definitions.items():
         model_name = chosen.get(agent_id, "Gemini 2.5 Flash")
-        model_id = model_map.get(model_name, "gemini")
-        
         audit_messages.append(f"🤖 Agent {agent_id.upper()} calling {model_name}...")
         
         agent_prompt = f"""
@@ -201,48 +230,36 @@ async def generate_analysis(tender: Tender, company: CompanyProfile, document_te
         PROPORCIONA TU ANÁLISIS ESPECÍFICO (Máx 200 palabras) EN ESPAÑOL.
         """
         
-        res = ""
-        if model_id == "gemini":
-            res = await call_gemini(agent_prompt)
-            # Failover to Featherless if Gemini fails (e.g. 429)
-            if not res and settings.featherless_api_key:
-                audit_messages.append(f"🔄 Gemini failed/rate-limited. Switching to DeepSeek for {agent_id.upper()}...")
-                res = await call_featherless(agent_prompt, model="deepseek-ai/DeepSeek-V3.2")
-        else:
-            res = await call_featherless(agent_prompt, model=model_id)
-            
-        agent_outputs[agent_id] = res or "Análisis no disponible por error de API."
+        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."
 
-    # FINAL CONSENSUS AGENT (Synthesis + Roadmap)
-    audit_messages.append("⚖️ Final Consensus Agent synthesizing results & roadmap...")
-    synthesis_prompt = f"""
-    Eres el AGENTE DE CONSENSO Y ESTRATEGIA. Debes unificar estos 3 análisis en un único JSON de 'AnalysisResult':
-    
-    1. LEGAL: {agent_outputs.get('legal')}
-    2. TECH: {agent_outputs.get('tech')}
-    3. RISK: {agent_outputs.get('risk')}
+    audit_messages.append("🧠 Synthesis phase: Consolidating agent insights...")
     
-    Genera el JSON final siguiendo estas reglas:
-    - executive_summary: Resumen integrador en español.
-    - fit_score: Promedio de encaje (0-100).
-    - decision: 'Recommended', 'Review Carefully' o 'Not Recommended'.
-    - risks, key_requirements, compliance_gaps.
-    - action_plan: Pasos concretos de ejecución.
-    - strategic_roadmap: (NUEVO) Un roadmap de 3 fases para ganar esta licitación.
-    - audit_log: Incluye los pasos tomados.
+    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)
-    if not final_json and settings.featherless_api_key:
-        final_json = await call_featherless(synthesis_prompt, model="deepseek-ai/DeepSeek-V3.2")
+    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:
-            # FORCE PROPOSAL GENERATION
+            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)
@@ -251,9 +268,8 @@ async def generate_analysis(tender: Tender, company: CompanyProfile, document_te
             result.audit_log = audit_messages + (result.audit_log or [])
             return result
         except Exception as e:
-            print(f"Synthesis Mapping Error: {e}")
-
-    # Final Fallback
+            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
@@ -273,56 +289,4 @@ async def generate_proposal_draft(analysis: dict, company: CompanyProfile) -> st
     4. Propuesta de Valor Estratégica
     """
     
-    # Use DeepSeek for high-quality drafting if available
-    if settings.featherless_api_key:
-        draft = await call_featherless(prompt, model="deepseek-ai/DeepSeek-V3.2")
-        if draft: return draft
-
-    # Fallback to Gemini
-    return await call_gemini(prompt) or "Error al generar el borrador de la propuesta."
-
-async def generate_synthetic_tenders(keyword: str) -> list[Tender]:
-    """
-    Generates realistic-looking synthetic tenders using an LLM.
-    Used as a fallback when the real scraper is blocked.
-    """
-    prompt = f"""
-    Genera 5 oportunidades de licitación (Compra Ágil) realistas en Chile para el rubro: '{keyword}'.
-    
-    Cada oportunidad debe tener:
-    - code: Un código ficticio pero realista (ej: COT26-123-AG24).
-    - name: Un título profesional (ej: Adquisición de Licencias de Software para RRHH).
-    - buyer: Nombre de un organismo público real de Chile (ej: Municipalidad de Santiago, Ministerio de Salud).
-    - status: 'Publicada'.
-    - closing_date: Una fecha en los próximos 7 días (YYYY-MM-DD).
-    - description: Una descripción breve de 2 párrafos sobre lo que se necesita.
-    - estimated_amount: Un monto en pesos chilenos (CLP) razonable (entre 1.000.000 y 30.000.000).
-    - region: Una región de Chile.
-    - sector: 'Software y Tecnología' (o el rubro correspondiente).
-    
-    Responde ÚNICAMENTE un JSON con una lista de objetos bajo la llave 'tenders'.
-    """
-    
-    res = await call_gemini(prompt)
-    if not res and settings.featherless_api_key:
-        res = await call_featherless(prompt)
-        
-    data = _parse_gemini_response(res)
-    results = []
-    if data and "tenders" in data:
-        for t in data["tenders"]:
-            results.append(Tender(
-                code=t.get("code", "SYN-001"),
-                name=t.get("name", "Oportunidad Sintética"),
-                buyer=t.get("buyer", "Organismo Público"),
-                status=t.get("status", "Publicada"),
-                closing_date=t.get("closing_date"),
-                description=t.get("description", ""),
-                estimated_amount=float(t.get("estimated_amount", 0)),
-                source="AndesOps AI Synthetic Intelligence",
-                region=t.get("region", "Nacional"),
-                sector="Compra Ágil",
-                items=[],
-                attachments=[]
-            ))
-    return results
+    return await call_gemini_with_model(prompt, model_name="Llama-3.3-70B (Groq)" if settings.groq_api_key else "Gemini 2.5 Flash")

backend/app/services/report.py

@@ -23,17 +23,23 @@ def generate_markdown_report(analysis: Any) -> str:
     lines.append("")
     lines.append("## Riesgos")
     for risk in _value(analysis, "risks") or []:
-        lines.append(f"- **{risk['title']}** ({risk['severity']}): {risk['explanation']}")
+        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"- {gap}")
+        lines.append(f"- {str(gap)}")
     lines.append("")
     lines.append("## Plan de Acción")
     for item in _value(analysis, "action_plan") or []:
-        lines.append(
-            f"- **{item['task']}** | Prioridad: {item['priority']} | Responsable: {item['owner']} | Tiempo: {item['timeline']}"
-        )
+        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"))

frontend/components/AgentAnalysis.tsx

@@ -99,7 +99,7 @@ export default function AgentAnalysis({ tender, companyProfile, analysis, onAnal
             }
             return prev;
         });
-      }, 3000);
+      }, 800); // Faster log timing for snappier feel
 
       // We call the parent's onAnalyze but we want the result back locally too
       // Actually, since we want multiple analyses, we might need to handle the result here
@@ -136,7 +136,7 @@ export default function AgentAnalysis({ tender, companyProfile, analysis, onAnal
 
   if (!tender && !analysis) {
     return (
-      <div className="flex flex-col items-center justify-center min-h-[60vh] space-y-12 animate-in fade-in duration-1000">
+      <div className="flex flex-col items-center justify-center min-h-[60vh] space-y-12 animate-in fade-in duration-300">
         <div className="text-center space-y-4">
           <div className="inline-block p-4 rounded-3xl bg-white/5 border border-white/10 mb-6">
             <span className="text-5xl">🤖</span>
@@ -173,7 +173,7 @@ export default function AgentAnalysis({ tender, companyProfile, analysis, onAnal
   }
 
   return (
-    <div className="space-y-8 animate-in fade-in slide-in-from-bottom-4 duration-700">
+    <div className="space-y-8 animate-in fade-in slide-in-from-bottom-4 duration-500">
       {/* Navigation Header */}
       <div className="flex justify-start">
         <button 
@@ -298,9 +298,11 @@ export default function AgentAnalysis({ tender, companyProfile, analysis, onAnal
                 <div className="space-y-1">
                   {[
                     "Gemini 2.5 Flash", 
-                    "DeepSeek-V3.2 (Featherless)", 
-                    "Qwen-3-32B (Featherless)", 
+                    "DeepSeek-V3 (Featherless)", 
                     "Qwen-2.5 (Featherless)",
+                    "Llama-3.3-70B (Groq)",
+                    "Llama-3.1-8B (Groq)",
+                    "Mixtral-8x7B (Groq)",
                     "Gemma-4-31B (Featherless)",
                     "Llama-3.1-8B (Featherless)"
                   ].map(model => (
@@ -360,7 +362,7 @@ export default function AgentAnalysis({ tender, companyProfile, analysis, onAnal
 
       {/* Analysis Results View */}
       {activeAnalysis && (
-        <div id="analysis-results" className="grid gap-8 lg:grid-cols-12 animate-in fade-in slide-in-from-bottom-8 duration-1000 scroll-mt-20">
+        <div id="analysis-results" className="grid gap-8 lg:grid-cols-12 animate-in fade-in slide-in-from-bottom-8 duration-500 scroll-mt-20">
           <div className="lg:col-span-8 space-y-8">
              <div className="glass-card rounded-3xl p-10 bg-white/[0.02]">
                 <div className="flex items-start justify-between mb-8">

frontend/components/ProposalDraft.tsx

@@ -4,7 +4,7 @@ type Props = {
 
 export default function ProposalDraft({ proposal }: Props) {
   return (
-    <div className="space-y-6 animate-in fade-in slide-in-from-bottom-4 duration-700">
+    <div className="space-y-6 animate-in fade-in slide-in-from-bottom-4 duration-300">
       <div className="glass-card rounded-[2rem] p-8 border border-white/10 relative overflow-hidden">
         <div className="absolute top-0 right-0 w-32 h-32 bg-purple-500/10 blur-[60px]" />
         <h2 className="text-2xl font-bold text-white mb-2">Technical Proposal Draft</h2>

frontend/components/Sidebar.tsx

@@ -71,7 +71,7 @@ export default function Sidebar({ tabs, activeTab, onTabSelect, status, lang, fo
                 onTabSelect(tab);
                 window.history.pushState({}, '', `?tab=${tabSlug}`);
               }}
-              className={`flex items-center rounded-xl transition-all duration-300 group relative ${
+              className={`flex items-center rounded-xl transition-all duration-200 active:scale-95 group relative ${
                 isActive
                   ? "bg-white/10 text-white shadow-inner"
                   : "text-slate-400 hover:bg-white/5 hover:text-white"

frontend/globals.css

@@ -41,10 +41,10 @@
 @layer components {
   .glass-card {
     background-color: rgba(0, 0, 0, 0.4);
-    backdrop-filter: blur(12px);
+    backdrop-filter: blur(8px);
     border: 1px solid rgba(255, 255, 255, 0.1);
     box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
-    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    transition: all 0.2s ease-out;
   }
   
   .glass-card:hover {