AI Chat

CHAT_SYSTEM_PROMPT = """You are ClinicalPilot AI, a clinical decision-support assistant for healthcare professionals.

Your role:
- Answer clinical questions with evidence-based, concise responses.
- Help with differential diagnoses, drug interactions, guideline lookups, lab interpretation, and clinical reasoning.
- Always cite relevant guidelines (e.g., ACC/AHA, WHO, UpToDate) when applicable.
- If a question involves patient safety, flag it clearly.
- Use structured formatting (bullet points, numbered lists) for clarity.
- If you are unsure, say so — never fabricate clinical information.

You are NOT a replacement for clinical judgment. Always remind users that your answers are for educational/decision-support purposes only.

IMPORTANT: In future you will have access to a LanceDB vector store with indexed medical literature for RAG-enhanced answers. For now, rely on your training knowledge."""

@app.post("/api/chat")
async def chat(payload: dict):
    """AI chat — tries OpenAI first, falls back to Groq."""
    messages = payload.get("messages", [])
    if not messages:
        raise HTTPException(400, "No messages provided")

    openai_key = get_effective("openai_api_key")
    groq_key = get_effective("groq_api_key")

    if not openai_key and not groq_key:
        raise HTTPException(
            503,
            "No LLM API key configured. Please set your OpenAI API key in Settings, or add GROQ_API_KEY to .env"
        )

    full_messages = [{"role": "system", "content": CHAT_SYSTEM_PROMPT}] + [
        {"role": m["role"], "content": m["content"]} for m in messages
    ]

    # Try OpenAI first
    if openai_key:
        try:
            from openai import OpenAI as SyncOpenAI

            client = SyncOpenAI(api_key=openai_key)

            t0 = time.time()
            completion = client.chat.completions.create(
                model=settings.openai_model,
                messages=full_messages,
                temperature=0.3,
                max_tokens=2048,
            )
            latency_ms = int((time.time() - t0) * 1000)

            reply = completion.choices[0].message.content
            return {
                "reply": reply,
                "model": settings.openai_model,
                "provider": "openai",
                "latency_ms": latency_ms,
                "tokens": completion.usage.total_tokens,
            }
        except Exception as e:
            logger.warning(f"OpenAI chat failed ({e}), falling back to Groq")
            if not groq_key:
                raise HTTPException(500, f"OpenAI chat failed and no Groq fallback: {str(e)}")

    # Fallback to Groq
    try:
        from groq import Groq

        client = Groq(api_key=groq_key)

        t0 = time.time()
        completion = client.chat.completions.create(
            model=settings.groq_model,
            messages=full_messages,
            temperature=0.3,
            max_tokens=2048,
        )
        latency_ms = int((time.time() - t0) * 1000)

        reply = completion.choices[0].message.content
        return {
            "reply": reply,
            "model": settings.groq_model,
            "provider": "groq",
            "latency_ms": latency_ms,
            "tokens": completion.usage.total_tokens,
        }
    except Exception as e:
        logger.exception("Chat failed on all providers")
        raise HTTPException(500, f"Chat failed: {str(e)}")

# Groq (required for AI Chat)
GROQ_API_KEY=gsk_...
GROQ_MODEL=llama-3.3-70b-versatile  # Default model

# OpenAI (optional, used if available)
OPENAI_API_KEY=sk-proj-...
OPENAI_MODEL=gpt-4o